@towles/tool 0.0.107 → 0.0.108

package/plugins/tt-agentboard/packages/runtime/src/agents/watchers/codex.ts

@@ -0,0 +1,364 @@
+/**
+ * Codex agent watcher
+ *
+ * Watches Codex transcript files under ~/.codex/sessions/ (or $CODEX_HOME/sessions),
+ * determines agent status from the latest transcript events, and emits events
+ * mapped to mux sessions via the working directory captured in turn_context.
+ *
+ * Detection uses a recursive fs.watch when available plus a periodic poll to
+ * catch missed writes and new files.
+ */
+
+import { watch } from "node:fs";
+import type { FSWatcher } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import type { AgentStatus } from "../../contracts/agent";
+import type { AgentWatcher, AgentWatcherContext } from "../../contracts/agent-watcher";
+
+interface CodexEntry {
+  type?: string;
+  payload?: {
+    type?: string;
+    role?: string;
+    phase?: string;
+    cwd?: string;
+    message?: string;
+    content?: Array<{ type?: string; text?: string }>;
+  };
+}
+
+interface SessionSnapshot {
+  status: AgentStatus;
+  fileSize: number;
+  projectDir?: string;
+  threadName?: string;
+}
+
+const POLL_MS = 2000;
+const STALE_MS = 5 * 60 * 1000;
+const THREAD_NAME_MAX = 80;
+
+function assistantStatus(phase?: string): AgentStatus {
+  return phase === "commentary" ? "running" : "done";
+}
+
+export function determineStatus(entry: CodexEntry): AgentStatus | null {
+  const payload = entry.payload;
+  if (!payload) return null;
+
+  if (entry.type === "event_msg") {
+    switch (payload.type) {
+      case "task_complete":
+        return "done";
+      case "turn_aborted":
+        return "interrupted";
+      case "user_message":
+        return "running";
+      case "agent_message":
+        return assistantStatus(payload.phase);
+      case "error":
+        return "error";
+      default:
+        return null;
+    }
+  }
+
+  if (entry.type === "response_item") {
+    if (payload.type === "message") {
+      if (payload.role === "user") return "running";
+      if (payload.role === "assistant") return assistantStatus(payload.phase);
+      return null;
+    }
+
+    if (
+      payload.type === "function_call" ||
+      payload.type === "function_call_output" ||
+      payload.type === "reasoning"
+    ) {
+      return "running";
+    }
+  }
+
+  return null;
+}
+
+function parseThreadId(filePath: string): string {
+  const name = basename(filePath, ".jsonl");
+  return name.match(/[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i)?.[0] ?? name;
+}
+
+function normalizeThreadName(text: string | undefined): string | undefined {
+  if (!text) return undefined;
+  const line = text
+    .split("\n")
+    .map((part) => part.trim())
+    .find(Boolean);
+  return line ? line.slice(0, THREAD_NAME_MAX) : undefined;
+}
+
+function extractThreadName(entry: CodexEntry): string | undefined {
+  const payload = entry.payload;
+  if (!payload) return undefined;
+
+  if (entry.type === "event_msg" && payload.type === "user_message") {
+    return normalizeThreadName(payload.message);
+  }
+
+  if (entry.type === "response_item" && payload.type === "message" && payload.role === "user") {
+    const text = Array.isArray(payload.content)
+      ? payload.content
+          .filter((item) => item?.type === "input_text")
+          .map((item) => item.text ?? "")
+          .join("\n")
+      : undefined;
+    const candidate = normalizeThreadName(text);
+    if (!candidate) return undefined;
+    if (candidate.startsWith("# AGENTS.md") || candidate.startsWith("<environment_context>"))
+      return undefined;
+    return candidate;
+  }
+
+  return undefined;
+}
+
+function applyEntries(
+  text: string,
+  base: SessionSnapshot,
+  indexedThreadName?: string,
+): SessionSnapshot {
+  let status = base.status;
+  let projectDir = base.projectDir;
+  let threadName = indexedThreadName ?? base.threadName;
+
+  for (const rawLine of text.split("\n")) {
+    if (!rawLine.trim()) continue;
+
+    let entry: CodexEntry;
+    try {
+      entry = JSON.parse(rawLine);
+    } catch {
+      continue;
+    }
+
+    if (!projectDir && entry.type === "turn_context" && typeof entry.payload?.cwd === "string") {
+      projectDir = entry.payload.cwd;
+    }
+
+    if (!threadName) {
+      threadName = extractThreadName(entry);
+    }
+
+    const nextStatus = determineStatus(entry);
+    if (nextStatus) {
+      status = nextStatus;
+    }
+  }
+
+  return { ...base, status, projectDir, threadName };
+}
+
+async function collectSessionFiles(dir: string): Promise<string[]> {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const files: string[] = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await collectSessionFiles(fullPath)));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+export class CodexAgentWatcher implements AgentWatcher {
+  readonly name = "codex";
+
+  private sessions = new Map<string, SessionSnapshot>();
+  private threadNames = new Map<string, string>();
+  private fsWatcher: FSWatcher | null = null;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private ctx: AgentWatcherContext | null = null;
+  private sessionsDir: string;
+  private sessionIndexFile: string;
+  private scanning = false;
+  private seeded = false;
+
+  constructor() {
+    const codexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
+    this.sessionsDir = join(codexHome, "sessions");
+    this.sessionIndexFile = join(codexHome, "session_index.jsonl");
+  }
+
+  start(ctx: AgentWatcherContext): void {
+    this.ctx = ctx;
+    this.setupWatch();
+    setTimeout(() => this.scan(), 50);
+    this.pollTimer = setInterval(() => this.scan(), POLL_MS);
+  }
+
+  stop(): void {
+    if (this.fsWatcher) {
+      try {
+        this.fsWatcher.close();
+      } catch {}
+      this.fsWatcher = null;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.ctx = null;
+  }
+
+  private async loadThreadIndex(): Promise<void> {
+    let text: string;
+    try {
+      text = await Bun.file(this.sessionIndexFile).text();
+    } catch {
+      return;
+    }
+
+    const names = new Map<string, string>();
+    for (const line of text.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line) as { id?: string; thread_name?: string };
+        if (entry.id && entry.thread_name) {
+          names.set(entry.id, entry.thread_name);
+        }
+      } catch {}
+    }
+
+    this.threadNames = names;
+  }
+
+  private async processFile(filePath: string): Promise<void> {
+    if (!this.ctx) return;
+
+    let fileStat;
+    try {
+      fileStat = await stat(filePath);
+    } catch {
+      return;
+    }
+
+    const threadId = parseThreadId(filePath);
+    const prev = this.sessions.get(threadId);
+
+    if (prev && fileStat.size === prev.fileSize) return;
+
+    const indexedThreadName = this.threadNames.get(threadId);
+    let nextSnapshot: SessionSnapshot;
+
+    if (prev && fileStat.size > prev.fileSize) {
+      let text: string;
+      try {
+        const buf = await Bun.file(filePath).arrayBuffer();
+        text = new TextDecoder().decode(new Uint8Array(buf).subarray(prev.fileSize, fileStat.size));
+      } catch {
+        return;
+      }
+
+      nextSnapshot = applyEntries(text, { ...prev, fileSize: fileStat.size }, indexedThreadName);
+    } else {
+      let text: string;
+      try {
+        text = await Bun.file(filePath).text();
+      } catch {
+        return;
+      }
+
+      nextSnapshot = applyEntries(
+        text,
+        { status: "idle", fileSize: fileStat.size },
+        indexedThreadName,
+      );
+    }
+
+    this.sessions.set(threadId, nextSnapshot);
+
+    if (!this.seeded) return;
+
+    const prevStatus = prev?.status;
+    if (nextSnapshot.status === prevStatus) return;
+
+    const session = nextSnapshot.projectDir
+      ? this.ctx.resolveSession(nextSnapshot.projectDir)
+      : null;
+    if (!session) return;
+    if (!prev && nextSnapshot.status === "idle") return;
+
+    this.ctx.emit({
+      agent: "codex",
+      session,
+      status: nextSnapshot.status,
+      ts: Date.now(),
+      threadId,
+      ...(nextSnapshot.threadName && { threadName: nextSnapshot.threadName }),
+    });
+  }
+
+  private async scan(): Promise<void> {
+    if (this.scanning || !this.ctx) return;
+    this.scanning = true;
+
+    try {
+      await this.loadThreadIndex();
+
+      const files = await collectSessionFiles(this.sessionsDir);
+      const now = Date.now();
+
+      for (const filePath of files) {
+        let fileStat;
+        try {
+          fileStat = await stat(filePath);
+        } catch {
+          continue;
+        }
+
+        if (now - fileStat.mtimeMs > STALE_MS) continue;
+        await this.processFile(filePath);
+      }
+    } finally {
+      if (!this.seeded) {
+        this.seeded = true;
+        // Emit seeded sessions with non-idle status (like amp watcher does)
+        for (const [threadId, snapshot] of this.sessions) {
+          if (snapshot.status === "idle" || !snapshot.projectDir) continue;
+          const session = this.ctx?.resolveSession(snapshot.projectDir);
+          if (!session) continue;
+          this.ctx?.emit({
+            agent: "codex",
+            session,
+            status: snapshot.status,
+            ts: Date.now(),
+            threadId,
+            ...(snapshot.threadName && { threadName: snapshot.threadName }),
+          });
+        }
+      }
+      this.scanning = false;
+    }
+  }
+
+  private setupWatch(): void {
+    try {
+      this.fsWatcher = watch(this.sessionsDir, { recursive: true }, (_eventType, filename) => {
+        if (!filename?.endsWith(".jsonl")) return;
+        this.processFile(join(this.sessionsDir, filename));
+      });
+    } catch {}
+  }
+}

package/plugins/tt-agentboard/packages/runtime/src/agents/watchers/opencode.ts

@@ -0,0 +1,249 @@
+/**
+ * OpenCode agent watcher
+ *
+ * Polls the OpenCode SQLite database (~/.local/share/opencode/opencode.db)
+ * to determine agent status and emits events mapped to mux sessions
+ * via the `directory` field on each OpenCode session row.
+ */
+
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AgentStatus } from "../../contracts/agent";
+import type { AgentWatcher, AgentWatcherContext } from "../../contracts/agent-watcher";
+
+// --- Types ---
+
+interface SessionRow {
+  id: string;
+  title: string | null;
+  directory: string;
+  time_updated: number;
+}
+
+interface MessageRow {
+  id: string;
+  data: string;
+}
+
+interface MessageData {
+  role?: string;
+  finish?: string;
+}
+
+interface PartData {
+  type?: string;
+}
+
+const POLL_MS = 3000;
+const STALE_MS = 5 * 60 * 1000;
+
+// --- Status detection ---
+
+export function determineStatus(msg: MessageData | null, parts: PartData[]): AgentStatus {
+  if (!msg) return "idle";
+
+  if (msg.role === "assistant") {
+    if (msg.finish === "tool-calls") return "running";
+    if (parts.some((p) => p.type === "tool")) return "running";
+    return "done";
+  }
+
+  if (msg.role === "user") return "running";
+
+  return "idle";
+}
+
+// --- Watcher implementation ---
+
+export class OpenCodeAgentWatcher implements AgentWatcher {
+  readonly name = "opencode";
+
+  private sessionTimestamps = new Map<string, number>();
+  private sessionStatuses = new Map<string, AgentStatus>();
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private ctx: AgentWatcherContext | null = null;
+  private db: any = null;
+  private dbPath: string;
+
+  constructor() {
+    this.dbPath =
+      process.env.OPENCODE_DB_PATH ?? join(homedir(), ".local", "share", "opencode", "opencode.db");
+  }
+
+  private polling = false;
+
+  start(ctx: AgentWatcherContext): void {
+    this.ctx = ctx;
+    setTimeout(() => this.poll(), 50);
+    this.pollTimer = setInterval(() => this.poll(), POLL_MS);
+  }
+
+  stop(): void {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    try {
+      this.db?.close();
+    } catch {}
+    this.db = null;
+    this.ctx = null;
+  }
+
+  private openDb(): boolean {
+    if (this.db) return true;
+    if (!existsSync(this.dbPath)) return false;
+    try {
+      // Dynamic import to avoid hard dependency on bun:sqlite at module level
+      const { Database } = require("bun:sqlite");
+      this.db = new Database(this.dbPath, { readonly: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private seeded = false;
+
+  private poll(): void {
+    if (!this.ctx || this.polling) return;
+    this.polling = true;
+
+    try {
+      if (!this.openDb()) return;
+
+      let sessions: SessionRow[];
+      const staleThreshold = Date.now() - STALE_MS;
+      try {
+        sessions = this.db
+          .query(
+            `SELECT id, title, directory, time_updated FROM session WHERE time_updated > ? ORDER BY time_updated DESC`,
+          )
+          .all(staleThreshold);
+      } catch {
+        try {
+          this.db.close();
+        } catch {}
+        this.db = null;
+        return;
+      }
+
+      // First poll: record timestamps, then emit current state for recent sessions.
+      if (!this.seeded) {
+        for (const row of sessions) {
+          this.sessionTimestamps.set(row.id, row.time_updated);
+        }
+        this.seeded = true;
+
+        // Emit seeded sessions by reading their current status (like amp watcher does)
+        for (const row of sessions) {
+          let lastMsg: MessageRow | null = null;
+          let lastParts: PartData[] = [];
+          try {
+            lastMsg = this.db
+              .query(
+                `SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created DESC LIMIT 1`,
+              )
+              .get(row.id);
+            if (lastMsg) {
+              const partRows: { data: string }[] = this.db
+                .query(`SELECT data FROM part WHERE message_id = ? ORDER BY time_created ASC`)
+                .all(lastMsg.id);
+              for (const pr of partRows) {
+                try {
+                  lastParts.push(JSON.parse(pr.data));
+                } catch {}
+              }
+            }
+          } catch {
+            continue;
+          }
+
+          let lastMsgData: MessageData | null = null;
+          if (lastMsg) {
+            try {
+              lastMsgData = JSON.parse(lastMsg.data);
+            } catch {}
+          }
+
+          const status = determineStatus(lastMsgData, lastParts);
+          if (status === "idle") continue;
+          this.sessionStatuses.set(row.id, status);
+
+          const session = this.ctx.resolveSession(row.directory);
+          if (!session) continue;
+
+          this.ctx.emit({
+            agent: "opencode",
+            session,
+            status,
+            ts: Date.now(),
+            threadId: row.id,
+            ...(row.title && { threadName: row.title }),
+          });
+        }
+        return;
+      }
+
+      for (const row of sessions) {
+        const prev = this.sessionTimestamps.get(row.id);
+        if (prev === row.time_updated) continue;
+        this.sessionTimestamps.set(row.id, row.time_updated);
+
+        // Only emit if we had a previous timestamp — a change means
+        // OpenCode is actively writing to this session right now.
+        if (prev === undefined) continue;
+
+        let lastMsg: MessageRow | null = null;
+        let lastParts: PartData[] = [];
+        try {
+          lastMsg = this.db
+            .query(
+              `SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created DESC LIMIT 1`,
+            )
+            .get(row.id);
+
+          if (lastMsg) {
+            const partRows: { data: string }[] = this.db
+              .query(`SELECT data FROM part WHERE message_id = ? ORDER BY time_created ASC`)
+              .all(lastMsg.id);
+            for (const pr of partRows) {
+              try {
+                lastParts.push(JSON.parse(pr.data));
+              } catch {}
+            }
+          }
+        } catch {
+          continue;
+        }
+
+        let lastMsgData: MessageData | null = null;
+        if (lastMsg) {
+          try {
+            lastMsgData = JSON.parse(lastMsg.data);
+          } catch {}
+        }
+
+        const status = determineStatus(lastMsgData, lastParts);
+        const prevStatus = this.sessionStatuses.get(row.id);
+        if (prevStatus === status) continue;
+        this.sessionStatuses.set(row.id, status);
+
+        const session = this.ctx.resolveSession(row.directory);
+        if (!session) continue;
+
+        this.ctx.emit({
+          agent: "opencode",
+          session,
+          status,
+          ts: Date.now(),
+          threadId: row.id,
+          ...(row.title && { threadName: row.title }),
+        });
+      }
+    } finally {
+      this.polling = false;
+    }
+  }
+}

package/plugins/tt-agentboard/packages/runtime/src/config.ts

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+import type { PartialTheme } from "./themes";
+
+export interface AgentboardConfig {
+  /** Explicit mux provider name (overrides auto-detect) */
+  mux?: string;
+  /** Custom server port */
+  port?: number;
+  /** Community plugin package names to load */
+  plugins: string[];
+  /** Theme: builtin name (e.g. "catppuccin-latte") or partial inline theme object */
+  theme?: string | PartialTheme;
+  /** Sidebar column width (default 26) */
+  sidebarWidth?: number;
+  /** Sidebar position relative to the terminal window (default "left") */
+  sidebarPosition?: "left" | "right";
+  /** Tmux prefix key for sidebar toggle (default "s") */
+  keybinding?: string;
+  /** Persisted detail panel heights keyed by mux session name */
+  detailPanelHeights?: Record<string, number>;
+}
+
+const DEFAULTS: AgentboardConfig = {
+  plugins: [],
+};
+
+/**
+ * Load config from ~/.config/towles-tool/agentboard/config.json
+ * @param homeDir — override home directory (for testing)
+ */
+export function loadConfig(homeDir?: string): AgentboardConfig {
+  const home = homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const configPath = join(home, ".config", "towles-tool", "agentboard", "config.json");
+
+  if (!existsSync(configPath)) {
+    return { ...DEFAULTS };
+  }
+
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw) as Partial<AgentboardConfig>;
+    return {
+      ...DEFAULTS,
+      ...parsed,
+      plugins: parsed.plugins ?? DEFAULTS.plugins,
+    };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+/**
+ * Save partial config updates to ~/.config/towles-tool/agentboard/config.json
+ * Merges with existing config on disk to preserve fields.
+ * @param updates — partial config fields to write
+ * @param homeDir — override home directory (for testing)
+ */
+export function saveConfig(updates: Partial<AgentboardConfig>, homeDir?: string): void {
+  const home = homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const configDir = join(home, ".config", "towles-tool", "agentboard");
+  const configPath = join(configDir, "config.json");
+
+  const existing = loadConfig(homeDir);
+  const merged = { ...existing, ...updates };
+
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n");
+}