@team-agent/installer 0.1.11 → 0.2.1

package/src/team_agent/provider_cli/codex.py

@@ -0,0 +1,319 @@
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import time
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+from team_agent.permissions import resolve_permissions
+from team_agent.provider_cli.adapter import (
+    ProviderAdapter,
+    ResumeUnavailable,
+    agent_model,
+    parse_time,
+)
+from team_agent.provider_cli.prompt import compile_system_prompt
+
+
+class CodexAdapter(ProviderAdapter):
+    provider = "codex"
+    command_name = "codex"
+    _model_catalog_cache: dict[str, Any] | None = None
+
+    def build_command(self, agent: dict[str, Any], workspace: Path, mcp_config: dict[str, Any]) -> list[str]:
+        cmd = self._base_command(agent, mcp_config, resume=False)
+        return cmd
+
+    def build_resume_command(
+        self,
+        agent_state: dict[str, Any],
+        workspace: Path,
+        mcp_config: dict[str, Any] | None = None,
+    ) -> list[str]:
+        _ = workspace
+        session_id = agent_state.get("session_id")
+        if not session_id:
+            raise ResumeUnavailable("codex resume requires session_id")
+        agent = dict(agent_state.get("_agent_spec") or agent_state)
+        cmd = self._base_command(agent, mcp_config or {}, resume=True)
+        cmd.append(str(session_id))
+        return cmd
+
+    def supports_session_fork(self, agent: dict[str, Any] | None = None) -> bool:
+        return not agent or agent.get("auth_mode") != "compatible_api"
+
+    def build_fork_command(
+        self,
+        agent: dict[str, Any],
+        source_session_id: str,
+        workspace: Path,
+        mcp_config: dict[str, Any],
+    ) -> list[str]:
+        _ = workspace
+        if not source_session_id:
+            raise ResumeUnavailable("codex fork requires source session_id")
+        cmd = self._base_command(agent, mcp_config, resume=False, fork=True)
+        cmd.append(str(source_session_id))
+        return cmd
+
+    def capture_session_id(
+        self,
+        agent_id: str,
+        spawn_context: dict[str, Any],
+        timeout_s: float = 3.0,
+    ) -> dict[str, Any] | None:
+        _ = agent_id
+        cwd = spawn_context.get("cwd")
+        if not cwd:
+            return None
+        start = parse_time(spawn_context.get("spawn_time")) or datetime.now(timezone.utc)
+        root = Path(spawn_context.get("sessions_root") or Path.home() / ".codex" / "sessions")
+        deadline = time.monotonic() + max(timeout_s, 0.0)
+        exclude = {str(item) for item in spawn_context.get("exclude_session_ids", []) if item}
+        while True:
+            match = find_codex_rollout(root, Path(str(cwd)), start, exclude_session_ids=exclude)
+            if match:
+                return {
+                    "session_id": match["session_id"],
+                    "rollout_path": match["rollout_path"],
+                    "captured_at": datetime.now(timezone.utc).isoformat(),
+                    "captured_via": "fs_watch",
+                    "attribution_confidence": match["confidence"],
+                    "spawn_cwd": str(cwd),
+                }
+            if time.monotonic() >= deadline:
+                return None
+            time.sleep(0.2)
+
+    def _base_command(
+        self,
+        agent: dict[str, Any],
+        mcp_config: dict[str, Any],
+        resume: bool,
+        fork: bool = False,
+    ) -> list[str]:
+        prompt = compile_system_prompt(agent)
+        cmd = ["codex"]
+        if resume:
+            cmd.append("resume")
+        elif fork:
+            cmd.append("fork")
+        cmd.extend(["--no-alt-screen", "--disable", "shell_snapshot", "--disable", "apps"])
+        profile_overrides = agent.get("_provider_profile", {}).get("command_overrides", {})
+        if profile_overrides.get("codex_profile"):
+            cmd.extend(["--profile", str(profile_overrides["codex_profile"])])
+        if agent.get("_runtime", {}).get("dangerous_auto_approve"):
+            cmd.append("--dangerously-bypass-approvals-and-sandbox")
+        else:
+            tools = set(resolve_permissions(agent)["tools"])
+            sandbox = "workspace-write" if {"fs_write", "execute_bash"} & tools else "read-only"
+            cmd.extend(["--sandbox", sandbox, "--ask-for-approval", "on-request"])
+        model = agent_model(agent)
+        if model:
+            cmd.extend(["--model", model])
+        for config in profile_overrides.get("codex_config", []):
+            cmd.extend(["-c", str(config)])
+        if prompt:
+            escaped = prompt.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+            cmd.extend(["-c", f'developer_instructions="{escaped}"'])
+        for server_name, cfg in mcp_config.items():
+            prefix = f"mcp_servers.{server_name}"
+            cmd.extend(["-c", f'{prefix}.command="{cfg["command"]}"'])
+            args = "[" + ", ".join(json.dumps(str(arg)) for arg in cfg.get("args", [])) + "]"
+            cmd.extend(["-c", f"{prefix}.args={args}"])
+            for env_key, env_val in cfg.get("env", {}).items():
+                cmd.extend(["-c", f'{prefix}.env.{env_key}="{env_val}"'])
+            cmd.extend(["-c", f"{prefix}.tool_timeout_sec=600.0"])
+        return cmd
+
+    def auth_hint(self) -> dict[str, Any]:
+        if "OPENAI_API_KEY" in __import__("os").environ:
+            return {"status": "present", "detail": "OPENAI_API_KEY is set"}
+        if Path.home().joinpath(".codex").exists():
+            return {"status": "present", "detail": "~/.codex exists; run codex login if startup fails"}
+        return {"status": "missing_or_unknown", "detail": "run codex login or set OPENAI_API_KEY"}
+
+    def status_patterns(self) -> dict[str, str]:
+        return {"idle": r"(›|❯|codex>)", "processing": r"•.*esc to interrupt", "error": "Error|Traceback|panic"}
+
+    def handle_startup_prompts(
+        self,
+        session_name: str,
+        window_name: str,
+        checks: int = 30,
+        sleep_s: float = 0.5,
+    ) -> list[dict[str, Any]]:
+        handled: list[dict[str, Any]] = []
+        target = f"{session_name}:{window_name}"
+        for _ in range(max(checks, 0)):
+            proc = subprocess.run(
+                ["tmux", "capture-pane", "-p", "-S", "-", "-t", target],
+                text=True,
+                capture_output=True,
+                timeout=5,
+                check=False,
+            )
+            output = proc.stdout if proc.returncode == 0 else ""
+            trust_pos = max(
+                output.rfind("Do you trust the contents of this directory?"),
+                output.rfind("Do you trust the files in this folder?"),
+                output.rfind("Do you trust this folder?"),
+            )
+            update_pos = max(output.rfind("Update available!"), output.rfind("Update now"))
+            ready_pos = max(output.rfind("OpenAI Codex"), output.rfind("›"), output.rfind("codex>"))
+            if update_pos >= 0 and update_pos > ready_pos:
+                subprocess.run(["tmux", "send-keys", "-t", target, "Down", "Enter"], check=False)
+                handled.append({"prompt": "codex_update_available", "action": "sent_skip"})
+                if sleep_s > 0:
+                    time.sleep(sleep_s)
+                continue
+            if trust_pos >= 0 and trust_pos > ready_pos:
+                subprocess.run(["tmux", "send-keys", "-t", target, "Enter"], check=False)
+                handled.append({"prompt": "codex_workspace_trust", "action": "sent_enter"})
+                if sleep_s > 0:
+                    time.sleep(sleep_s)
+                continue
+            if ready_pos >= 0:
+                break
+            if sleep_s > 0:
+                time.sleep(sleep_s)
+        return handled
+
+    def handle_runtime_prompts(self, session_name: str, window_name: str) -> list[dict[str, Any]]:
+        _ = session_name, window_name
+        return []
+
+    def validate_model(self, model: str | None) -> dict[str, Any]:
+        if not model:
+            return {"ok": True, "status": "model_not_set", "provider": self.provider, "model": model}
+        catalog = self._model_catalog()
+        if not catalog.get("ok"):
+            details = {key: value for key, value in catalog.items() if key != "ok"}
+            return {"ok": False, "status": "model_catalog_unavailable", "provider": self.provider, "model": model, **details}
+        models = catalog.get("models", [])
+        slugs = {str(item.get("slug") or "") for item in models if item.get("slug")}
+        if model in slugs:
+            return {"ok": True, "status": "model_supported", "provider": self.provider, "model": model}
+        slug_by_lower = {slug.lower(): slug for slug in slugs}
+        display_to_slug = {
+            str(item.get("display_name") or "").lower(): str(item.get("slug"))
+            for item in models
+            if item.get("display_name") and item.get("slug")
+        }
+        normalized = model.lower()
+        suggested = slug_by_lower.get(normalized) or display_to_slug.get(normalized)
+        result = {
+            "ok": False,
+            "status": "unsupported_model",
+            "reason": "model_id_not_found",
+            "provider": self.provider,
+            "model": model,
+            "available_models": sorted(slugs),
+        }
+        if suggested:
+            result["reason"] = "model_id_not_exact"
+            result["suggested_model"] = suggested
+        return result
+
+    def _model_catalog(self) -> dict[str, Any]:
+        if self._model_catalog_cache is not None:
+            return self._model_catalog_cache
+        if not self.is_installed():
+            return {"ok": False, "reason": "codex_command_missing", "command": self.command_name}
+        try:
+            proc = subprocess.run(
+                [self.command_name, "debug", "models"],
+                text=True,
+                capture_output=True,
+                timeout=12,
+                check=False,
+            )
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            return {"ok": False, "reason": "model_catalog_command_failed", "command": "codex debug models", "error": str(exc)}
+        if proc.returncode != 0:
+            return {
+                "ok": False,
+                "reason": "model_catalog_command_failed",
+                "command": "codex debug models",
+                "stderr": proc.stderr.strip(),
+            }
+        try:
+            data = json.loads(proc.stdout or "{}")
+        except json.JSONDecodeError as exc:
+            return {"ok": False, "reason": "model_catalog_parse_failed", "command": "codex debug models", "error": str(exc)}
+        models = data.get("models")
+        if not isinstance(models, list):
+            return {"ok": False, "reason": "model_catalog_shape_invalid", "command": "codex debug models"}
+        self._model_catalog_cache = {"ok": True, "command": "codex debug models", "models": models}
+        return self._model_catalog_cache
+
+
+def find_codex_rollout(
+    root: Path,
+    cwd: Path,
+    spawn_time: datetime,
+    exclude_session_ids: set[str] | None = None,
+) -> dict[str, Any] | None:
+    if not root.exists():
+        return None
+    exclude_session_ids = exclude_session_ids or set()
+    lower_bound = spawn_time - timedelta(seconds=2)
+    upper_bound = datetime.now(timezone.utc) + timedelta(seconds=5)
+    candidates: list[dict[str, Any]] = []
+    for path in sorted(root.glob("**/rollout-*.jsonl"), key=lambda p: p.stat().st_mtime, reverse=True)[:1500]:
+        meta = read_codex_session_meta(path)
+        if not meta:
+            continue
+        meta_cwd = meta.get("cwd")
+        if not meta_cwd:
+            continue
+        try:
+            same_cwd = Path(str(meta_cwd)).resolve() == cwd.resolve()
+        except OSError:
+            same_cwd = str(meta_cwd) == str(cwd)
+        if not same_cwd:
+            continue
+        ts = parse_time(meta.get("timestamp"))
+        if ts and (ts < lower_bound or ts > upper_bound):
+            continue
+        originator = meta.get("originator")
+        origin_ok = originator in {"codex-tui", "codex_exec"}
+        session_id = meta.get("id") or rollout_id_from_name(path)
+        if not session_id:
+            continue
+        if str(session_id) in exclude_session_ids:
+            continue
+        candidates.append(
+            {
+                "session_id": str(session_id),
+                "rollout_path": str(path),
+                "timestamp": ts or datetime.fromtimestamp(path.stat().st_mtime, timezone.utc),
+                "confidence": "high" if origin_ok and ts else "medium",
+            }
+        )
+    if not candidates:
+        return None
+    candidates.sort(key=lambda item: item["timestamp"])
+    return candidates[0]
+
+
+def read_codex_session_meta(path: Path) -> dict[str, Any] | None:
+    try:
+        with path.open(encoding="utf-8") as handle:
+            first = handle.readline()
+        data = json.loads(first)
+    except (OSError, json.JSONDecodeError):
+        return None
+    if "session_meta" in data:
+        payload = data.get("session_meta", {}).get("payload")
+    else:
+        payload = data.get("payload")
+    return payload if isinstance(payload, dict) else None
+
+
+def rollout_id_from_name(path: Path) -> str | None:
+    match = re.search(r"([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$", path.name)
+    return match.group(1) if match else None

package/src/team_agent/provider_cli/copilot.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from team_agent.provider_cli.unsupported import UnsupportedCliPlug
+
+
+class CopilotCliPlug(UnsupportedCliPlug):
+    provider = "copilot"
+    command_name = "copilot"

package/src/team_agent/provider_cli/fake.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from team_agent.provider_cli.adapter import ProviderAdapter
+
+
+class FakeAdapter(ProviderAdapter):
+    provider = "fake"
+    command_name = sys.executable
+
+    def build_command(self, agent: dict[str, Any], workspace: Path, mcp_config: dict[str, Any]) -> list[str]:
+        return [
+            sys.executable,
+            "-m",
+            "team_agent.fake_worker",
+            "--workspace",
+            str(workspace),
+            "--agent-id",
+            agent["id"],
+        ]
+
+    def build_resume_command(
+        self,
+        agent_state: dict[str, Any],
+        workspace: Path,
+        mcp_config: dict[str, Any] | None = None,
+    ) -> list[str]:
+        agent = dict(agent_state.get("_agent_spec") or agent_state)
+        agent.setdefault("id", agent_state.get("agent_id") or agent_state.get("id"))
+        return self.build_command(agent, workspace, mcp_config or {})
+
+    def auth_hint(self) -> dict[str, Any]:
+        return {"status": "present", "detail": "fake provider is local test worker"}
+
+    def status_patterns(self) -> dict[str, str]:
+        return {"idle": "TEAM_AGENT_FAKE_READY", "processing": "TEAM_AGENT_FAKE_WORKING", "error": "Traceback"}

package/src/team_agent/provider_cli/gemini.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from team_agent.provider_cli.adapter import (
+    ProviderAdapter,
+    agent_model,
+    read_json_object,
+)
+from team_agent.provider_cli.prompt import compile_system_prompt
+
+
+class GeminiCliAdapter(ProviderAdapter):
+    provider = "gemini_cli"
+    command_name = "gemini"
+
+    def build_command(self, agent: dict[str, Any], workspace: Path, mcp_config: dict[str, Any]) -> list[str]:
+        prompt = compile_system_prompt(agent)
+        cmd = ["gemini"]
+        if agent.get("_runtime", {}).get("dangerous_auto_approve"):
+            cmd.extend(["--yolo", "--sandbox", "false"])
+        model = agent_model(agent)
+        if model:
+            cmd.extend(["--model", model])
+        if prompt:
+            cmd.extend(["-i", prompt])
+        return cmd
+
+    def install_mcp(self, workspace: Path, agent_id: str, config: dict[str, Any]) -> Path:
+        path = super().install_mcp(workspace, agent_id, config)
+        self._register_mcp_servers(path, config)
+        return path
+
+    def cleanup_mcp(self, workspace: Path, agent_id: str, mcp_path: Path | None = None) -> None:
+        path = mcp_path or workspace / ".team" / "runtime" / "mcp" / f"{agent_id}.json"
+        self._restore_mcp_servers(path)
+
+    def _register_mcp_servers(self, mcp_path: Path, config: dict[str, Any]) -> None:
+        settings_path = Path.home() / ".gemini" / "settings.json"
+        settings_path.parent.mkdir(parents=True, exist_ok=True)
+        settings = read_json_object(settings_path)
+        mcp_servers = settings.setdefault("mcpServers", {})
+        if not isinstance(mcp_servers, dict):
+            raise ValueError(f"{settings_path}: mcpServers must be an object")
+
+        backup = {
+            "settings_path": str(settings_path),
+            "servers": {name: mcp_servers.get(name) for name in config},
+        }
+        gemini_backup_path(mcp_path).write_text(json.dumps(backup, indent=2), encoding="utf-8")
+
+        for name, server in config.items():
+            mcp_servers[name] = {
+                "command": server["command"],
+                "args": server.get("args", []),
+                "env": server.get("env", {}),
+            }
+        settings_path.write_text(json.dumps(settings, indent=2), encoding="utf-8")
+
+    def _restore_mcp_servers(self, mcp_path: Path) -> None:
+        backup_path = gemini_backup_path(mcp_path)
+        if not backup_path.exists():
+            return
+        backup = json.loads(backup_path.read_text(encoding="utf-8"))
+        settings_path = Path(backup["settings_path"])
+        settings = read_json_object(settings_path)
+        mcp_servers = settings.setdefault("mcpServers", {})
+        if not isinstance(mcp_servers, dict):
+            raise ValueError(f"{settings_path}: mcpServers must be an object")
+        for name, previous in backup.get("servers", {}).items():
+            if previous is None:
+                mcp_servers.pop(name, None)
+            else:
+                mcp_servers[name] = previous
+        settings_path.write_text(json.dumps(settings, indent=2), encoding="utf-8")
+        backup_path.unlink(missing_ok=True)
+
+    def auth_hint(self) -> dict[str, Any]:
+        if "GEMINI_API_KEY" in __import__("os").environ:
+            return {"status": "present", "detail": "GEMINI_API_KEY is set"}
+        if Path.home().joinpath(".gemini").exists():
+            return {"status": "present", "detail": "~/.gemini exists; run gemini to verify OAuth"}
+        return {"status": "missing_or_unknown", "detail": "run gemini OAuth setup or set GEMINI_API_KEY"}
+
+    def status_patterns(self) -> dict[str, str]:
+        return {"idle": r"\*\s+Type your message", "processing": r"\(esc to cancel", "error": "Error|APIError|Traceback"}
+
+    def exit_text(self) -> str:
+        return "\x04"
+
+
+def gemini_backup_path(mcp_path: Path) -> Path:
+    return mcp_path.with_suffix(".gemini-backup.json")

package/src/team_agent/provider_cli/opencode.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from team_agent.provider_cli.unsupported import UnsupportedCliPlug
+
+
+class OpenCodeCliPlug(UnsupportedCliPlug):
+    provider = "opencode"
+    command_name = "opencode"

package/src/team_agent/provider_cli/prompt.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from team_agent.permissions import resolve_permissions
+
+
+TEAMMATE_SYSTEM_PROMPT = """# Team Agent Teammate Runtime Contract
+
+You are a teammate in a Team Agent runtime, not the user's primary assistant.
+The user normally talks to the team lead. Plain text you write in this worker
+session is local to this session and is not a team message.
+
+Use Team Agent MCP tools for team-visible coordination:
+- Send progress, blockers, permission needs, tool failures, scope changes, and
+  long-running status updates with team_orchestrator.send_message(to='leader',
+  content='<short message>').
+- Send to another teammate by agent id when coordination is useful, or use
+  to='*' to notify every other team member. The runtime resolves only this team
+  and excludes your own worker.
+- When the task is complete, call team_orchestrator.report_result exactly once.
+- Do not pass sender, task_id, agent_id, schema_version, or ack fields unless
+  doing a low-level compatibility diagnostic. The MCP runtime fills protocol
+  fields from the current worker and task state.
+
+If you are blocked or cannot continue, message the leader promptly instead of
+waiting silently. If work takes several minutes, send a short progress update.
+"""
+
+
+def compile_system_prompt(agent: dict[str, Any]) -> str:
+    prompt_cfg = agent.get("system_prompt", {})
+    identity = (
+        f"You are Team Agent worker `{agent.get('id')}` with role `{agent.get('role')}`. "
+        "When asked about your role or identity, answer with this Team Agent worker identity first, "
+        "not only the generic provider product identity."
+    )
+    chunks: list[str] = [identity, TEAMMATE_SYSTEM_PROMPT]
+    if prompt_cfg.get("inline"):
+        chunks.append(str(prompt_cfg["inline"]))
+    if prompt_cfg.get("file"):
+        chunks.append(Path(prompt_cfg["file"]).read_text(encoding="utf-8"))
+    contract = agent.get("output_contract", {})
+    if contract.get("format") == "result_envelope_v1":
+        chunks.append(
+            "For progress or blockers, call team_orchestrator.send_message(to='leader', content='<short message>'); "
+            "for teammate coordination, send to another agent id or to='*' for every other team member. "
+            "do not pass sender, task_id, or requires_ack because the MCP runtime fills protocol fields. "
+            "the runtime injects it into the attached Codex leader pane when the leader has run attach-leader. "
+            "If no leader is attached, the tool returns a fallback/failed result instead of completion. "
+            "Final completion must call team_orchestrator.report_result exactly once with a short summary "
+            "and optional status/changes/tests; MCP fills schema_version, task_id, and agent_id."
+        )
+    perms = resolve_permissions(agent)
+    if perms["has_prompt_only"]:
+        prompt_only = [e["tool"] for e in perms["resolved_tools"] if e["enforcement"] == "prompt_only"]
+        chunks.append(
+            "Permission note: these tools are prompt-only for this provider and not hard-enforced: "
+            + ", ".join(prompt_only)
+        )
+    return "\n\n".join(chunk for chunk in chunks if chunk)

package/src/team_agent/provider_cli/registry.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from team_agent.provider_cli.base import ProviderCliSocket
+from team_agent.provider_cli.copilot import CopilotCliPlug
+from team_agent.provider_cli.opencode import OpenCodeCliPlug
+
+
+PLUG_TYPES = {
+    "opencode": OpenCodeCliPlug,
+    "copilot": CopilotCliPlug,
+}
+
+
+def build_plug(provider: str) -> ProviderCliSocket:
+    try:
+        return PLUG_TYPES[provider]()
+    except KeyError as exc:
+        raise KeyError(f"Unsupported provider plug: {provider}") from exc

package/src/team_agent/provider_cli/unsupported.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any
+
+from team_agent.provider_cli.base import ProviderCapabilityError, ProviderStartupInput
+
+
+class UnsupportedCliPlug:
+    provider = ""
+    command_name = ""
+
+    def build_command(self, startup: ProviderStartupInput) -> list[str]:
+        _ = startup
+        self._unsupported("start")
+
+    def build_resume_command(self, startup: ProviderStartupInput) -> list[str]:
+        _ = startup
+        self._unsupported("resume")
+
+    def build_fork_command(self, startup: ProviderStartupInput, source_session_id: str) -> list[str]:
+        _ = startup, source_session_id
+        self._unsupported("fork_or_branch")
+
+    def capture_session_id(self, startup: ProviderStartupInput, timeout_s: float = 3.0) -> dict[str, Any] | None:
+        _ = startup, timeout_s
+        return None
+
+    def cleanup(self, startup: ProviderStartupInput) -> None:
+        _ = startup
+
+    def _unsupported(self, capability: str) -> Any:
+        raise ProviderCapabilityError(self.provider, capability, "provider plug exists but is not implemented yet")