agentlink-cli 0.1.4__tar.gz → 0.1.6__tar.gz

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/.gitignore

@@ -6,6 +6,7 @@ __pycache__/
 .pytest_cache/
 .ruff_cache/
 .venv/
+server-rust/target/
 .next/
 web-next/out/
 .env.local

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentlink-cli
-Version: 0.1.4
+Version: 0.1.6
 Summary: Local runtime connector for AgentLink
 Requires-Python: >=3.12
 Requires-Dist: claude-agent-sdk
@@ -44,6 +44,13 @@ Install dependencies:
 uv sync
 ```
 
+Check the installed CLI version:
+
+```bash
+agentlink-cli -v
+agentlink-cli --version
+```
+
 Start with explicit credentials from the web pairing flow:
 
 ```bash
@@ -84,6 +91,20 @@ CLAUDE_BIN=/path/to/claude
 The connector uses local runtime credentials and local filesystem permissions.
 AgentLink does not proxy Claude or Codex account credentials.
 
+Custom Codex launch commands may name an executable or a bash/zsh alias or
+function from the Connector user's interactive shell configuration. For
+example, after defining this in `~/.bashrc` or `~/.zshrc`:
+
+```bash
+alias codex-api='CODEX_HOME="$HOME/.codex-api" codex'
+```
+
+enter `codex-api` as the custom launch command in AgentLink. Arguments are
+passed without shell re-evaluation, and AgentLink still rejects pipelines,
+redirects, command lists, and multiline commands. Shell aliases and functions
+are supported on Linux and macOS with bash or zsh; Windows custom commands must
+resolve to an executable or a supported script file.
+
 ## Local Operations
 
 The server can ask an online connector to perform local work:

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/README.md

@@ -27,6 +27,13 @@ Install dependencies:
 uv sync
 ```
 
+Check the installed CLI version:
+
+```bash
+agentlink-cli -v
+agentlink-cli --version
+```
+
 Start with explicit credentials from the web pairing flow:
 
 ```bash
@@ -67,6 +74,20 @@ CLAUDE_BIN=/path/to/claude
 The connector uses local runtime credentials and local filesystem permissions.
 AgentLink does not proxy Claude or Codex account credentials.
 
+Custom Codex launch commands may name an executable or a bash/zsh alias or
+function from the Connector user's interactive shell configuration. For
+example, after defining this in `~/.bashrc` or `~/.zshrc`:
+
+```bash
+alias codex-api='CODEX_HOME="$HOME/.codex-api" codex'
+```
+
+enter `codex-api` as the custom launch command in AgentLink. Arguments are
+passed without shell re-evaluation, and AgentLink still rejects pipelines,
+redirects, command lists, and multiline commands. Shell aliases and functions
+are supported on Linux and macOS with bash or zsh; Windows custom commands must
+resolve to an executable or a supported script file.
+
 ## Local Operations
 
 The server can ask an online connector to perform local work:

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/connector/capabilities.py

@@ -4,6 +4,7 @@ import asyncio
 import importlib
 import os
 import shutil
+import signal
 import sys
 import time
 from collections.abc import Iterable
@@ -133,7 +134,7 @@ async def discover_codex_capability(
     """
     if launch_command:
         try:
-            parsed = parse_launch_command(launch_command)
+            parsed = await parse_launch_command(launch_command)
         except ValueError as exc:
             return (
                 {
@@ -238,16 +239,17 @@ async def _check_codex_candidate(candidate: dict[str, str] | LaunchTarget | Laun
     path = target.path
     source = target.source
     base = {"source": source, "path": path}
-    if not Path(path).is_file():
-        return {**base, "status": "missing", "reason": "file not found"}
-    if not path_exists_for_launch(path):
-        return {**base, "status": "failed", "reason": "not executable"}
+    if not target.is_shell_command:
+        if not Path(path).is_file():
+            return {**base, "status": "missing", "reason": "file not found"}
+        if not path_exists_for_launch(path):
+            return {**base, "status": "failed", "reason": "not executable"}
 
-    version = await _run_version(command.command(["--version"]))
+    version = await _run_launch_version(command)
     if version["status"] != "ok":
         return {**base, "status": "failed", "stage": "version", **version}
 
-    client = JsonRpcStdioClient(command=command.command(["app-server", "--listen", "stdio://"]))
+    client = _codex_stdio_client(command)
     try:
         await asyncio.wait_for(client.start(lambda _payload: _noop()), timeout=_CODEX_CHECK_TIMEOUT_S)
         list_result = await asyncio.wait_for(
@@ -294,12 +296,14 @@ async def prepare_codex_launch(
     """Validate a command while keeping the initialized candidate alive."""
 
     target = command.target
-    if not Path(target.path).is_file() or not path_exists_for_launch(target.path):
+    if not target.is_shell_command and (
+        not Path(target.path).is_file() or not path_exists_for_launch(target.path)
+    ):
         raise ValueError(f"executable is unavailable: {target.path}")
-    version = await _run_version(command.command(["--version"]))
+    version = await _run_launch_version(command)
     if version["status"] != "ok":
         raise RuntimeError(str(version.get("reason") or "Codex version check failed"))
-    client = JsonRpcStdioClient(command=command.command(["app-server", "--listen", "stdio://"]))
+    client = _codex_stdio_client(command)
     try:
         await asyncio.wait_for(client.start(handler), timeout=_CODEX_CHECK_TIMEOUT_S)
         list_result = await asyncio.wait_for(
@@ -515,15 +519,36 @@ def _list_claude_sdk_sessions() -> list[Any]:
     return list(list_sessions())
 
 
-async def _run_version(command: list[str]) -> dict[str, Any]:
+async def _run_launch_version(command: LaunchCommand) -> dict[str, Any]:
+    kwargs = {"start_new_session": True} if command.target.starts_process_group else {}
+    return await _run_version(command.command(["--version"]), **kwargs)
+
+
+def _codex_stdio_client(command: LaunchCommand) -> JsonRpcStdioClient:
+    kwargs = {"start_new_session": True} if command.target.starts_process_group else {}
+    return JsonRpcStdioClient(
+        command=command.command(["app-server", "--listen", "stdio://"]),
+        **kwargs,
+    )
+
+
+async def _run_version(command: list[str], *, start_new_session: bool = False) -> dict[str, Any]:
+    proc: asyncio.subprocess.Process | None = None
     try:
         proc = await asyncio.create_subprocess_exec(
             *command,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
+            start_new_session=start_new_session,
         )
         stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=_COMMAND_CHECK_TIMEOUT_S)
+    except asyncio.CancelledError:
+        if proc is not None and proc.returncode is None:
+            await _terminate_process(proc, process_group=start_new_session)
+        raise
     except Exception as exc:
+        if proc is not None and proc.returncode is None:
+            await _terminate_process(proc, process_group=start_new_session)
         return {"status": "failed", "reason": _exception_reason(exc)}
     out = stdout.decode(errors="replace").strip()
     err = stderr.decode(errors="replace").strip()
@@ -537,6 +562,30 @@ async def _run_version(command: list[str]) -> dict[str, Any]:
     return {"status": "ok", "stdout": out[:500], "stderr": err[:500]}
 
 
+async def _terminate_process(
+    process: asyncio.subprocess.Process,
+    *,
+    process_group: bool,
+) -> None:
+    try:
+        if process_group:
+            os.killpg(process.pid, signal.SIGTERM)
+        else:
+            process.terminate()
+        await asyncio.wait_for(process.wait(), timeout=5)
+    except ProcessLookupError:
+        return
+    except TimeoutError:
+        try:
+            if process_group:
+                os.killpg(process.pid, signal.SIGKILL)
+            else:
+                process.kill()
+        except ProcessLookupError:
+            return
+        await process.wait()
+
+
 def _claude_candidate_paths() -> list[dict[str, str]]:
     if sys.platform == "win32":
         home = Path.home()

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/connector/cli.py

@@ -20,7 +20,7 @@ from connector.local_runtime import (
 )
 from connector.logging import install_rpc_log_sink
 from connector.runtime import BackendRpcClient, ConnectorConfig
-
+from connector.version import connector_version
 
 SHELL_LIFETIME_WARNING = (
     "Note: this connector runs in the current shell session. "
@@ -69,6 +69,12 @@ class CliError(RuntimeError):
 
 def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="agentlink-cli", description="Agent Server Codex connector CLI")
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {connector_version()}",
+    )
     subparsers = parser.add_subparsers(dest="command", metavar="{start,pair,configure,rpc}")
 
     start = subparsers.add_parser("start", help="start the connector")

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/connector/codex/adapter.py

@@ -590,6 +590,24 @@ class CodexAdapter:
                     "target": target,
                 }
             else:
+                # A connector restart clears the app-server's in-memory
+                # thread set. Resume the requested thread before reading its
+                # status so Codex resolves workspace-sensitive information
+                # (including Git state) against the thread's workspace.
+                try:
+                    await self._ensure_thread_loaded(thread_id)
+                except Exception as exc:
+                    # Archived/unresumable threads remain readable and status
+                    # is intentionally a read-only command. Preserve that
+                    # behavior when app-server refuses to resume them.
+                    reason = _unresumable_thread_failure_reason(str(exc))
+                    if reason not in {"archived", "unresumable"}:
+                        raise
+                    logger.info(
+                        "codex status using read-only archived thread thread_id={} reason={}",
+                        thread_id,
+                        reason,
+                    )
                 thread = await self.rpc.request(
                     "thread/read", {"threadId": thread_id, "includeTurns": False}
                 )

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/connector/codex/rpc.py

@@ -4,6 +4,7 @@ import asyncio
 import json
 import os
 import shutil
+import signal
 import sys
 import time
 from collections.abc import Awaitable, Callable
@@ -21,8 +22,14 @@ APP_SERVER_STREAM_LIMIT = 64 * 1024 * 1024
 class JsonRpcStdioClient:
     """Line-delimited JSON-RPC client for `codex app-server --listen stdio://`."""
 
-    def __init__(self, command: list[str] | None = None) -> None:
+    def __init__(
+        self,
+        command: list[str] | None = None,
+        *,
+        start_new_session: bool = False,
+    ) -> None:
         self.command = command or _resolve_codex_command()
+        self.start_new_session = start_new_session
         self.process: asyncio.subprocess.Process | None = None
         self._start_lock = asyncio.Lock()
         self._next_id = 1
@@ -46,6 +53,7 @@ class JsonRpcStdioClient:
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
                     limit=APP_SERVER_STREAM_LIMIT,
+                    start_new_session=self.start_new_session,
                 )
                 self._track_reader(asyncio.create_task(self._read_stdout(self.process)), "stdout")
                 self._track_reader(asyncio.create_task(self._read_stderr(self.process)), "stderr")
@@ -112,11 +120,25 @@ class JsonRpcStdioClient:
     async def close(self) -> None:
         if self.process is None:
             return
-        self.process.terminate()
+        try:
+            if self.start_new_session:
+                os.killpg(self.process.pid, signal.SIGTERM)
+            else:
+                self.process.terminate()
+        except ProcessLookupError:
+            self.process = None
+            self._initialized = False
+            return
         try:
             await asyncio.wait_for(self.process.wait(), timeout=5)
         except TimeoutError:
-            self.process.kill()
+            try:
+                if self.start_new_session:
+                    os.killpg(self.process.pid, signal.SIGKILL)
+                else:
+                    self.process.kill()
+            except ProcessLookupError:
+                pass
             await self.process.wait()
         finally:
             self.process = None

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/connector/launch.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
+import asyncio
 import hashlib
 import json
 import os
 import re
 import shlex
 import shutil
+import signal
 import sys
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal
 
-Launcher = Literal["direct", "powershell", "cmd"]
+Launcher = Literal["direct", "powershell", "cmd", "posix-shell"]
 
 
 @dataclass(frozen=True, slots=True)
@@ -52,6 +54,14 @@ class LaunchTarget:
     def report_path(self) -> str:
         return self.path
 
+    @property
+    def is_shell_command(self) -> bool:
+        return self.launcher == "posix-shell"
+
+    @property
+    def starts_process_group(self) -> bool:
+        return self.is_shell_command
+
 
 @dataclass(frozen=True, slots=True)
 class LaunchCommand:
@@ -84,9 +94,10 @@ class LaunchCommand:
 
 _UNSUPPORTED_SHELL_TOKENS = {"|", "||", "&", "&&", ";", ">", ">>", "<", "<<"}
 _CMD_METACHARACTERS = frozenset('&|<>^()%!"')
+_SHELL_PROBE_TIMEOUT_S = 5
 
 
-def parse_launch_command(value: str) -> LaunchCommand:
+async def parse_launch_command(value: str) -> LaunchCommand:
     """Parse a frontend command as argv and resolve its executable locally.
 
     Shell operators are deliberately rejected.  The resulting command is
@@ -108,12 +119,14 @@ def parse_launch_command(value: str) -> LaunchCommand:
         raise ValueError("shell operators are not supported; enter an executable and arguments only")
 
     executable = expand_vars(argv[0])
-    resolved = shutil.which(executable)
-    if resolved is None and Path(executable).is_file():
-        resolved = executable
-    if resolved is None:
+    target = await _resolve_posix_shell_command(executable)
+    if target is None:
+        resolved = shutil.which(executable)
+        if resolved is None and Path(executable).is_file():
+            resolved = executable
+        target = launch_target("custom", resolved) if resolved is not None else None
+    if target is None:
         raise ValueError(f"executable not found: {argv[0]}")
-    target = launch_target("custom", resolved)
     if target.launcher == "cmd" and any(
         character in _CMD_METACHARACTERS
         for token in argv[1:]
@@ -125,6 +138,84 @@ def parse_launch_command(value: str) -> LaunchCommand:
     return LaunchCommand(raw=raw, target=target, args=tuple(argv[1:]))
 
 
+async def _resolve_posix_shell_command(name: str) -> LaunchTarget | None:
+    if sys.platform == "win32" or not re.fullmatch(r"[A-Za-z0-9_][A-Za-z0-9_.+-]*", name):
+        return None
+
+    shell = _user_shell()
+    if shell is None:
+        return None
+    shell_name = Path(shell).name.lower()
+    if shell_name == "bash":
+        probe = (
+            'kind=$(type -t -- "$1" 2>/dev/null); '
+            '[ "$kind" = alias ] || [ "$kind" = function ]'
+        )
+    elif shell_name == "zsh":
+        probe = (
+            'kind=$(whence -w -- "$1" 2>/dev/null); kind=${kind##*: }; '
+            '[ "$kind" = alias ] || [ "$kind" = function ]'
+        )
+    else:
+        return None
+
+    process: asyncio.subprocess.Process | None = None
+    try:
+        process = await asyncio.create_subprocess_exec(
+            shell,
+            "-ic",
+            probe,
+            "agentlink-shell-probe",
+            name,
+            stdin=asyncio.subprocess.DEVNULL,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        await asyncio.wait_for(process.wait(), timeout=_SHELL_PROBE_TIMEOUT_S)
+    except asyncio.CancelledError:
+        if process is not None and process.returncode is None:
+            await _kill_shell_probe_group(process)
+        raise
+    except (OSError, TimeoutError):
+        if process is not None and process.returncode is None:
+            await _kill_shell_probe_group(process)
+        return None
+    if process.returncode != 0:
+        return None
+
+    script = f'{shlex.quote(name)} "$@"'
+    return LaunchTarget(
+        source="shell",
+        path=name,
+        launcher="posix-shell",
+        exec_argv=(shell, "-ic", script, "agentlink-codex"),
+    )
+
+
+async def _kill_shell_probe_group(process: asyncio.subprocess.Process) -> None:
+    try:
+        os.killpg(process.pid, signal.SIGKILL)
+    except ProcessLookupError:
+        pass
+    await process.wait()
+
+
+def _user_shell() -> str | None:
+    configured = expand_vars(os.environ.get("SHELL", ""))
+    if not configured and sys.platform != "win32":
+        try:
+            import pwd
+
+            configured = pwd.getpwuid(os.getuid()).pw_shell
+        except (ImportError, KeyError, OSError):
+            return None
+    resolved = shutil.which(configured) if configured else None
+    if resolved is None and configured and Path(configured).is_file():
+        resolved = configured
+    return resolved
+
+
 def launch_command_from_target(target: LaunchTarget, *, raw: str | None = None) -> LaunchCommand:
     return LaunchCommand(raw=raw or target.report_path(), target=target)
 

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/connector/runtime.py

@@ -735,6 +735,7 @@ class BackendRpcClient:
         if (
             codex.rpc is not None
             and codex.rpc.command == command
+            and codex.rpc.start_new_session == launch.target.starts_process_group
             and getattr(codex, "_started", False)
         ):
             self._blocked_runtimes.discard("codex")
@@ -744,7 +745,10 @@ class BackendRpcClient:
                 await codex.rpc.close()
             except Exception:
                 logger.exception("closing previous codex app-server failed")
-        codex.rpc = JsonRpcStdioClient(command=command)
+        codex.rpc = JsonRpcStdioClient(
+            command=command,
+            start_new_session=launch.target.starts_process_group,
+        )
         codex._started = False
         self._blocked_runtimes.discard("codex")
 
@@ -756,7 +760,7 @@ class BackendRpcClient:
         if mode == "command":
             if not isinstance(raw, str):
                 raise ValueError("missing Codex launch command")
-            launch = parse_launch_command(raw)
+            launch = await parse_launch_command(raw)
         else:
             report, target = await discover_codex_capability()
             if target is None:

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/connector/version.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from importlib.metadata import PackageNotFoundError, version
 
-FALLBACK_VERSION = "0.1.4"
+FALLBACK_VERSION = "0.1.6"
 
 
 def connector_version() -> str:

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentlink-cli"
-version = "0.1.4"
+version = "0.1.6"
 description = "Local runtime connector for AgentLink"
 readme = "README.md"
 requires-python = ">=3.12"

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/tests/test_codex_adapter.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import signal
 from collections.abc import Awaitable, Callable
 from typing import Any
 
@@ -11,7 +12,10 @@ from connector.codex.adapter import (
     CodexAdapter,
     stable_session_id,
 )
-from connector.codex.collaboration import collaboration_mode_payload, normalize_collaboration_modes
+from connector.codex.collaboration import (
+    collaboration_mode_payload,
+    normalize_collaboration_modes,
+)
 from connector.codex.history import read_timeline_history, read_tool_history
 from connector.codex.reducer import TimelineReducer
 from connector.codex.rpc import APP_SERVER_STREAM_LIMIT, JsonRpcStdioClient
@@ -121,6 +125,7 @@ class ArchivedThreadListRpc(FakeCodexRpc):
 class ArchivedResumeRpc(FakeCodexRpc):
     async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
         if method == "thread/resume":
+            self.requests.append((method, params))
             raise RuntimeError(json.dumps({"code": -32600, "message": "thread is archived"}))
         return await super().request(method, params)
 
@@ -386,6 +391,29 @@ def test_stdio_client_start_is_serialized(monkeypatch) -> None:
     asyncio.run(_exercise_stdio_client_start_is_serialized(monkeypatch))
 
 
+def test_stdio_client_closes_shell_process_group(monkeypatch) -> None:
+    class GroupProcess:
+        pid = 4321
+        returncode: int | None = None
+
+        async def wait(self) -> int:
+            self.returncode = 0
+            return 0
+
+    signals: list[tuple[int, signal.Signals]] = []
+    monkeypatch.setattr(
+        "connector.codex.rpc.os.killpg",
+        lambda pid, sent_signal: signals.append((pid, sent_signal)),
+    )
+    client = JsonRpcStdioClient(command=["bash"], start_new_session=True)
+    client.process = GroupProcess()  # type: ignore[assignment]
+
+    asyncio.run(client.close())
+
+    assert signals == [(4321, signal.SIGTERM)]
+    assert client.process is None
+
+
 def test_stdio_client_ignores_response_for_cancelled_request() -> None:
     client = JsonRpcStdioClient(command=["codex"])
     loop = asyncio.new_event_loop()
@@ -1138,12 +1166,37 @@ def test_status_command_returns_thread_and_cached_token_usage() -> None:
         assert result["status"] == "completed"
         assert result["data"]["thread"]["id"] == "thr_1"
         assert result["data"]["tokenUsage"]["total"]["totalTokens"] == 42
+        assert ("thread/resume", {"threadId": "thr_1"}) in rpc.requests
         assert ("thread/read", {"threadId": "thr_1", "includeTurns": False}) in rpc.requests
         assert all(method != "turn/start" for method, _params in rpc.requests)
 
     asyncio.run(exercise())
 
 
+def test_status_command_reads_archived_thread_when_resume_is_rejected() -> None:
+    async def exercise() -> None:
+        rpc = ArchivedResumeRpc()
+        adapter = CodexAdapter(rpc=rpc)  # type: ignore[arg-type]
+        await adapter.start()
+        adapter._loaded_thread_ids.clear()  # noqa: SLF001
+
+        result = await adapter.execute_command(
+            {
+                "sessionId": "sess_1",
+                "externalSessionId": "thr_1",
+                "command": "status",
+                "clientCommandId": "cmd_status_archived",
+            }
+        )
+
+        assert result["status"] == "completed"
+        assert result["data"]["thread"]["id"] == "thr_1"
+        assert ("thread/resume", {"threadId": "thr_1"}) in rpc.requests
+        assert ("thread/read", {"threadId": "thr_1", "includeTurns": False}) in rpc.requests
+
+    asyncio.run(exercise())
+
+
 def test_reducer_normalizes_review_and_compaction_items() -> None:
     reducer = TimelineReducer()
     reducer.bind_session("sess_1", "thr_1")

{agentlink_cli-0.1.4 → agentlink_cli-0.1.6}/tests/test_connector_capabilities.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import signal
 from pathlib import Path
 from typing import Any
 
@@ -14,6 +15,40 @@ def _write_executable(path: Path, content: str) -> None:
     path.chmod(0o755)
 
 
+def test_version_timeout_terminates_shell_process_group(monkeypatch) -> None:
+    class HangingProcess:
+        pid = 7654
+        returncode: int | None = None
+
+        async def communicate(self) -> tuple[bytes, bytes]:
+            await asyncio.Event().wait()
+            raise AssertionError("unreachable")
+
+        async def wait(self) -> int:
+            self.returncode = 0
+            return 0
+
+    process = HangingProcess()
+    signals: list[tuple[int, signal.Signals]] = []
+
+    async def fake_create_subprocess_exec(*_command: str, **_kwargs: object) -> HangingProcess:
+        return process
+
+    monkeypatch.setattr(capabilities, "_COMMAND_CHECK_TIMEOUT_S", 0.01)
+    monkeypatch.setattr(asyncio, "create_subprocess_exec", fake_create_subprocess_exec)
+    monkeypatch.setattr(
+        "connector.capabilities.os.killpg",
+        lambda pid, sent_signal: signals.append((pid, sent_signal)),
+    )
+
+    result = asyncio.run(
+        capabilities._run_version(["bash", "-ic", "codex-api"], start_new_session=True)
+    )
+
+    assert result == {"status": "failed", "reason": "timeout"}
+    assert signals == [(7654, signal.SIGTERM)]
+
+
 def test_claude_capability_checks_version_and_help_only(monkeypatch, tmp_path: Path) -> None:
     claude_bin = tmp_path / "claude"
     _write_executable(