@team-agent/installer 0.1.10 → 0.2.0

package/src/team_agent/launch/config.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from typing import Any
+
+
+DANGEROUS_LEADER_FLAGS = (
+    ("claude", "--dangerously-skip-permissions"),
+    ("claude", "--dangerously-skip-permission"),
+    ("codex", "--dangerously-bypass-approvals-and-sandbox"),
+)
+
+
+def effective_runtime_config(runtime_cfg: dict[str, Any]) -> dict[str, Any]:
+    # Route via the runtime alias surface so tests patching
+    # team_agent.runtime._detect_inherited_dangerous_permissions still take effect.
+    from team_agent.runtime import _detect_inherited_dangerous_permissions
+    effective = dict(runtime_cfg)
+    if effective.get("dangerous_auto_approve"):
+        effective["dangerous_auto_approve_source"] = "runtime_config"
+        effective["dangerous_auto_approve_inherited"] = False
+        return effective
+    inherited = _detect_inherited_dangerous_permissions()
+    if not inherited.get("enabled"):
+        effective["dangerous_auto_approve"] = False
+        effective["dangerous_auto_approve_source"] = "disabled"
+        effective["dangerous_auto_approve_inherited"] = False
+        return effective
+    effective["dangerous_auto_approve"] = True
+    effective["dangerous_auto_approve_source"] = "leader_process"
+    effective["dangerous_auto_approve_inherited"] = True
+    effective["dangerous_auto_approve_provider"] = inherited.get("provider")
+    effective["dangerous_auto_approve_flag"] = inherited.get("flag")
+    return effective
+
+
+def requires_direct_leader_receiver(spec: dict[str, Any], runtime_cfg: dict[str, Any]) -> bool:
+    if runtime_cfg.get("require_leader_receiver") is not None:
+        return bool(runtime_cfg.get("require_leader_receiver"))
+    return any(agent.get("provider") != "fake" for agent in spec.get("agents", []))
+
+
+def detect_inherited_dangerous_permissions() -> dict[str, Any]:
+    # Route via runtime alias so existing patches of
+    # team_agent.runtime._process_ancestry take effect at call time.
+    from team_agent.runtime import _process_ancestry
+    for proc in _process_ancestry(os.getpid()):
+        command = str(proc.get("command") or "")
+        for provider, flag in DANGEROUS_LEADER_FLAGS:
+            if command_has_flag(command, flag):
+                return {
+                    "enabled": True,
+                    "provider": provider,
+                    "flag": flag,
+                    "pid": proc.get("pid"),
+                }
+    return {"enabled": False}
+
+
+def command_has_flag(command: str, flag: str) -> bool:
+    return re.search(rf"(?<!\S){re.escape(flag)}(?!\S)", command) is not None
+
+
+def process_ancestry(pid: int, max_depth: int = 12) -> list[dict[str, Any]]:
+    ancestry: list[dict[str, Any]] = []
+    current = pid
+    seen: set[int] = set()
+    for _ in range(max_depth):
+        if current in seen or current <= 0:
+            break
+        seen.add(current)
+        info = process_info(current)
+        if not info:
+            break
+        ancestry.append(info)
+        parent = info.get("ppid")
+        if not isinstance(parent, int) or parent <= 1 or parent == current:
+            break
+        current = parent
+    return ancestry
+
+
+def process_info(pid: int) -> dict[str, Any] | None:
+    try:
+        proc = subprocess.run(
+            ["ps", "-p", str(pid), "-o", "ppid=", "-o", "command="],
+            text=True,
+            capture_output=True,
+            timeout=2,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if proc.returncode != 0:
+        return None
+    line = proc.stdout.strip()
+    if not line:
+        return None
+    parts = line.split(None, 1)
+    try:
+        ppid = int(parts[0])
+    except (IndexError, ValueError):
+        return None
+    return {"pid": pid, "ppid": ppid, "command": parts[1] if len(parts) > 1 else ""}

package/src/team_agent/launch/core.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from team_agent.events import EventLog
+from team_agent.launch.bootstrap import (
+    attach_team_profile_dirs,
+    spec_team_dir,
+    tmux_session_conflict_error,
+)
+from team_agent.launch.config import effective_runtime_config, requires_direct_leader_receiver
+from team_agent.launch.requirements import ensure_agent_start_requirements
+from team_agent.message_store import MessageStore
+from team_agent.permissions import resolve_permissions
+from team_agent.routing import route_task
+from team_agent.spec import load_spec, workspace_from_spec
+from team_agent.state import (
+    load_runtime_state,
+    merge_workspace_team_state,
+    populate_team_owner_from_env,
+    save_runtime_state,
+    write_team_state,
+)
+
+
+def launch(
+    spec_path: Path,
+    dry_run: bool = False,
+    auto_approve: bool = False,
+    skip_profile_smoke: bool = False,
+) -> dict[str, Any]:
+    from team_agent.runtime import (
+        GHOSTTY_DISPLAY_BACKENDS,
+        RuntimeError,
+        _attach_leader_to_state,
+        _capture_agent_session,
+        _enable_codex_fast_mode,
+        _open_worker_displays,
+        _save_team_runtime_snapshot,
+        _tmux_session_exists,
+        ensure_workspace_dirs,
+        get_adapter,
+        get_adapter_or_raise,
+        run_cmd,
+        shell_command_for_agent,
+    )
+
+    spec = load_spec(spec_path)
+    workspace = workspace_from_spec(spec, spec_path)
+    team_dir = spec_team_dir(spec_path, workspace)
+    attach_team_profile_dirs(spec, spec_path, workspace, team_dir)
+    ensure_workspace_dirs(workspace)
+    event_log = EventLog(workspace)
+    session_name = spec.get("runtime", {}).get("session_name") or f"team-{spec['team']['name']}"
+    state = {
+        "spec_path": str(spec_path.resolve()),
+        "workspace": str(workspace),
+        "team_dir": str(team_dir),
+        "session_name": session_name,
+        "leader": spec.get("leader"),
+        "agents": {},
+        "tasks": [dict(task) for task in spec.get("tasks", [])],
+        "display_backend": spec.get("runtime", {}).get("display_backend", "none"),
+    }
+    runtime_cfg = effective_runtime_config(spec.get("runtime", {}))
+    dangerous_auto_approve = bool(runtime_cfg.get("dangerous_auto_approve"))
+    dangerous_inherited = bool(runtime_cfg.get("dangerous_auto_approve_inherited"))
+
+    routing_decisions: list[dict[str, Any]] = []
+    for task in state["tasks"]:
+        route = route_task(spec, task)
+        task["assignee"] = route["agent_id"]
+        decision = {
+            "source": "launch",
+            "task_id": task.get("id"),
+            "selected_agent": route["agent_id"],
+            "reason": route["reason"],
+            "manual_override": False,
+        }
+        routing_decisions.append(decision)
+        event_log.write("routing.decision", **decision)
+
+    permission_summary = [resolve_permissions(agent) for agent in spec.get("agents", [])]
+    event_log.write(
+        "launch.permissions_resolved",
+        permissions=permission_summary,
+        dangerous_auto_approve=dangerous_auto_approve,
+        dangerous_auto_approve_source=runtime_cfg.get("dangerous_auto_approve_source"),
+    )
+    if dry_run:
+        return {
+            "ok": True,
+            "dry_run": True,
+            "session_name": session_name,
+            "permissions": permission_summary,
+            "routes": routing_decisions,
+            "safety": {
+                "dangerous_auto_approve": dangerous_auto_approve,
+                "dangerous_auto_approve_source": runtime_cfg.get("dangerous_auto_approve_source"),
+                "dangerous_auto_approve_inherited": dangerous_inherited,
+                "requires_explicit_yes": dangerous_auto_approve and not dangerous_inherited,
+            },
+        }
+    if dangerous_auto_approve:
+        event_log.write(
+            "launch.dangerous_auto_approve_requested",
+            reason="provider may bypass approvals or sandbox",
+            source=runtime_cfg.get("dangerous_auto_approve_source"),
+            inherited=dangerous_inherited,
+            inherited_provider=runtime_cfg.get("dangerous_auto_approve_provider"),
+            inherited_flag=runtime_cfg.get("dangerous_auto_approve_flag"),
+        )
+    if dangerous_auto_approve and not dangerous_inherited and not auto_approve:
+        raise RuntimeError("dangerous_auto_approve requires explicit --yes after reviewing launch risk")
+    if runtime_cfg.get("require_user_approval_before_launch", True) and not auto_approve:
+        raise RuntimeError("launch requires approval; rerun with --yes after reviewing resolved permissions")
+
+    tmux = get_adapter_or_raise("tmux")
+    _ = tmux
+    if _tmux_session_exists(session_name):
+        event_log.write(
+            "launch.session_conflict",
+            session=session_name,
+            action="use a different team name or runtime.session_name; do not terminate existing tmux sessions from startup",
+        )
+        raise RuntimeError(tmux_session_conflict_error(session_name))
+    ensure_agent_start_requirements(
+        workspace,
+        spec.get("agents", []),
+        event_log,
+        "launch",
+        skip_profile_smoke=skip_profile_smoke,
+    )
+
+    leader_receiver = None
+    leader_provider = state.get("leader", {}).get("provider")
+    require_leader_receiver = requires_direct_leader_receiver(spec, runtime_cfg)
+    if runtime_cfg.get("auto_attach_leader", True) and leader_provider != "fake":
+        try:
+            leader_receiver, _ = _attach_leader_to_state(
+                workspace,
+                state,
+                pane=None,
+                provider=leader_provider,
+                event_log=event_log,
+                source="launch",
+                require_current=require_leader_receiver,
+            )
+        except RuntimeError as exc:
+            event_log.write(
+                "leader_receiver.auto_attach_skipped",
+                provider=leader_provider,
+                reason=str(exc),
+                required=require_leader_receiver,
+                suggestion="Start the leader with `team-agent codex` or run quick-start from an existing tmux pane.",
+            )
+            if require_leader_receiver:
+                raise
+
+    first = True
+    started: list[dict[str, Any]] = []
+    display_jobs: list[tuple[str, dict[str, Any]]] = []
+    for agent in spec.get("agents", []):
+        if agent.get("paused"):
+            state["agents"][agent["id"]] = {"status": "paused", "provider": agent["provider"]}
+            continue
+        adapter = get_adapter(agent["provider"])
+        if not adapter.is_installed():
+            event_log.write(
+                "launch.provider_missing",
+                agent_id=agent["id"],
+                provider=agent["provider"],
+                command=adapter.command_name,
+            )
+            raise RuntimeError(
+                f"Provider {agent['provider']} command {adapter.command_name!r} not found for agent {agent['id']}"
+            )
+        mcp_config = adapter.mcp_config(workspace, agent["id"])
+        mcp_path = adapter.install_mcp(workspace, agent["id"], mcp_config)
+        command_agent = dict(agent)
+        command_agent["_runtime"] = runtime_cfg
+        command = shell_command_for_agent(command_agent, workspace, mcp_config)
+        spawn_time = datetime.now(timezone.utc)
+        event_log.write(
+            "launch.agent_start",
+            agent_id=agent["id"],
+            provider=agent["provider"],
+            session=session_name,
+            window=agent["id"],
+            command=command,
+            mcp_config=str(mcp_path),
+        )
+        if first:
+            proc = run_cmd(["tmux", "new-session", "-d", "-s", session_name, "-n", agent["id"], "sh", "-lc", command])
+            first = False
+        else:
+            proc = run_cmd(["tmux", "new-window", "-t", session_name, "-n", agent["id"], "sh", "-lc", command])
+        if proc.returncode != 0:
+            try:
+                adapter.cleanup_mcp(workspace, agent["id"], mcp_path)
+            except Exception as exc:
+                event_log.write(
+                    "launch.mcp_cleanup_failed",
+                    agent_id=agent["id"],
+                    provider=agent["provider"],
+                    mcp_config=str(mcp_path),
+                    error=str(exc),
+                )
+            event_log.write(
+                "launch.agent_failed",
+                agent_id=agent["id"],
+                stderr=proc.stderr,
+                stdout=proc.stdout,
+            )
+            raise RuntimeError(f"Failed to start agent {agent['id']}: {proc.stderr.strip()}")
+        handled_prompts = adapter.handle_startup_prompts(session_name, agent["id"], checks=1, sleep_s=0.0)
+        for prompt_event in handled_prompts:
+            event_log.write(
+                "launch.startup_prompt_handled",
+                agent_id=agent["id"],
+                provider=agent["provider"],
+                **prompt_event,
+            )
+        if runtime_cfg.get("fast") and agent.get("provider") == "codex":
+            fast_result = _enable_codex_fast_mode(session_name, agent["id"])
+            event_log.write("launch.codex_fast_mode", agent_id=agent["id"], **fast_result)
+        state["agents"][agent["id"]] = {
+            "status": "running",
+            "provider": agent["provider"],
+            "agent_id": agent["id"],
+            "model": agent.get("model"),
+            "auth_mode": agent.get("auth_mode"),
+            "profile": agent.get("profile"),
+            "window": agent["id"],
+            "mcp_config": str(mcp_path),
+            "permissions": resolve_permissions(agent),
+            "session_id": None,
+            "rollout_path": None,
+            "captured_at": None,
+            "captured_via": None,
+            "attribution_confidence": None,
+            "spawn_cwd": str(workspace),
+            "spawned_at": spawn_time.isoformat(),
+        }
+        profile_launch = command_agent.get("_provider_profile") or {}
+        if profile_launch.get("claude_projects_root"):
+            state["agents"][agent["id"]]["claude_projects_root"] = profile_launch["claude_projects_root"]
+        if command_agent.get("_session_id"):
+            state["agents"][agent["id"]]["_pending_session_id"] = command_agent["_session_id"]
+        known_session_ids = {
+            str(item.get("session_id"))
+            for aid, item in state.get("agents", {}).items()
+            if aid != agent["id"] and item.get("session_id")
+        }
+        _capture_agent_session(
+            workspace,
+            agent["id"],
+            state["agents"][agent["id"]],
+            event_log,
+            timeout_s=1.5,
+            exclude_session_ids=known_session_ids,
+        )
+        if state.get("display_backend") in GHOSTTY_DISPLAY_BACKENDS:
+            display_jobs.append((agent["id"], agent))
+        started.append({"agent_id": agent["id"], "provider": agent["provider"], "window": agent["id"]})
+    for agent_id, display in _open_worker_displays(
+        workspace,
+        session_name,
+        display_jobs,
+        event_log,
+        state.get("display_backend", "none"),
+    ).items():
+        if agent_id in state["agents"]:
+            state["agents"][agent_id]["display"] = display
+    populate_team_owner_from_env(state, source="launch")
+    workspace_state = merge_workspace_team_state(load_runtime_state(workspace), state)
+    save_runtime_state(workspace, workspace_state)
+    _save_team_runtime_snapshot(workspace, state)
+    MessageStore(workspace)
+    write_team_state(workspace, spec, state)
+    event_log.write("launch.complete", session=session_name, started=started)
+    return {
+        "ok": True,
+        "session_name": session_name,
+        "agents": started,
+        "permissions": permission_summary,
+        "routes": routing_decisions,
+        "leader_receiver": leader_receiver,
+    }

package/src/team_agent/launch/requirements.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from team_agent.diagnose import (
+    compact_model_checks,
+    format_model_check_failures,
+    format_profile_check_failures,
+    format_profile_smoke_failures,
+    model_checks_for_agents,
+    profile_checks_for_agents,
+    profile_smoke_checks_for_agents,
+)
+from team_agent.events import EventLog
+from team_agent.profiles import compact_profile_check
+
+
+def ensure_agent_start_requirements(
+    workspace: Path,
+    agents: list[dict[str, Any]],
+    event_log: EventLog,
+    event_prefix: str,
+    skip_profile_smoke: bool = False,
+) -> None:
+    from team_agent.runtime import RuntimeError, get_adapter
+    active_agents = [agent for agent in agents if not agent.get("paused")]
+    for agent in active_agents:
+        adapter = get_adapter(agent["provider"])
+        if not adapter.is_installed():
+            event_log.write(
+                f"{event_prefix}.provider_missing",
+                agent_id=agent["id"],
+                provider=agent["provider"],
+                command=adapter.command_name,
+            )
+            raise RuntimeError(
+                f"Provider {agent['provider']} command {adapter.command_name!r} not found for agent {agent['id']}"
+            )
+    profile_checks = profile_checks_for_agents(workspace, active_agents)
+    profile_failures = [item for item in profile_checks if item.get("ok") is False]
+    event_log.write(f"{event_prefix}.profile_check", ok=not profile_failures, checks=[compact_profile_check(item) for item in profile_checks])
+    if profile_failures:
+        raise RuntimeError(format_profile_check_failures(profile_failures))
+    if skip_profile_smoke:
+        event_log.write(f"{event_prefix}.profile_smoke_check", ok=True, skipped=True, reason="already_checked")
+    else:
+        smoke_checks = profile_smoke_checks_for_agents(workspace, active_agents)
+        smoke_failures = [item for item in smoke_checks if item.get("ok") is False]
+        event_log.write(f"{event_prefix}.profile_smoke_check", ok=not smoke_failures, checks=[compact_profile_check(item) for item in smoke_checks])
+        if smoke_failures:
+            raise RuntimeError(format_profile_smoke_failures(smoke_failures))
+    checks = model_checks_for_agents(active_agents, workspace)
+    failures = [item for item in checks if item.get("ok") is False]
+    event_log.write(f"{event_prefix}.model_check", ok=not failures, checks=compact_model_checks(checks))
+    if failures:
+        raise RuntimeError(format_model_check_failures(failures))