@team-agent/installer 0.1.10 → 0.2.0

package/src/team_agent/rust_core.py

@@ -141,16 +141,33 @@ def list_targets() -> dict[str, Any]:
 
 
 def contains_inline_secret(value: str) -> bool:
-    lower = value.lower()
     return (
-        "api_key" in lower
-        or "apikey" in lower
-        or "token" in lower
-        or "secret" in lower
+        _contains_secret_assignment(value)
+        or _contains_bearer_secret(value)
+        or any(chunk.startswith("sk-") or _looks_base64_secret(chunk) for chunk in value.split())
         or value.startswith("sk-")
         or _looks_base64_secret(value)
     )
 
 
+def _contains_secret_assignment(value: str) -> bool:
+    for line in value.splitlines():
+        for separator in ("=", ":"):
+            if separator not in line:
+                continue
+            key, raw = line.split(separator, 1)
+            normalized = re.sub(r"[^a-z0-9]", "", key.lower())
+            if normalized not in {"apikey", "token", "secret", "password", "credential"}:
+                continue
+            candidate = raw.strip().strip("'\"")
+            if candidate.startswith("sk-") or len(candidate) >= 8 or _looks_base64_secret(candidate):
+                return True
+    return False
+
+
+def _contains_bearer_secret(value: str) -> bool:
+    return re.search(r"(?i)\bbearer\s+[A-Za-z0-9._~+/=-]{16,}", value) is not None
+
+
 def _looks_base64_secret(value: str) -> bool:
     return len(value) >= 32 and re.fullmatch(r"[A-Za-z0-9+/=_-]+", value) is not None

package/src/team_agent/sessions/__init__.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from team_agent.sessions.capture import (
+    capture_agent_session,
+    capture_missing_sessions,
+    clear_session_capture_fields,
+    copy_session_metadata,
+)
+from team_agent.sessions.inventory import sessions_overview
+from team_agent.sessions.resume import (
+    attach_profile_resume_root,
+    prepare_resume_state,
+    recover_resume_session_from_events,
+)
+
+__all__ = [
+    "attach_profile_resume_root",
+    "capture_agent_session",
+    "capture_missing_sessions",
+    "clear_session_capture_fields",
+    "copy_session_metadata",
+    "prepare_resume_state",
+    "recover_resume_session_from_events",
+    "sessions_overview",
+]

package/src/team_agent/sessions/capture.py

@@ -0,0 +1,93 @@
+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.providers import get_adapter
+from team_agent.state import SESSION_CAPTURE_FIELDS, SESSION_STATE_FIELDS
+
+
+def capture_missing_sessions(
+    workspace: Path,
+    state: dict[str, Any],
+    event_log: EventLog,
+    timeout_s: float,
+    log_miss: bool = True,
+) -> list[str]:
+    captured: list[str] = []
+    for agent_id, agent_state in state.get("agents", {}).items():
+        if agent_state.get("session_id"):
+            continue
+        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")
+        }
+        result = capture_agent_session(
+            workspace,
+            agent_id,
+            agent_state,
+            event_log,
+            timeout_s=timeout_s,
+            exclude_session_ids=known_session_ids,
+        )
+        if result:
+            captured.append(agent_id)
+        elif log_miss:
+            event_log.write(
+                "session.capture_timeout",
+                agent_id=agent_id,
+                provider=agent_state.get("provider"),
+                timeout_s=timeout_s,
+                spawn_cwd=agent_state.get("spawn_cwd"),
+            )
+    return captured
+
+
+def capture_agent_session(
+    workspace: Path,
+    agent_id: str,
+    agent_state: dict[str, Any],
+    event_log: EventLog,
+    timeout_s: float,
+    exclude_session_ids: set[str] | None = None,
+) -> dict[str, Any] | None:
+    if agent_state.get("session_id"):
+        return None
+    adapter = get_adapter(agent_state["provider"])
+    spawn_context = {
+        "agent_id": agent_id,
+        "cwd": agent_state.get("spawn_cwd") or str(workspace),
+        "spawn_time": agent_state.get("spawned_at") or datetime.now(timezone.utc).isoformat(),
+        "tmux_target": f"{agent_state.get('session_name', '')}:{agent_state.get('window', agent_id)}",
+        "predetermined_session_id": agent_state.get("_pending_session_id"),
+        "exclude_session_ids": sorted(exclude_session_ids or set()),
+        "claude_projects_root": agent_state.get("claude_projects_root"),
+    }
+    result = adapter.capture_session_id(agent_id, spawn_context, timeout_s=timeout_s)
+    if not isinstance(result, dict) or not result.get("session_id"):
+        return None
+    copy_session_metadata(agent_state, result)
+    agent_state.pop("_pending_session_id", None)
+    event_log.write(
+        "session.captured",
+        agent_id=agent_id,
+        provider=agent_state.get("provider"),
+        session_id=agent_state.get("session_id"),
+        rollout_path=agent_state.get("rollout_path"),
+        captured_via=agent_state.get("captured_via"),
+        attribution_confidence=agent_state.get("attribution_confidence"),
+    )
+    return result
+
+
+def copy_session_metadata(target: dict[str, Any], source: dict[str, Any]) -> None:
+    for key in SESSION_STATE_FIELDS:
+        target[key] = source.get(key)
+
+
+def clear_session_capture_fields(target: dict[str, Any]) -> None:
+    for key in SESSION_CAPTURE_FIELDS:
+        target[key] = None

package/src/team_agent/sessions/inventory.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from team_agent.spec import load_spec
+from team_agent.state import load_runtime_state
+
+
+def sessions_overview(workspace: Path) -> dict[str, Any]:
+    state = load_runtime_state(workspace)
+    spec_path = Path(state.get("spec_path", workspace / "team.spec.yaml"))
+    spec = load_spec(spec_path) if spec_path.exists() else {}
+    tasks = state.get("tasks", [])
+    rows = []
+    for agent in spec.get("agents", []):
+        agent_state = state.get("agents", {}).get(agent["id"], {})
+        last_task = next((task.get("id") for task in reversed(tasks) if task.get("assignee") == agent["id"]), None)
+        rows.append(
+            {
+                "agent_id": agent["id"],
+                "provider": agent.get("provider"),
+                "model": agent.get("model"),
+                "profile": agent.get("profile"),
+                "session_id": agent_state.get("session_id"),
+                "resume_id": agent_state.get("resume_id"),
+                "rollout_path": agent_state.get("rollout_path"),
+                "captured_at": agent_state.get("captured_at"),
+                "captured_via": agent_state.get("captured_via"),
+                "attribution_confidence": agent_state.get("attribution_confidence"),
+                "spawn_cwd": agent_state.get("spawn_cwd"),
+                "context_usage": agent_state.get("context_usage"),
+                "status": agent_state.get("status", "unknown"),
+                "last_task": last_task,
+                "handoff_path": agent_state.get("handoff_path"),
+                "display_target": agent_state.get("display"),
+                "terminal_target": {
+                    "session": state.get("session_name"),
+                    "window": agent_state.get("window", agent["id"]),
+                    "pane": agent_state.get("pane_id"),
+                },
+            }
+        )
+    return {"ok": True, "sessions": rows, "workspace": str(workspace)}

package/src/team_agent/sessions/resume.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from team_agent.events import EventLog
+from team_agent.paths import logs_dir
+from team_agent.profiles import prepare_agent_profile_launch
+from team_agent.providers import ResumeUnavailable
+from team_agent.sessions.capture import clear_session_capture_fields, copy_session_metadata
+
+
+def attach_profile_resume_root(workspace: Path, command_agent: dict[str, Any], previous: dict[str, Any]) -> dict[str, Any]:
+    profile_launch = command_agent.get("_provider_profile") or prepare_agent_profile_launch(workspace, command_agent)
+    if not profile_launch:
+        return previous
+    command_agent["_provider_profile"] = profile_launch
+    root = profile_launch.get("claude_projects_root")
+    if not root:
+        return previous
+    prepared = dict(previous)
+    prepared["claude_projects_root"] = root
+    return prepared
+
+
+def prepare_resume_state(
+    workspace: Path,
+    agent_id: str,
+    previous: dict[str, Any],
+    adapter: Any,
+    event_log: EventLog,
+    exclude_session_ids: set[str] | None = None,
+    allow_fresh_on_resume_failure: bool = False,
+) -> dict[str, Any]:
+    prepared = dict(previous)
+    session_id = prepared.get("session_id")
+    if session_id and adapter.session_is_resumable(prepared, workspace):
+        return prepared
+    if session_id:
+        event_log.write(
+            "resume.session_unverified",
+            agent_id=agent_id,
+            provider=prepared.get("provider"),
+            session_id=session_id,
+            captured_via=prepared.get("captured_via"),
+            spawn_cwd=prepared.get("spawn_cwd"),
+        )
+    else:
+        event_log.write(
+            "resume.session_missing_repair_attempt",
+            agent_id=agent_id,
+            provider=prepared.get("provider"),
+            spawn_cwd=prepared.get("spawn_cwd"),
+        )
+    repaired = recover_resume_session_from_events(workspace, agent_id, prepared, adapter, exclude_session_ids or set())
+    if not repaired:
+        repaired = adapter.recover_session_id(agent_id, prepared, workspace, exclude_session_ids or set())
+    if repaired:
+        copy_session_metadata(prepared, repaired)
+        event_log.write(
+            "resume.session_repaired",
+            agent_id=agent_id,
+            provider=prepared.get("provider"),
+            old_session_id=session_id,
+            session_id=prepared.get("session_id"),
+            rollout_path=prepared.get("rollout_path"),
+            captured_via=prepared.get("captured_via"),
+            attribution_confidence=prepared.get("attribution_confidence"),
+        )
+        return prepared
+    if session_id and not allow_fresh_on_resume_failure:
+        event_log.write(
+            "resume.session_required_missing",
+            agent_id=agent_id,
+            provider=prepared.get("provider"),
+            old_session_id=session_id,
+            rollout_path=prepared.get("rollout_path"),
+            reason="provider transcript not found",
+        )
+        raise ResumeUnavailable(
+            f"Cannot resume agent {agent_id}: stored session {session_id} is not available. "
+            "Use --allow-fresh only if losing that worker context is acceptable."
+        )
+    clear_session_capture_fields(prepared)
+    event_log.write(
+        "resume.session_unavailable",
+        agent_id=agent_id,
+        provider=prepared.get("provider"),
+        old_session_id=session_id,
+        reason="provider transcript not found",
+    )
+    return prepared
+
+
+def recover_resume_session_from_events(
+    workspace: Path,
+    agent_id: str,
+    previous: dict[str, Any],
+    adapter: Any,
+    exclude_session_ids: set[str],
+) -> dict[str, Any] | None:
+    events_path = logs_dir(workspace) / "events.jsonl"
+    try:
+        lines = events_path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return None
+    current_session_id = str(previous.get("session_id") or "")
+    for line in reversed(lines):
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if event.get("agent_id") != agent_id:
+            continue
+        if event.get("event") == "discard.session_tombstone":
+            return None
+        if event.get("event") != "session.captured":
+            continue
+        session_id = str(event.get("session_id") or "")
+        if not session_id or session_id == current_session_id or session_id in exclude_session_ids:
+            continue
+        candidate = dict(previous)
+        candidate.update(
+            {
+                "session_id": session_id,
+                "rollout_path": event.get("rollout_path"),
+                "captured_at": event.get("ts"),
+                "captured_via": "event_log_repair",
+                "attribution_confidence": event.get("attribution_confidence"),
+            }
+        )
+        if adapter.session_is_resumable(candidate, workspace):
+            return candidate
+    return None

package/src/team_agent/spec.py

@@ -131,7 +131,7 @@ def _result_schema_errors(envelope: Any) -> list[str]:
 
 def _check_agent(agent: Any, path: str, errors: list[str]) -> None:
     required = {"id", "role", "provider", "model", "working_directory", "system_prompt", "tools", "permission_mode", "preferred_for", "avoid_for", "output_contract"}
-    allowed = required | {"paused", "auth_mode", "profile", "credential_ref"}
+    allowed = required | {"paused", "auth_mode", "profile", "credential_ref", "forked_from"}
     _check_keys(agent, path, required, allowed, errors)
     if not isinstance(agent, dict):
         return
@@ -245,6 +245,8 @@ def _semantic_errors(spec: dict[str, Any], base_dir: Path) -> list[str]:
     agents = spec.get("agents", [])
     agent_ids = {a.get("id") for a in agents if isinstance(a, dict)}
     all_ids = set(agent_ids)
+    if len(agent_ids) != len([a for a in agents if isinstance(a, dict)]):
+        errors.append("/agents: duplicate agent id")
     if leader.get("id"):
         all_ids.add(leader["id"])
 

package/src/team_agent/state.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import json
 import os
+import copy
+import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -46,12 +48,207 @@ def load_runtime_state(workspace: Path) -> dict[str, Any]:
     return state
 
 
+def team_state_key(state: dict[str, Any]) -> str:
+    for field in ("team_dir", "spec_path"):
+        value = state.get(field)
+        if not value:
+            continue
+        path = Path(str(value))
+        key = path.name if field == "team_dir" else path.parent.name
+        if key and key not in {".team", "runtime"}:
+            return key
+    return str(state.get("session_name") or "current")
+
+
+def compact_team_state(state: dict[str, Any]) -> dict[str, Any]:
+    compact = copy.deepcopy(state)
+    compact.pop("teams", None)
+    return compact
+
+
+def merge_workspace_team_state(existing: dict[str, Any], launched: dict[str, Any]) -> dict[str, Any]:
+    launched_key = team_state_key(launched)
+    if not existing.get("session_name"):
+        merged = copy.deepcopy(launched)
+        merged.setdefault("teams", {})[launched_key] = compact_team_state(launched)
+        return merged
+    existing_key = team_state_key(existing)
+    if existing_key == launched_key:
+        merged = copy.deepcopy(launched)
+        teams = copy.deepcopy(existing.get("teams") or {})
+        teams[launched_key] = compact_team_state(launched)
+        merged["teams"] = teams
+        return merged
+    merged = copy.deepcopy(existing)
+    teams = merged.setdefault("teams", {})
+    teams.setdefault(existing_key, compact_team_state(existing))
+    teams[launched_key] = compact_team_state(launched)
+    return merged
+
+
+def team_state_candidates(state: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    candidates: dict[str, dict[str, Any]] = {}
+    teams = state.get("teams")
+    if isinstance(teams, dict):
+        for key, value in teams.items():
+            if isinstance(value, dict):
+                candidates[str(key)] = value
+    if state.get("session_name"):
+        candidates.setdefault(team_state_key(state), compact_team_state(state))
+    return candidates
+
+
+def format_team_candidates(candidates: dict[str, dict[str, Any]]) -> str:
+    if not candidates:
+        return "No team state was found."
+    parts = []
+    for key, state in sorted(candidates.items()):
+        agents = ",".join(sorted(state.get("agents", {}).keys())) or "-"
+        parts.append(f"{key} session={state.get('session_name') or '-'} agents={agents}")
+    return "Candidates: " + "; ".join(parts)
+
+
+def select_runtime_state(workspace: Path, team: str | None = None) -> dict[str, Any]:
+    state = load_runtime_state(workspace)
+    candidates = team_state_candidates(state)
+    if team:
+        matches = [
+            value
+            for key, value in candidates.items()
+            if team in {key, str(value.get("session_name") or ""), str(value.get("team_dir") or "")}
+        ]
+        if len(matches) == 1:
+            return copy.deepcopy(matches[0])
+        from team_agent.errors import RuntimeError
+        if len(matches) > 1:
+            raise RuntimeError("team selector is ambiguous. " + format_team_candidates(candidates))
+        raise RuntimeError(f"team {team!r} not found. " + format_team_candidates(candidates))
+    if len(candidates) > 1:
+        from team_agent.errors import RuntimeError
+        raise RuntimeError("multiple teams found in this workspace; pass --team <team> to choose. " + format_team_candidates(candidates))
+    return copy.deepcopy(state)
+
+
+def ambiguous_team_target_result(state: dict[str, Any]) -> dict[str, Any] | None:
+    candidates = team_state_candidates(state)
+    if len(candidates) <= 1:
+        return None
+    return {
+        "ok": False,
+        "status": "refused",
+        "reason": "team_target_ambiguous",
+        "candidates": sorted(candidates),
+        "message": "multiple teams found in this workspace; pass --team <team> to choose. " + format_team_candidates(candidates),
+    }
+
+
+def resolve_team_scoped_state(
+    workspace: Path,
+    team: str | None,
+) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+    if team is None:
+        ambiguous = ambiguous_team_target_result(load_runtime_state(workspace))
+        if ambiguous:
+            return None, ambiguous
+    try:
+        from team_agent.errors import RuntimeError as _TeamAgentRuntimeError
+        return select_runtime_state(workspace, team), None
+    except _TeamAgentRuntimeError as exc:
+        return None, {
+            "ok": False,
+            "status": "refused",
+            "reason": "team_target_unresolved",
+            "team": team,
+            "error": str(exc),
+        }
+
+
+def _caller_identity_from_env() -> dict[str, str]:
+    return {
+        "pane_id": os.environ.get("TEAM_AGENT_LEADER_PANE_ID") or "",
+        "provider": os.environ.get("TEAM_AGENT_LEADER_PROVIDER") or "",
+        "machine_fingerprint": os.environ.get("TEAM_AGENT_MACHINE_FINGERPRINT") or "",
+    }
+
+
+def check_team_owner(state: dict[str, Any]) -> dict[str, Any] | None:
+    owner = state.get("team_owner") or {}
+    if not owner:
+        return None
+    caller = _caller_identity_from_env()
+    if (
+        caller["pane_id"] == (owner.get("pane_id") or "")
+        and caller["provider"] == (owner.get("provider") or "")
+        and caller["machine_fingerprint"] == (owner.get("machine_fingerprint") or "")
+    ):
+        return None
+    return {
+        "ok": False,
+        "status": "refused",
+        "reason": "team_owner_mismatch",
+        "error": "not_owner",
+        "action": "use team-agent takeover --confirm",
+        "team_owner": owner,
+        "caller": caller,
+    }
+
+
+def populate_team_owner_from_env(state: dict[str, Any], source: str = "autopopulate") -> dict[str, Any] | None:
+    if state.get("team_owner"):
+        return state["team_owner"]
+    caller = _caller_identity_from_env()
+    if not caller["pane_id"]:
+        return None
+    owner = {
+        "pane_id": caller["pane_id"],
+        "provider": caller["provider"],
+        "machine_fingerprint": caller["machine_fingerprint"],
+        "claimed_at": datetime.now(timezone.utc).isoformat(),
+        "claimed_via": source,
+    }
+    state["team_owner"] = owner
+    return owner
+
+
 def save_runtime_state(workspace: Path, state: dict[str, Any]) -> None:
     path = runtime_state_path(workspace)
     path.parent.mkdir(parents=True, exist_ok=True)
-    tmp_path = path.with_suffix(path.suffix + ".tmp")
-    tmp_path.write_text(json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8")
-    os.replace(tmp_path, path)
+    tmp_path = path.with_name(f"{path.name}.{os.getpid()}.{uuid.uuid4().hex}.tmp")
+    try:
+        tmp_path.write_text(json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8")
+        os.replace(tmp_path, path)
+    finally:
+        tmp_path.unlink(missing_ok=True)
+
+
+def save_team_scoped_state(workspace: Path, team_state: dict[str, Any]) -> None:
+    target_key = team_state_key(team_state)
+    existing = load_runtime_state(workspace)
+    existing_primary_key = team_state_key(existing) if existing.get("session_name") else None
+    if (
+        existing_primary_key is not None
+        and existing_primary_key != target_key
+        and existing.get("session_name")
+        and existing.get("session_name") == team_state.get("session_name")
+    ):
+        existing_primary_key = target_key
+    existing_teams = existing.get("teams") or {}
+    if not existing_teams and existing_primary_key == target_key:
+        merged = copy.deepcopy(team_state)
+        merged.pop("teams", None)
+        save_runtime_state(workspace, merged)
+        return
+    teams = copy.deepcopy(existing_teams)
+    teams[target_key] = compact_team_state(team_state)
+    if existing_primary_key is None or existing_primary_key == target_key:
+        merged = copy.deepcopy(team_state)
+        merged["teams"] = teams
+    else:
+        merged = copy.deepcopy(existing)
+        merged["teams"] = teams
+    if not merged.get("teams"):
+        merged.pop("teams", None)
+    save_runtime_state(workspace, merged)
 
 
 def write_team_state(workspace: Path, spec: dict[str, Any], runtime: dict[str, Any], results: list[dict[str, Any]] | None = None) -> Path:
@@ -119,4 +316,7 @@ def write_team_state(workspace: Path, spec: dict[str, Any], runtime: dict[str, A
 
 
 def write_spec(path: Path, spec: dict[str, Any]) -> None:
-    path.write_text(dumps(spec), encoding="utf-8")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    tmp_path.write_text(dumps(spec), encoding="utf-8")
+    os.replace(tmp_path, path)

package/src/team_agent/status/__init__.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from team_agent.status.approvals import approvals, format_approvals
+from team_agent.status.compact import (
+    compact_agent_state,
+    compact_event,
+    compact_mapping,
+    compact_status,
+    compact_task,
+    compact_value,
+)
+from team_agent.status.constants import (
+    APPROVAL_SCAN_LINES,
+    PEEK_MAX_LINES,
+    PEEK_MAX_MATCHES,
+    PEEK_SEARCH_SCAN_LINES,
+    PENDING_DELIVERY_STATUSES,
+    STATUS_EVENT_LIMIT,
+    STATUS_TEXT_LIMIT,
+)
+from team_agent.status.inbox import format_inbox, inbox
+from team_agent.status.peek import (
+    format_search_matches,
+    peek,
+    search_lines,
+    validate_line_count,
+)
+from team_agent.status.queries import (
+    format_status,
+    latest_result_summaries,
+    queued_message_statuses,
+    result_summary_from_row,
+    status,
+)
+
+__all__ = [
+    "APPROVAL_SCAN_LINES",
+    "PEEK_MAX_LINES",
+    "PEEK_MAX_MATCHES",
+    "PEEK_SEARCH_SCAN_LINES",
+    "PENDING_DELIVERY_STATUSES",
+    "STATUS_EVENT_LIMIT",
+    "STATUS_TEXT_LIMIT",
+    "approvals",
+    "compact_agent_state",
+    "compact_event",
+    "compact_mapping",
+    "compact_status",
+    "compact_task",
+    "compact_value",
+    "format_approvals",
+    "format_inbox",
+    "format_search_matches",
+    "format_status",
+    "inbox",
+    "latest_result_summaries",
+    "peek",
+    "queued_message_statuses",
+    "result_summary_from_row",
+    "search_lines",
+    "status",
+    "validate_line_count",
+]