@team-agent/installer 0.2.11 → 0.3.0

package/src/team_agent/approvals/runtime_prompts.py

@@ -1,171 +0,0 @@
-from __future__ import annotations
-
-import time
-from pathlib import Path
-from typing import Any
-
-from team_agent.approvals.constants import (
-    INTERNAL_MCP_AUTO_APPROVE_TOOLS,
-    STARTUP_PROMPT_RUNTIME_CHECK_LIMIT,
-)
-from team_agent.approvals.parsing import (
-    approval_choice_keys,
-    approval_prompt_fingerprint,
-    choose_internal_mcp_approval_choice,
-    extract_approval_prompt,
-)
-from team_agent.events import EventLog
-from team_agent.status import APPROVAL_SCAN_LINES
-
-
-def handle_provider_runtime_prompts(workspace: Path, state: dict[str, Any], event_log: EventLog) -> None:
-    from team_agent.runtime import _tmux_session_exists, _tmux_window_exists, get_adapter
-    _ = workspace
-    session_name = state.get("session_name")
-    if not session_name or not _tmux_session_exists(session_name):
-        return
-    for agent_id, agent_state in state.get("agents", {}).items():
-        if agent_state.get("status") in {"paused", "stopped", "missing"}:
-            continue
-        window = agent_state.get("window", agent_id)
-        if not _tmux_window_exists(session_name, window):
-            continue
-        internal_mcp = handle_internal_mcp_approval_prompt(agent_id, session_name, window, event_log)
-        if internal_mcp is not None:
-            continue
-        adapter = get_adapter(agent_state["provider"])
-        for prompt_event in adapter.handle_runtime_prompts(session_name, window):
-            event_log.write(
-                "runtime.prompt_handled",
-                agent_id=agent_id,
-                provider=agent_state["provider"],
-                **prompt_event,
-            )
-
-
-def handle_provider_startup_prompts(workspace: Path, state: dict[str, Any], event_log: EventLog) -> None:
-    from team_agent.runtime import _tmux_session_exists, _tmux_window_exists, get_adapter
-    _ = workspace
-    session_name = state.get("session_name")
-    if not session_name or not _tmux_session_exists(session_name):
-        return
-    for agent_id, agent_state in state.get("agents", {}).items():
-        if agent_state.get("status") in {"paused", "stopped", "missing"}:
-            continue
-        window = agent_state.get("window", agent_id)
-        if not _tmux_window_exists(session_name, window):
-            continue
-        spawned_at = str(agent_state.get("spawned_at") or "")
-        if agent_state.get("startup_prompt_check_spawned_at") != spawned_at:
-            agent_state["startup_prompt_check_spawned_at"] = spawned_at
-            agent_state["startup_prompt_check_count"] = 0
-        check_count = int(agent_state.get("startup_prompt_check_count") or 0)
-        if check_count >= STARTUP_PROMPT_RUNTIME_CHECK_LIMIT:
-            continue
-        agent_state["startup_prompt_check_count"] = check_count + 1
-        adapter = get_adapter(agent_state["provider"])
-        for prompt_event in adapter.handle_startup_prompts(session_name, window, checks=20, sleep_s=0.5):
-            event_log.write(
-                "runtime.startup_prompt_handled",
-                agent_id=agent_id,
-                provider=agent_state["provider"],
-                **prompt_event,
-            )
-
-
-def handle_internal_mcp_approval_prompt(
-    agent_id: str,
-    session_name: str,
-    window: str,
-    event_log: EventLog,
-) -> dict[str, Any] | None:
-    from team_agent.runtime import run_cmd
-    target = f"{session_name}:{window}"
-    proc = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{APPROVAL_SCAN_LINES}", "-t", target], timeout=5)
-    if proc.returncode != 0:
-        return None
-    prompt = extract_approval_prompt(agent_id, proc.stdout)
-    if not prompt or prompt.get("kind") != "mcp_tool":
-        return None
-    tool = str(prompt.get("tool") or "")
-    fingerprint = approval_prompt_fingerprint(prompt)
-    if tool not in INTERNAL_MCP_AUTO_APPROVE_TOOLS:
-        result = {
-            "ok": False,
-            "action": "skipped",
-            "reason": "tool_not_allowlisted",
-            "tool": tool,
-            "fingerprint": fingerprint,
-        }
-        event_log.write("runtime.internal_mcp_approval.skipped", agent_id=agent_id, **result)
-        return result
-    result = submit_internal_mcp_approval(agent_id, target, tool, prompt, proc.stdout)
-    event_log.write("runtime.internal_mcp_approval.auto", agent_id=agent_id, **result)
-    return result
-
-
-def submit_internal_mcp_approval(
-    agent_id: str,
-    target: str,
-    tool: str,
-    prompt: dict[str, Any],
-    capture_text: str,
-    attempts: int = 3,
-) -> dict[str, Any]:
-    from team_agent.runtime import run_cmd
-    choice = choose_internal_mcp_approval_choice(prompt)
-    fingerprint = approval_prompt_fingerprint(prompt)
-    attempt_log: list[dict[str, Any]] = []
-    current_prompt = prompt
-    current_capture = capture_text
-    for attempt in range(1, attempts + 1):
-        keys = approval_choice_keys(current_prompt, current_capture, choice)
-        proc = run_cmd(["tmux", "send-keys", "-t", target, *keys], timeout=10)
-        if proc.returncode != 0:
-            return {
-                "ok": False,
-                "action": "auto_approve",
-                "tool": tool,
-                "choice": choice,
-                "fingerprint": fingerprint,
-                "attempts": attempt_log + [{"attempt": attempt, "submitted": False, "error": proc.stderr.strip()}],
-                "verification": "send_keys_failed",
-            }
-        time.sleep(0.35)
-        verify = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{APPROVAL_SCAN_LINES}", "-t", target], timeout=5)
-        if verify.returncode != 0:
-            attempt_log.append({"attempt": attempt, "submitted": True, "keys": keys, "verification": "capture_failed"})
-            continue
-        after_prompt = extract_approval_prompt(agent_id, verify.stdout)
-        if not after_prompt:
-            return {
-                "ok": True,
-                "action": "auto_approved",
-                "tool": tool,
-                "choice": choice,
-                "fingerprint": fingerprint,
-                "attempts": attempt_log + [{"attempt": attempt, "submitted": True, "keys": keys, "verification": "prompt_absent"}],
-                "verification": "prompt_absent_after_submit",
-            }
-        if after_prompt.get("kind") != "mcp_tool" or after_prompt.get("tool") != tool:
-            return {
-                "ok": True,
-                "action": "auto_approved",
-                "tool": tool,
-                "choice": choice,
-                "fingerprint": fingerprint,
-                "attempts": attempt_log + [{"attempt": attempt, "submitted": True, "keys": keys, "verification": "different_prompt_present"}],
-                "verification": "original_prompt_replaced",
-            }
-        attempt_log.append({"attempt": attempt, "submitted": True, "keys": keys, "verification": "prompt_still_present"})
-        current_prompt = after_prompt
-        current_capture = verify.stdout
-    return {
-        "ok": False,
-        "action": "auto_approve",
-        "tool": tool,
-        "choice": choice,
-        "fingerprint": fingerprint,
-        "attempts": attempt_log,
-        "verification": "prompt_still_present_after_retries",
-    }

package/src/team_agent/approvals/status.py

@@ -1,176 +0,0 @@
-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:
-            status_capture = detect_provider_status(agent_state["provider"], session_name, window, include_capture=True)
-            detected, capture_tail = status_capture if isinstance(status_capture, tuple) else (status_capture, "")
-            if detected:
-                agent_state["status"] = detected
-                if detected == "awaiting_trust_prompt":
-                    agent_state["pane_capture_tail"] = capture_tail
-            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)
-        current_task = current_task_for_agent(state.get("tasks", []), agent_id)
-        pane_delta_recent = False
-        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"):
-                    pane_delta_recent = True
-                    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,
-                    active_task=current_task is not None,
-                    pane_delta_recent=pane_delta_recent,
-                )
-                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
-        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, *, include_capture: bool = False) -> str | tuple[str | None, str] | None:
-    from team_agent.runtime import get_adapter, run_cmd
-    from team_agent.messaging.tmux_prompt import detect_non_input_scrollback
-    proc = run_cmd(["tmux", "capture-pane", "-p", "-t", f"{session_name}:{window}"], timeout=5)
-    if proc.returncode != 0:
-        return (None, "") if include_capture else None
-    if detect_non_input_scrollback(proc.stdout) == "codex_trust_prompt":
-        return ("awaiting_trust_prompt", proc.stdout) if include_capture else "awaiting_trust_prompt"
-    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, proc.stdout) if include_capture else None
-    latest = max(positions, key=positions.get)
-    detected = {"idle": "running", "processing": "busy", "error": "error"}.get(latest)
-    return (detected, proc.stdout) if include_capture else detected

package/src/team_agent/cli/__init__.py

@@ -1,137 +0,0 @@
-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_acknowledge_idle,
-    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_acknowledge_idle',
-    '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',
-
-]