diff --git a/loopx/cli_commands/extension.py b/loopx/cli_commands/extension.py index 14cedbb5a3..77b86ce0af 100644 --- a/loopx/cli_commands/extension.py +++ b/loopx/cli_commands/extension.py @@ -21,6 +21,7 @@ run_standalone_extension, ) from ..extensions.scaffold import scaffold_extension +from ..paths import effective_runtime_root PrintPayload = Callable[ [dict[str, object], str, Callable[[dict[str, object]], str]], @@ -61,10 +62,14 @@ def _render(payload: dict[str, object]) -> str: return "\n".join(lines) + "\n" -def _state_file(args: argparse.Namespace, runtime_root_arg: str | None) -> Path: +def _state_file( + args: argparse.Namespace, runtime_root_arg: str | None, *, registry_path: Path, +) -> Path: override = getattr(args, "extension_state_file", None) if override: return Path(override).expanduser() + if runtime_root_arg is None: + runtime_root_arg = str(effective_runtime_root(registry_path, None)) return default_extension_state_file(runtime_root_arg) @@ -201,13 +206,14 @@ def _load_json_object(path_text: str) -> dict[str, object]: def handle_extension_command( args: argparse.Namespace, *, + registry_path: Path, runtime_root_arg: str | None, output_format: FormatSelector, print_payload: PrintPayload, ) -> int | None: if args.command != "extension": return None - state_file = _state_file(args, runtime_root_arg) + state_file = _state_file(args, runtime_root_arg, registry_path=registry_path) try: if args.extension_command == "init": payload = scaffold_extension( diff --git a/loopx/cli_runtime.py b/loopx/cli_runtime.py index 6cbd890bc8..3579b126dd 100644 --- a/loopx/cli_runtime.py +++ b/loopx/cli_runtime.py @@ -699,7 +699,7 @@ def _dispatch_common_command( from .cli_commands.extension import handle_extension_command return handle_extension_command( - args, runtime_root_arg=args.runtime_root, + args, registry_path=registry_path, runtime_root_arg=args.runtime_root, output_format=output_format, print_payload=print_payload, ) if args.command == "slash-commands": diff --git a/tests/extensions/test_extension_readiness_contexts.py b/tests/extensions/test_extension_readiness_contexts.py index c714edcb13..b59b265229 100644 --- a/tests/extensions/test_extension_readiness_contexts.py +++ b/tests/extensions/test_extension_readiness_contexts.py @@ -7,6 +7,8 @@ import subprocess import sys +import pytest + from tests.control_plane import test_refresh_external_delivery as settlement_fixtures from tests.control_plane.test_quota_settlement_cli import AGENT_ID, GOAL_ID, TODO_ID, TURN_ID from loopx.extensions.lark.goal_channel_contracts import ( @@ -139,6 +141,113 @@ def test_legacy_single_proof_is_read_only_then_migrated_by_real_doctor(tmp_path: assert extension_status(state_file=state_file)["extensions"][0]["doctor_verified"] +@pytest.mark.parametrize("selection", ["registry", "environment"]) +def test_real_extension_cli_follows_selected_registry_with_conflicting_defaults( + tmp_path: Path, selection: str, +) -> None: + home = tmp_path / "home" + defaults = [home / ".loopx", home / ".codex" / "loopx"] + for root in defaults: + root.mkdir(parents=True) + (root / "preserve.txt").write_text("existing independent state") + project = tmp_path / "project" + registry = project / ".loopx" / "registry.json" + registry.parent.mkdir(parents=True) + registry.write_text(json.dumps({"goals": [], "common_runtime_root": "selected state"})) + runtime = project / "selected state" + context = tmp_path / "unrelated working directory" + context.mkdir() + (context / f"{MODULE}.py").write_text("raise SystemExit(0)\n") + manifest = _manifest(tmp_path / "extension.toml") + repo = Path(__file__).resolve().parents[2] + environment = { + key: value for key, value in os.environ.items() + if not key.startswith(("LOOPX_", "PYTHON", "CODEX_")) + } + environment.update( + HOME=str(home), PYTHONPATH=os.pathsep.join((str(context), str(repo))), + LOOPX_USAGE_PING="0", DO_NOT_TRACK="1", + ) + prefix = [sys.executable, "-c", "from loopx.entrypoint import main; raise SystemExit(main())", + "--format", "json"] + + def run(*args: str, env: dict | None = None) -> dict: + result = subprocess.run( + [*prefix, *args], cwd=context, env=env or environment, + capture_output=True, text=True, timeout=30, + ) + assert result.returncode == 0, result.stderr + return json.loads(result.stdout) + + installed = run("--runtime-root", str(runtime), "extension", "install", + "--manifest", str(manifest), "--execute") + assert installed["doctor"]["verified"] is True + state = runtime / "extensions" / "state.json" + before = state.read_bytes() + route = ["--registry", str(registry)] if selection == "registry" else [] + selected_env = {**environment, "LOOPX_REGISTRY": str(registry)} + listed = run(*route, "extension", "list", env=selected_env if not route else None) + assert [item["id"] for item in listed["extensions"]] == [EXTENSION_ID] + assert listed["extensions"][0]["doctor_verified"] is True + assert state.read_bytes() == before + checked = run(*route, "extension", "doctor", "--all-enabled", "--execute", + env=selected_env if not route else None) + assert checked["status"] == "ready" and checked["verified_count"] == 1 + for root in defaults: + assert sorted(path.name for path in root.iterdir()) == ["preserve.txt"] + assert (root / "preserve.txt").read_text() == "existing independent state" + + +@pytest.mark.parametrize("override", ["runtime-root", "state-file"]) +def test_real_extension_cli_explicit_storage_does_not_open_unused_registry( + tmp_path: Path, override: str, +) -> None: + registry = tmp_path / "unreadable-registry.json" + registry.write_text("not registry JSON") + state = tmp_path / "selected" / "extensions" / "state.json" + state.parent.mkdir(parents=True) + state.write_text(json.dumps({"schema_version": "loopx_extension_state_v0", "extensions": {}})) + prefix = ["--runtime-root", str(state.parent.parent)] if override == "runtime-root" else [] + suffix = ["--state-file", str(state)] if override == "state-file" else [] + environment = {key: value for key, value in os.environ.items() + if not key.startswith(("LOOPX_", "PYTHON", "CODEX_"))} + environment.update(LOOPX_USAGE_PING="0", DO_NOT_TRACK="1", + PYTHONPATH=str(Path(__file__).resolve().parents[2])) + before = {path: path.read_bytes() for path in (registry, state)} + result = subprocess.run( + [sys.executable, "-c", "from loopx.entrypoint import main; raise SystemExit(main())", + "--format", "json", "--registry", str(registry), *prefix, + "extension", "list", *suffix], + cwd=tmp_path, env=environment, capture_output=True, text=True, timeout=30, + ) + assert result.returncode == 0, result.stderr + assert json.loads(result.stdout)["extensions"] == [] + assert {path: path.read_bytes() for path in before} == before + + +def test_real_extension_cli_does_not_choose_between_conflicting_defaults(tmp_path: Path) -> None: + home = tmp_path / "home" + for relative in (".loopx", ".codex/loopx"): + root = home / relative + root.mkdir(parents=True) + (root / "preserve.txt").write_text("independent state") + environment = {key: value for key, value in os.environ.items() + if not key.startswith(("LOOPX_", "PYTHON", "CODEX_"))} + environment.update(HOME=str(home), LOOPX_USAGE_PING="0", DO_NOT_TRACK="1", + PYTHONPATH=str(Path(__file__).resolve().parents[2])) + before = {str(path.relative_to(home)): path.read_bytes() + for path in home.rglob("*") if path.is_file()} + result = subprocess.run( + [sys.executable, "-c", "from loopx.entrypoint import main; raise SystemExit(main())", + "--format", "json", "extension", "doctor", "--all-enabled", "--execute"], + cwd=tmp_path, env=environment, capture_output=True, text=True, timeout=30, + ) + assert result.returncode != 0 + assert "Both default LoopX runtime roots contain state" in result.stderr + assert {str(path.relative_to(home)): path.read_bytes() + for path in home.rglob("*") if path.is_file()} == before + + settlement_session = settlement_fixtures.session