@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/display/close.py

@@ -1,154 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from team_agent.events import EventLog
-from team_agent.display.adaptive import close_adaptive_display
-from team_agent.display.ghostty import ghostty_pids_by_title
-from team_agent.display.workspace import kill_ghostty_workspace_linked_sessions
-
-
-def close_team_display_backends(state: dict[str, Any], event_log: EventLog) -> dict[str, Any]:
-    result = close_adaptive_display(state, event_log)
-    close_ghostty_workspace(state, event_log)
-    return result
-
-
-def close_ghostty_display(
-    agent_id: str,
-    agent_state: dict[str, Any],
-    event_log: EventLog,
-) -> None:
-    from team_agent.runtime import _tmux_session_exists, run_cmd
-    display = agent_state.get("display") or {}
-    if display.get("backend") != "ghostty_window":
-        return
-    display_session = display.get("display_session")
-    pids = [str(pid) for pid in display.get("pids", []) if str(pid).isdigit()]
-    title = display.get("title")
-    if not pids and title:
-        pids = [str(pid) for pid in ghostty_pids_by_title(str(title))]
-    killed: list[str] = []
-    for pid in pids:
-        proc = run_cmd(["kill", pid], timeout=5)
-        if proc.returncode == 0:
-            killed.append(pid)
-    if killed:
-        event_log.write("display.ghostty_closed", agent_id=agent_id, pids=killed, title=title)
-    if display_session and _tmux_session_exists(str(display_session)):
-        proc = run_cmd(["tmux", "kill-session", "-t", str(display_session)], timeout=10)
-        if proc.returncode == 0:
-            event_log.write("display.ghostty_display_session_closed", agent_id=agent_id, display_session=display_session)
-        else:
-            event_log.write(
-                "display.ghostty_display_session_close_failed",
-                agent_id=agent_id,
-                display_session=display_session,
-                error=proc.stderr.strip(),
-            )
-
-
-def close_ghostty_workspace_slot(
-    agent_id: str,
-    display: dict[str, Any],
-    event_log: EventLog,
-) -> None:
-    from team_agent.runtime import _tmux_session_exists, run_cmd
-    pane_id = display.get("pane_id")
-    linked_session = display.get("linked_session")
-    stopped_title = f"stopped: {agent_id}"
-    relabeled = False
-    if pane_id:
-        proc = run_cmd(["tmux", "select-pane", "-t", str(pane_id), "-T", stopped_title], timeout=10)
-        if proc.returncode == 0:
-            relabeled = True
-        else:
-            event_log.write(
-                "display.ghostty_workspace_slot_relabel_failed",
-                agent_id=agent_id,
-                pane_id=pane_id,
-                error=proc.stderr.strip(),
-            )
-    linked_session_closed = False
-    if linked_session and _tmux_session_exists(str(linked_session)):
-        proc = run_cmd(["tmux", "kill-session", "-t", str(linked_session)], timeout=10)
-        if proc.returncode == 0:
-            linked_session_closed = True
-        else:
-            event_log.write(
-                "display.ghostty_workspace_slot_linked_session_close_failed",
-                agent_id=agent_id,
-                linked_session=linked_session,
-                error=proc.stderr.strip(),
-            )
-    display["status"] = "stopped"
-    display["pane_title"] = stopped_title
-    event_log.write(
-        "display.ghostty_workspace_slot_closed",
-        agent_id=agent_id,
-        pane_id=pane_id,
-        linked_session=linked_session,
-        relabeled=relabeled,
-        linked_session_closed=linked_session_closed,
-    )
-
-
-def close_ghostty_workspace(state: dict[str, Any], event_log: EventLog) -> None:
-    from team_agent.runtime import _tmux_session_exists, run_cmd
-    displays = [
-        (agent_id, agent_state.get("display") or {})
-        for agent_id, agent_state in state.get("agents", {}).items()
-        if (agent_state.get("display") or {}).get("backend") == "ghostty_workspace"
-    ]
-    if not displays:
-        return
-    aggregator_session = next(
-        (
-            str(display.get("aggregator_session") or display.get("display_session"))
-            for _agent_id, display in displays
-            if display.get("aggregator_session") or display.get("display_session")
-        ),
-        None,
-    )
-    title = next((str(display.get("title")) for _agent_id, display in displays if display.get("title")), None)
-    pids = {
-        str(pid)
-        for _agent_id, display in displays
-        for pid in display.get("pids", [])
-        if str(pid).isdigit()
-    }
-    if not pids and title:
-        pids = {str(pid) for pid in ghostty_pids_by_title(str(title))}
-
-    aggregator_closed = False
-    if aggregator_session and _tmux_session_exists(aggregator_session):
-        proc = run_cmd(["tmux", "kill-session", "-t", aggregator_session], timeout=10)
-        if proc.returncode == 0:
-            aggregator_closed = True
-        else:
-            event_log.write(
-                "display.ghostty_workspace_close_failed",
-                aggregator_session=aggregator_session,
-                error=proc.stderr.strip(),
-            )
-
-    linked_sessions = [
-        str(display.get("linked_session"))
-        for _agent_id, display in displays
-        if display.get("linked_session")
-    ]
-    linked_closed = kill_ghostty_workspace_linked_sessions(linked_sessions)
-
-    killed: list[str] = []
-    for pid in sorted(pids):
-        proc = run_cmd(["kill", pid], timeout=5)
-        if proc.returncode == 0:
-            killed.append(pid)
-    event_log.write(
-        "display.ghostty_workspace_closed",
-        pids=killed,
-        title=title,
-        aggregator_session=aggregator_session,
-        linked_sessions=linked_closed,
-        aggregator_closed=aggregator_closed,
-    )

package/src/team_agent/display/ghostty.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import re
-import time
-from pathlib import Path
-from typing import Any
-
-
-def ghostty_command() -> str | None:
-    from team_agent.runtime import shutil_which
-    return shutil_which("ghostty") or (
-        "/Applications/Ghostty.app/Contents/MacOS/ghostty"
-        if Path("/Applications/Ghostty.app/Contents/MacOS/ghostty").exists()
-        else None
-    )
-
-
-def ghostty_app_exists() -> bool:
-    return Path("/Applications/Ghostty.app").exists()
-
-
-def ghostty_pids_by_title(title: str, wait_s: float = 0.0) -> list[int]:
-    from team_agent.runtime import run_cmd
-    deadline = time.monotonic() + max(wait_s, 0.0)
-    while True:
-        pgrep = run_cmd(["pgrep", "-f", f"--title={title}"], timeout=5)
-        if pgrep.returncode == 0:
-            pids = [int(pid) for pid in pgrep.stdout.split() if pid.isdigit()]
-            if pids:
-                return pids
-        if time.monotonic() >= deadline:
-            return []
-        time.sleep(0.2)
-
-
-def ghostty_attach_args(display_session: str, title: str) -> list[str]:
-    return [
-        "open",
-        "-na",
-        "Ghostty.app",
-        "--args",
-        f"--title={title}",
-        "-e",
-        "tmux",
-        "attach-session",
-        "-t",
-        display_session,
-    ]
-
-
-def ghostty_display_session_name(session_name: str, window_name: str) -> str:
-    raw = f"{session_name}:{window_name}"
-    digest = hashlib.sha1(raw.encode("utf-8")).hexdigest()[:8]
-    safe_session = re.sub(r"[^A-Za-z0-9_.-]", "_", session_name)[:80].strip("._-") or "team"
-    safe_window = re.sub(r"[^A-Za-z0-9_.-]", "_", window_name)[:40].strip("._-") or "agent"
-    return f"{safe_session}__display__{safe_window}__{digest}"
-
-
-def prepare_ghostty_display_session(session_name: str, window_name: str, display_session: str) -> dict[str, Any]:
-    from team_agent.runtime import _tmux_session_exists, _tmux_window_exists, run_cmd
-    if not _tmux_window_exists(session_name, window_name):
-        return {"ok": False, "reason": "tmux_target_missing"}
-    if display_session == session_name:
-        return {"ok": False, "reason": "display_session_conflicts_with_base_session"}
-    if _tmux_session_exists(display_session):
-        proc = run_cmd(["tmux", "kill-session", "-t", display_session], timeout=10)
-        if proc.returncode != 0:
-            return {"ok": False, "reason": "display_session_cleanup_failed", "error": proc.stderr.strip()}
-    proc = run_cmd(["tmux", "new-session", "-d", "-t", session_name, "-s", display_session], timeout=10)
-    if proc.returncode != 0:
-        return {"ok": False, "reason": "display_session_create_failed", "error": proc.stderr.strip()}
-    proc = run_cmd(["tmux", "select-window", "-t", f"{display_session}:{window_name}"], timeout=10)
-    if proc.returncode != 0:
-        run_cmd(["tmux", "kill-session", "-t", display_session], timeout=10)
-        return {"ok": False, "reason": "display_session_select_window_failed", "error": proc.stderr.strip()}
-    return {"ok": True, "display_session": display_session}

package/src/team_agent/display/rebuild.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from team_agent.events import EventLog
-
-
-def rebuild_restart_display_after_rebind(
-    display_backend: str,
-    workspace: Path,
-    session_name: str,
-    spec: dict[str, Any],
-    event_log: EventLog,
-    restarted: list[dict[str, Any]],
-    receiver: dict[str, Any] | None = None,
-) -> dict[str, Any]:
-    if display_backend != "adaptive":
-        return {}
-    from team_agent.restart.snapshot import save_team_runtime_snapshot
-    from team_agent.state import load_runtime_state, save_runtime_state, write_team_state
-    state = load_runtime_state(workspace)
-    state, display_results = rebuild_adaptive_display_after_rebind(
-        workspace,
-        session_name,
-        spec,
-        state,
-        event_log,
-        save_runtime_state,
-        save_team_runtime_snapshot,
-        write_team_state,
-        receiver=receiver,
-    )
-    for item in restarted:
-        display = display_results.get(item["agent_id"])
-        if display:
-            item["display_target"] = display
-    return state
-
-
-def rebuild_adaptive_display_after_rebind(
-    workspace: Path,
-    session_name: str,
-    spec: dict[str, Any],
-    state: dict[str, Any],
-    event_log: EventLog,
-    save_state: Any,
-    save_snapshot: Any,
-    write_team_state: Any,
-    receiver: dict[str, Any] | None = None,
-) -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
-    if receiver:
-        state["leader_receiver"] = receiver
-    receiver = receiver or (state.get("leader_receiver") if isinstance(state.get("leader_receiver"), dict) else {})
-    rebind_session = latest_rebind_session(event_log)
-    if rebind_session:
-        receiver = {**receiver, "session_name": rebind_session}
-    jobs = [
-        (agent["id"], agent)
-        for agent in spec.get("agents", [])
-        if agent["id"] in state.get("agents", {}) and state["agents"][agent["id"]].get("status") == "running"
-    ]
-    from team_agent.runtime import _open_worker_displays
-    display_results = _open_worker_displays(
-        workspace,
-        session_name,
-        jobs,
-        event_log,
-        "adaptive",
-        capability_probe={
-            "in_tmux": bool(receiver.get("session_name")),
-            "leader_session": receiver.get("session_name"),
-            "leader_pane": receiver.get("pane_id"),
-            "platform": None,
-            "caps": {"adaptive_display": bool(receiver.get("session_name"))},
-            "reason": None if receiver.get("session_name") else "leader_not_in_tmux",
-        },
-    )
-    for agent_id, display in display_results.items():
-        if agent_id in state.get("agents", {}):
-            state["agents"][agent_id]["display"] = display
-    event_log.write(
-        "display.adaptive_rebuilt",
-        session=session_name,
-        workers=sorted(display_results),
-        leader_session=next((display.get("leader_session") for display in display_results.values()), None),
-        stale_windows_recreated=True,
-    )
-    save_state(workspace, state)
-    save_snapshot(workspace, state)
-    write_team_state(workspace, spec, state)
-    return state, display_results
-
-
-def latest_rebind_session(event_log: EventLog) -> str | None:
-    for event in reversed(event_log.tail(50)):
-        if event.get("event") != "leader_receiver.rebind_applied":
-            continue
-        session = event.get("new_session_name") or event.get("session_name")
-        if session:
-            return str(session)
-    return None

package/src/team_agent/display/tiling.py

@@ -1,156 +0,0 @@
-from __future__ import annotations
-
-import shlex
-from typing import Any, Callable
-
-
-DISPLAY_PANES_PER_WINDOW = 3
-
-
-def display_window_name(index: int) -> str:
-    return "overview" if index == 0 else f"overview-{index + 1}"
-
-
-def grouped_display_jobs(
-    jobs: list[tuple[str, dict[str, Any], str]],
-    panes_per_window: int = DISPLAY_PANES_PER_WINDOW,
-) -> list[tuple[int, str, list[tuple[str, dict[str, Any], str]]]]:
-    groups: list[tuple[int, str, list[tuple[str, dict[str, Any], str]]]] = []
-    for window_index, start in enumerate(range(0, len(jobs), panes_per_window)):
-        groups.append((window_index, display_window_name(window_index), jobs[start : start + panes_per_window]))
-    return groups
-
-
-def team_scoped_display_window_name(session_name: str, index: int) -> str:
-    return f"team-agent:{session_name}:{display_window_name(index)}"
-
-
-def tmux_stdout_last_line(stdout: str) -> str | None:
-    lines = [line.strip() for line in stdout.splitlines() if line.strip()]
-    return lines[-1] if lines else None
-
-
-def tmux_attach_pane_command(linked_session: str) -> str:
-    return f"TMUX= tmux attach-session -t {shlex.quote(linked_session)}"
-
-
-def display_pane_title(agent: dict[str, Any]) -> str:
-    return f"team-agent:{agent['id']}:{agent.get('role', '')}"
-
-
-def set_tmux_display_pane_title(pane_id: str, title: str, reason: str) -> dict[str, Any]:
-    from team_agent.runtime import run_cmd
-    proc = run_cmd(["tmux", "select-pane", "-t", pane_id, "-T", title], timeout=10)
-    if proc.returncode != 0:
-        return {"ok": False, "reason": reason, "error": proc.stderr.strip()}
-    return {"ok": True}
-
-
-def prepare_tmux_attached_panes(
-    host_session: str,
-    linked_jobs: list[tuple[str, dict[str, Any], str]],
-    *,
-    window_name_for_index: Callable[[int], str],
-    create_first_as_session: bool,
-    panes_per_window: int = DISPLAY_PANES_PER_WINDOW,
-    reason_map: dict[str, str] | None = None,
-    stderr_reason_allowlist: set[str] | None = None,
-    cleanup_session: str | None = None,
-    enable_mouse: bool = False,
-    select_first_window: bool = False,
-) -> dict[str, Any]:
-    from team_agent.runtime import run_cmd
-
-    reasons = reason_map or {}
-
-    def reason(key: str) -> str:
-        return reasons.get(key, key)
-
-    def fail(key: str, proc: Any | None = None, target: str | None = None) -> dict[str, Any]:
-        if cleanup_session:
-            run_cmd(["tmux", "kill-session", "-t", cleanup_session], timeout=10)
-        result = {"ok": False, "reason": reason(key)}
-        if proc is not None:
-            detail = (proc.stderr or proc.stdout or "").strip()
-            if stderr_reason_allowlist and detail in stderr_reason_allowlist:
-                result["reason"] = detail
-            result["error"] = detail
-        if target:
-            result["target"] = target
-        return result
-
-    panes: list[dict[str, Any]] = []
-    for window_index, _base_window_name, window_jobs in grouped_display_jobs(linked_jobs, panes_per_window):
-        window_name = window_name_for_index(window_index)
-        first_agent_id, first_agent, first_linked_session = window_jobs[0]
-        if create_first_as_session and window_index == 0:
-            command = [
-                "tmux", "new-session", "-d", "-P", "-F", "#{pane_id}",
-                "-s", host_session, "-n", window_name, tmux_attach_pane_command(first_linked_session),
-            ]
-            fail_key = "create_session"
-        else:
-            command = [
-                "tmux", "new-window", "-t", host_session, "-n", window_name,
-                "-P", "-F", "#{pane_id}", tmux_attach_pane_command(first_linked_session),
-            ]
-            fail_key = "create_window"
-        proc = run_cmd(command, timeout=10)
-        if proc.returncode != 0:
-            return fail(fail_key, proc, f"{host_session}:{window_name}")
-
-        first_pane_id = tmux_stdout_last_line(proc.stdout) or f"{host_session}:{window_name}.0"
-        title = display_pane_title(first_agent)
-        title_result = set_tmux_display_pane_title(first_pane_id, title, reason("title"))
-        if not title_result["ok"]:
-            return fail(title_result["reason"], target=first_pane_id)
-        panes.append(
-            {
-                "agent_id": first_agent_id,
-                "pane_id": first_pane_id,
-                "title": title,
-                "linked_session": first_linked_session,
-                "window_name": window_name,
-            }
-        )
-
-        proc = run_cmd(["tmux", "set-window-option", "-t", f"{host_session}:{window_name}", "remain-on-exit", "on"], timeout=10)
-        if proc.returncode != 0:
-            return fail("remain", proc, f"{host_session}:{window_name}")
-
-        for index, (agent_id, agent, linked_session) in enumerate(window_jobs[1:], start=1):
-            proc = run_cmd(
-                [
-                    "tmux", "split-window", "-t", f"{host_session}:{window_name}",
-                    "-h", "-P", "-F", "#{pane_id}", tmux_attach_pane_command(linked_session),
-                ],
-                timeout=10,
-            )
-            if proc.returncode != 0:
-                return fail("split", proc, f"{host_session}:{window_name}")
-            pane_id = tmux_stdout_last_line(proc.stdout) or f"{host_session}:{window_name}.{index}"
-            title = display_pane_title(agent)
-            title_result = set_tmux_display_pane_title(pane_id, title, reason("title"))
-            if not title_result["ok"]:
-                return fail(title_result["reason"], target=pane_id)
-            panes.append(
-                {
-                    "agent_id": agent_id,
-                    "pane_id": pane_id,
-                    "title": title,
-                    "linked_session": linked_session,
-                    "window_name": window_name,
-                }
-            )
-
-        proc = run_cmd(["tmux", "select-layout", "-t", f"{host_session}:{window_name}", "even-horizontal"], timeout=10)
-        if proc.returncode != 0:
-            return fail("layout", proc, f"{host_session}:{window_name}")
-
-    if enable_mouse:
-        proc = run_cmd(["tmux", "set-option", "-t", host_session, "mouse", "on"], timeout=10)
-        if proc.returncode != 0:
-            return fail("mouse", proc)
-    if select_first_window:
-        run_cmd(["tmux", "select-window", "-t", f"{host_session}:{window_name_for_index(0)}"], timeout=10)
-    return {"ok": True, "host_session": host_session, "panes": panes}

package/src/team_agent/display/worker_window.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from pathlib import Path
-from typing import Any
-
-from team_agent.events import EventLog
-from team_agent.display.adaptive import open_adaptive_display
-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.workspace import open_ghostty_workspace
-
-
-def open_worker_displays(
-    workspace: Path,
-    session_name: str,
-    jobs: list[tuple[str, dict[str, Any]]],
-    event_log: EventLog,
-    display_backend: str = "adaptive",
-    capability_probe: dict[str, Any] | None = None,
-) -> dict[str, dict[str, Any]]:
-    if not jobs:
-        return {}
-    if display_backend == "adaptive":
-        return open_adaptive_display(workspace, session_name, jobs, event_log, capability_probe=capability_probe)
-    if display_backend == "ghostty_workspace":
-        return open_ghostty_workspace(workspace, session_name, jobs, event_log)
-    if len(jobs) == 1:
-        agent_id, agent = jobs[0]
-        return {agent_id: open_ghostty_worker_window(workspace, session_name, agent_id, agent, event_log)}
-    results: dict[str, dict[str, Any]] = {}
-    max_workers = min(4, len(jobs))
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        futures = {
-            executor.submit(open_ghostty_worker_window, workspace, session_name, agent_id, agent, event_log): 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:
-                display = {
-                    "backend": "ghostty_window",
-                    "status": "blocked",
-                    "reason": "display_open_exception",
-                    "error": str(exc),
-                    "fallback": "tmux_headless",
-                }
-                event_log.write("display.ghostty_blocked", agent_id=agent_id, **display)
-                results[agent_id] = display
-    return results
-
-
-def open_ghostty_worker_window(
-    workspace: Path,
-    session_name: str,
-    window_name: str,
-    agent: dict[str, Any],
-    event_log: EventLog,
-) -> dict[str, Any]:
-    from team_agent.runtime import run_cmd
-    _ = workspace
-    if not ghostty_app_exists():
-        blocker = {
-            "backend": "ghostty_window",
-            "status": "blocked",
-            "reason": "ghostty_app_missing",
-            "fallback": "tmux_headless",
-        }
-        event_log.write("display.ghostty_blocked", agent_id=agent["id"], **blocker)
-        return blocker
-    title = f"team-agent:{agent['id']}:{agent.get('role', '')}"
-    display_session = ghostty_display_session_name(session_name, window_name)
-    prepared = prepare_ghostty_display_session(session_name, window_name, display_session)
-    if not prepared["ok"]:
-        blocker = {
-            "backend": "ghostty_window",
-            "status": "blocked",
-            "reason": prepared["reason"],
-            "error": prepared.get("error"),
-            "target": f"{session_name}:{window_name}",
-            "display_session": display_session,
-            "fallback": "tmux_headless",
-        }
-        event_log.write("display.ghostty_blocked", agent_id=agent["id"], **blocker)
-        return blocker
-    launch_args = ghostty_attach_args(display_session, title)
-    proc = run_cmd(launch_args, timeout=10)
-    display = {
-        "backend": "ghostty_window",
-        "status": "opened" if proc.returncode == 0 else "blocked",
-        "title": title,
-        "target": f"{session_name}:{window_name}",
-        "display_session": display_session,
-        "launch_args": launch_args,
-        "pid": None,
-        "pids": [],
-        "tty": None,
-        "fallback": "tmux_headless",
-        "note": "Ghostty opens a dedicated linked tmux session per worker so each display has an independent active window; runtime injection remains tmux-backed.",
-    }
-    if proc.returncode != 0:
-        display["reason"] = proc.stderr.strip() or proc.stdout.strip() or "open Ghostty.app failed"
-    else:
-        display["pids"] = ghostty_pids_by_title(title, wait_s=3.0)
-        display["pid"] = display["pids"][0] if display["pids"] else None
-    event_log.write("display.ghostty_window", agent_id=agent["id"], **display)
-    return display