@towles/tool 0.0.106 → 0.0.108

package/plugins/tt-agentboard/packages/runtime/src/server/launcher.ts

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { connect } from "node:net";
+import { SERVER_PORT, SERVER_HOST, PID_FILE } from "../shared";
+import { SERVER_ERR_LOG } from "../debug";
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function isPortOpen(host: string, port: number, timeoutMs = 200): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = connect({ host, port });
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeoutMs);
+    socket.on("connect", () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+
+function resolveAgentboardDir(): string {
+  if (process.env.TT_AGENTBOARD_DIR) return process.env.TT_AGENTBOARD_DIR;
+  // Walk up from packages/runtime/src/server/ to the plugin root
+  return new URL("../../../..", import.meta.url).pathname;
+}
+
+function resolveServerEntryPath(pluginDir: string): string {
+  return join(pluginDir, "apps", "server", "src", "main.ts");
+}
+
+export async function ensureServer(): Promise<void> {
+  if (existsSync(PID_FILE)) {
+    const pid = Number.parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+    if (!Number.isNaN(pid) && isProcessAlive(pid) && (await isPortOpen(SERVER_HOST, SERVER_PORT))) {
+      return;
+    }
+  }
+
+  const pluginDir = resolveAgentboardDir();
+  const serverPath = resolveServerEntryPath(pluginDir);
+
+  const proc = Bun.spawn([process.execPath, "run", serverPath], {
+    stdio: ["ignore", "ignore", Bun.file(SERVER_ERR_LOG)],
+    cwd: pluginDir,
+    env: { ...process.env, TT_AGENTBOARD_DIR: pluginDir },
+  });
+  proc.unref();
+
+  for (let i = 0; i < 60; i++) {
+    await Bun.sleep(50);
+    if (await isPortOpen(SERVER_HOST, SERVER_PORT, 100)) return;
+  }
+
+  const errLog = existsSync(SERVER_ERR_LOG) ? readFileSync(SERVER_ERR_LOG, "utf-8").trim() : "";
+  const detail = errLog || `No error output. Check ${SERVER_ERR_LOG}`;
+  throw new Error(`AgentBoard server failed to start:\n${detail}`);
+}

package/plugins/tt-agentboard/packages/runtime/src/server/metadata-store.ts

@@ -0,0 +1,86 @@
+import type { MetadataTone, SessionMetadata } from "../shared";
+
+const MAX_LOGS = 50;
+const MAX_MESSAGE_LENGTH = 500;
+
+function truncate(s: string, max: number = MAX_MESSAGE_LENGTH): string {
+  return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+
+export class SessionMetadataStore {
+  private store = new Map<string, SessionMetadata>();
+
+  private getOrCreate(session: string): SessionMetadata {
+    let meta = this.store.get(session);
+    if (!meta) {
+      meta = { status: null, progress: null, logs: [] };
+      this.store.set(session, meta);
+    }
+    return meta;
+  }
+
+  get(session: string): SessionMetadata | null {
+    const meta = this.store.get(session);
+    if (!meta) return null;
+    // Return null if everything is empty
+    if (!meta.status && !meta.progress && meta.logs.length === 0) return null;
+    return meta;
+  }
+
+  setStatus(session: string, status: { text: string; tone?: MetadataTone } | null): void {
+    if (!status) {
+      const meta = this.store.get(session);
+      if (meta) meta.status = null;
+      return;
+    }
+    const meta = this.getOrCreate(session);
+    meta.status = { text: truncate(status.text, 100), tone: status.tone, ts: Date.now() };
+  }
+
+  setProgress(
+    session: string,
+    progress: { current?: number; total?: number; percent?: number; label?: string } | null,
+  ): void {
+    if (!progress) {
+      const meta = this.store.get(session);
+      if (meta) meta.progress = null;
+      return;
+    }
+    const meta = this.getOrCreate(session);
+    meta.progress = {
+      current: progress.current,
+      total: progress.total,
+      percent: progress.percent,
+      label: progress.label ? truncate(progress.label, 100) : undefined,
+      ts: Date.now(),
+    };
+  }
+
+  appendLog(
+    session: string,
+    entry: { message: string; tone?: MetadataTone; source?: string },
+  ): void {
+    const meta = this.getOrCreate(session);
+    meta.logs.push({
+      message: truncate(entry.message),
+      tone: entry.tone,
+      source: entry.source ? truncate(entry.source, 50) : undefined,
+      ts: Date.now(),
+    });
+    if (meta.logs.length > MAX_LOGS) {
+      meta.logs = meta.logs.slice(meta.logs.length - MAX_LOGS);
+    }
+  }
+
+  clearLogs(session: string): void {
+    const meta = this.store.get(session);
+    if (meta) meta.logs = [];
+  }
+
+  /** Remove metadata for sessions that no longer exist */
+  pruneSessions(validNames: Set<string>): void {
+    for (const name of this.store.keys()) {
+      if (!validNames.has(name)) this.store.delete(name);
+    }
+  }
+}

package/plugins/tt-agentboard/packages/runtime/src/server/pane-scanner.ts

@@ -0,0 +1,327 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { AgentStatus } from "../contracts/agent";
+import type { SidebarPane } from "../contracts/mux";
+import type { ServerContext, PaneAgentPresence } from "./context";
+import { shell } from "./git-info";
+
+const AGENT_TITLE_PATTERNS: Record<string, string[]> = {
+  amp: ["amp"],
+  "claude-code": ["claude"],
+  codex: ["codex"],
+  opencode: ["opencode"],
+};
+
+/** Build parent->children map from a single ps snapshot (avoids per-pane pgrep calls). */
+function buildProcessTree(): { childrenOf: Map<number, number[]>; commOf: Map<number, string> } {
+  const childrenOf = new Map<number, number[]>();
+  const commOf = new Map<number, string>();
+  const psResult = Bun.spawnSync(["ps", "-eo", "pid=,ppid=,comm="], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  for (const line of psResult.stdout.toString().trim().split("\n")) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 3) continue;
+    const pid = Number.parseInt(parts[0], 10);
+    const ppid = Number.parseInt(parts[1], 10);
+    const comm = parts.slice(2).join(" ").toLowerCase();
+    if (Number.isNaN(pid) || Number.isNaN(ppid)) continue;
+    commOf.set(pid, comm);
+    let arr = childrenOf.get(ppid);
+    if (!arr) {
+      arr = [];
+      childrenOf.set(ppid, arr);
+    }
+    arr.push(pid);
+  }
+  return { childrenOf, commOf };
+}
+
+/** Walk up to 3 levels of child processes using a pre-built process tree. */
+function matchProcessTreeFast(
+  pid: number,
+  patterns: string[],
+  tree: ReturnType<typeof buildProcessTree>,
+  depth = 0,
+): boolean {
+  if (depth > 2) return false;
+  const children = tree.childrenOf.get(pid);
+  if (!children) return false;
+  for (const childPid of children) {
+    const comm = tree.commOf.get(childPid);
+    if (comm && patterns.some((pat) => comm.includes(pat))) return true;
+    if (matchProcessTreeFast(childPid, patterns, tree, depth + 1)) return true;
+  }
+  return false;
+}
+
+/** Find child PID matching a name pattern using pre-built process tree. */
+function findChildPidFast(
+  pid: number,
+  name: string,
+  tree: ReturnType<typeof buildProcessTree>,
+  depth = 0,
+): number | undefined {
+  if (depth > 2) return undefined;
+  const children = tree.childrenOf.get(pid);
+  if (!children) return undefined;
+  for (const childPid of children) {
+    const comm = tree.commOf.get(childPid);
+    if (comm?.includes(name)) return childPid;
+    const found = findChildPidFast(childPid, name, tree, depth + 1);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+/** Resolve threadId/threadName for an amp pane from its title. */
+function resolveAmpPaneInfo(title: string): { threadId?: string; threadName?: string } {
+  if (!title.toLowerCase().startsWith("amp - ")) return {};
+  const rest = title.slice(6);
+  const dashIdx = rest.lastIndexOf(" - ");
+  const threadName = dashIdx > 0 ? rest.slice(0, dashIdx) : rest;
+  return { threadName: threadName || undefined };
+}
+
+/** Resolve threadId/threadName/status for a Claude Code pane via ~/.claude/sessions/<pid>.json + journal. */
+function resolveClaudeCodePaneInfo(
+  panePid: number,
+  tree: ReturnType<typeof buildProcessTree>,
+): { threadId?: string; threadName?: string; status?: AgentStatus } {
+  const agentPid = findChildPidFast(panePid, "claude", tree);
+  if (!agentPid) return {};
+  const sessionsDir = join(homedir(), ".claude", "sessions");
+  try {
+    const data = JSON.parse(readFileSync(join(sessionsDir, `${agentPid}.json`), "utf-8"));
+    const threadId: string | undefined = data.sessionId;
+    if (!threadId) return {};
+    const journalInfo = resolveClaudeCodeJournalInfo(threadId);
+    return { threadId, ...journalInfo };
+  } catch {
+    return {};
+  }
+}
+
+/** Read the JSONL journal to extract thread name and current status. */
+function resolveClaudeCodeJournalInfo(threadId: string): {
+  threadName?: string;
+  status?: AgentStatus;
+} {
+  const projectsDir = join(homedir(), ".claude", "projects");
+  try {
+    const dirs = require("node:fs").readdirSync(projectsDir) as string[];
+    for (const dir of dirs) {
+      const filePath = join(projectsDir, dir, `${threadId}.jsonl`);
+      try {
+        const text = readFileSync(filePath, "utf-8");
+        const lines = text.split("\n").filter(Boolean);
+        let threadName: string | undefined;
+        let lastStatus: AgentStatus = "idle";
+
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            const msg = entry.message;
+            if (!msg?.role) continue;
+
+            if (!threadName && msg.role === "user") {
+              const content = msg.content;
+              let t: string | undefined;
+              if (typeof content === "string") t = content;
+              else if (Array.isArray(content))
+                t = content.find((c: any) => c.type === "text" && c.text)?.text;
+              if (t && !t.startsWith("<") && !t.startsWith("{")) threadName = t.slice(0, 80);
+            }
+
+            if (msg.role === "assistant") {
+              const items = Array.isArray(msg.content) ? msg.content : [];
+              lastStatus = items.some((c: any) => c.type === "tool_use") ? "running" : "done";
+            } else if (msg.role === "user") {
+              lastStatus = "running";
+            }
+          } catch {
+            continue;
+          }
+        }
+
+        return { threadName, status: lastStatus };
+      } catch {
+        continue;
+      }
+    }
+  } catch {}
+  return {};
+}
+
+/** Resolve threadId for a Codex pane via logs_1.sqlite. */
+function resolveCodexPaneInfo(
+  panePid: number,
+  tree: ReturnType<typeof buildProcessTree>,
+): { threadId?: string; threadName?: string } {
+  const agentPid = findChildPidFast(panePid, "codex", tree);
+  if (!agentPid) return {};
+  const dbPath = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "logs_1.sqlite");
+  let db: any;
+  try {
+    const { Database } = require("bun:sqlite");
+    db = new Database(dbPath, { readonly: true });
+  } catch {
+    return {};
+  }
+  try {
+    const row = db
+      .query(
+        `SELECT thread_id FROM logs WHERE process_uuid LIKE ? AND thread_id IS NOT NULL ORDER BY ts DESC LIMIT 1`,
+      )
+      .get(`pid:${agentPid}:%`);
+    if (row?.thread_id) return { threadId: row.thread_id };
+  } catch {
+  } finally {
+    try {
+      db.close();
+    } catch {}
+  }
+  return {};
+}
+
+/** Scan all panes across all tmux sessions and identify running agents.
+ *  Uses a single `tmux list-panes -a` call for efficiency. */
+function scanAllTmuxPaneAgents(
+  listSidebarPanesByProvider: () => { panes: SidebarPane[] }[],
+): Map<string, Map<string, PaneAgentPresence>> {
+  const result = new Map<string, Map<string, PaneAgentPresence>>();
+
+  const raw = shell([
+    "tmux",
+    "list-panes",
+    "-a",
+    "-F",
+    "#{session_name}|#{pane_id}|#{pane_pid}|#{pane_current_command}|#{pane_title}",
+  ]);
+  if (!raw) return result;
+
+  const panes = raw
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const idx1 = line.indexOf("|");
+      const idx2 = line.indexOf("|", idx1 + 1);
+      const idx3 = line.indexOf("|", idx2 + 1);
+      const idx4 = line.indexOf("|", idx3 + 1);
+      return {
+        session: line.slice(0, idx1),
+        id: line.slice(idx1 + 1, idx2),
+        pid: Number.parseInt(line.slice(idx2 + 1, idx3), 10),
+        cmd: line.slice(idx3 + 1, idx4),
+        title: line.slice(idx4 + 1),
+      };
+    });
+
+  // Exclude sidebar panes
+  const sidebarPaneIds = new Set<string>();
+  for (const { panes: sbPanes } of listSidebarPanesByProvider()) {
+    for (const sb of sbPanes) sidebarPaneIds.add(sb.paneId);
+  }
+
+  const nonSidebar = panes.filter((p) => !sidebarPaneIds.has(p.id));
+  if (nonSidebar.length === 0) return result;
+
+  // Build process tree once for all panes
+  const tree = buildProcessTree();
+  const now = Date.now();
+
+  for (const pane of nonSidebar) {
+    for (const [agentName, patterns] of Object.entries(AGENT_TITLE_PATTERNS)) {
+      if (!matchProcessTreeFast(pane.pid, patterns, tree)) continue;
+
+      let threadId: string | undefined;
+      let threadName: string | undefined;
+      let status: AgentStatus | undefined;
+
+      if (agentName === "amp") {
+        const info = resolveAmpPaneInfo(pane.title);
+        threadName = info.threadName;
+      } else if (agentName === "claude-code") {
+        const info = resolveClaudeCodePaneInfo(pane.pid, tree);
+        threadId = info.threadId;
+        threadName = info.threadName;
+        status = info.status;
+      } else if (agentName === "codex") {
+        const info = resolveCodexPaneInfo(pane.pid, tree);
+        threadId = info.threadId;
+      }
+
+      const key = `${agentName}:pane:${pane.id}`;
+      let sessionAgents = result.get(pane.session);
+      if (!sessionAgents) {
+        sessionAgents = new Map();
+        result.set(pane.session, sessionAgents);
+      }
+      sessionAgents.set(key, {
+        agent: agentName,
+        session: pane.session,
+        paneId: pane.id,
+        threadId,
+        threadName,
+        status,
+        lastSeenTs: now,
+      });
+    }
+  }
+
+  return result;
+}
+
+/** Refresh pane agent cache for all tmux sessions. */
+export function refreshPaneAgents(ctx: ServerContext): void {
+  const hasTmux = ctx.allProviders.some((p) => p.name === "tmux");
+  if (!hasTmux) {
+    if (ctx.paneAgentsBySession.size > 0) {
+      ctx.paneAgentsBySession.clear();
+      ctx.tracker.setPinnedInstancesMulti(new Map());
+      ctx.broadcastState();
+    }
+    return;
+  }
+
+  const nextBySession = scanAllTmuxPaneAgents(ctx.listSidebarPanesByProvider);
+  const allPinnedKeys = new Map<string, string[]>();
+  for (const [session, agents] of nextBySession) {
+    allPinnedKeys.set(session, [...agents.keys()]);
+  }
+
+  // Check if anything changed
+  let changed = ctx.paneAgentsBySession.size !== nextBySession.size;
+  if (!changed) {
+    for (const [session, agents] of nextBySession) {
+      const prev = ctx.paneAgentsBySession.get(session);
+      if (!prev || prev.size !== agents.size) {
+        changed = true;
+        break;
+      }
+      for (const key of agents.keys()) {
+        if (!prev.has(key)) {
+          changed = true;
+          break;
+        }
+      }
+      if (changed) break;
+    }
+  }
+
+  ctx.paneAgentsBySession = nextBySession;
+  ctx.tracker.setPinnedInstancesMulti(allPinnedKeys);
+
+  if (changed) ctx.broadcastState();
+}
+
+const PANE_SCAN_INTERVAL_MS = 3_000;
+
+export function startPaneScan(ctx: ServerContext): ReturnType<typeof setInterval> {
+  return setInterval(() => {
+    if (ctx.clientCount === 0) return;
+    refreshPaneAgents(ctx);
+  }, PANE_SCAN_INTERVAL_MS);
+}

package/plugins/tt-agentboard/packages/runtime/src/server/port-scanner.ts

@@ -0,0 +1,155 @@
+import { debugLog } from "../debug";
+
+// Global port snapshot — refreshed by the port poll timer, read by computeState.
+// Runs lsof + ps once for ALL sessions instead of per-session.
+let portSnapshot = new Map<string, number[]>();
+
+export function refreshPortSnapshot(sessionNames: string[]): boolean {
+  try {
+    // 1. Gather pane PIDs for all sessions in one tmux call per session
+    const panePidsBySession = new Map<string, number[]>();
+    for (const name of sessionNames) {
+      const r = Bun.spawnSync(["tmux", "list-panes", "-s", "-t", name, "-F", "#{pane_pid}"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const pids = r.stdout
+        .toString()
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map(Number)
+        .filter((n) => !Number.isNaN(n));
+      if (pids.length > 0) panePidsBySession.set(name, pids);
+    }
+
+    if (panePidsBySession.size === 0) {
+      portSnapshot = new Map();
+      return false;
+    }
+
+    // 2. Build parent->children map from a single ps call
+    const childrenOf = new Map<number, number[]>();
+    const psResult = Bun.spawnSync(["ps", "-eo", "pid=,ppid="], { stdout: "pipe", stderr: "pipe" });
+    for (const line of psResult.stdout.toString().trim().split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 2) continue;
+      const pid = Number.parseInt(parts[0], 10);
+      const ppid = Number.parseInt(parts[1], 10);
+      if (Number.isNaN(pid) || Number.isNaN(ppid)) continue;
+      let arr = childrenOf.get(ppid);
+      if (!arr) {
+        arr = [];
+        childrenOf.set(ppid, arr);
+      }
+      arr.push(pid);
+    }
+
+    // 3. BFS from pane PIDs to get full descendant tree per session
+    const pidToSessions = new Map<number, string[]>();
+    for (const [name, panePids] of panePidsBySession) {
+      const allPids = new Set<number>(panePids);
+      const queue = [...panePids];
+      while (queue.length > 0) {
+        const pid = queue.pop()!;
+        const kids = childrenOf.get(pid);
+        if (!kids) continue;
+        for (const kid of kids) {
+          if (!allPids.has(kid)) {
+            allPids.add(kid);
+            queue.push(kid);
+          }
+        }
+      }
+      for (const pid of allPids) {
+        let arr = pidToSessions.get(pid);
+        if (!arr) {
+          arr = [];
+          pidToSessions.set(pid, arr);
+        }
+        arr.push(name);
+      }
+    }
+
+    // 4. Single lsof call for all listening TCP ports
+    const lsofResult = Bun.spawnSync(["lsof", "-iTCP", "-sTCP:LISTEN", "-nP", "-F", "pn"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (lsofResult.exitCode !== 0) {
+      debugLog("ports", "lsof failed", {
+        exitCode: lsofResult.exitCode,
+        stderr: lsofResult.stderr.toString().slice(0, 200),
+      });
+      return false;
+    }
+
+    // 5. Parse and attribute ports to sessions
+    const sessionPorts = new Map<string, Set<number>>();
+    let currentPid = 0;
+    for (const line of lsofResult.stdout.toString().split("\n")) {
+      if (line.startsWith("p")) {
+        currentPid = Number.parseInt(line.slice(1), 10);
+      } else if (line.startsWith("n")) {
+        const sessions = pidToSessions.get(currentPid);
+        if (!sessions) continue;
+        const match = line.match(/:(\d+)$/);
+        if (!match) continue;
+        const port = Number.parseInt(match[1], 10);
+        if (Number.isNaN(port)) continue;
+        for (const name of sessions) {
+          let set = sessionPorts.get(name);
+          if (!set) {
+            set = new Set();
+            sessionPorts.set(name, set);
+          }
+          set.add(port);
+        }
+      }
+    }
+
+    // 6. Build the new snapshot
+    const next = new Map<string, number[]>();
+    for (const name of sessionNames) {
+      const set = sessionPorts.get(name);
+      next.set(name, set ? [...set].sort((a, b) => a - b) : []);
+    }
+
+    const changed = !mapsEqual(portSnapshot, next);
+    portSnapshot = next;
+    return changed;
+  } catch (err) {
+    debugLog("ports", "refreshPortSnapshot failed", { error: String(err) });
+    return false;
+  }
+}
+
+function mapsEqual(a: Map<string, number[]>, b: Map<string, number[]>): boolean {
+  if (a.size !== b.size) return false;
+  for (const [k, v] of a) {
+    const bv = b.get(k);
+    if (!bv || bv.length !== v.length || v.some((n, i) => n !== bv[i])) return false;
+  }
+  return true;
+}
+
+export function getSessionPorts(sessionName: string): number[] {
+  return portSnapshot.get(sessionName) ?? [];
+}
+
+export function startPortPoll(ctx: {
+  lastState: { sessions: { name: string }[] } | null;
+  clientCount: number;
+  broadcastState: () => void;
+}): ReturnType<typeof setInterval> {
+  // Run initial snapshot immediately so first broadcast has ports
+  if (ctx.lastState) {
+    refreshPortSnapshot(ctx.lastState.sessions.map((s) => s.name));
+  }
+  const PORT_POLL_INTERVAL_MS = 10_000;
+  return setInterval(() => {
+    if (!ctx.lastState || ctx.clientCount === 0) return;
+    const changed = refreshPortSnapshot(ctx.lastState.sessions.map((s) => s.name));
+    if (changed) ctx.broadcastState();
+  }, PORT_POLL_INTERVAL_MS);
+}