diff --git a/plugins/ndf/bin/ndf b/plugins/ndf/bin/ndf index fc4429f056..6f546aa6fc 100755 --- a/plugins/ndf/bin/ndf +++ b/plugins/ndf/bin/ndf @@ -16,8 +16,11 @@ # 入れられない(curl が無い・ネットワークが無い・ハッシュが違うなど)ときは、理由を結果 JSON(stopped・deps_missing)で出し、 # 終了コードの表(contracts/facts/exit-codes.json)の deps_missing の終了コードで止まる。 # -# 呼び出し元の CLAUDE_PLUGIN_ROOT は、子へ自分の根を渡す前に NDF_CALLER_PLUGIN_ROOT へ写す。Python 側は -# それを読み、ほかのプラグインの根なら旧い状態の保存先を退避しない(identity.py)。 +# 呼び出し元の CLAUDE_PLUGIN_ROOT は、子へ自分の根を渡す前に NDF_CALLER_PLUGIN_ROOT へ写す(無ければ空)。 +# ほかに NDF と uv run が入れる UV_PROJECT_ENVIRONMENT・VIRTUAL_ENV・UV_RUN_RECURSION_DEPTH・PATH・PYTHONPATH は、 +# 呼び出し元の値を NDF_CALLER_<名前> へ写す(あれば空でも写し、無ければ写しを消す。外側の ndf の写しを残さない)。 +# start.py は `python -m ndf` の前に、写しから呼び出し元の値へ戻す。NDF の子孫が利用先で打つ uv run が NDF の venv を +# 書き換えない(#4029)。子が `ndf` を打てば、このファイルが毎回 NDF の venv を指し直す。 set -euo pipefail UV_VERSION="0.13.7" @@ -84,6 +87,9 @@ if got != want: fi export NDF_CALLER_PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-}" +for held in UV_PROJECT_ENVIRONMENT VIRTUAL_ENV UV_RUN_RECURSION_DEPTH PATH PYTHONPATH; do + if [ -n "${!held+set}" ]; then export "NDF_CALLER_$held=${!held}"; else unset "NDF_CALLER_$held"; fi +done export CLAUDE_PLUGIN_ROOT="$root" export UV_PROJECT_ENVIRONMENT="$cache_home/venv/$version" export PYTHONPATH="$root/src${PYTHONPATH:+:$PYTHONPATH}" diff --git a/plugins/ndf/bin/start.py b/plugins/ndf/bin/start.py index a9756a4252..99e3cf27e1 100644 --- a/plugins/ndf/bin/start.py +++ b/plugins/ndf/bin/start.py @@ -7,14 +7,22 @@ 確かめるのは、確かめたマーカー(環境の中の `.deps-checked`)が無いか、`uv.lock` より古いときだけにする(ふだんの起動はマーカーの 更新時刻を見るだけ)。標準ライブラリだけを読む(依存が欠けていても動く)。 + +自分のパッケージを呼ぶ前に、エントリポイントと uv run が入れた環境の変数を、エントリポイントが写した呼び出し元の値へ戻す +(`CALLER_ENV`。#4029)。NDF の子孫(プランのステップ・レーンのセッション・cross-review の相手役など)が利用先のリポジトリで +uv run を打っても、NDF の venv を書き換えない。自分の import の道(sys.path)は起動のときに決まっているので変わらない。 +NDF が自分のパッケージを子で打つときは `ndf.cli` の `ndf_command` で src を子の sys.path にだけ渡す。写しの変数は +消す(呼び出し元の `CLAUDE_PLUGIN_ROOT` は戻した値として identity.py が読む)。 """ from __future__ import annotations import csv import json +import os import runpy import sys +from collections.abc import MutableMapping from importlib import metadata from pathlib import Path @@ -24,6 +32,17 @@ STAMP = Path(sys.prefix) / ".deps-checked" # 入れる手段によって作られないことがあるファイル(RECORD に載っても欠けを数えない) OPTIONAL_SUFFIXES = (".pyc",) +# エントリポイントと uv run が入れる変数と、エントリポイントが呼び出し元の値を写す変数(無かった値は写しを持たない) +CALLER_ENV = { + "CLAUDE_PLUGIN_ROOT": "NDF_CALLER_PLUGIN_ROOT", + "UV_PROJECT_ENVIRONMENT": "NDF_CALLER_UV_PROJECT_ENVIRONMENT", + "VIRTUAL_ENV": "NDF_CALLER_VIRTUAL_ENV", + "UV_RUN_RECURSION_DEPTH": "NDF_CALLER_UV_RUN_RECURSION_DEPTH", + "PATH": "NDF_CALLER_PATH", + "PYTHONPATH": "NDF_CALLER_PYTHONPATH", +} +# 写しの空の値を「無かった」と読む変数(エントリポイントが無いときも空で写す) +EMPTY_IS_UNSET = frozenset({"CLAUDE_PLUGIN_ROOT"}) def recorded_files(dist) -> list[str]: @@ -72,6 +91,18 @@ def emit_deps_missing(detail: str) -> int: return next(row["code"] for row in rows if row["id"] == "deps_missing") +def restore_caller_env(env: MutableMapping[str, str]) -> None: + """`env` を写しの呼び出し元の値へ戻し、写しの変数を消す。写しが 1 つも無ければ(エントリポイントを通らずに打った)何もしない。""" + if not any(held in env for held in CALLER_ENV.values()): + return + for name, held in CALLER_ENV.items(): + value = env.pop(held, None) + if value is None or (not value and name in EMPTY_IS_UNSET): + env.pop(name, None) + else: + env[name] = value + + def main() -> int: if not checked(): broken = broken_distributions() @@ -81,6 +112,7 @@ def main() -> int: STAMP.touch() except OSError: # noqa: NDF401 ファイル: マーカーを書けない環境は、次の起動でも確かめる pass + restore_caller_env(os.environ) runpy.run_module(PACKAGE, run_name="__main__", alter_sys=True) return 0 diff --git a/plugins/ndf/contracts/domains/env.json b/plugins/ndf/contracts/domains/env.json index 5eb413a793..06d0ad2704 100644 --- a/plugins/ndf/contracts/domains/env.json +++ b/plugins/ndf/contracts/domains/env.json @@ -14,7 +14,12 @@ {"id": "UV_PROJECT_ENVIRONMENT", "area": "identity", "set_by": "ndf", "type": "path", "secret": false, "meaning": "bin/ndf が NDF の依存の環境(<キャッシュ>/ndf/venv/<バージョン>)を指して uv へ渡す。中継が起動するセッションへ渡すと、セッションの中の uv run が NDF の環境を書き換えるため渡さない", "child": "drop"}, {"id": "VIRTUAL_ENV", "area": "identity", "set_by": "runtime", "type": "path", "secret": false, "meaning": "uv run が NDF の依存の環境を指して入れる。中継が起動するセッションへ渡すと、セッションの中の uv と python が NDF の環境を使うため渡さない", "child": "drop"}, {"id": "UV_RUN_RECURSION_DEPTH", "area": "identity", "set_by": "runtime", "type": "integer", "secret": false, "meaning": "uv run が入れ子の深さとして入れる。中継が起動するセッションへ渡すと、セッションの中の uv run の深さを誤って数えるため渡さない", "child": "drop"}, - {"id": "NDF_CALLER_PLUGIN_ROOT", "area": "identity", "set_by": "ndf", "type": "path", "secret": false, "meaning": "bin/ndf が子へ自分の根を渡す前に写した、呼び出し元の CLAUDE_PLUGIN_ROOT(空なら無かった)。ほかのプラグインの根なら旧い状態の保存先を退避しない。中継が起動するセッションへ渡さない", "child": "drop"}, + {"id": "NDF_CALLER_PLUGIN_ROOT", "area": "identity", "set_by": "ndf", "type": "path", "secret": false, "meaning": "bin/ndf が子へ自分の根を渡す前に写した、呼び出し元の CLAUDE_PLUGIN_ROOT(空なら無かった)。bin/start.py が自分のパッケージを呼ぶ前に CLAUDE_PLUGIN_ROOT へ戻して消す(#4029)。残っていれば(bin/ndf を通らずに打った子)ほかのプラグインの根のとき旧い状態の保存先を退避しない。中継が起動するセッションへ渡さない", "child": "drop"}, + {"id": "NDF_CALLER_UV_PROJECT_ENVIRONMENT", "area": "identity", "set_by": "ndf", "type": "path", "secret": false, "meaning": "bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の UV_PROJECT_ENVIRONMENT(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない", "child": "drop"}, + {"id": "NDF_CALLER_VIRTUAL_ENV", "area": "identity", "set_by": "ndf", "type": "path", "secret": false, "meaning": "bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の VIRTUAL_ENV(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない", "child": "drop"}, + {"id": "NDF_CALLER_UV_RUN_RECURSION_DEPTH", "area": "identity", "set_by": "ndf", "type": "integer", "secret": false, "meaning": "bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の UV_RUN_RECURSION_DEPTH(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない", "child": "drop"}, + {"id": "NDF_CALLER_PATH", "area": "identity", "set_by": "ndf", "type": "string", "secret": false, "meaning": "bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の PATH(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない", "child": "drop"}, + {"id": "NDF_CALLER_PYTHONPATH", "area": "identity", "set_by": "ndf", "type": "string", "secret": false, "meaning": "bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の PYTHONPATH(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない", "child": "drop"}, {"id": "NDF_STATE_HOME", "area": "identity", "set_by": "user", "type": "path", "secret": false, "meaning": "状態の保存先の根。保存先は <値>/<プラグイン名>(XDG_STATE_HOME と同じ読み方。入れ替えの前に旧い NDF と同じ値を渡されても、旧い保存先を退避しない)。無ければ XDG_STATE_HOME の下"}, {"id": "XDG_STATE_HOME", "area": "identity", "set_by": "user", "type": "path", "secret": false, "meaning": "XDG の状態の保存先。無ければ ~/.local/state"}, {"id": "CLAUDECODE", "area": "runtime", "set_by": "runtime", "type": "flag", "secret": false, "meaning": "Claude Code の中で動いているマーカー(ホストの推定)。中継が起動するセッションへ渡さない(残ると claude が入れ子の起動を断る)", "child": "drop"}, diff --git a/plugins/ndf/docs/contracts/env.md b/plugins/ndf/docs/contracts/env.md index d655da04ba..d3d8cab13f 100644 --- a/plugins/ndf/docs/contracts/env.md +++ b/plugins/ndf/docs/contracts/env.md @@ -25,7 +25,12 @@ NDF が読む環境変数と、NDF が子のプロセスへ渡す環境変数で | `NDF_ACCOUNTS_DIR` | user | path | — | アカウントの登録の保存先(ndf relay account の登録のサブコマンド)。無ければ <共有の設定ディレクトリ>/ndf/accounts(旧いプラグインと同じ保存先) | 内部(予告なく変えてよい) | | `NDF_API_KEY_CHECK_MODEL` | user | string | — | API キーの確かめに使うモデル。無ければ claude-haiku-4-5 | 内部(予告なく変えてよい) | | `NDF_API_KEY_CHECK_URL` | user | string | — | API キーの確かめの送信先。無ければ https://api.anthropic.com/v1/messages | 内部(予告なく変えてよい) | -| `NDF_CALLER_PLUGIN_ROOT` | ndf | path | — | bin/ndf が子へ自分の根を渡す前に写した、呼び出し元の CLAUDE_PLUGIN_ROOT(空なら無かった)。ほかのプラグインの根なら旧い状態の保存先を退避しない。中継が起動するセッションへ渡さない | 内部(予告なく変えてよい) | +| `NDF_CALLER_PATH` | ndf | string | — | bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の PATH(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない | 内部(予告なく変えてよい) | +| `NDF_CALLER_PLUGIN_ROOT` | ndf | path | — | bin/ndf が子へ自分の根を渡す前に写した、呼び出し元の CLAUDE_PLUGIN_ROOT(空なら無かった)。bin/start.py が自分のパッケージを呼ぶ前に CLAUDE_PLUGIN_ROOT へ戻して消す(#4029)。残っていれば(bin/ndf を通らずに打った子)ほかのプラグインの根のとき旧い状態の保存先を退避しない。中継が起動するセッションへ渡さない | 内部(予告なく変えてよい) | +| `NDF_CALLER_PYTHONPATH` | ndf | string | — | bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の PYTHONPATH(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない | 内部(予告なく変えてよい) | +| `NDF_CALLER_UV_PROJECT_ENVIRONMENT` | ndf | path | — | bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の UV_PROJECT_ENVIRONMENT(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない | 内部(予告なく変えてよい) | +| `NDF_CALLER_UV_RUN_RECURSION_DEPTH` | ndf | integer | — | bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の UV_RUN_RECURSION_DEPTH(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない | 内部(予告なく変えてよい) | +| `NDF_CALLER_VIRTUAL_ENV` | ndf | path | — | bin/ndf が子へ自分の値を入れる前に写した、呼び出し元の VIRTUAL_ENV(無ければ写しを持たない)。bin/start.py が自分のパッケージを呼ぶ前に呼び出し元の値へ戻して消す(#4029)。中継が起動するセッションへ渡さない | 内部(予告なく変えてよい) | | `NDF_CLAUDE_ACCOUNT` | user | string | — | 子の claude を起動する登録済みのアカウントの名前 | 内部(予告なく変えてよい) | | `NDF_CLAUDE_API_KEY_GENERATION` | ndf | integer | — | 子へ渡した API キーの世代。入れ子の監督が読む | 内部(予告なく変えてよい) | | `NDF_CLAUDE_API_KEY_NAME` | ndf | string | — | 子へ渡した API キーの名前。入れ子の監督が読む | 内部(予告なく変えてよい) | diff --git a/plugins/ndf/docs/contracts/index.md b/plugins/ndf/docs/contracts/index.md index 41006386f1..483717ff47 100644 --- a/plugins/ndf/docs/contracts/index.md +++ b/plugins/ndf/docs/contracts/index.md @@ -13,7 +13,7 @@ NDF を外から呼ぶ面(設定・サブコマンド・環境変数・受け | [設定(.ndf/)](ndf-settings.md) | 公開 18・内部 1 | | [サブコマンドの引数と結果](commands.md) | 公開 0・内部 28 | | [終了コードと停止理由](exit-codes.md) | 終了コード 11・停止理由 33 | -| [環境変数](env.md) | 公開 10・内部 55 | +| [環境変数](env.md) | 公開 10・内部 60 | | [受け渡しのファイル](files.md) | 公開 12・内部 56 | | [hook の入出力](hooks.md) | 公開 6・内部 11 | | [Skill と起動スクリプト](skills.md) | 公開 1・内部 48 | diff --git a/plugins/ndf/src/ndf/cli.py b/plugins/ndf/src/ndf/cli.py index 5d7150657c..ea00ef1f36 100644 --- a/plugins/ndf/src/ndf/cli.py +++ b/plugins/ndf/src/ndf/cli.py @@ -11,13 +11,25 @@ どのサブコマンドも結果 JSON を 1 行出して終わる。サブコマンドが捕まえない例外は `stopped`(種類 `unknown`)、使い方の誤り (argparse の終了コード 2 の `SystemExit`)は `stopped`(種類 `invalid`)の結果 JSON をここで出す(#3394)。 + +サブコマンドを子プロセスで打つ所は `ndf_command` で argv を組む。`bin/start.py` が `PYTHONPATH` を呼び出し元の値へ +戻すので(#4029)、子へは自分の `src` を argv で渡して子の `sys.path` にだけ入れる(環境変数は呼び出し元の値のまま)。 +子は `-I` で起動し、起動時の import の探索に呼び出し元の `PYTHONPATH` を使わない(その道の `sitecustomize` が同じ名前の +パッケージを先に `sys.modules` へ入れない)。環境変数は消さないので、子の下のステップは呼び出し元の値をそのまま受ける。 +子の標準出力・標準エラーは UTF-8 に決め(`CHILD_ENCODING`)、読む側も `child_encoding` で UTF-8 と分かる。ロケールの +文字コードは呼び出し元のまま(`-I` が無視する `PYTHONUTF8` は `-X utf8=` で写す)なので、子の下のステップの出力は従来どおり +ロケールで読む。`os.execv` で自分を置き換えるとき(`ndf answer work`)は、呼び出し元が置き換える前の文字コードで読むので、 +今の標準出力・標準エラーの文字コードを写す(`ndf_command` の `keep_streams`)。 """ from __future__ import annotations import importlib import logging +import os import sys +from pathlib import Path +from typing import Optional from ndf import contracts, identity from ndf.contracts import result @@ -29,6 +41,32 @@ # 結果 JSON の tool の名前(サブコマンドへ渡す前に止まったとき) TOOL = "cli" +# このプラグインの Python のパッケージの名前(`python -m` で打つ名前) +PACKAGE = __package__.partition(".")[0] +# このパッケージの保存先(`src`。子プロセスの import の道) +SRC = Path(__file__).resolve().parents[1] +# `ndf_command` の子の標準出力・標準エラーの文字コード。子の出力をパイプで読む側はこれで読む(`child_encoding`) +CHILD_ENCODING = "utf-8" +# `ndf_command` の子の標準出力・標準エラーの文字コードと誤りの扱い(既定。`keep_streams` なら呼び出し元の値を写す) +_CHILD_STREAMS = ((CHILD_ENCODING, "surrogateescape"), (CHILD_ENCODING, "backslashreplace")) + + +def _boot(streams: tuple[tuple[str, str], tuple[str, str]]) -> str: + """子プロセスの起動の 1 行(標準出力・標準エラーを `streams` の文字コードと誤りの扱いに決め直し、第 1 引数の `src` を + sys.path の頭へ入れ、残りの引数で `python -m ndf` と同じに走らせる)。ロケールの文字コードは変えない。""" + (out_enc, out_err), (err_enc, err_err) = streams + return ( + "import runpy, sys; " + f"sys.stdout and sys.stdout.reconfigure(encoding={out_enc!r}, errors={out_err!r}); " + f"sys.stderr and sys.stderr.reconfigure(encoding={err_enc!r}, errors={err_err!r}); " + f"sys.path.insert(0, sys.argv.pop(1)); runpy.run_module({PACKAGE!r}, run_name='__main__', alter_sys=True)" + ) + + +# `-I` が無視する UTF-8 モードの指定(`PYTHONUTF8`)。呼び出し元の値を `-X utf8=` で子へ写す +_UTF8_MODE_ENV = "PYTHONUTF8" +_UTF8_MODES = ("0", "1") + # サブコマンドの名前 → モジュールのパス COMMANDS: dict[str, str] = { "answer": "ndf.progress.gate", @@ -156,3 +194,36 @@ def _call(name: str, module: str, argv: list[str]) -> int: except Exception as exc: # サブコマンドが捕まえない例外も結果 JSON(stopped/unknown)で終える log.exception("サブコマンドが捕まえない例外で止まった: %s", name) return _stop(name, "unknown", f"{name} が捕まえない例外で止まった: {type(exc).__name__}: {exc}") + + +def ndf_command(*args: str, keep_streams: bool = False) -> list[str]: + """このプラグインのサブコマンドを子プロセスで打つ argv(同じ Python で `python -m ndf` と同じに走らせる)。 + + 自分の `src` は子の `sys.path` の頭へだけ入れ、環境変数(`PYTHONPATH`)には入れない(子孫のステップへ渡らない。#4029)。 + `-I` で作業ディレクトリと `PYTHON*` の環境変数(呼び出し元の `PYTHONPATH` とその道の `sitecustomize`)を import の道に + 入れない。環境変数そのものは子の `os.environ` に残る。 + + `-I` は `PYTHONUTF8`・`PYTHONIOENCODING` も無視するので、子の標準出力・標準エラーは起動の 1 行で決める。既定は + `CHILD_ENCODING`(ロケールや呼び出し元の指定で親子の文字コードが食い違わない。読む側は `child_encoding` で選ぶ)。 + `keep_streams` は今の標準出力・標準エラーの文字コードと誤りの扱いを写す(`os.execv` で自分を置き換えるとき。呼び出し元は + 置き換える前のプロセスの文字コードで読むため。`ndf answer work`)。ロケールの文字コードは変えず、`PYTHONUTF8` は + `-X utf8=` で写す(子の下のステップの出力は、従来どおり呼び出し元のロケールで読む。#4029)。""" + mode = os.environ.get(_UTF8_MODE_ENV) + utf8 = ["-X", f"utf8={mode}"] if mode in _UTF8_MODES else [] + streams = _current_streams() if keep_streams else _CHILD_STREAMS + return [sys.executable, "-I", *utf8, "-c", _boot(streams), str(SRC), *args] + + +def _current_streams() -> tuple[tuple[str, str], tuple[str, str]]: + """今の標準出力・標準エラーの文字コードと誤りの扱い(無いストリームは `_CHILD_STREAMS` の値)。""" + pairs = [] + for stream, fallback in zip((sys.stdout, sys.stderr), _CHILD_STREAMS): + encoding, errors = getattr(stream, "encoding", None), getattr(stream, "errors", None) + pairs.append((encoding, errors or fallback[1]) if encoding else fallback) + return pairs[0], pairs[1] + + +def child_encoding(argv: list[str]) -> Optional[str]: + """`argv` の出力を読む文字コード。`ndf_command` の子なら `CHILD_ENCODING`、ほかのコマンドは None(ロケールで読む)。""" + head = ndf_command() + return CHILD_ENCODING if argv[: len(head)] == head else None diff --git a/plugins/ndf/src/ndf/core/plan/queue_run.py b/plugins/ndf/src/ndf/core/plan/queue_run.py index 1e0ee6d15b..b4f52d7218 100644 --- a/plugins/ndf/src/ndf/core/plan/queue_run.py +++ b/plugins/ndf/src/ndf/core/plan/queue_run.py @@ -16,20 +16,17 @@ import json import os import subprocess -import sys from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait from dataclasses import dataclass from pathlib import Path from typing import Any, Optional from ndf.adapters import run_log +from ndf.cli import CHILD_ENCODING, ndf_command from ndf.contracts import result from ndf.contracts.exit_codes import GATE, OK, STOPPED from ndf.core.plan import files, model, queue_decide, runner, steps, wait_decide -# 子のプランを `python -m` で起動するパッケージ(プラグイン名から切り離した名前) -_PACKAGE = __name__.split(".")[0] - QUEUE_SUFFIX = ".queue" QUEUE_FILE = "queue.json" QUEUE_PRS = "queue_prs" @@ -84,7 +81,7 @@ def _outcome(entry: Entry, out: dict[str, Any]) -> queue_decide.Outcome: def _child_args(entry: Entry, sets: dict[str, str], fresh: bool = False) -> list[str]: - args = [sys.executable, "-m", _PACKAGE, "plan", "next", str(entry.path)] + args = ndf_command("plan", "next", str(entry.path)) if entry.start is not None: args += ["--from", entry.start] for name, value in sets.items(): @@ -191,7 +188,12 @@ def _launch(self, wave: list[Entry]) -> list[queue_decide.Outcome]: def _start(self, entry: Entry, sets: dict[str, str]) -> subprocess.Popen: return subprocess.Popen( - _child_args(entry, sets, self.options.fresh), cwd=self.cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True + _child_args(entry, sets, self.options.fresh), + cwd=self.cwd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + encoding=CHILD_ENCODING, + errors="replace", ) def _all_at_once(self, ready: list[tuple[Entry, dict[str, str]]]) -> dict[str, queue_decide.Outcome]: diff --git a/plugins/ndf/src/ndf/progress/gate/entry.py b/plugins/ndf/src/ndf/progress/gate/entry.py index 62c447eaab..5f59917ac2 100644 --- a/plugins/ndf/src/ndf/progress/gate/entry.py +++ b/plugins/ndf/src/ndf/progress/gate/entry.py @@ -101,7 +101,9 @@ def _cmd_work(argv: list[str], exec_: Callable[[str, list[str]], Any] = os.execv args = work_argv(a.kind, Path(a.state_dir), Path(a.cwd)) except model.Refused as exc: return result.emit(result.stopped(TOOL, "invalid", str(exc))) - argv = invoke.ndf_command("worker", *args) # -P: 作業場所の ndf.py・ndf/ をインストールしたパッケージより先に読まない + # -I: 作業場所と呼び出し元の PYTHONPATH の ndf.py・ndf/ を NDF の src より先に読まない。置き換えた先も、呼び出し元が読む + # 今の標準出力・標準エラーの文字コードで書く(プランのステップはロケールで読む。#4029) + argv = invoke.ndf_command("worker", *args, keep_streams=True) exec_(argv[0], argv) return 0 diff --git a/plugins/ndf/src/ndf/progress/invoke.py b/plugins/ndf/src/ndf/progress/invoke.py index d118d09a2b..747b4e3908 100644 --- a/plugins/ndf/src/ndf/progress/invoke.py +++ b/plugins/ndf/src/ndf/progress/invoke.py @@ -31,7 +31,6 @@ import json import os import subprocess -import sys from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field, replace from pathlib import Path @@ -40,6 +39,7 @@ from ndf import contracts, identity from ndf.adapters import claude, git, github from ndf.adapters.git import GitError +from ndf.cli import PACKAGE, child_encoding, ndf_command from ndf.contracts import facts, limits, result from ndf.core import durable, route from ndf.core.plan import cli as plan_cli @@ -72,10 +72,6 @@ # プランの実行の保存先に残す、回の打ち直しの数(`plan_attempt`)と、それを渡す差し込みの名前 ATTEMPT_FILE = "progress-attempt.json" ATTEMPT_SET = "progress_attempt" -# このプラグインの Python のパッケージの名前(`python -m` で打つ名前) -PACKAGE = __package__.partition(".")[0] -# このパッケージの保存先(`src`。子プロセスの import の道) -SRC = Path(__file__).resolve().parents[2] class StageInputError(Exception): @@ -147,7 +143,7 @@ class StageRun: again: bool = False def env(self, extra: Mapping[str, str]) -> dict[str, str]: - out = ndf_env({**os.environ, **extra}) + out = {**os.environ, **extra} if self.notes is not None: out[NOTES_ENV] = self.notes return out @@ -171,19 +167,6 @@ def cause(self) -> Optional[dict[str, Any]]: return held if isinstance(held, dict) else None -def ndf_command(*args: str) -> list[str]: - """このプラグインのサブコマンドを子プロセスで打つ argv(同じ Python で `-m ndf`。作業ディレクトリを import の道に入れない)。""" - return [sys.executable, "-P", "-m", PACKAGE, *args] - - -def ndf_env(env: Mapping[str, str]) -> dict[str, str]: - """子プロセスの環境変数。このパッケージの保存先(`src`)を `PYTHONPATH` の頭へ足す。""" - out = dict(env) - held = out["PYTHONPATH"] if "PYTHONPATH" in out else "" - out["PYTHONPATH"] = os.pathsep.join(p for p in (str(SRC), held) if p) - return out - - # 外部のコマンドを打つ関数(argv・作業ディレクトリ・環境変数 → 終了した子プロセス)。テストが差し替える Runner = Callable[[list[str], Path, dict[str, str]], "subprocess.CompletedProcess[str]"] @@ -203,7 +186,12 @@ def stage_inputs(environ: Mapping[str, str]) -> Optional[dict[str, Any]]: def run_command(argv: list[str], cwd: Path, env: dict[str, str]) -> subprocess.CompletedProcess[str]: - return subprocess.run(argv, cwd=cwd, env=env, capture_output=True, text=True, check=False) + """子を打ち、出力を読む。`ndf_command` の子は決めた文字コード(UTF-8)で、ほかのコマンド(script の外部スクリプト)は + 従来どおりロケールの文字コードで読む(#4029)。""" + encoding = child_encoding(argv) + if encoding is None: + return subprocess.run(argv, cwd=cwd, env=env, capture_output=True, text=True, check=False) + return subprocess.run(argv, cwd=cwd, env=env, capture_output=True, encoding=encoding, errors="replace", check=False) # --- 引数と値の形 -------------------------------------------------------------------------- diff --git a/plugins/ndf/src/ndf/progress/run.py b/plugins/ndf/src/ndf/progress/run.py index f499b8b52d..af2a63ce6d 100644 --- a/plugins/ndf/src/ndf/progress/run.py +++ b/plugins/ndf/src/ndf/progress/run.py @@ -22,7 +22,6 @@ import argparse import hashlib import json -import os import re import subprocess import time @@ -486,8 +485,7 @@ def launch_worker(st: store.Store, machine_id: str, cwd: Path) -> Optional[int]: log.parent.mkdir(parents=True, exist_ok=True) with log.open("a", encoding="utf-8") as out: argv = invoke.ndf_command(TOOL, "work", machine_id) - env = invoke.ndf_env(os.environ) - proc = subprocess.Popen(argv, cwd=cwd, env=env, stdin=subprocess.DEVNULL, stdout=out, stderr=out, start_new_session=True) + proc = subprocess.Popen(argv, cwd=cwd, stdin=subprocess.DEVNULL, stdout=out, stderr=out, start_new_session=True) return proc.pid diff --git a/plugins/ndf/tests/bin/test_start.py b/plugins/ndf/tests/bin/test_start.py index fba1842adc..1e2cc1de2f 100644 --- a/plugins/ndf/tests/bin/test_start.py +++ b/plugins/ndf/tests/bin/test_start.py @@ -7,6 +7,7 @@ import os import shutil import subprocess +import sys from pathlib import Path import pytest @@ -89,3 +90,112 @@ def test_the_entrypoint_stops_when_a_file_of_the_environment_is_gone(tmp_path): assert done.returncode == causes.exit_code("deps_missing") report = json.loads(done.stdout.strip().splitlines()[-1]) assert report["cause"]["kind"] == "deps_missing" and "tabulate" in report["cause"]["detail"] + + +# --- 呼び出し元の環境へ戻す(#4029) --- + +# bin/ndf と uv run が NDF の子孫へ足す変数(呼び出し元の値へ戻す) +ADDED = ("CLAUDE_PLUGIN_ROOT", "UV_PROJECT_ENVIRONMENT", "VIRTUAL_ENV", "UV_RUN_RECURSION_DEPTH", "PATH", "PYTHONPATH") + + +def test_the_callers_values_come_back_and_the_held_copies_go(start): + # bin/ndf が写した形: あった値(空も)は NDF_CALLER_<名前>、無かった値は写し無し。CLAUDE_PLUGIN_ROOT だけは空で「無かった」 + env = { + "CLAUDE_PLUGIN_ROOT": "/ndf", + "NDF_CALLER_PLUGIN_ROOT": "", + "UV_PROJECT_ENVIRONMENT": "/ndf-venv", + "NDF_CALLER_UV_PROJECT_ENVIRONMENT": "/caller-venv", + "VIRTUAL_ENV": "/ndf-venv", + "UV_RUN_RECURSION_DEPTH": "1", + "NDF_CALLER_UV_RUN_RECURSION_DEPTH": "", + "PATH": "/ndf-venv/bin:/usr/bin", + "NDF_CALLER_PATH": "/usr/bin", + "PYTHONPATH": "/ndf/src", + "NDF_CALLER_PYTHONPATH": "/caller-pp", + "HOME": "/home/x", + } + + start.restore_caller_env(env) + + assert env == { + "UV_PROJECT_ENVIRONMENT": "/caller-venv", + "UV_RUN_RECURSION_DEPTH": "", + "PATH": "/usr/bin", + "PYTHONPATH": "/caller-pp", + "HOME": "/home/x", + } + + +def test_another_plugins_root_comes_back_as_the_callers_value(start): + env = {"CLAUDE_PLUGIN_ROOT": "/ndf", "NDF_CALLER_PLUGIN_ROOT": "/other-plugin", "PATH": "/b", "NDF_CALLER_PATH": "/a"} + start.restore_caller_env(env) + assert env == {"CLAUDE_PLUGIN_ROOT": "/other-plugin", "PATH": "/a"} + + +def test_a_start_not_through_the_entrypoint_keeps_the_environment(start): + # 写しが 1 つも無い(bin/ndf を通らずに start.py を打った)ときは何も変えない + env = {"UV_PROJECT_ENVIRONMENT": "/v", "VIRTUAL_ENV": "/v", "PATH": "/v/bin", "PYTHONPATH": "/src"} + start.restore_caller_env(env) + assert env == {"UV_PROJECT_ENVIRONMENT": "/v", "VIRTUAL_ENV": "/v", "PATH": "/v/bin", "PYTHONPATH": "/src"} + + +def test_the_package_runs_after_the_environment_is_restored(start, monkeypatch): + monkeypatch.setattr(start.metadata, "distributions", lambda: []) + for name in ADDED: # 戻した後に monkeypatch がテストの前の値へ戻すよう、触る変数を記録させる + if name in os.environ: + monkeypatch.setenv(name, os.environ[name]) + monkeypatch.setenv("NDF_CALLER_PATH", "/caller") + seen = [] + monkeypatch.setattr(start.runpy, "run_module", lambda *a, **k: seen.append(os.environ["PATH"])) + assert start.main() == 0 + assert seen == ["/caller"] and "NDF_CALLER_PATH" not in os.environ + + +# uv run の代わり: uv run と同じく VIRTUAL_ENV・UV_RUN_RECURSION_DEPTH・PATH の先頭の venv の bin を足し、`python` の後を +# テストの python で打つ +_FAKE_UV_RUN = """#!/bin/sh +export VIRTUAL_ENV="$UV_PROJECT_ENVIRONMENT" UV_RUN_RECURSION_DEPTH=1 PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" +while [ "$1" != python ]; do shift; done +shift +exec "$FAKE_UV_PYTHON" "$@" +""" +_DUMP = "import json, os, sys; open(sys.argv[1], 'w').write(json.dumps(dict(os.environ)))" + + +@pytest.mark.parametrize( + "caller", + [ + {"UV_PROJECT_ENVIRONMENT": "/caller/env", "VIRTUAL_ENV": "/caller/venv", "PYTHONPATH": "/caller/pp"}, + {}, + ], + ids=["caller-has-values", "caller-has-none"], +) +def test_a_child_of_ndf_gets_the_callers_environment(tmp_path, caller): + """#4029 の再現: NDF が起動した子(プランのステップ)の環境に、NDF が足した UV_PROJECT_ENVIRONMENT・VIRTUAL_ENV・ + UV_RUN_RECURSION_DEPTH・CLAUDE_PLUGIN_ROOT が無く、PATH の先頭が NDF の venv の bin でなく、PYTHONPATH に NDF の + src が無い。呼び出し元が元から持っていた値は残る。""" + import git_sandbox + + fake = tmp_path / "fake" + fake.mkdir() + (fake / "uv").write_text(_FAKE_UV_RUN) + (fake / "uv").chmod(0o755) + repo = tmp_path / "repo" + repo.mkdir() + git_sandbox.sh(repo, "init", "-q", identity=True) + git_sandbox.sh(repo, "commit", "-q", "--allow-empty", "-m", "init", identity=True) + dump = tmp_path / "child-env.json" + plan = repo / "plan.json" + plan.write_text(json.dumps({"name": "p", "repo": str(repo), "steps": [{"id": "s", "run": [sys.executable, "-c", _DUMP, str(dump)]}]})) + env = {k: v for k, v in os.environ.items() if k not in ADDED and not k.startswith("NDF_CALLER_")} + env |= {"PATH": f"{fake}{os.pathsep}{os.environ['PATH']}", "FAKE_UV_PYTHON": sys.executable, **caller} + env.pop("NDF_PROGRESS_DB", None) + + done = subprocess.run( + [str(ROOT / "bin" / "ndf"), "plan", "next", str(plan)], cwd=repo, env=env, capture_output=True, text=True, check=False, timeout=300 + ) + + assert done.returncode == 0, done.stdout + done.stderr + child = json.loads(dump.read_text()) + assert {k: child.get(k) for k in ADDED} == {k: env.get(k) for k in ADDED} + assert not [k for k in child if k.startswith("NDF_CALLER_")] diff --git a/plugins/ndf/tests/cli/test_cli.py b/plugins/ndf/tests/cli/test_cli.py index 0a77e450b4..549249a342 100644 --- a/plugins/ndf/tests/cli/test_cli.py +++ b/plugins/ndf/tests/cli/test_cli.py @@ -303,6 +303,45 @@ def test_entrypoint_passes_the_callers_plugin_root_on(tmp_path): assert done.stdout.splitlines() == [str(other), str(PLUGIN_ROOT)] +_HELD = ("UV_PROJECT_ENVIRONMENT", "VIRTUAL_ENV", "UV_RUN_RECURSION_DEPTH", "PATH", "PYTHONPATH") + + +def test_entrypoint_holds_the_callers_values_and_points_uv_at_its_own_venv(tmp_path): + """#4029: 子へ自分の値を入れる前に、呼び出し元の値を NDF_CALLER_<名前> へ写す(空も写し、無ければ写しを消す。外側の ndf の + 古い写しを残さない)。NDF の子が `ndf` を打っても、毎回 NDF の venv を指して uv を起動する。""" + fake_dir = tmp_path / "fake" + fake_dir.mkdir() + uv = fake_dir / "uv" + names = [*_HELD, *(f"NDF_CALLER_{n}" for n in _HELD)] + uv.write_text("#!/bin/sh\n" + "".join(f'echo "{n}=${{{n}-}}"\n' for n in names)) + uv.chmod(0o755) + path = f"{fake_dir}{os.pathsep}{os.environ['PATH']}" + cache = tmp_path / "cache" + env = {k: v for k, v in os.environ.items() if k not in _HELD and not k.startswith("NDF_CALLER_")} + env |= { + "PATH": path, + "XDG_CACHE_HOME": str(cache), + "UV_PROJECT_ENVIRONMENT": "/caller/env", # 呼び出し元のリポジトリの環境(NDF の子の中で打ったとき) + "UV_RUN_RECURSION_DEPTH": "", + "NDF_CALLER_VIRTUAL_ENV": "/stale/from/outer/ndf", + } + + done = subprocess.run([str(PLUGIN_ROOT / "bin" / "ndf")], env=env, capture_output=True, text=True, check=False) + + assert done.returncode == 0, done.stderr + got = dict(line.split("=", 1) for line in done.stdout.splitlines()) + manifest = json.loads((PLUGIN_ROOT / ".claude-plugin" / "plugin.json").read_text(encoding="utf-8")) + assert got["UV_PROJECT_ENVIRONMENT"] == str(cache / manifest["name"] / "venv" / manifest["version"]) + assert got["PYTHONPATH"] == str(PLUGIN_ROOT / "src") + assert {n: got[f"NDF_CALLER_{n}"] for n in _HELD} == { + "UV_PROJECT_ENVIRONMENT": "/caller/env", + "VIRTUAL_ENV": "", + "UV_RUN_RECURSION_DEPTH": "", + "PATH": path, + "PYTHONPATH": "", + } + + @pytest.mark.skipif(shutil.which("uv") is None, reason="uv が要る") def test_entrypoint_does_not_import_from_callers_directory(tmp_path): # 呼び出し元のディレクトリに置かれた同じ名前のパッケージを読まない @@ -329,3 +368,31 @@ def test_every_subcommand_reports_its_table_name_as_tool(): def test_tool_of_rejects_a_module_outside_the_table(): with pytest.raises(LookupError): cli.tool_of("ndf.no_such_command") + + +def test_ndf_command_imports_its_own_src_without_putting_it_on_pythonpath(tmp_path): + """#4029: `ndf_command` の子は PYTHONPATH が無くても自分の src を読み、呼び出し元の道と作業ディレクトリにある同じ名前の + パッケージを読まない。子の環境の PYTHONPATH は呼び出し元の値のまま(src を足さない)。""" + own = tmp_path / "callers" + (own / "ndf").mkdir(parents=True) + (own / "ndf" / "__init__.py").write_text("raise ImportError('呼び出し元の ndf を読んだ')\n", encoding="utf-8") + (tmp_path / "ndf").mkdir() + (tmp_path / "ndf" / "__init__.py").write_text("raise ImportError('作業ディレクトリの ndf を読んだ')\n", encoding="utf-8") + argv = cli.ndf_command("--help") + assert str(cli.SRC) in argv + for env in ({k: v for k, v in os.environ.items() if k != "PYTHONPATH"}, {**os.environ, "PYTHONPATH": str(own)}): + done = subprocess.run(argv, cwd=tmp_path, env=env, capture_output=True, text=True, timeout=60, check=False) + assert done.returncode == 0 and "呼び出し元" not in done.stderr and "作業ディレクトリ" not in done.stderr, done.stderr + + +def test_ndf_command_does_not_let_a_callers_sitecustomize_load_its_own_ndf(tmp_path): + """#4029: 呼び出し元の PYTHONPATH にある sitecustomize が同じ名前のパッケージを import しても、子は NDF の src を走らせる + (子の下のステップが呼び出し元の PYTHONPATH を受けることは test_queue_run が確かめる)。""" + own = tmp_path / "callers" + (own / "ndf").mkdir(parents=True) + (own / "ndf" / "__init__.py").write_text("", encoding="utf-8") + (own / "ndf" / "__main__.py").write_text("print('CALLERS_NDF')\n", encoding="utf-8") + (own / "sitecustomize.py").write_text("import ndf\n", encoding="utf-8") + env = {**os.environ, "PYTHONPATH": str(own)} + done = subprocess.run(cli.ndf_command("--help"), cwd=tmp_path, env=env, capture_output=True, text=True, timeout=60, check=False) + assert done.returncode == 0 and "CALLERS_NDF" not in done.stdout, (done.stdout, done.stderr) diff --git a/plugins/ndf/tests/core/plan/test_queue_run.py b/plugins/ndf/tests/core/plan/test_queue_run.py index 96cd0b1c89..48329a7cb0 100644 --- a/plugins/ndf/tests/core/plan/test_queue_run.py +++ b/plugins/ndf/tests/core/plan/test_queue_run.py @@ -3,6 +3,7 @@ from __future__ import annotations import json +import os import sys import threading from pathlib import Path @@ -10,12 +11,20 @@ import git_sandbox import pytest +from ndf import cli +from ndf.cli import ndf_command from ndf.core.plan import model, queue_run from . import _plan_helpers as H _WRITE = "import pathlib, sys; pathlib.Path(sys.argv[1]).write_text(sys.argv[2])" +# start.py と同じ親の起動(`-P` で環境の文字コードの指定を受け、src を sys.path にだけ入れて `python -m ndf` と同じに走らせる) +_START = "import runpy, sys; sys.path.insert(0, sys.argv.pop(1)); runpy.run_module('ndf', run_name='__main__', alter_sys=True)" + + +def _like_start(*args: str) -> list[str]: + return [sys.executable, "-P", "-c", _START, str(cli.SRC), *args] def _gate_with_pr(sid: str, number: int) -> dict: @@ -81,6 +90,86 @@ def test_resume_skips_the_finished_plans(repo, tmp_path): assert H.count(tmp_path / "a") == 1 +@pytest.mark.parametrize("caller", [None, "own"], ids=["no-pythonpath", "callers-pythonpath"]) +def test_a_queue_step_keeps_the_callers_pythonpath(repo, tmp_path, caller): + """#4029: bin/start.py が PYTHONPATH を呼び出し元の値へ戻した後も、キューの子の `ndf plan next` が ndf を import でき、 + その下のステップは呼び出し元の PYTHONPATH をそのまま受ける(NDF の src を足さない)。呼び出し元の道に同じ名前の + パッケージがあっても、NDF の子は自分の src を読む。親は start.py が戻した後の形(sys.path にだけ src)で走らせる。""" + import subprocess + + env = {k: v for k, v in os.environ.items() if k != "PYTHONPATH"} + env.pop("NDF_PROGRESS_DB", None) + if caller is not None: + own = tmp_path / "callers" + (own / "ndf").mkdir(parents=True) + (own / "ndf" / "__init__.py").write_text("raise ImportError('呼び出し元の ndf を読んだ')\n", encoding="utf-8") + env["PYTHONPATH"] = str(own) + seen = tmp_path / "seen.json" + code = f"import json, os, pathlib; pathlib.Path({str(seen)!r}).write_text(json.dumps(os.environ.get('PYTHONPATH')))" + a = H.write_plan(repo, "a", [H.py_step("s", code)], touches=["a.py"]) + done = subprocess.run(ndf_command("plan", "queue", a), cwd=repo, env=env, capture_output=True, text=True, timeout=180) + out = json.loads(done.stdout.strip().splitlines()[-1]) + assert out["status"] == "ok", (out, done.stderr) + assert json.loads(seen.read_text()) == env.get("PYTHONPATH") + + +def test_a_queue_reads_a_japanese_child_result_under_an_ascii_locale(repo, tmp_path): + """#4029: 子は `-I` で `PYTHONUTF8`・`PYTHONIOENCODING` を受けないので、結果のパイプは親子とも UTF-8 に決めてある。 + C ロケールで親が ASCII を出す環境でも、キューは日本語の要約を含む子の結果 JSON を回収できる。""" + import subprocess + + if not all(str(p).isascii() for p in (sys.executable, sys.prefix, repo)): + pytest.skip("C ロケールの Python は ASCII でないパスの venv・作業場所を扱えない") + env = {k: v for k, v in os.environ.items() if k != "PYTHONPATH"} + env.pop("NDF_PROGRESS_DB", None) + env.update(LC_ALL="C", LANG="C", PYTHONUTF8="0", PYTHONIOENCODING="ascii:backslashreplace") + a = H.write_plan(repo, "a", [H.py_step("s", r"print('\u65e5\u672c\u8a9e')")], touches=["a.py"]) + parent = _like_start("plan", "queue", a) + done = subprocess.run(parent, cwd=repo, env=env, capture_output=True, timeout=180) + assert done.stdout.strip(), done.stderr.decode("ascii", "replace")[-2000:] + out = json.loads(done.stdout.decode("ascii").strip().splitlines()[-1]) + assert out["status"] == "ok" and not out["summary"].isascii(), (out, done.stderr.decode("utf-8", "replace")) + + +def test_a_queue_reads_step_and_probe_outputs_in_the_callers_locale(repo, tmp_path): + """#4029: キューの子の標準入出力だけを UTF-8 に決め、ロケールの文字コードは変えない。EUC-JP のロケールで日本語を出す + `probe` と `run` の出力を子は従来どおりロケールで読み、ステップが返した止まった種類がキューの結果まで届く(読めなければ + 子が例外で unknown に止まる)。""" + import subprocess + + import eucjp_locale + + env = eucjp_locale.environ(tmp_path / "locale") + probe = [sys.executable, "-c", "import sys; print('まだ済んでいない'); sys.exit(1)"] + line = json.dumps({"tool": "t", "status": "stopped", "cause": {"kind": "precondition"}, "summary": "日本語の理由"}, ensure_ascii=False) + a = H.write_plan(repo, "a", [H.py_step("s", f"print({line!r})", probe=probe)], touches=["a.py"]) + done = subprocess.run(_like_start("plan", "queue", a), cwd=repo, env=env, capture_output=True, timeout=180) + err = done.stderr.decode(eucjp_locale.ENCODING, "replace")[-2000:] + assert done.stdout.strip(), err + out = json.loads(done.stdout.decode(eucjp_locale.ENCODING).strip().splitlines()[-1]) + assert out["cause"]["kind"] == "precondition", (out, err) + + +def test_a_queue_reads_the_worker_result_of_answer_work_in_the_callers_locale(repo, tmp_path): + """#4029: `ndf answer work` は `ndf worker run` へ自分を置き換える。置き換えた先も呼び出し元の標準出力の文字コードで + 書くので、EUC-JP のロケールのキューのステップは日本語の要約を含む worker の結果 JSON を読み、その止まった種類(作業の本文が + 無いので invalid)がキューの結果まで届く(UTF-8 で書けば読めずに unknown で止まる)。""" + import subprocess + + import eucjp_locale + + env = eucjp_locale.environ(tmp_path / "locale") + state = tmp_path / "state" + state.mkdir() + work = {"id": "w", "run": _like_start("answer", "work", "--state-dir", str(state), "--cwd", str(repo), "impl")} + a = H.write_plan(repo, "a", [work], touches=["a.py"]) + done = subprocess.run(_like_start("plan", "queue", a), cwd=repo, env=env, capture_output=True, timeout=180) + err = done.stderr.decode(eucjp_locale.ENCODING, "replace")[-2000:] + assert done.stdout.strip(), err + out = json.loads(done.stdout.decode(eucjp_locale.ENCODING).strip().splitlines()[-1]) + assert out["cause"]["kind"] == "invalid", (out, err) + + # --- 現状固定テスト: `queue_run.run` を同じプロセスで流す(子の `ndf plan next` を偽の Popen に置き換える) --- @@ -92,12 +181,14 @@ def __init__(self, outputs: dict[str, object]): self.log: list[tuple[str, str]] = [] self.args: dict[str, list[str]] = {} self.cwds: dict[str, object] = {} + self.envs: dict[str, dict] = {} - def __call__(self, args, cwd=None, **_kw): - name = Path(args[5]).stem + def __call__(self, args, cwd=None, env=None, **_kw): + name = Path(args[args.index("next") + 1]).stem self.log.append(("start", name)) self.args[name] = list(args) self.cwds[name] = cwd + self.envs[name] = env return _FakeProc(self, name) @@ -276,7 +367,8 @@ def test_run_fills_queue_prs_from_the_prior_stage(tmp_path, children): outs = queue_run.run([[a, r], [b]], tmp_path / "q", tmp_path, queue_run.QueueOptions()) assert [o.status for o in outs] == ["ok", "ok", "ok"] assert fake.args["b"][-2:] == ["--set", "queue_prs=11 12"] - assert fake.args["a"] == [sys.executable, "-m", "ndf", "plan", "next", str(tmp_path / "a.json")] + assert fake.args["a"] == ndf_command("plan", "next", str(tmp_path / "a.json")) + assert fake.envs["a"] is None # 環境は呼び出し元のまま(src を PYTHONPATH へ入れない。#4029) def test_run_stops_a_queue_prs_plan_without_prs(tmp_path, children): diff --git a/plugins/ndf/tests/progress/gate/test_gate_work.py b/plugins/ndf/tests/progress/gate/test_gate_work.py index 532127f21f..b92990dd33 100644 --- a/plugins/ndf/tests/progress/gate/test_gate_work.py +++ b/plugins/ndf/tests/progress/gate/test_gate_work.py @@ -7,6 +7,7 @@ import pytest +from ndf import cli from ndf.contracts import causes, result from ndf.core import route, worker from ndf.progress import gate, model @@ -30,7 +31,9 @@ def test_an_unknown_work_name_stops_as_invalid(tmp_path, capsys): def test_ndf_answer_work_hands_the_arguments_to_worker_run(): got: list[list[str]] = [] code = gate._cmd_work(["--state-dir", "/s", "--cwd", "/w", "fix"], lambda exe, argv: got.append(argv)) - assert code == 0 and got[0][1:5] == ["-P", "-m", "ndf", "worker"] and got[0][5:] == gate.work_argv("fix", Path("/s"), Path("/w")) + # #4029: src は置き換えた先の argv(sys.path)で渡す。PYTHONPATH には入れない。標準出力の文字コードは今のものを写す + want = cli.ndf_command("worker", *gate.work_argv("fix", Path("/s"), Path("/w")), keep_streams=True) + assert code == 0 and got[0] == want def test_the_template_worker_has_no_default_until_prompts_are_written(): diff --git a/plugins/ndf/tests/progress/test_invoke.py b/plugins/ndf/tests/progress/test_invoke.py index 1e1cb08562..33fdad76da 100644 --- a/plugins/ndf/tests/progress/test_invoke.py +++ b/plugins/ndf/tests/progress/test_invoke.py @@ -12,6 +12,7 @@ import sprint_fixture from sprint_fixture import sprint_repo as _sprint_repo +from ndf import cli from ndf.adapters import github from ndf.contracts import result from ndf.core import route @@ -174,7 +175,7 @@ def test_plan_argv_passes_inputs_and_the_answer(tmp_path, monkeypatch): assert argv[argv.index("--state-dir") + 1] == str(tmp_path) assert argv[argv.index("--set") + 1] == "issues=[1, 2]" assert argv[-2:] == ["--answer", "approved"] - assert argv[1] == "-P" + assert argv[1] == "-I" def test_every_plan_a_stage_calls_has_a_route_template(): @@ -808,7 +809,9 @@ def runner(argv, cwd, env): run = invoke.StageRun(**{**vars(_plan_run({"issues": [1]})), "outputs": ("worktree", "branch"), "notes": "直す所"}) got = invoke.invoke(run, tmp_path, tmp_path / "w", runner=runner) assert got.outputs == {"worktree": "/w", "branch": "sprint/s"} - assert str(invoke.SRC) in seen["env"]["PYTHONPATH"].split(os.pathsep) + # #4029: src は子の argv(sys.path)で渡し、PYTHONPATH には入れない(プランのステップへ渡らない) + assert seen["argv"][: len(cli.ndf_command())] == cli.ndf_command() + assert seen["env"].get("PYTHONPATH") == os.environ.get("PYTHONPATH") assert seen["env"][invoke.NOTES_ENV] == "直す所" assert (tmp_path / "w").is_dir() @@ -955,3 +958,34 @@ def test_skill_answer_keeps_only_declared_outputs(tmp_path, calls): got = invoke.invoke(_skill_run(), tmp_path, tmp_path, call_claude=fake) # outputs のキーは文脈の閉じた語彙なので、設定に無いキーは語彙の中の別のキーで確かめる assert got.outputs == {"pr": 3} and got.warnings and "branch" in got.warnings[0] + + +_READ_BOTH = """ +import json, os, sys +from pathlib import Path +src, script = sys.argv[1:3] +sys.path.insert(0, src) +from ndf import cli +from ndf.progress import invoke +ext = invoke.run_command([sys.executable, "-c", script], Path.cwd(), dict(os.environ)) +own = invoke.run_command(cli.ndf_command("plan", "next", "missing.json"), Path.cwd(), dict(os.environ)) +print(json.dumps({"ext": ext.stdout, "own": own.stdout})) +""" + + +def test_run_command_reads_external_scripts_in_the_locale_and_ndf_children_in_utf8(tmp_path): + """#4029: `ndf_command` の子だけを UTF-8 で読み、script の外部スクリプトの結果 JSON は従来どおりロケールの文字コード + (EUC-JP)で読む。日本語のパスが置換文字に変わらない。""" + import sys + + import eucjp_locale + + env = eucjp_locale.environ(tmp_path / "locale") + report = "import json; print(json.dumps({'tool': 't', 'status': 'ok', 'summary': 's', 'outputs': {'path': '/作業/日本語'}}, ensure_ascii=False))" + argv = [sys.executable, "-P", "-c", _READ_BOTH, str(cli.SRC), report.encode(eucjp_locale.ENCODING)] # 子はロケールで argv を読む + done = subprocess.run(argv, cwd=tmp_path, env=env, capture_output=True, timeout=120, check=False) + assert done.stdout.strip(), done.stderr.decode(eucjp_locale.ENCODING, "replace")[-2000:] + got = json.loads(done.stdout.decode("ascii").strip().splitlines()[-1]) + assert json.loads(got["ext"])["outputs"] == {"path": "/作業/日本語"}, done.stderr.decode(eucjp_locale.ENCODING, "replace") + own = got["own"].strip().splitlines()[-1] + assert "�" not in own and not own.isascii(), got diff --git a/plugins/ndf/tests/support/eucjp_locale.py b/plugins/ndf/tests/support/eucjp_locale.py new file mode 100644 index 0000000000..433ae2036e --- /dev/null +++ b/plugins/ndf/tests/support/eucjp_locale.py @@ -0,0 +1,39 @@ +"""非 UTF-8 のロケール(`ja_JP.eucJP`)を使い捨ての保存先に作り、その環境変数を返す(#4029)。 + +`localedef` で `LOCPATH` の下へ作るので、システムのロケールを入れなくてよい。`localedef` か元データが無ければテストを飛ばす。 +`tests/core/plan/test_queue_run.py` と `tests/progress/test_invoke.py` が使う。 +""" + +from __future__ import annotations + +import os +import shutil +import subprocess +import sys +from pathlib import Path + +import pytest + +NAME = "ja_JP.eucJP" +ENCODING = "euc_jp" + + +def environ(root: Path) -> dict[str, str]: + """`root` の下に `ja_JP.eucJP` を作り、それを使う環境変数(`PYTHONPATH`・UTF-8 モードの指定・ASCII でない値を外した写し)を返す。""" + if shutil.which("localedef") is None: + pytest.skip("localedef が無い") + if not all(str(p).isascii() for p in (sys.executable, sys.prefix, root)): + pytest.skip("ASCII でないパスは EUC-JP のロケールで読み違える") + root.mkdir(parents=True, exist_ok=True) + done = subprocess.run(["localedef", "-i", "ja_JP", "-f", "EUC-JP", str(root / NAME)], capture_output=True, text=True, check=False) + if not (root / NAME).is_dir(): + pytest.skip(f"ja_JP.eucJP を作れない: {done.stderr[-500:]}") + dropped = ("PYTHONPATH", "PYTHONUTF8", "PYTHONIOENCODING", "NDF_PROGRESS_DB") + # UTF-8 の日本語を持つ値(呼び出し元のパスなど)は EUC-JP のロケールの子へ渡せないので外す + env = {k: v for k, v in os.environ.items() if k not in dropped and v.isascii()} + env.update(LOCPATH=str(root), LC_ALL=NAME, LANG=NAME) + check = [sys.executable, "-c", "import locale; print(locale.getpreferredencoding(False))"] + got = subprocess.run(check, env=env, capture_output=True, text=True, check=False).stdout.strip() + if got.replace("-", "_").lower() != ENCODING: + pytest.skip(f"ja_JP.eucJP のロケールが効かない({got})") + return env