@team-agent/installer 0.1.10 → 0.2.0

package/src/team_agent/display/__init__.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from team_agent.display.close import (
+    close_ghostty_display,
+    close_ghostty_workspace,
+    close_ghostty_workspace_slot,
+)
+from team_agent.display.ghostty import (
+    ghostty_app_exists,
+    ghostty_attach_args,
+    ghostty_command,
+    ghostty_display_session_name,
+    ghostty_pids_by_title,
+    prepare_ghostty_display_session,
+)
+from team_agent.display.worker_window import (
+    open_ghostty_worker_window,
+    open_worker_displays,
+)
+from team_agent.display.workspace import (
+    GHOSTTY_WORKSPACE_PANES_PER_WINDOW,
+    ghostty_workspace_aggregator_name,
+    ghostty_workspace_blocked,
+    ghostty_workspace_pane_command,
+    ghostty_workspace_pane_title,
+    ghostty_workspace_partial_update_display,
+    ghostty_workspace_window_name,
+    kill_ghostty_workspace_linked_sessions,
+    open_ghostty_workspace,
+    open_ghostty_workspace_agent_display,
+    prepare_ghostty_workspace_aggregator,
+    prepare_ghostty_workspace_linked_sessions,
+    set_ghostty_workspace_pane_title,
+)
+
+__all__ = [
+    "GHOSTTY_WORKSPACE_PANES_PER_WINDOW",
+    "close_ghostty_display",
+    "close_ghostty_workspace",
+    "close_ghostty_workspace_slot",
+    "ghostty_app_exists",
+    "ghostty_attach_args",
+    "ghostty_command",
+    "ghostty_display_session_name",
+    "ghostty_pids_by_title",
+    "ghostty_workspace_aggregator_name",
+    "ghostty_workspace_blocked",
+    "ghostty_workspace_pane_command",
+    "ghostty_workspace_pane_title",
+    "ghostty_workspace_partial_update_display",
+    "ghostty_workspace_window_name",
+    "kill_ghostty_workspace_linked_sessions",
+    "open_ghostty_worker_window",
+    "open_ghostty_workspace",
+    "open_ghostty_workspace_agent_display",
+    "open_worker_displays",
+    "prepare_ghostty_display_session",
+    "prepare_ghostty_workspace_aggregator",
+    "prepare_ghostty_workspace_linked_sessions",
+    "set_ghostty_workspace_pane_title",
+]

package/src/team_agent/display/close.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from typing import Any
+
+from team_agent.events import EventLog
+from team_agent.display.ghostty import ghostty_pids_by_title
+from team_agent.display.workspace import kill_ghostty_workspace_linked_sessions
+
+
+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

@@ -0,0 +1,77 @@
+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/worker_window.py

@@ -0,0 +1,110 @@
+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.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 = "ghostty_window",
+) -> dict[str, dict[str, Any]]:
+    if not jobs:
+        return {}
+    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