@team-agent/installer 0.1.10 → 0.2.0

package/src/team_agent/approvals/status.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import hashlib
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from team_agent.approvals.parsing import capture_has_approval_prompt
+from team_agent.events import EventLog
+from team_agent.message_store import MessageStore
+from team_agent.state import team_state_key
+
+
+def refresh_agent_runtime_statuses(workspace: Path, state: dict[str, Any], event_log: EventLog) -> None:
+    from team_agent.runtime import _tmux_session_exists, _tmux_window_exists
+    _ = workspace
+    session_name = state.get("session_name")
+    tmux_exists = _tmux_session_exists(session_name) if session_name else False
+    for agent_id, agent_state in state.get("agents", {}).items():
+        if agent_state.get("status") in {"paused", "stopped"}:
+            continue
+        old_status = agent_state.get("status")
+        window = agent_state.get("window", agent_id)
+        window_present = _tmux_window_exists(session_name, window) if tmux_exists else False
+        agent_state["tmux_window_present"] = window_present
+        if not window_present:
+            if session_name:
+                agent_state["status"] = "missing"
+        else:
+            detected = detect_provider_status(agent_state["provider"], session_name, window)
+            if detected:
+                agent_state["status"] = detected
+            else:
+                agent_state.setdefault("status", "running")
+        if old_status != agent_state.get("status"):
+            event_log.write(
+                "runtime.status_detected",
+                agent_id=agent_id,
+                provider=agent_state.get("provider"),
+                old_status=old_status,
+                status=agent_state.get("status"),
+            )
+
+
+def sync_agent_health(workspace: Path, state: dict[str, Any], store: MessageStore | None = None) -> dict[str, dict[str, Any]]:
+    from team_agent.runtime import _tmux_window_exists, _tmux_pane_info, run_cmd
+    from team_agent.messaging.activity_detector import classify_agent_activity
+    store = store or MessageStore(workspace)
+    session_name = state.get("session_name")
+    owner_team_id = team_state_key(state)
+    captures: dict[str, dict[str, Any]] = {}
+    for agent_id, agent_state in state.get("agents", {}).items():
+        health_status = agent_health_status(agent_state)
+        last_output_at = agent_state.get("last_output_at")
+        window = agent_state.get("window", agent_id)
+        scrollback = ""
+        pane_info: dict[str, Any] | None = None
+        if session_name and _tmux_window_exists(session_name, window):
+            proc = run_cmd(["tmux", "capture-pane", "-p", "-S", "-40", "-t", f"{session_name}:{window}"], timeout=5)
+            if proc.returncode == 0:
+                scrollback = proc.stdout
+                digest = hashlib.sha256(proc.stdout.encode("utf-8", errors="ignore")).hexdigest()
+                if digest != agent_state.get("last_output_hash"):
+                    last_output_at = datetime.now(timezone.utc).isoformat()
+                    agent_state["last_output_hash"] = digest
+                    agent_state["last_output_at"] = last_output_at
+                if capture_has_approval_prompt(proc.stdout):
+                    health_status = "AWAITING_APPROVAL"
+            try:
+                pane_info = _tmux_pane_info(f"{session_name}:{window}")
+            except Exception:
+                pane_info = None
+            if scrollback and health_status != "AWAITING_APPROVAL":
+                activity = classify_agent_activity(
+                    agent_id,
+                    agent_state.get("provider") or "",
+                    last_output_at,
+                    pane_info,
+                    scrollback,
+                )
+                agent_state["activity"] = {
+                    "status": activity.get("status"),
+                    "confidence": activity.get("confidence"),
+                    "rationale": activity.get("rationale"),
+                    "classified_at": datetime.now(timezone.utc).isoformat(),
+                }
+                if activity.get("confidence", 0) >= 0.85:
+                    raw = str(activity.get("status") or "")
+                    mapping = {"idle": "IDLE", "working": "WORKING", "stuck": "STUCK", "uncertain": "UNCERTAIN"}
+                    mapped = mapping.get(raw)
+                    if mapped:
+                        health_status = mapped
+        current_task = current_task_for_agent(state.get("tasks", []), agent_id)
+        store.upsert_agent_health(
+            agent_id,
+            health_status,
+            last_output_at=last_output_at,
+            context_usage_pct=agent_state.get("context_usage_pct"),
+            current_task_id=current_task,
+            owner_team_id=owner_team_id,
+        )
+        captures[agent_id] = {"scrollback": scrollback, "pane_info": pane_info, "health_status": health_status}
+    return captures
+
+
+def agent_health_status(agent_state: dict[str, Any]) -> str:
+    raw = str(agent_state.get("status") or "").lower()
+    if raw in {"busy", "running"}:
+        return "RUNNING" if raw == "busy" else "IDLE"
+    if raw in {"paused", "blocked"}:
+        return "BLOCKED"
+    if raw in {"error", "missing", "interrupted"}:
+        return "ERROR"
+    if raw in {"stopped", "done"}:
+        return "DONE"
+    return "IDLE"
+
+
+def current_task_for_agent(tasks: list[dict[str, Any]], agent_id: str) -> str | None:
+    active = {"pending", "ready", "running", "blocked", "needs_retry"}
+    for task in reversed(tasks):
+        if task.get("assignee") == agent_id and task.get("status", "pending") in active:
+            return task.get("id")
+    return None
+
+
+def age_text(iso_text: str | None) -> str:
+    if not iso_text:
+        return "-"
+    try:
+        dt = datetime.fromisoformat(iso_text)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        seconds = max(0, int((datetime.now(timezone.utc) - dt).total_seconds()))
+    except ValueError:
+        return "-"
+    if seconds < 60:
+        return f"{seconds}s ago"
+    minutes = seconds // 60
+    if minutes < 60:
+        return f"{minutes}m ago"
+    return f"{minutes // 60}h ago"
+
+
+def detect_provider_status(provider: str, session_name: str, window: str) -> str | None:
+    from team_agent.runtime import get_adapter, run_cmd
+    proc = run_cmd(["tmux", "capture-pane", "-p", "-t", f"{session_name}:{window}"], timeout=5)
+    if proc.returncode != 0:
+        return None
+    patterns = get_adapter(provider).status_patterns()
+    positions: dict[str, int] = {}
+    for status_name, pattern in patterns.items():
+        if not pattern:
+            continue
+        try:
+            matches = list(re.finditer(pattern, proc.stdout, re.MULTILINE))
+        except re.error:
+            continue
+        if matches:
+            positions[status_name] = matches[-1].start()
+    if not positions:
+        return None
+    latest = max(positions, key=positions.get)
+    return {"idle": "running", "processing": "busy", "error": "error"}.get(latest)

package/src/team_agent/cli/__init__.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from team_agent.cli.parser import (
+    SEND_ORDER_HINT,
+    TeamAgentArgumentParser,
+    _run_leader_passthrough,
+    add_json,
+    main,
+)
+from team_agent.cli.helpers import (
+    _cli_error_payload,
+    _emit_cli_error,
+    _leader_launcher_args,
+    _provider_args,
+    _tmux_session_conflict_action,
+    _tmux_session_conflict_name,
+    _tmux_session_conflict_next_action,
+    _workspace_from_args,
+    emit,
+)
+from team_agent.cli.commands import (
+    cmd_quick_start,
+    cmd_codex,
+    cmd_claude,
+    cmd_init,
+    cmd_validate,
+    cmd_compile,
+    _profile_scope,
+    cmd_profile_init,
+    cmd_profile_doctor,
+    cmd_profile_show,
+    cmd_launch,
+    cmd_preflight,
+    cmd_start,
+    cmd_wait_ready,
+    cmd_settle,
+    cmd_status,
+    cmd_approvals,
+    cmd_peek,
+    cmd_inbox,
+    cmd_sessions,
+    cmd_attach_leader,
+    cmd_send,
+    cmd_collect,
+    cmd_diagnose,
+    cmd_repair_state,
+    cmd_validate_result,
+    cmd_doctor,
+    cmd_shutdown,
+    cmd_restart,
+    cmd_start_agent,
+    cmd_stop_agent,
+    cmd_reset_agent,
+    cmd_add_agent,
+    cmd_fork_agent,
+    cmd_remove_agent,
+    cmd_stuck_list,
+    cmd_stuck_cancel,
+    cmd_allow_peer_talk,
+    cmd_advanced,
+    cmd_install_skill,
+    _skill_dest_dir,
+    _install_skill_to,
+
+)
+from team_agent.cli.e2e import (
+    _fake_spec,
+    _run_fake_e2e,
+    _run_real_launch_smoke,
+    cmd_e2e,
+)
+
+__all__ = [
+    'SEND_ORDER_HINT',
+    'TeamAgentArgumentParser',
+    'main',
+    'add_json',
+    '_run_leader_passthrough',
+    'emit',
+    '_workspace_from_args',
+    '_emit_cli_error',
+    '_cli_error_payload',
+    '_tmux_session_conflict_name',
+    '_tmux_session_conflict_next_action',
+    '_tmux_session_conflict_action',
+    '_provider_args',
+    '_leader_launcher_args',
+    'cmd_quick_start',
+    'cmd_codex',
+    'cmd_claude',
+    'cmd_init',
+    'cmd_validate',
+    'cmd_compile',
+    '_profile_scope',
+    'cmd_profile_init',
+    'cmd_profile_doctor',
+    'cmd_profile_show',
+    'cmd_launch',
+    'cmd_preflight',
+    'cmd_start',
+    'cmd_wait_ready',
+    'cmd_settle',
+    'cmd_status',
+    'cmd_approvals',
+    'cmd_peek',
+    'cmd_inbox',
+    'cmd_sessions',
+    'cmd_attach_leader',
+    'cmd_send',
+    'cmd_collect',
+    'cmd_diagnose',
+    'cmd_repair_state',
+    'cmd_validate_result',
+    'cmd_doctor',
+    'cmd_shutdown',
+    'cmd_restart',
+    'cmd_start_agent',
+    'cmd_stop_agent',
+    'cmd_reset_agent',
+    'cmd_add_agent',
+    'cmd_fork_agent',
+    'cmd_remove_agent',
+    'cmd_stuck_list',
+    'cmd_stuck_cancel',
+    'cmd_allow_peer_talk',
+    'cmd_advanced',
+    'cmd_install_skill',
+    '_skill_dest_dir',
+    '_install_skill_to',
+    'cmd_e2e',
+    '_run_fake_e2e',
+    '_run_real_launch_smoke',
+    '_fake_spec',
+
+]

package/src/team_agent/cli/commands.py

@@ -0,0 +1,335 @@
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+
+from team_agent import compiler, profiles, runtime
+from team_agent.errors import TeamAgentError
+from team_agent.paths import repo_root, team_workspace
+from team_agent.spec import validate_result_envelope
+
+from team_agent.cli.helpers import _provider_args
+
+
+def cmd_quick_start(args: argparse.Namespace) -> dict[str, Any]:
+    result = runtime.quick_start(Path(args.agents_dir), name=args.name, yes=args.yes, fresh=args.fresh, team_id=args.team_id)
+    if args.json or not result.get("ok"):
+        return result
+    return result["summary"]
+
+
+def cmd_codex(args: argparse.Namespace) -> None:
+    runtime.start_leader("codex", _provider_args(args.provider_args), Path.cwd().resolve())
+
+
+def cmd_claude(args: argparse.Namespace) -> None:
+    runtime.start_leader("claude_code", _provider_args(args.provider_args), Path.cwd().resolve())
+
+
+def cmd_init(args: argparse.Namespace) -> dict[str, Any]:
+    paths = runtime.init_workspace(Path(args.workspace).resolve(), force=args.force)
+    return {"ok": True, "spec": str(paths["spec"]), "state": str(paths["state"])}
+
+
+def cmd_validate(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.validate_file(Path(args.spec).resolve())
+
+
+def cmd_compile(args: argparse.Namespace) -> dict[str, Any]:
+    result = compiler.compile_team(Path(args.team).resolve(), Path(args.out).resolve())
+    return {"ok": True, "team_dir": result["team_dir"], "out": result["out"], "agents": [a["id"] for a in result["spec"]["agents"]]}
+
+
+def _profile_scope(args: argparse.Namespace) -> tuple[Path, Path | None]:
+    team = getattr(args, "team", None)
+    if team:
+        team_dir = Path(team).resolve()
+        return team_workspace(team_dir), team_dir / "profiles"
+    return Path(args.workspace).resolve(), None
+
+
+def cmd_profile_init(args: argparse.Namespace) -> dict[str, Any]:
+    workspace, profiles_dir = _profile_scope(args)
+    return profiles.init_profile(workspace, args.name, args.auth_mode, profiles_dir=profiles_dir)
+
+
+def cmd_profile_doctor(args: argparse.Namespace) -> dict[str, Any]:
+    workspace, profiles_dir = _profile_scope(args)
+    return profiles.doctor_profile(workspace, args.name, profiles_dir=profiles_dir)
+
+
+def cmd_profile_show(args: argparse.Namespace) -> dict[str, Any]:
+    workspace, profiles_dir = _profile_scope(args)
+    return profiles.show_profile(workspace, args.name, profiles_dir=profiles_dir)
+
+
+def cmd_launch(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.launch(Path(args.spec).resolve(), dry_run=args.dry_run, auto_approve=args.yes)
+
+
+def cmd_preflight(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.preflight(Path(args.team).resolve())
+
+
+def cmd_start(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.start(Path(args.team).resolve(), yes=args.yes)
+
+
+def cmd_wait_ready(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.wait_ready(Path(args.workspace).resolve(), timeout=args.timeout)
+
+
+def cmd_settle(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.settle(Path(args.workspace).resolve())
+
+
+def cmd_status(args: argparse.Namespace) -> dict[str, Any]:
+    if args.json:
+        return runtime.status(Path(args.workspace).resolve(), as_json=True, compact=not args.detail)
+    return runtime.format_status(Path(args.workspace).resolve(), args.agent)
+
+
+def cmd_approvals(args: argparse.Namespace) -> dict[str, Any]:
+    if args.json:
+        return runtime.approvals(Path(args.workspace).resolve(), agent_id=args.agent)
+    return runtime.format_approvals(Path(args.workspace).resolve(), agent_id=args.agent)
+
+
+def cmd_peek(args: argparse.Namespace) -> dict[str, Any]:
+    if not args.allow_raw_screen:
+        raise TeamAgentError(
+            "raw worker terminal inspection requires explicit user authorization and --allow-raw-screen; "
+            "normal operation must use status, approvals, inbox, collect, or event logs"
+        )
+    result = runtime.peek(
+        Path(args.workspace).resolve(),
+        args.agent,
+        head=args.head,
+        tail=args.tail,
+        search=args.search,
+        context=args.context,
+    )
+    if args.json:
+        return result
+    return result["text"]
+
+
+def cmd_inbox(args: argparse.Namespace) -> dict[str, Any]:
+    if args.json:
+        return runtime.inbox(Path(args.workspace).resolve(), args.agent, limit=args.limit)
+    return runtime.format_inbox(Path(args.workspace).resolve(), args.agent, limit=args.limit)
+
+
+def cmd_sessions(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.sessions(Path(args.workspace).resolve())
+
+
+def cmd_attach_leader(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.attach_leader(Path(args.workspace).resolve(), pane=args.pane, provider=args.provider)
+
+
+def cmd_takeover(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.takeover(Path(args.workspace).resolve(), team=args.team, confirm=args.confirm)
+
+
+def cmd_send(args: argparse.Namespace) -> dict[str, Any]:
+    target = _send_target(args)
+    return runtime.send_message(
+        Path(args.workspace).resolve(),
+        target,
+        " ".join(args.message),
+        task_id=args.task,
+        sender=args.sender,
+        requires_ack=not args.no_ack,
+        confirm_human=args.confirm_human,
+        wait_visible=not args.no_wait,
+        timeout=args.timeout,
+        watch_result=args.watch_result,
+        team=args.team,
+    )
+
+
+def _send_target(args: argparse.Namespace) -> str | list[str] | None:
+    if getattr(args, "targets", None):
+        return [item.strip() for item in args.targets.split(",") if item.strip()]
+    return args.target
+
+
+def cmd_collect(args: argparse.Namespace) -> dict[str, Any]:
+    result_file = Path(args.result_file).resolve() if args.result_file else None
+    return runtime.collect(Path(args.workspace).resolve(), result_file=result_file)
+
+
+def cmd_diagnose(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.diagnose(Path(args.workspace).resolve())
+
+
+def cmd_repair_state(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.repair_state(
+        Path(args.workspace).resolve(),
+        task_id=args.task,
+        assignee=args.assignee,
+        status_value=args.status,
+        summary=args.summary,
+    )
+
+
+def cmd_validate_result(args: argparse.Namespace) -> dict[str, Any]:
+    if args.file:
+        raw = Path(args.file).read_text(encoding="utf-8")
+    elif args.result:
+        raw = args.result
+    else:
+        raw = sys.stdin.read()
+    envelope = json.loads(raw)
+    validate_result_envelope(envelope)
+    return {"ok": True, "task_id": envelope["task_id"], "agent_id": envelope["agent_id"], "status": envelope["status"]}
+
+
+def cmd_doctor(args: argparse.Namespace) -> dict[str, Any]:
+    spec = Path(args.spec).resolve() if args.spec else None
+    return runtime.doctor(spec)
+
+
+def cmd_shutdown(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.shutdown(Path(args.workspace).resolve(), keep_logs=args.keep_logs, team=args.team)
+
+
+def cmd_restart(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.restart(Path(args.workspace).resolve(), allow_fresh=args.allow_fresh, team=args.team)
+
+
+def cmd_start_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.start_agent(
+        Path(args.workspace).resolve(),
+        args.agent,
+        force=args.force,
+        open_display=not args.no_display,
+        allow_fresh=args.allow_fresh,
+        team=args.team,
+    )
+
+
+def cmd_stop_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.stop_agent(Path(args.workspace).resolve(), args.agent, team=args.team)
+
+
+def cmd_reset_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.reset_agent(
+        Path(args.workspace).resolve(),
+        args.agent,
+        discard_session=args.discard_session,
+        open_display=not args.no_display,
+        team=args.team,
+    )
+
+
+def cmd_add_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.add_agent(
+        Path(args.workspace).resolve(),
+        args.agent,
+        role_file_path=args.role_file,
+        open_display=not args.no_display,
+        team=args.team,
+    )
+
+
+def cmd_fork_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.fork_agent(
+        Path(args.workspace).resolve(),
+        args.source_agent,
+        as_agent_id=args.as_agent,
+        label=args.label,
+        open_display=not args.no_display,
+        team=args.team,
+    )
+
+
+def cmd_remove_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.remove_agent(
+        Path(args.workspace).resolve(),
+        args.agent,
+        from_spec=args.from_spec,
+        confirm=args.confirm,
+        force=args.force,
+        team=args.team,
+    )
+
+
+def cmd_stuck_list(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.stuck_list(Path(args.workspace).resolve())
+
+
+def cmd_stuck_cancel(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.stuck_cancel(
+        Path(args.workspace).resolve(),
+        args.agent,
+        alert_type=args.alert_type,
+        suppressed_by="leader",
+    )
+
+
+def cmd_allow_peer_talk(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.allow_peer_talk(Path(args.workspace).resolve(), args.agent_a, args.agent_b)
+
+
+def cmd_run_overnight(args: argparse.Namespace) -> dict[str, Any]:
+    from team_agent import orchestrator
+    workspace = Path(args.workspace).resolve()
+    if args.status:
+        return orchestrator.plan_status(workspace, plan_id=args.plan_id)
+    if args.halt:
+        if not args.plan_id:
+            raise TeamAgentError("--halt requires --plan-id")
+        return orchestrator.halt_plan(workspace, args.plan_id, reason=args.reason)
+    if not args.plan:
+        raise TeamAgentError("--plan PATH is required unless --status or --halt is used")
+    return orchestrator.start_plan(workspace, Path(args.plan).resolve(), start=not args.no_start)
+
+
+def cmd_advanced(args: argparse.Namespace) -> str:
+    return "\n".join(
+        [
+            "Low-level commands:",
+            "  init validate compile profile launch preflight start wait-ready settle",
+            "  sessions attach-leader collect diagnose repair-state validate-result",
+            "  install-skill e2e",
+        ]
+    )
+
+
+def cmd_install_skill(args: argparse.Namespace) -> dict[str, Any]:
+    source = repo_root() / "skills" / "team-agent"
+    if args.dest and args.target == "all":
+        raise TeamAgentError("--dest cannot be combined with --target all")
+    if args.dest:
+        dest_dir = Path(args.dest).expanduser().resolve()
+        return _install_skill_to(source, dest_dir, args.dry_run)
+    if args.target == "all":
+        results = [
+            _install_skill_to(source, _skill_dest_dir("codex"), args.dry_run),
+            _install_skill_to(source, _skill_dest_dir("claude"), args.dry_run),
+        ]
+        return {"ok": all(item["ok"] for item in results), "targets": results}
+    return _install_skill_to(source, _skill_dest_dir(args.target), args.dry_run)
+
+
+def _skill_dest_dir(target: str) -> Path:
+    if target == "claude":
+        dest_dir = Path.home() / ".claude" / "skills" / "team-agent"
+    else:
+        dest_dir = Path.home() / ".codex" / "skills" / "team-agent"
+    return dest_dir
+
+
+def _install_skill_to(source: Path, dest_dir: Path, dry_run: bool) -> dict[str, Any]:
+    dest = dest_dir / "SKILL.md"
+    if dry_run:
+        return {"ok": True, "source": str(source / "SKILL.md"), "dest": str(dest), "dry_run": True}
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(source, dest_dir, dirs_exist_ok=True)
+    return {"ok": True, "source": str(source / "SKILL.md"), "dest": str(dest)}