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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentlink-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: Local runtime connector for AgentLink
 Requires-Python: >=3.12
 Requires-Dist: claude-agent-sdk
@@ -84,6 +84,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.5}/README.md

@@ -67,6 +67,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.5}/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.5}/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.5}/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.5}/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.5}/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.5"
 
 
 def connector_version() -> str:

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

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

{agentlink_cli-0.1.4 → agentlink_cli-0.1.5}/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
@@ -386,6 +390,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()

{agentlink_cli-0.1.4 → agentlink_cli-0.1.5}/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(

{agentlink_cli-0.1.4 → agentlink_cli-0.1.5}/tests/test_connector_runtime.py

@@ -85,6 +85,7 @@ class FakeAdapter:
 class FakeCodexRpc:
     def __init__(self, command: list[str]) -> None:
         self.command = command
+        self.start_new_session = False
         self.closed = False
 
     async def close(self) -> None:

agentlink_cli-0.1.5/tests/test_launch_command.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from connector.launch import LaunchTarget, parse_launch_command
+
+
+async def _no_shell_command(_name: str) -> None:
+    return None
+
+
+def test_parse_launch_command_preserves_prefix_arguments(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    executable = tmp_path / "codex-team"
+    executable.write_text("#!/bin/sh\n", encoding="utf-8")
+    executable.chmod(0o755)
+    monkeypatch.setattr("connector.launch.shutil.which", lambda name: str(executable) if name == "codex-team" else None)
+    monkeypatch.setattr("connector.launch._resolve_posix_shell_command", _no_shell_command)
+
+    launch = asyncio.run(parse_launch_command('codex-team --yolo -c "model=team"'))
+
+    assert launch.command(["app-server", "--listen", "stdio://"]) == [
+        str(executable),
+        "--yolo",
+        "-c",
+        "model=team",
+        "app-server",
+        "--listen",
+        "stdio://",
+    ]
+    assert launch.report()["launchId"].startswith("codex:")
+
+
+@pytest.mark.parametrize("command", ["", "codex | other", "codex && other", "codex\nother"])
+def test_parse_launch_command_rejects_empty_or_shell_syntax(command: str) -> None:
+    with pytest.raises(ValueError):
+        asyncio.run(parse_launch_command(command))
+
+
+def test_parse_launch_command_reports_missing_executable(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("connector.launch.shutil.which", lambda _name: None)
+    monkeypatch.setattr("connector.launch._resolve_posix_shell_command", _no_shell_command)
+    with pytest.raises(ValueError, match="executable not found"):
+        asyncio.run(parse_launch_command("not-a-real-codex --yolo"))
+
+
+@pytest.mark.parametrize(
+    "argument",
+    [
+        "model=R&D",
+        "foo|bar",
+        "redirect>file",
+        "%PATH%",
+        "value^next",
+        "(group)",
+        "wow!",
+        'say\\"hello',
+    ],
+)
+def test_parse_launch_command_rejects_embedded_cmd_metacharacters(
+    monkeypatch: pytest.MonkeyPatch,
+    argument: str,
+) -> None:
+    monkeypatch.setattr("connector.launch.shutil.which", lambda _name: "C:/tools/codex-team.cmd")
+    monkeypatch.setattr("connector.launch._resolve_posix_shell_command", _no_shell_command)
+    monkeypatch.setattr(
+        "connector.launch.launch_target",
+        lambda source, path: LaunchTarget(source=source, path=path, launcher="cmd"),
+    )
+
+    with pytest.raises(ValueError, match="shell metacharacters"):
+        asyncio.run(parse_launch_command(f"codex-team {argument}"))
+
+
+def test_parse_launch_command_allows_metacharacters_for_direct_executables(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    executable = tmp_path / "codex-team"
+    executable.write_text("#!/bin/sh\n", encoding="utf-8")
+    executable.chmod(0o755)
+    monkeypatch.setattr("connector.launch.shutil.which", lambda _name: str(executable))
+    monkeypatch.setattr("connector.launch._resolve_posix_shell_command", _no_shell_command)
+
+    launch = asyncio.run(parse_launch_command("codex-team model=R&D"))
+
+    assert launch.args == ("model=R&D",)
+
+
+@pytest.mark.skipif(shutil.which("bash") is None, reason="bash is required")
+@pytest.mark.parametrize("definition_kind", ["alias", "function"])
+def test_parse_launch_command_resolves_bash_alias_and_function(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    definition_kind: str,
+) -> None:
+    fake_codex = tmp_path / "fake codex"
+    _script = """#!/usr/bin/env sh
+printf '%s\\n' "$CODEX_HOME"
+printf '<%s>\\n' "$@"
+"""
+    fake_codex.write_text(_script, encoding="utf-8")
+    fake_codex.chmod(0o755)
+    command = f'CODEX_HOME="$HOME/.codex-api" {shlex.quote(str(fake_codex))}'
+    if definition_kind == "alias":
+        definition = f"alias codex-api={shlex.quote(command)}\n"
+    else:
+        definition = f"codex-api() {{ {command} \"$@\"; }}\n"
+    (tmp_path / ".bashrc").write_text(definition, encoding="utf-8")
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("SHELL", shutil.which("bash") or "/bin/bash")
+
+    launch = asyncio.run(parse_launch_command("codex-api --profile team"))
+    result = subprocess.run(
+        launch.command(["app-server", "--listen", "stdio://", "$(touch nope)"]),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    assert launch.target.source == "shell"
+    assert launch.target.starts_process_group is True
+    assert result.stdout.splitlines() == [
+        str(tmp_path / ".codex-api"),
+        "<--profile>",
+        "<team>",
+        "<app-server>",
+        "<--listen>",
+        "<stdio://>",
+        "<$(touch nope)>",
+    ]
+    assert not (tmp_path / "nope").exists()
+
+
+@pytest.mark.skipif(shutil.which("bash") is None, reason="bash is required")
+def test_shell_alias_takes_precedence_over_same_named_path_executable(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    codex = bin_dir / "codex"
+    codex.write_text(
+        """#!/usr/bin/env sh
+printf '%s\\n' "$CODEX_HOME"
+printf '<%s>\\n' "$@"
+""",
+        encoding="utf-8",
+    )
+    codex.chmod(0o755)
+    (tmp_path / ".bashrc").write_text(
+        'alias codex=\'CODEX_HOME="$HOME/.codex-api" codex\'\n',
+        encoding="utf-8",
+    )
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("SHELL", shutil.which("bash") or "/bin/bash")
+    monkeypatch.setenv("PATH", f"{bin_dir}{os.pathsep}{os.environ.get('PATH', '')}")
+
+    launch = asyncio.run(parse_launch_command("codex --profile api"))
+    explicit_launch = asyncio.run(parse_launch_command(str(codex)))
+    result = subprocess.run(
+        launch.command(["--version"]),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    assert launch.target.source == "shell"
+    assert explicit_launch.target.source == "custom"
+    assert explicit_launch.command(["--version"]) == [str(codex), "--version"]
+    assert result.stdout.splitlines() == [
+        str(tmp_path / ".codex-api"),
+        "<--profile>",
+        "<api>",
+        "<--version>",
+    ]
+
+
+def test_parse_launch_command_does_not_use_unsupported_shell(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    shell = tmp_path / "fish"
+    shell.write_text("#!/usr/bin/env sh\n", encoding="utf-8")
+    shell.chmod(0o755)
+    monkeypatch.setenv("SHELL", str(shell))
+    monkeypatch.setattr(
+        "connector.launch.shutil.which",
+        lambda name: str(shell) if name == str(shell) else None,
+    )
+
+    with pytest.raises(ValueError, match="executable not found: codex-api"):
+        asyncio.run(parse_launch_command("codex-api"))
+
+
+def test_parse_launch_command_builds_zsh_function_target(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class ProbeProcess:
+        returncode = 0
+
+        async def wait(self) -> int:
+            return 0
+
+    probe_commands: list[tuple[str, ...]] = []
+
+    async def fake_create_subprocess_exec(*command: str, **_kwargs: object) -> ProbeProcess:
+        probe_commands.append(command)
+        return ProbeProcess()
+
+    monkeypatch.setattr("connector.launch.shutil.which", lambda _name: None)
+    monkeypatch.setattr("connector.launch._user_shell", lambda: "/bin/zsh")
+    monkeypatch.setattr(
+        "connector.launch.asyncio.create_subprocess_exec",
+        fake_create_subprocess_exec,
+    )
+
+    launch = asyncio.run(parse_launch_command("codex-api --profile team"))
+
+    assert "whence -w" in probe_commands[0][2]
+    assert launch.command(["--version"]) == [
+        "/bin/zsh",
+        "-ic",
+        'codex-api "$@"',
+        "agentlink-codex",
+        "--profile",
+        "team",
+        "--version",
+    ]
+
+
+def test_shell_probe_timeout_kills_process_group(monkeypatch: pytest.MonkeyPatch) -> None:
+    class HangingProbeProcess:
+        pid = 2468
+        returncode: int | None = None
+
+        def __init__(self) -> None:
+            self.stopped = asyncio.Event()
+
+        async def wait(self) -> int:
+            await self.stopped.wait()
+            return self.returncode or 0
+
+    process = HangingProbeProcess()
+    spawn_kwargs: list[dict[str, object]] = []
+    signals: list[tuple[int, signal.Signals]] = []
+
+    async def fake_create_subprocess_exec(
+        *_command: str,
+        **kwargs: object,
+    ) -> HangingProbeProcess:
+        spawn_kwargs.append(kwargs)
+        return process
+
+    def fake_killpg(pid: int, sent_signal: signal.Signals) -> None:
+        signals.append((pid, sent_signal))
+        process.returncode = -int(sent_signal)
+        process.stopped.set()
+
+    monkeypatch.setattr("connector.launch._SHELL_PROBE_TIMEOUT_S", 0.01)
+    monkeypatch.setattr("connector.launch._user_shell", lambda: "/bin/bash")
+    monkeypatch.setattr("connector.launch.shutil.which", lambda _name: None)
+    monkeypatch.setattr(
+        "connector.launch.asyncio.create_subprocess_exec",
+        fake_create_subprocess_exec,
+    )
+    monkeypatch.setattr("connector.launch.os.killpg", fake_killpg)
+
+    with pytest.raises(ValueError, match="executable not found: codex-api"):
+        asyncio.run(parse_launch_command("codex-api"))
+
+    assert spawn_kwargs[0]["start_new_session"] is True
+    assert signals == [(2468, signal.SIGKILL)]
+
+
+def test_cancelled_shell_probe_kills_process_group(monkeypatch: pytest.MonkeyPatch) -> None:
+    signals: list[tuple[int, signal.Signals]] = []
+
+    async def exercise() -> None:
+        spawned = asyncio.Event()
+
+        class HangingProbeProcess:
+            pid = 1357
+            returncode: int | None = None
+
+            def __init__(self) -> None:
+                self.stopped = asyncio.Event()
+
+            async def wait(self) -> int:
+                await self.stopped.wait()
+                return self.returncode or 0
+
+        process = HangingProbeProcess()
+
+        async def fake_create_subprocess_exec(
+            *_command: str,
+            **_kwargs: object,
+        ) -> HangingProbeProcess:
+            spawned.set()
+            return process
+
+        def fake_killpg(pid: int, sent_signal: signal.Signals) -> None:
+            signals.append((pid, sent_signal))
+            process.returncode = -int(sent_signal)
+            process.stopped.set()
+
+        monkeypatch.setattr("connector.launch._user_shell", lambda: "/bin/bash")
+        monkeypatch.setattr(
+            "connector.launch.asyncio.create_subprocess_exec",
+            fake_create_subprocess_exec,
+        )
+        monkeypatch.setattr("connector.launch.os.killpg", fake_killpg)
+
+        task = asyncio.create_task(parse_launch_command("codex-api"))
+        await spawned.wait()
+        await asyncio.sleep(0)
+        task.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await task
+
+    asyncio.run(exercise())
+
+    assert signals == [(1357, signal.SIGKILL)]

{agentlink_cli-0.1.4 → agentlink_cli-0.1.5}/tests/test_version.py

@@ -17,4 +17,4 @@ def test_connector_version_falls_back_in_source_tree(monkeypatch) -> None:
 
     monkeypatch.setattr(version_module, "version", missing)
 
-    assert version_module.connector_version() == "0.1.4"
+    assert version_module.connector_version() == "0.1.5"

{agentlink_cli-0.1.4 → agentlink_cli-0.1.5}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "agentlink-cli"
-version = "0.1.4"
+version = "0.1.5"
 source = { editable = "." }
 dependencies = [
     { name = "claude-agent-sdk" },

agentlink_cli-0.1.4/tests/test_launch_command.py

@@ -1,82 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from connector.launch import LaunchTarget, parse_launch_command
-
-
-def test_parse_launch_command_preserves_prefix_arguments(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    executable = tmp_path / "codex-team"
-    executable.write_text("#!/bin/sh\n", encoding="utf-8")
-    executable.chmod(0o755)
-    monkeypatch.setattr("connector.launch.shutil.which", lambda name: str(executable) if name == "codex-team" else None)
-
-    launch = parse_launch_command('codex-team --yolo -c "model=team"')
-
-    assert launch.command(["app-server", "--listen", "stdio://"]) == [
-        str(executable),
-        "--yolo",
-        "-c",
-        "model=team",
-        "app-server",
-        "--listen",
-        "stdio://",
-    ]
-    assert launch.report()["launchId"].startswith("codex:")
-
-
-@pytest.mark.parametrize("command", ["", "codex | other", "codex && other", "codex\nother"])
-def test_parse_launch_command_rejects_empty_or_shell_syntax(command: str) -> None:
-    with pytest.raises(ValueError):
-        parse_launch_command(command)
-
-
-def test_parse_launch_command_reports_missing_executable(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("connector.launch.shutil.which", lambda _name: None)
-    with pytest.raises(ValueError, match="executable not found"):
-        parse_launch_command("not-a-real-codex --yolo")
-
-
-@pytest.mark.parametrize(
-    "argument",
-    [
-        "model=R&D",
-        "foo|bar",
-        "redirect>file",
-        "%PATH%",
-        "value^next",
-        "(group)",
-        "wow!",
-        'say\\"hello',
-    ],
-)
-def test_parse_launch_command_rejects_embedded_cmd_metacharacters(
-    monkeypatch: pytest.MonkeyPatch,
-    argument: str,
-) -> None:
-    monkeypatch.setattr("connector.launch.shutil.which", lambda _name: "C:/tools/codex-team.cmd")
-    monkeypatch.setattr(
-        "connector.launch.launch_target",
-        lambda source, path: LaunchTarget(source=source, path=path, launcher="cmd"),
-    )
-
-    with pytest.raises(ValueError, match="shell metacharacters"):
-        parse_launch_command(f"codex-team {argument}")
-
-
-def test_parse_launch_command_allows_metacharacters_for_direct_executables(
-    monkeypatch: pytest.MonkeyPatch,
-    tmp_path: Path,
-) -> None:
-    executable = tmp_path / "codex-team"
-    executable.write_text("#!/bin/sh\n", encoding="utf-8")
-    executable.chmod(0o755)
-    monkeypatch.setattr("connector.launch.shutil.which", lambda _name: str(executable))
-
-    launch = parse_launch_command("codex-team model=R&D")
-
-    assert launch.args == ("model=R&D",)