relay-codex 0.4.1 → 0.5.0

package/tests/test_features.py

@@ -0,0 +1,350 @@
+"""Local management and native-option behavior, with isolated state."""
+
+import asyncio
+import contextlib
+import io
+import json
+import os
+from pathlib import Path
+import plistlib
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from unittest.mock import patch
+
+from launch import backend_arguments, native_mode, prepare_worktree, translate
+from pool import Pool
+from router import parse_arguments
+from settings import atomic_json
+import commands
+import desktop
+import execution
+import tools
+
+
+class ManagementTests(unittest.TestCase):
+    def test_profile_layer_and_explicit_config_precedence(self):
+        with tempfile.TemporaryDirectory() as folder:
+            home = Path(folder)
+            (home / "work.config.toml").write_text(
+                'model="profile-model"\n[features]\nexample=true\n'
+            )
+            with patch.dict(os.environ, {"CODEX_HOME": folder}):
+                args = backend_arguments(["-pwork", "-c", 'model="explicit-model"'])
+                self.assertEqual(args[-2:], ["-c", 'model="explicit-model"'])
+                self.assertIn('model="profile-model"', args)
+                self.assertIn("features.example=true", args)
+                self.assertEqual(
+                    translate(["resume", "-pwork", "--add-dir", "/tmp"])[0], ["resume"]
+                )
+                with self.assertRaises(ValueError):
+                    backend_arguments(["-p", "../outside"])
+                self.assertFalse(native_mode(["resume", "-pwork", "--add-dir=/tmp"]))
+
+    def test_background_cd_resolves_against_supplied_directory(self):
+        with tempfile.TemporaryDirectory() as folder:
+            root = Path(folder).resolve()
+            (root / "child").mkdir()
+            cwd, settings, backend = __import__("service").headless_options(
+                ["-Cchild", "-mtest", "-c", "features.x=true"], str(root)
+            )
+            self.assertEqual(cwd, str(root / "child"))
+            self.assertEqual(settings["model"], "test")
+            self.assertEqual(backend[-2:], ["-c", "features.x=true"])
+
+    def test_real_git_worktree_is_separate_and_resume_combination_is_rejected(self):
+        with tempfile.TemporaryDirectory() as folder:
+            root = Path(folder).resolve()
+            repo = root / "repo"
+            state = root / "state"
+            repo.mkdir()
+            state.mkdir()
+            subprocess.run(["git", "init", "-q", str(repo)], check=True)
+            subprocess.run(
+                [
+                    "git",
+                    "-C",
+                    str(repo),
+                    "-c",
+                    "user.name=Test",
+                    "-c",
+                    "user.email=test@example.invalid",
+                    "commit",
+                    "--allow-empty",
+                    "-qm",
+                    "test",
+                ],
+                check=True,
+            )
+            args, cwd = prepare_worktree(["--worktree", "hello"], state, str(repo))
+            self.assertNotEqual(cwd, str(repo))
+            self.assertTrue((Path(cwd) / ".git").exists())
+            self.assertNotIn("--worktree", args)
+            with self.assertRaises(ValueError):
+                prepare_worktree(["resume", "--worktree"], state, str(repo))
+
+    def test_account_emails_are_displayed_and_resolve_without_reading_tokens(self):
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder)
+            home = state / "accounts" / "account1"
+            home.mkdir(parents=True)
+            atomic_json(home / "enrolled", {"identity": "synthetic"})
+            atomic_json(home / "identity.json", {"email": "person@example.invalid"})
+            with patch(
+                "router.read_keychain",
+                side_effect=AssertionError("Status must not read Keychain"),
+            ):
+                result = commands.snapshot(state)
+                self.assertEqual(
+                    result["accounts"][0]["name"], "person@example.invalid"
+                )
+                self.assertEqual(
+                    commands.resolve_label(state, "person@example.invalid"), "account1"
+                )
+
+    def test_redacted_diagnostics_omit_paths_names_and_prompts(self):
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder)
+            pool = Pool(state)
+            pool.assign("private-label")
+            pool.touch(
+                cwd="/secret/project",
+                name="secret-task",
+                state="working",
+                prompt="PRIVATE_PROMPT",
+            )
+            pool.record("working", project="/secret/project", email="PRIVATE_EMAIL")
+            target = state / "diagnostics.json"
+            tools.diagnostics(state, target)
+            output = target.read_text()
+            for secret in [
+                "/secret/project",
+                "private-label",
+                "secret-task",
+                "PRIVATE_PROMPT",
+                "PRIVATE_EMAIL",
+                folder,
+            ]:
+                self.assertNotIn(secret, output)
+            self.assertEqual(target.stat().st_mode & 0o777, 0o600)
+            pool.close()
+
+    def test_cleanup_dry_run_retains_workspace_and_runtime_references(self):
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder)
+            old = state / "native-runtimes" / "old"
+            old.mkdir(parents=True)
+            (old / "binary").write_text("test")
+            unused = state / "relay-runtimes" / "unused"
+            unused.mkdir(parents=True)
+            job = state / "services" / "saved.job.json"
+            atomic_json(job, {"state": "stopped", "binary": str(old / "binary")})
+            atomic_json(state / "workspaces.json", {"daily": ["saved"]})
+            before = time.time() - 90 * 86400
+            for p in [old, unused, job]:
+                os.utime(p, (before, before))
+            value = tools.cleanup(state, days=30, jobs=True)
+            self.assertTrue(value["dry_run"])
+            self.assertEqual(value["paths"], [str(unused)])
+            self.assertTrue(unused.exists())
+            self.assertTrue(job.exists())
+
+    def test_launch_agent_uses_stable_app_and_has_no_auth_token(self):
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder) / "state"
+            with patch(
+                "subprocess.run", return_value=subprocess.CompletedProcess([], 0)
+            ):
+                path = desktop.login_item(state, enabled=True, home=folder)
+                data = plistlib.loads(path.read_bytes())
+                self.assertIn("RelayMenu", data["ProgramArguments"][0])
+                self.assertTrue(data["RunAtLoad"])
+                self.assertNotIn("token", path.read_text().lower())
+                desktop.login_item(state, enabled=False, home=folder)
+                self.assertFalse(path.exists())
+
+    @unittest.skipUnless(sys.platform == "darwin", "Native app bundle test")
+    def test_native_menu_bundle_signs_and_symbols_exist(self):
+        with tempfile.TemporaryDirectory() as folder:
+            app = desktop.menubar(
+                Path(folder), launcher="/usr/bin/false", build_only=True
+            )
+            verify = subprocess.run(
+                ["/usr/bin/codesign", "--verify", "--strict", str(app)],
+                capture_output=True,
+            )
+            self.assertEqual(verify.returncode, 0, verify.stderr.decode())
+            result = subprocess.run(
+                [str(app / "Contents/MacOS/RelayMenu"), "--self-check"],
+                capture_output=True,
+                text=True,
+            )
+            self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+
+    def test_secret_profile_fields_do_not_enter_process_arguments_or_pool_settings(
+        self,
+    ):
+        from launch import profile_config
+        from router import Controller
+        from test_router import FakeAccount, FakeBackend
+
+        with tempfile.TemporaryDirectory() as folder:
+            home = Path(folder)
+            (home / "private.config.toml").write_text(
+                'model="normal"\n[mcp_servers.example.http_headers]\nAuthorization="PRIVATE_TEST_SECRET"\n'
+            )
+            with patch.dict(os.environ, {"CODEX_HOME": folder}):
+                arguments = backend_arguments(["-p", "private"])
+                self.assertNotIn("PRIVATE_TEST_SECRET", " ".join(arguments))
+                overrides = profile_config(["-p", "private"])
+                self.assertIn("PRIVATE_TEST_SECRET", json.dumps(overrides))
+                c = Controller(
+                    [FakeAccount("one")], FakeBackend(), report=lambda _: None
+                )
+                c.merge_settings("thread", {"config": overrides})
+                self.assertNotIn("PRIVATE_TEST_SECRET", json.dumps(c.thread_settings))
+
+    def test_help_command_and_combined_run_help(self):
+        import router
+
+        for args in [
+            [],
+            ["help"],
+            ["help", "workspace"],
+            ["help", "run"],
+            ["run", "--help"],
+        ]:
+            with (
+                self.subTest(args=args),
+                patch.object(sys, "argv", ["relay", *args]),
+                patch("router.codex_path", return_value="/codex"),
+                patch("subprocess.call", return_value=0),
+                contextlib.redirect_stdout(io.StringIO()) as out,
+            ):
+                if args in (["help", "run"], ["run", "--help"]):
+                    self.assertEqual(router.main(), 0)
+                    self.assertIn("Relay launch options", out.getvalue())
+                else:
+                    with self.assertRaises(SystemExit) as end:
+                        router.main()
+                    self.assertEqual(end.exception.code, 0)
+                    self.assertNotIn("router.py", out.getvalue())
+
+
+class ExecutionTests(unittest.IsolatedAsyncioTestCase):
+    async def test_managed_exec_json_and_last_message_over_real_jsonl(self):
+        from test_services import fake_executable
+        from test_router import FakeAccount
+
+        with tempfile.TemporaryDirectory() as folder:
+            root = Path(folder)
+            home = root / "home"
+            home.mkdir()
+            state = root / "state"
+            state.mkdir()
+            for label in ("one", "two"):
+                account = state / "accounts" / label
+                account.mkdir(parents=True)
+                (account / "enrolled").write_text("{}")
+            binary = fake_executable(root)
+            output_file = root / "answer.txt"
+            args = parse_arguments(
+                [
+                    "run",
+                    "--",
+                    "exec",
+                    "--skip-git-repo-check",
+                    "--json",
+                    "-o",
+                    str(output_file),
+                    "test only",
+                ]
+            )
+
+            class Account(FakeAccount):
+                def __init__(self, label, *args):
+                    super().__init__(label)
+
+            output = io.StringIO()
+            with (
+                patch.dict(os.environ, {"CODEX_HOME": str(home)}),
+                patch("broker.ClientAccount", Account),
+                patch("sys.stdin", io.StringIO("")),
+                contextlib.redirect_stdout(output),
+            ):
+                self.assertEqual(
+                    await asyncio.wait_for(execution.run(args, state, binary), 8), 0
+                )
+            events = [json.loads(line) for line in output.getvalue().splitlines()]
+            self.assertEqual(events[0]["type"], "thread.started")
+            self.assertEqual(events[-1]["type"], "turn.completed")
+            self.assertEqual(output_file.read_text(), "FAKE_OK\n")
+            history = json.loads((home / "fake-history.json").read_text())
+            self.assertEqual(
+                sum(call["method"] == "turn/start" for call in history["calls"]), 1
+            )
+
+    async def test_noninteractive_approval_is_not_automatically_accepted(self):
+        output = execution.Output(True)
+        with contextlib.redirect_stderr(io.StringIO()):
+            await output.send(
+                json.dumps(
+                    {
+                        "id": 1,
+                        "method": "item/commandExecution/requestApproval",
+                        "params": {},
+                    }
+                )
+            )
+        self.assertTrue(output.done.is_set())
+        self.assertEqual(output.status, 1)
+
+    async def test_exec_json_includes_tool_records(self):
+        output = execution.Output(True)
+        output.thread = "parent"
+        stream = io.StringIO()
+        with contextlib.redirect_stdout(stream):
+            for kind in ("mcpToolCall", "webSearch", "collabAgentToolCall"):
+                await output.send(
+                    json.dumps(
+                        {
+                            "method": "item/completed",
+                            "params": {
+                                "threadId": "parent",
+                                "item": {"id": kind, "type": kind},
+                            },
+                        }
+                    )
+                )
+        self.assertEqual(
+            [
+                json.loads(line)["item"]["type"]
+                for line in stream.getvalue().splitlines()
+            ],
+            ["mcp_tool_call", "web_search", "collab_tool_call"],
+        )
+
+    async def test_only_foreground_thread_can_finish_exec(self):
+        output = execution.Output(True)
+        output.thread = "parent"
+        await output.send(
+            json.dumps(
+                {
+                    "method": "turn/completed",
+                    "params": {"threadId": "child", "turn": {"status": "completed"}},
+                }
+            )
+        )
+        self.assertFalse(output.done.is_set())
+
+    def test_native_exec_subcommands_and_prompt_separator(self):
+        value = execution.options(
+            ["exec", "resume", "saved", "--json", "--", "--yolo"], "/tmp"
+        )
+        self.assertEqual(value["mode"], "resume")
+        self.assertEqual(value["target"], "saved")
+        self.assertEqual(value["prompt"], "--yolo")
+        self.assertNotIn("--yolo", value["flags"])
+        self.assertTrue(native_mode(["exec", "help"]))

package/tests/test_launch.py

@@ -0,0 +1,150 @@
+"""Native argv and working-directory regressions."""
+
+import argparse
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import AsyncMock, patch
+
+from launch import (
+    backend_arguments,
+    frontend_arguments,
+    native_mode,
+    translate,
+    working_directory,
+)
+from router import dispatch, resume_target, run_pool
+
+
+class ArgumentTests(unittest.TestCase):
+    def test_values_that_look_like_flags_are_not_reinterpreted(self):
+        argv = ["resume", "-c", "--yolo", "-i", "--sandbox", "-m", "--search"]
+        self.assertEqual(translate(argv), (argv, {}))
+        self.assertEqual(
+            backend_arguments(argv), ["-c", "--yolo", "-c", 'model="--search"']
+        )
+        self.assertFalse(native_mode(["resume", "-i", "--oss"]))
+
+    def test_attached_options_and_config_boundaries(self):
+        argv, overrides = translate(
+            [
+                "resume",
+                "-sworkspace-write",
+                "-anever",
+                "-mcustom",
+                "--",
+                "--yolo",
+                "--search",
+            ]
+        )
+        self.assertEqual(
+            overrides, {"sandbox": "workspace-write", "approvalPolicy": "never"}
+        )
+        self.assertEqual(backend_arguments(argv), ["-c", 'model="custom"'])
+
+    def test_approve_for_me_and_private_backend(self):
+        argv, overrides = translate(["resume", "--approve-for-me", "--no-daemon"])
+        self.assertEqual(argv, ["resume"])
+        self.assertEqual(
+            overrides,
+            {
+                "approvalPolicy": "on-request",
+                "sandbox": "workspace-write",
+                "approvalsReviewer": "auto_review",
+            },
+        )
+
+    def test_native_modes_keep_command_and_option_values_distinct(self):
+        for argv in (
+            ["resume", "--oss"],
+            ["resume", "--help"],
+            ["--remote=ws://localhost:1", "resume"],
+        ):
+            with self.subTest(argv=argv):
+                self.assertTrue(native_mode(argv))
+        for argv in (
+            ["resume", "--last"],
+            ["exec", "--json", "hello"],
+            ["-m", "custom", "review", "--uncommitted"],
+            ["-c", "exec", "resume"],
+            ["fork", "--", "--oss"],
+            ["a prompt", "exec"],
+        ):
+            with self.subTest(argv=argv):
+                self.assertFalse(native_mode(argv))
+
+    def test_cwd_defaults_and_relative_explicit_options(self):
+        with tempfile.TemporaryDirectory() as folder:
+            cwd = str(Path(folder).resolve())
+            self.assertEqual(frontend_arguments(["resume"], cwd), ["-C", cwd, "resume"])
+            for option in (["-C", "child"], ["--cd=child"], ["-Cchild"]):
+                argv = ["resume", *option, "--all", "-i", "picture.png"]
+                target = str(Path(cwd) / "child")
+                self.assertEqual(working_directory(argv, cwd), target)
+                self.assertEqual(
+                    frontend_arguments(argv, cwd),
+                    ["-C", target, "resume", "--all", "-i", "picture.png"],
+                )
+            self.assertEqual(
+                working_directory(["-c", "--cd=wrong", "--", "-Cwrong"], cwd), cwd
+            )
+
+    def test_uuid_in_an_option_is_not_a_resume_target(self):
+        ident = "01a1aa71-5cb7-7bc0-8c23-bcb26f693cf7"
+        self.assertIsNone(
+            resume_target(["resume", "-m", ident], Path("/missing"), "/tmp")
+        )
+        self.assertEqual(
+            resume_target(["resume", "-m", "custom", ident], Path("/missing"), "/tmp"),
+            ident,
+        )
+        self.assertIsNone(
+            resume_target(["resume", "named-session", ident], Path("/missing"), "/tmp")
+        )
+
+
+class LaunchFlowTests(unittest.IsolatedAsyncioTestCase):
+    async def test_effective_project_and_frontend_invocation_cwd_are_separate(self):
+        with tempfile.TemporaryDirectory() as folder:
+            root = Path(folder).resolve()
+            project = root / "project"
+            project.mkdir()
+            state = root / "state"
+            state.mkdir()
+            args = argparse.Namespace(
+                codex_args=["--", "resume", "--cd", "project", "--all", "--yolo"],
+                profile=None,
+                first=None,
+                name=None,
+            )
+            with (
+                patch("os.getcwd", return_value=str(root)),
+                patch(
+                    "settings.load", return_value={"background_on_disconnect": True}
+                ) as prefs,
+                patch("service.start", return_value="test") as start,
+                patch("service.attach", new=AsyncMock(return_value=0)) as attach,
+            ):
+                self.assertEqual(await run_pool(args, state, "/codex"), 0)
+            self.assertEqual(start.call_args.kwargs["cwd"], str(project))
+            self.assertEqual(
+                start.call_args.kwargs["arguments"],
+                ["-C", str(project), "resume", "--all", "--yolo"],
+            )
+            self.assertEqual(attach.call_args.kwargs["cwd"], str(root))
+            self.assertTrue(
+                all(call.args[1] == str(project) for call in prefs.call_args_list)
+            )
+
+    async def test_native_utilities_need_no_account_pool_or_protocol_adaptation(self):
+        argv = ["--", "mcp", "list", "--", "literal value"]
+        args = argparse.Namespace(command="run", codex_args=argv)
+        process = type("Process", (), {"wait": AsyncMock(return_value=7)})()
+        with (
+            patch("launch.native_commands", return_value={"mcp"}),
+            patch(
+                "asyncio.create_subprocess_exec", new=AsyncMock(return_value=process)
+            ) as spawn,
+        ):
+            self.assertEqual(await dispatch(args, Path("/unused"), "/codex"), 7)
+        self.assertEqual(spawn.call_args.args, ("/codex", *argv[1:]))

package/tests/test_services.py

@@ -396,6 +396,12 @@ class ServiceTests(unittest.IsolatedAsyncioTestCase):
                 await service.attach(self.state, self.ident, "/new/global/codex"), 0
             )
             self.assertEqual(spawn.call_args.args[0], self.binary)
+            expected_cwd = json.loads(self.meta.read_text())["cwd"]
+            argv = spawn.call_args.args
+            self.assertEqual(
+                argv[argv.index("-C") + 1], str(Path(expected_cwd).resolve())
+            )
+            self.assertEqual(spawn.call_args.kwargs["cwd"], expected_cwd)
 
     async def test_takeover_rotates_capability_and_old_frontend_cannot_reconnect(self):
         from websockets.asyncio.client import connect