@team-agent/installer 0.2.11 → 0.3.1

package/src/team_agent/display/workspace.py

@@ -1,382 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import re
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import Any
-
-from team_agent.events import EventLog
-from team_agent.display.ghostty import (
-    ghostty_app_exists,
-    ghostty_attach_args,
-    ghostty_display_session_name,
-    ghostty_pids_by_title,
-    prepare_ghostty_display_session,
-)
-from team_agent.display.tiling import (
-    DISPLAY_PANES_PER_WINDOW,
-    display_pane_title,
-    display_window_name,
-    prepare_tmux_attached_panes,
-    set_tmux_display_pane_title,
-    tmux_attach_pane_command,
-    tmux_stdout_last_line as _tmux_stdout_last_line,
-)
-
-
-GHOSTTY_WORKSPACE_PANES_PER_WINDOW = DISPLAY_PANES_PER_WINDOW
-
-
-def open_ghostty_workspace(
-    workspace,
-    session_name: str,
-    jobs: list[tuple[str, dict[str, Any]]],
-    event_log: EventLog,
-) -> dict[str, dict[str, Any]]:
-    from team_agent.runtime import run_cmd
-    _ = workspace
-    if not ghostty_app_exists():
-        return ghostty_workspace_blocked(jobs, event_log, "ghostty_app_missing")
-    aggregator_session = ghostty_workspace_aggregator_name(session_name)
-    linked_results = prepare_ghostty_workspace_linked_sessions(session_name, jobs)
-    displays: dict[str, dict[str, Any]] = {}
-    linked_jobs: list[tuple[str, dict[str, Any], str]] = []
-    for agent_id, agent in jobs:
-        linked = linked_results.get(agent_id, {})
-        linked_session = linked.get("linked_session") or ghostty_display_session_name(session_name, agent_id)
-        if linked.get("ok"):
-            linked_jobs.append((agent_id, agent, linked_session))
-            continue
-        displays.update(
-            ghostty_workspace_blocked(
-                [(agent_id, agent)],
-                event_log,
-                linked.get("reason", "display_session_create_failed"),
-                aggregator_session=aggregator_session,
-                linked_sessions={agent_id: linked_session},
-                error=linked.get("error"),
-                target=f"{session_name}:{agent_id}",
-            )
-        )
-    if not linked_jobs:
-        return displays
-    prepared = prepare_ghostty_workspace_aggregator(aggregator_session, linked_jobs)
-    if not prepared["ok"]:
-        kill_ghostty_workspace_linked_sessions([linked_session for _agent_id, _agent, linked_session in linked_jobs])
-        displays.update(
-            ghostty_workspace_blocked(
-                [(agent_id, agent) for agent_id, agent, _linked_session in linked_jobs],
-                event_log,
-                prepared["reason"],
-                aggregator_session=aggregator_session,
-                linked_sessions={agent_id: linked_session for agent_id, _agent, linked_session in linked_jobs},
-                error=prepared.get("error"),
-                target=prepared.get("target"),
-            )
-        )
-        return displays
-    title = f"team-agent:{session_name}:workspace"
-    launch_args = ghostty_attach_args(aggregator_session, title)
-    proc = run_cmd(launch_args, timeout=10)
-    if proc.returncode != 0:
-        run_cmd(["tmux", "kill-session", "-t", aggregator_session], timeout=10)
-        kill_ghostty_workspace_linked_sessions([linked_session for _agent_id, _agent, linked_session in linked_jobs])
-        displays.update(
-            ghostty_workspace_blocked(
-                [(agent_id, agent) for agent_id, agent, _linked_session in linked_jobs],
-                event_log,
-                "open Ghostty.app failed",
-                aggregator_session=aggregator_session,
-                linked_sessions={agent_id: linked_session for agent_id, _agent, linked_session in linked_jobs},
-                error=proc.stderr.strip() or proc.stdout.strip(),
-            )
-        )
-        return displays
-    pids = ghostty_pids_by_title(title, wait_s=3.0)
-    panes = {pane["agent_id"]: pane for pane in prepared["panes"]}
-    for agent_id, agent, linked_session in linked_jobs:
-        pane = panes.get(agent_id, {})
-        display = {
-            "backend": "ghostty_workspace",
-            "status": "opened",
-            "title": title,
-            "pane_title": pane.get("title") or ghostty_workspace_pane_title(agent),
-            "target": f"{session_name}:{agent_id}",
-            "linked_session": linked_session,
-            "aggregator_session": aggregator_session,
-            "display_session": aggregator_session,
-            "workspace_window": pane.get("window_name"),
-            "pane_id": pane.get("pane_id"),
-            "launch_args": launch_args,
-            "pid": pids[0] if pids else None,
-            "pids": pids,
-            "tty": None,
-            "fallback": "tmux_headless",
-            "note": "Ghostty opens one aggregator tmux session; each pane attaches to a distinct linked session pinned to one base worker window, so runtime injection remains session:agent_id addressed.",
-        }
-        event_log.write("display.ghostty_workspace", agent_id=agent_id, **display)
-        displays[agent_id] = display
-    return displays
-
-
-def ghostty_workspace_blocked(
-    jobs: list[tuple[str, dict[str, Any]]],
-    event_log: EventLog,
-    reason: str,
-    aggregator_session: str | None = None,
-    linked_sessions: dict[str, str] | None = None,
-    error: str | None = None,
-    target: str | None = None,
-) -> dict[str, dict[str, Any]]:
-    displays: dict[str, dict[str, Any]] = {}
-    for agent_id, _agent in jobs:
-        linked_session = (linked_sessions or {}).get(agent_id)
-        display = {
-            "backend": "ghostty_workspace",
-            "status": "blocked",
-            "reason": reason,
-            "error": error,
-            "target": target or f"{agent_id}",
-            "linked_session": linked_session,
-            "aggregator_session": aggregator_session,
-            "display_session": aggregator_session,
-            "fallback": "tmux_headless",
-        }
-        event_log.write("display.ghostty_workspace_blocked", agent_id=agent_id, **display)
-        displays[agent_id] = display
-    return displays
-
-
-def ghostty_workspace_aggregator_name(session_name: str) -> str:
-    raw = f"{session_name}:workspace"
-    digest = hashlib.sha1(raw.encode("utf-8")).hexdigest()[:8]
-    safe_session = re.sub(r"[^A-Za-z0-9_.-]", "_", session_name)[:80].strip("._-") or "team"
-    return f"{safe_session}__display__workspace__{digest}"
-
-
-def ghostty_workspace_window_name(index: int) -> str:
-    return display_window_name(index)
-
-
-def ghostty_workspace_pane_command(linked_session: str) -> str:
-    return tmux_attach_pane_command(linked_session)
-
-
-def ghostty_workspace_pane_title(agent: dict[str, Any]) -> str:
-    return display_pane_title(agent)
-
-
-def prepare_ghostty_workspace_linked_sessions(
-    session_name: str,
-    jobs: list[tuple[str, dict[str, Any]]],
-) -> dict[str, dict[str, Any]]:
-    def prepare(agent_id: str) -> dict[str, Any]:
-        linked_session = ghostty_display_session_name(session_name, agent_id)
-        result = prepare_ghostty_display_session(session_name, agent_id, linked_session)
-        result["linked_session"] = linked_session
-        return result
-
-    if len(jobs) == 1:
-        agent_id, _agent = jobs[0]
-        return {agent_id: prepare(agent_id)}
-    results: dict[str, dict[str, Any]] = {}
-    max_workers = min(4, len(jobs))
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        futures = {executor.submit(prepare, agent_id): agent_id for agent_id, _agent in jobs}
-        for future in as_completed(futures):
-            agent_id = futures[future]
-            try:
-                results[agent_id] = future.result()
-            except Exception as exc:
-                results[agent_id] = {
-                    "ok": False,
-                    "reason": "display_session_create_exception",
-                    "error": str(exc),
-                    "linked_session": ghostty_display_session_name(session_name, agent_id),
-                }
-    return results
-
-
-def prepare_ghostty_workspace_aggregator(
-    aggregator_session: str,
-    linked_jobs: list[tuple[str, dict[str, Any], str]],
-) -> dict[str, Any]:
-    from team_agent.runtime import _tmux_session_exists, run_cmd
-    if _tmux_session_exists(aggregator_session):
-        proc = run_cmd(["tmux", "kill-session", "-t", aggregator_session], timeout=10)
-        if proc.returncode != 0:
-            return {"ok": False, "reason": "display_session_cleanup_failed", "error": proc.stderr.strip()}
-    prepared = prepare_tmux_attached_panes(
-        aggregator_session,
-        linked_jobs,
-        window_name_for_index=ghostty_workspace_window_name,
-        create_first_as_session=True,
-        panes_per_window=GHOSTTY_WORKSPACE_PANES_PER_WINDOW,
-        cleanup_session=aggregator_session,
-        enable_mouse=True,
-        select_first_window=True,
-        reason_map={
-            "create_session": "display_session_create_failed",
-            "create_window": "display_session_window_create_failed",
-            "title": "display_session_pane_title_failed",
-            "remain": "display_session_remain_on_exit_failed",
-            "split": "display_session_split_failed",
-            "layout": "display_session_layout_failed",
-            "mouse": "display_session_mouse_failed",
-        },
-    )
-    if prepared.get("ok"):
-        prepared["aggregator_session"] = aggregator_session
-    return prepared
-
-
-def set_ghostty_workspace_pane_title(pane_id: str, title: str) -> dict[str, Any]:
-    return set_tmux_display_pane_title(pane_id, title, "display_session_pane_title_failed")
-
-
-def open_ghostty_workspace_agent_display(
-    session_name: str,
-    agent_id: str,
-    agent: dict[str, Any],
-    previous_display: dict[str, Any],
-    event_log: EventLog,
-) -> dict[str, Any]:
-    from team_agent.runtime import _tmux_session_exists, run_cmd
-    if not ghostty_app_exists():
-        return ghostty_workspace_blocked(
-            [(agent_id, agent)],
-            event_log,
-            "ghostty_app_missing",
-            aggregator_session=ghostty_workspace_aggregator_name(session_name),
-            linked_sessions={agent_id: ghostty_display_session_name(session_name, agent_id)},
-            target=f"{session_name}:{agent_id}",
-        )[agent_id]
-    aggregator_session = str(
-        previous_display.get("aggregator_session")
-        or previous_display.get("display_session")
-        or ghostty_workspace_aggregator_name(session_name)
-    )
-    linked_session = ghostty_display_session_name(session_name, agent_id)
-    prepared = prepare_ghostty_display_session(session_name, agent_id, linked_session)
-    if not prepared["ok"]:
-        return ghostty_workspace_blocked(
-            [(agent_id, agent)],
-            event_log,
-            prepared["reason"],
-            aggregator_session=aggregator_session,
-            linked_sessions={agent_id: linked_session},
-            error=prepared.get("error"),
-            target=f"{session_name}:{agent_id}",
-        )[agent_id]
-    if not _tmux_session_exists(aggregator_session):
-        return ghostty_workspace_partial_update_display(
-            session_name,
-            agent_id,
-            agent,
-            event_log,
-            reason="aggregator_session_missing",
-            note="pane refresh requires full team restart",
-        )
-
-    pane_title = ghostty_workspace_pane_title(agent)
-    command = ghostty_workspace_pane_command(linked_session)
-    pane_id = str(previous_display.get("pane_id") or "")
-    workspace_window = str(previous_display.get("workspace_window") or ghostty_workspace_window_name(0))
-    refreshed = False
-    if pane_id:
-        proc = run_cmd(["tmux", "respawn-pane", "-k", "-t", pane_id, command], timeout=10)
-        refreshed = proc.returncode == 0
-    if not refreshed:
-        proc = run_cmd(
-            [
-                "tmux",
-                "split-window",
-                "-t",
-                f"{aggregator_session}:{workspace_window}",
-                "-h",
-                "-P",
-                "-F",
-                "#{pane_id}",
-                command,
-            ],
-            timeout=10,
-        )
-        if proc.returncode != 0:
-            return ghostty_workspace_partial_update_display(
-                session_name,
-                agent_id,
-                agent,
-                event_log,
-                reason="aggregator_pane_refresh_failed",
-                note=proc.stderr.strip() or "pane refresh requires full team restart",
-            )
-        pane_id = _tmux_stdout_last_line(proc.stdout) or pane_id
-    title_result = set_ghostty_workspace_pane_title(pane_id, pane_title)
-    if not title_result["ok"]:
-        return ghostty_workspace_partial_update_display(
-            session_name,
-            agent_id,
-            agent,
-            event_log,
-            reason=title_result["reason"],
-            note=title_result.get("error") or "pane refresh requires full team restart",
-        )
-    run_cmd(["tmux", "select-layout", "-t", f"{aggregator_session}:{workspace_window}", "even-horizontal"], timeout=10)
-    title = str(previous_display.get("title") or f"team-agent:{session_name}:workspace")
-    pids = [int(pid) for pid in previous_display.get("pids", []) if str(pid).isdigit()]
-    display = {
-        "backend": "ghostty_workspace",
-        "status": "opened",
-        "title": title,
-        "pane_title": pane_title,
-        "target": f"{session_name}:{agent_id}",
-        "linked_session": linked_session,
-        "aggregator_session": aggregator_session,
-        "display_session": aggregator_session,
-        "workspace_window": workspace_window,
-        "pane_id": pane_id,
-        "pid": pids[0] if pids else None,
-        "pids": pids,
-        "tty": None,
-        "fallback": "tmux_headless",
-        "note": "Refreshed this worker's Ghostty workspace pane by respawning it against a distinct linked session.",
-    }
-    event_log.write("display.ghostty_workspace", agent_id=agent_id, **display)
-    return display
-
-
-def ghostty_workspace_partial_update_display(
-    session_name: str,
-    agent_id: str,
-    agent: dict[str, Any],
-    event_log: EventLog,
-    reason: str = "partial_update_requires_team_restart",
-    note: str = "pane refresh requires full team restart",
-) -> dict[str, Any]:
-    aggregator_session = ghostty_workspace_aggregator_name(session_name)
-    display = {
-        "backend": "ghostty_workspace",
-        "status": "blocked",
-        "reason": reason,
-        "target": f"{session_name}:{agent_id}",
-        "linked_session": ghostty_display_session_name(session_name, agent_id),
-        "aggregator_session": aggregator_session,
-        "display_session": aggregator_session,
-        "pane_title": ghostty_workspace_pane_title(agent),
-        "fallback": "tmux_headless",
-        "note": note,
-        "action": "restart the team to rebuild the Ghostty workspace layout",
-    }
-    event_log.write("display.ghostty_workspace_partial_update", agent_id=agent_id, **display)
-    return display
-
-
-def kill_ghostty_workspace_linked_sessions(linked_sessions: list[str]) -> list[str]:
-    from team_agent.runtime import _tmux_session_exists, run_cmd
-    killed: list[str] = []
-    for linked_session in dict.fromkeys(linked_sessions):
-        if _tmux_session_exists(linked_session):
-            proc = run_cmd(["tmux", "kill-session", "-t", linked_session], timeout=10)
-            if proc.returncode == 0:
-                killed.append(linked_session)
-    return killed

package/src/team_agent/errors.py

@@ -1,10 +0,0 @@
-class TeamAgentError(Exception):
-    """Base exception for user-facing Team Agent errors."""
-
-
-class ValidationError(TeamAgentError):
-    """Spec or result envelope validation failed."""
-
-
-class RuntimeError(TeamAgentError):
-    """Runtime operation failed."""

package/src/team_agent/events.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-from team_agent.paths import logs_dir
-
-
-# Stage 14 (Gap 36a) — bounded retention. 5 MB cap × 5 archives = 25 MB worst-case.
-# Mac mini 2026-05-26 evidence: events.jsonl grew to 28 MB / 128k lines in one day with
-# unbounded retention; coordinator's tick-time scan over the file was a ~22% CPU hot path.
-# Rotation keeps the current segment small so reads are cheap; archives preserve forensic
-# history but are NOT consulted by hot-path scans.
-EVENT_LOG_ROTATE_BYTES = 5 * 1024 * 1024
-EVENT_LOG_ARCHIVE_KEEP = 5
-
-
-class EventLog:
-    def __init__(self, workspace: Path):
-        self.workspace = workspace
-        self.path = logs_dir(workspace) / "events.jsonl"
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-
-    def write(self, event_type: str, **fields: Any) -> dict[str, Any]:
-        event = {
-            "ts": datetime.now(timezone.utc).isoformat(),
-            "event": event_type,
-            **fields,
-        }
-        self._maybe_rotate()
-        with self.path.open("a", encoding="utf-8") as f:
-            f.write(json.dumps(event, ensure_ascii=False, sort_keys=True) + "\n")
-        return event
-
-    def tail(self, limit: int = 20) -> list[dict[str, Any]]:
-        # Hot-path scan reads only the current segment. Archives are forensic; if a
-        # caller genuinely needs longer history it can iterate _archive_paths explicitly.
-        if not self.path.exists():
-            return []
-        lines = self.path.read_text(encoding="utf-8").splitlines()[-limit:]
-        out: list[dict[str, Any]] = []
-        for line in lines:
-            try:
-                out.append(json.loads(line))
-            except json.JSONDecodeError:
-                out.append({"raw": line})
-        return out
-
-    def _maybe_rotate(self) -> None:
-        try:
-            size = self.path.stat().st_size
-        except FileNotFoundError:
-            return
-        if size < EVENT_LOG_ROTATE_BYTES:
-            return
-        # Shift archives: events.jsonl.4 → .5, .3 → .4, …, .1 → .2, current → .1
-        # Drop the oldest if it would overflow the keep budget.
-        oldest = self._archive_path(EVENT_LOG_ARCHIVE_KEEP)
-        if oldest.exists():
-            try:
-                oldest.unlink()
-            except OSError:
-                pass
-        for idx in range(EVENT_LOG_ARCHIVE_KEEP - 1, 0, -1):
-            src = self._archive_path(idx)
-            dst = self._archive_path(idx + 1)
-            if src.exists():
-                try:
-                    os.replace(src, dst)
-                except OSError:
-                    pass
-        try:
-            os.replace(self.path, self._archive_path(1))
-        except OSError:
-            pass
-
-    def _archive_path(self, index: int) -> Path:
-        return self.path.with_name(f"{self.path.name}.{index}")
-
-    def _archive_paths(self) -> list[Path]:
-        return [self._archive_path(i) for i in range(1, EVENT_LOG_ARCHIVE_KEEP + 1)]

package/src/team_agent/fake_worker.py

@@ -1,80 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-
-from team_agent.runtime import report_result
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--workspace", required=True)
-    parser.add_argument("--agent-id", required=True)
-    args = parser.parse_args()
-    workspace = Path(args.workspace)
-    print(f"TEAM_AGENT_FAKE_READY agent={args.agent_id}", flush=True)
-    rendered_message: list[str] | None = None
-    for line in sys.stdin:
-        line = line.strip()
-        if not line:
-            if rendered_message is not None:
-                rendered_message.append("")
-            continue
-        print(f"TEAM_AGENT_FAKE_WORKING agent={args.agent_id}", flush=True)
-        if line.startswith("TEAM_AGENT_MESSAGE "):
-            payload = json.loads(line.removeprefix("TEAM_AGENT_MESSAGE "))
-            _report_fake_result(workspace, args.agent_id, payload)
-        elif line.startswith("Team Agent message from "):
-            rendered_message = [line]
-        elif rendered_message is not None:
-            rendered_message.append(line)
-            if line.startswith("[team-agent-token:"):
-                payload = _parse_rendered_message(rendered_message)
-                _report_fake_result(workspace, args.agent_id, payload)
-                rendered_message = None
-        print(f"TEAM_AGENT_FAKE_READY agent={args.agent_id}", flush=True)
-
-
-def _parse_rendered_message(lines: list[str]) -> dict[str, str | None]:
-    header = lines[0]
-    match = re.match(r"Team Agent message from (?P<sender>[^:]+?)(?: for (?P<task_id>[^:]+))?:$", header)
-    token_line = next((line for line in lines if line.startswith("[team-agent-token:")), "[team-agent-token:manual]")
-    token = token_line.removeprefix("[team-agent-token:").removesuffix("]")
-    content_lines = [line for line in lines[1:] if not line.startswith("[team-agent-token:")]
-    content = "\n".join(content_lines).strip()
-    return {
-        "message_id": token,
-        "task_id": match.group("task_id") if match else None,
-        "from": match.group("sender") if match else "leader",
-        "content": content,
-    }
-
-
-def _report_fake_result(workspace: Path, agent_id: str, payload: dict) -> None:
-    task_id = payload.get("task_id") or "manual"
-    envelope = {
-        "schema_version": "result_envelope_v1",
-        "task_id": task_id,
-        "agent_id": agent_id,
-        "status": "success",
-        "summary": f"Fake worker handled message {payload['message_id']}",
-        "changes": [],
-        "tests": [{"command": "fake-provider", "status": "passed"}],
-        "risks": [],
-        "artifacts": [
-            {
-                "path": str(workspace / ".team" / "logs" / f"{agent_id}.scrollback"),
-                "description": "tmux scrollback for fake worker",
-            }
-        ],
-        "next_actions": [],
-    }
-    report_result(workspace, envelope)
-    print(json.dumps(envelope), flush=True)
-
-
-if __name__ == "__main__":
-    main()