@team-agent/installer 0.1.10 → 0.2.0

package/crates/team-agent-core/src/lib.rs

@@ -215,15 +215,54 @@ pub fn validate_profile(profile: &Profile) -> Result<(), Vec<String>> {
 }
 
 pub fn contains_inline_secret(value: &str) -> bool {
-    let lower = value.to_ascii_lowercase();
-    lower.contains("api_key")
-        || lower.contains("apikey")
-        || lower.contains("token")
-        || lower.contains("secret")
+    contains_secret_assignment(value)
+        || contains_bearer_secret(value)
+        || value
+            .split_whitespace()
+            .any(|chunk| chunk.starts_with("sk-") || looks_base64_secret(chunk))
         || value.starts_with("sk-")
         || looks_base64_secret(value)
 }
 
+fn contains_secret_assignment(value: &str) -> bool {
+    for line in value.lines() {
+        for separator in ['=', ':'] {
+            let Some((key, raw)) = line.split_once(separator) else {
+                continue;
+            };
+            let normalized: String = key
+                .to_ascii_lowercase()
+                .chars()
+                .filter(|ch| ch.is_ascii_alphanumeric())
+                .collect();
+            if !matches!(
+                normalized.as_str(),
+                "apikey" | "token" | "secret" | "password" | "credential"
+            ) {
+                continue;
+            }
+            let candidate = raw.trim().trim_matches(|ch| ch == '"' || ch == '\'');
+            if candidate.starts_with("sk-") || candidate.len() >= 8 || looks_base64_secret(candidate) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn contains_bearer_secret(value: &str) -> bool {
+    let mut previous_was_bearer = false;
+    for chunk in value.split_whitespace() {
+        if previous_was_bearer && chunk.len() >= 16 && chunk.chars().all(|ch| {
+            ch.is_ascii_alphanumeric() || matches!(ch, '.' | '_' | '~' | '+' | '/' | '=' | '-')
+        }) {
+            return true;
+        }
+        previous_was_bearer = chunk.eq_ignore_ascii_case("bearer");
+    }
+    false
+}
+
 pub fn json_escape(input: &str) -> String {
     let mut out = String::new();
     for ch in input.chars() {
@@ -273,6 +312,12 @@ mod tests {
         assert!(!redacted.contains("sk-test"));
     }
 
+    #[test]
+    fn inline_secret_scan_allows_ordinary_token_prose() {
+        assert!(!contains_inline_secret("Use the visible token in logs for delivery evidence."));
+        assert!(contains_inline_secret("API_KEY=sk-inline-secret"));
+    }
+
     #[test]
     fn profile_rejects_inline_secret() {
         let profile = Profile {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.1.10",
+  "version": "0.2.0",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",

package/schemas/team.schema.json

@@ -134,6 +134,7 @@
         "auth_mode": { "enum": ["subscription", "official_api", "compatible_api"] },
         "profile": { "type": "string", "minLength": 1 },
         "credential_ref": { "type": "string", "minLength": 1 },
+        "forked_from": { "type": "string", "minLength": 1 },
         "working_directory": { "type": "string", "minLength": 1 },
         "paused": { "type": "boolean" },
         "system_prompt": {

package/skills/team-agent/SKILL.md

@@ -118,7 +118,7 @@ For diagnosis, run `team-agent profile show deepseek --workspace . --json`; neve
 - `team-agent send --watch-result coder "Do the bounded task"` sends a direct worker message, returns after delivery, and lets the coordinator collect/report completion asynchronously.
 - After `send --watch-result` succeeds, do not run `sleep`, `status`, `inbox`, or `collect` polling loops unless the user explicitly asks for diagnosis; the coordinator will notify the leader when the result arrives.
 - `team-agent send --task task_initial "Start"` routes by task.
-- `team-agent status` shows team, worker health, result-store counts, `session_id`, `captured_via`, and attribution confidence.
+- `team-agent status` shows team, worker health, result-store counts, `session_id`, `captured_via`, and attribution confidence. `team-agent status --json` is compact and context-safe by default; use `team-agent status --detail --json` only for raw runtime-state diagnostics.
 - `team-agent status coder` shows one worker.
 - `team-agent approvals [coder]` shows structured pending approval prompts without copying worker terminal pages.
 - `team-agent inbox coder` shows message history only. Final results are not in inbox.

package/src/team_agent/approvals/__init__.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from team_agent.approvals.constants import (
+    INTERNAL_MCP_APPROVAL_CHOICE,
+    INTERNAL_MCP_AUTO_APPROVE_TOOLS,
+    STARTUP_PROMPT_RUNTIME_CHECK_LIMIT,
+)
+from team_agent.approvals.parsing import (
+    APPROVAL_CHOICE_RE,
+    active_approval_choice_index,
+    active_approval_control_index,
+    approval_choice_keys,
+    approval_prompt_fingerprint,
+    capture_has_approval_prompt,
+    capture_has_team_orchestrator_mcp_prompt,
+    choose_internal_mcp_approval_choice,
+    extract_approval_choices,
+    extract_approval_prompt,
+    extract_command_approval_subject,
+    is_approval_control_line,
+    line_is_approval_choice,
+)
+from team_agent.approvals.runtime_prompts import (
+    handle_internal_mcp_approval_prompt,
+    handle_provider_runtime_prompts,
+    handle_provider_startup_prompts,
+    submit_internal_mcp_approval,
+)
+from team_agent.approvals.status import (
+    age_text,
+    agent_health_status,
+    current_task_for_agent,
+    detect_provider_status,
+    refresh_agent_runtime_statuses,
+    sync_agent_health,
+)
+
+__all__ = [
+    "APPROVAL_CHOICE_RE",
+    "INTERNAL_MCP_APPROVAL_CHOICE",
+    "INTERNAL_MCP_AUTO_APPROVE_TOOLS",
+    "STARTUP_PROMPT_RUNTIME_CHECK_LIMIT",
+    "active_approval_choice_index",
+    "active_approval_control_index",
+    "age_text",
+    "agent_health_status",
+    "approval_choice_keys",
+    "approval_prompt_fingerprint",
+    "capture_has_approval_prompt",
+    "capture_has_team_orchestrator_mcp_prompt",
+    "choose_internal_mcp_approval_choice",
+    "current_task_for_agent",
+    "detect_provider_status",
+    "extract_approval_choices",
+    "extract_approval_prompt",
+    "extract_command_approval_subject",
+    "handle_internal_mcp_approval_prompt",
+    "handle_provider_runtime_prompts",
+    "handle_provider_startup_prompts",
+    "is_approval_control_line",
+    "line_is_approval_choice",
+    "refresh_agent_runtime_statuses",
+    "submit_internal_mcp_approval",
+    "sync_agent_health",
+]

package/src/team_agent/approvals/constants.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+
+STARTUP_PROMPT_RUNTIME_CHECK_LIMIT = 3
+INTERNAL_MCP_AUTO_APPROVE_TOOLS = {"send_message", "report_result", "get_team_status", "request_human"}
+INTERNAL_MCP_APPROVAL_CHOICE = "Allow for this session"

package/src/team_agent/approvals/parsing.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Any
+
+from team_agent.approvals.constants import INTERNAL_MCP_APPROVAL_CHOICE
+
+
+APPROVAL_CHOICE_RE = re.compile(r"(?:[›❯>]\s*)?(\d+)\.\s+(.+?)(?:\s{2,}.+)?$")
+
+
+def capture_has_approval_prompt(text: str) -> bool:
+    return extract_approval_prompt("_", text) is not None
+
+
+def extract_approval_prompt(agent_id: str, text: str) -> dict[str, Any] | None:
+    lines = text.splitlines()
+    control_index = active_approval_control_index(lines)
+    if control_index is None:
+        return None
+    for index in range(control_index, -1, -1):
+        line = lines[index]
+        if "Allow the team_orchestrator MCP server to run tool" not in line:
+            continue
+        tool_match = re.search(r'run tool "([^"]+)"', line)
+        return {
+            "agent_id": agent_id,
+            "state": "waiting_approval",
+            "kind": "mcp_tool",
+            "tool": tool_match.group(1) if tool_match else None,
+            "prompt": line.strip(),
+            "choices": extract_approval_choices(lines[index : control_index + 1]),
+        }
+    for index in range(control_index, -1, -1):
+        line = lines[index]
+        if line_is_approval_choice(line):
+            continue
+        tool_match = re.search(r"\bteam_orchestrator\s*[-.]\s*([A-Za-z_][A-Za-z0-9_]*)\b", line)
+        if not tool_match:
+            continue
+        return {
+            "agent_id": agent_id,
+            "state": "waiting_approval",
+            "kind": "mcp_tool",
+            "tool": tool_match.group(1),
+            "prompt": f"team_orchestrator - {tool_match.group(1)}",
+            "choices": extract_approval_choices(lines[index : control_index + 1]),
+        }
+    for index in range(control_index, -1, -1):
+        line = lines[index]
+        if "Would you like to run the following command" not in line:
+            continue
+        return {
+            "agent_id": agent_id,
+            "state": "waiting_approval",
+            "kind": "command",
+            "command": extract_command_approval_subject(lines[: control_index + 1], index),
+            "prompt": line.strip(),
+            "choices": extract_approval_choices(lines[index : control_index + 1]),
+        }
+    return {
+        "agent_id": agent_id,
+        "state": "waiting_approval",
+        "kind": "unknown",
+        "prompt": "approval prompt detected",
+        "choices": extract_approval_choices(lines[: control_index + 1]),
+    }
+
+
+def active_approval_control_index(lines: list[str]) -> int | None:
+    control_indices = [
+        index
+        for index, line in enumerate(lines)
+        if is_approval_control_line(line)
+    ]
+    if not control_indices:
+        return None
+    control_index = control_indices[-1]
+    if any(line.strip() for line in lines[control_index + 1 :]):
+        return None
+    return control_index
+
+
+def is_approval_control_line(line: str) -> bool:
+    normalized = line.lower()
+    return "enter to submit | esc to cancel" in normalized or ("esc to cancel" in normalized and "tab to amend" in normalized)
+
+
+def extract_approval_choices(lines: list[str]) -> list[str]:
+    choices: list[str] = []
+    for line in lines:
+        stripped = line.strip()
+        match = APPROVAL_CHOICE_RE.match(stripped)
+        if not match:
+            continue
+        label = match.group(2).strip()
+        if label and label not in choices:
+            choices.append(label)
+    return choices
+
+
+def line_is_approval_choice(line: str) -> bool:
+    return APPROVAL_CHOICE_RE.match(line.strip()) is not None
+
+
+def extract_command_approval_subject(lines: list[str], prompt_index: int) -> str | None:
+    for line in reversed(lines[:prompt_index]):
+        stripped = line.strip()
+        if stripped.startswith("Bash(") or stripped.startswith("Shell("):
+            return stripped[:200]
+    for line in lines[prompt_index + 1 : prompt_index + 8]:
+        stripped = line.strip()
+        if stripped.startswith("Bash(") or stripped.startswith("Shell("):
+            return stripped[:200]
+    return None
+
+
+def active_approval_choice_index(text: str) -> int | None:
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not (stripped.startswith("›") or stripped.startswith("❯") or stripped.startswith(">")):
+            continue
+        match = re.match(r"[›❯>]\s*(\d+)\.", stripped)
+        if match:
+            return int(match.group(1)) - 1
+    return None
+
+
+def capture_has_team_orchestrator_mcp_prompt(text: str) -> bool:
+    return (
+        "Allow the team_orchestrator MCP server to run tool" in text
+        or re.search(r"\bteam_orchestrator\s*[-.]\s*[A-Za-z_][A-Za-z0-9_]*\b", text) is not None
+    )
+
+
+def approval_prompt_fingerprint(prompt: dict[str, Any]) -> str:
+    data = {
+        "kind": prompt.get("kind"),
+        "tool": prompt.get("tool"),
+        "prompt": prompt.get("prompt"),
+        "choices": prompt.get("choices") or [],
+    }
+    return hashlib.sha256(json.dumps(data, sort_keys=True, ensure_ascii=False).encode("utf-8")).hexdigest()[:16]
+
+
+def choose_internal_mcp_approval_choice(prompt: dict[str, Any]) -> str:
+    choices = prompt.get("choices") or []
+    if INTERNAL_MCP_APPROVAL_CHOICE in choices:
+        return INTERNAL_MCP_APPROVAL_CHOICE
+    for choice in choices:
+        if str(choice).startswith("Yes, and don't ask again"):
+            return str(choice)
+    if "Allow" in choices:
+        return "Allow"
+    if "Yes" in choices:
+        return "Yes"
+    return INTERNAL_MCP_APPROVAL_CHOICE
+
+
+def approval_choice_keys(prompt: dict[str, Any], capture_text: str, choice: str) -> list[str]:
+    choices = prompt.get("choices") or []
+    try:
+        target_index = choices.index(choice)
+    except ValueError:
+        return ["Down", "Enter"]
+    active_index = active_approval_choice_index(capture_text)
+    if active_index is None:
+        return [str(target_index + 1), "Enter"]
+    delta = target_index - active_index
+    if delta > 0:
+        return ["Down"] * delta + ["Enter"]
+    if delta < 0:
+        return ["Up"] * abs(delta) + ["Enter"]
+    return ["Enter"]

package/src/team_agent/approvals/runtime_prompts.py

@@ -0,0 +1,171 @@
+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=1, sleep_s=0.0):
+            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",
+    }