@towles/tool 0.0.96 → 0.0.104

package/src/commands/agentboard.ts

@@ -1,22 +1,24 @@
-import { Args } from "@oclif/core";
-import { execSync } from "node:child_process";
+import { defineCommand } from "citty";
+import { execSync, spawn, spawnSync } from "node:child_process";
 import { readFileSync, writeFileSync, existsSync, realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import consola from "consola";
 import { colors } from "consola/utils";
-import { BaseCommand } from "./base.js";
+import { debugArg } from "./shared.js";
+
+const SERVER_HOST = "127.0.0.1";
+const SERVER_PORT = 4201;
 
 const PLUGIN_DIR = resolve(import.meta.dirname, "../../plugins/tt-agentboard");
 
 // Keybinding defaults
 const DEFAULT_KEY = "a";
 const TMUX_BINDINGS = { toggle: "t", focus: "s" } as const;
-const RUN_SHELL_LINE = `run-shell '${PLUGIN_DIR}/agentboard.tmux'`;
+const RUN_SHELL_LINE = "run-shell 'tt agentboard init'";
 const MARKER = "# agentboard";
 
 function findTmuxConf(): string | null {
   const candidates = [
-    resolve(process.env.HOME ?? "~", ".tmux.conf"),
     resolve(process.env.HOME ?? "~", ".config/tmux/tmux.conf"),
   ];
   for (const path of candidates) {
@@ -30,251 +32,421 @@ function findTmuxConf(): string | null {
   return null;
 }
 
-export default class Agentboard2 extends BaseCommand {
-  static override aliases = ["ag2"];
-  static override description = "AgentBoard2 — opensessions-style tmux TUI sidebar";
-
-  static override examples = [
-    {
-      description: "Install agentboard into tmux",
-      command: "<%= config.bin %> agentboard setup",
-    },
-    {
-      description: "Uninstall from tmux",
-      command: "<%= config.bin %> agentboard uninstall",
-    },
-    {
-      description: "Launch the server",
-      command: "<%= config.bin %> agentboard server",
-    },
-    {
-      description: "Launch the TUI directly",
-      command: "<%= config.bin %> agentboard tui",
-    },
-  ];
+function ensureDeps(): void {
+  try {
+    execSync("bun --version", { stdio: "pipe" });
+  } catch {
+    consola.error("bun is required but not found. Install: https://bun.sh");
+    process.exit(1);
+  }
 
-  static override args = {
-    subcommand: Args.string({
-      description: "Subcommand: setup, uninstall, server, tui, keys",
-      required: false,
-      options: ["setup", "uninstall", "server", "tui", "start", "keys"],
-    }),
-  };
+  const runtimeNodeModules = resolve(PLUGIN_DIR, "packages/runtime/node_modules");
+  if (!existsSync(runtimeNodeModules)) {
+    consola.info("Installing agentboard dependencies...");
+    execSync("bun install", { cwd: PLUGIN_DIR, stdio: "inherit" });
+  }
+}
 
-  async run(): Promise<void> {
-    const { args } = await this.parse(Agentboard2);
+function reloadTmux(): void {
+  try {
+    execSync(
+      "tmux source-file ~/.config/tmux/tmux.conf 2>/dev/null || tmux source-file ~/.tmux.conf 2>/dev/null",
+      {
+        stdio: "pipe",
+      },
+    );
+    consola.success("tmux config reloaded");
+  } catch {
+    consola.info("Reload tmux manually: tmux source-file ~/.config/tmux/tmux.conf");
+  }
+}
 
-    switch (args.subcommand) {
-      case "setup":
-        this.setup();
-        break;
-      case "uninstall":
-        this.uninstall();
-        break;
-      case "server":
-        this.startServer();
-        break;
-      case "tui":
-        this.startTui();
-        break;
-      case "start":
-        // For backwards compat, start = tui
-        this.startTui();
-        break;
-      case "keys":
-        this.showKeys();
-        break;
-      default:
-        this.showKeys();
-        break;
-    }
+function showKeys(): void {
+  let prefix = "C-a";
+  let key = DEFAULT_KEY;
+  try {
+    prefix = execSync("tmux show-option -gv prefix", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    const abKey = execSync(
+      `tmux show-option -gv @agentboard-key 2>/dev/null || echo ${DEFAULT_KEY}`,
+      {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    ).trim();
+    if (abKey) key = abKey;
+  } catch {
+    // use defaults
   }
 
-  private ensureDeps(): void {
-    // Check bun is installed
-    try {
-      execSync("bun --version", { stdio: "pipe" });
-    } catch {
-      this.error("bun is required but not found. Install: https://bun.sh");
-    }
+  const { toggle, focus } = TMUX_BINDINGS;
+  consola.box(
+    [
+      `${colors.bold("AgentBoard Keybindings")}\n`,
+      `${colors.cyan(`tmux (prefix = ${prefix}, C = Ctrl):`)}`,
+      `  ${prefix} ${key} ${toggle}     toggle sidebar`,
+      `  ${prefix} ${key} ${focus}     focus sidebar`,
+      `  ${prefix} ${key} 1-9   jump to session\n`,
+      `${colors.cyan("In sidebar:")}`,
+      `  Tab         cycle sessions`,
+      `  j / ↓       move down`,
+      `  k / ↑       move up`,
+      `  Enter / l   switch to selected session`,
+      `  1-9         jump to session`,
+      `  d           hide session`,
+      `  x           kill session`,
+      `  r           refresh`,
+      `  ?           help`,
+      `  q           quit`,
+    ].join("\n"),
+  );
+}
 
-    // Install deps if needed for runtime package
-    const runtimeNodeModules = resolve(PLUGIN_DIR, "packages/runtime/node_modules");
-    if (!existsSync(runtimeNodeModules)) {
-      consola.info("Installing agentboard dependencies...");
-      execSync("pnpm install", { cwd: PLUGIN_DIR, stdio: "inherit" });
-    }
+function setup(): void {
+  ensureDeps();
+
+  const confPath = findTmuxConf();
+  if (!confPath) {
+    consola.warn("No tmux.conf found. Add this line manually:");
+    consola.info(colors.cyan(`  ${RUN_SHELL_LINE}`));
+    return;
   }
 
-  private setup(): void {
-    this.ensureDeps();
+  let editPath = confPath;
+  try {
+    editPath = realpathSync(confPath);
+  } catch {
+    // keep confPath
+  }
 
-    // Find tmux.conf
-    const confPath = findTmuxConf();
-    if (!confPath) {
-      consola.warn("No tmux.conf found. Add this line manually:");
-      consola.info(colors.cyan(`  ${RUN_SHELL_LINE}`));
-      return;
-    }
+  const content = readFileSync(editPath, "utf8");
+  if (content.includes(MARKER)) {
+    consola.success("Already installed in tmux.conf");
+    reloadTmux();
+    return;
+  }
 
-    // If it's a symlink, resolve to the real file for editing
-    let editPath = confPath;
-    try {
-      editPath = realpathSync(confPath);
-    } catch {
-      // keep confPath
-    }
+  const tpmLine = "run '~/.config/tmux/plugins/tpm/tpm'";
+  const altTpmLine = "run-shell '~/.tmux/plugins/tpm/tpm'";
+  const insertLines = `\n${MARKER}\n${RUN_SHELL_LINE}\n`;
+
+  let newContent: string;
+  if (content.includes(tpmLine)) {
+    newContent = content.replace(tpmLine, `${insertLines}\n${tpmLine}`);
+  } else if (content.includes(altTpmLine)) {
+    newContent = content.replace(altTpmLine, `${insertLines}\n${altTpmLine}`);
+  } else {
+    newContent = content + insertLines;
+  }
 
-    // Check if already installed
-    const content = readFileSync(editPath, "utf8");
-    if (content.includes("agentboard.tmux")) {
-      consola.success("Already installed in tmux.conf");
-      this.reloadTmux();
-      return;
-    }
+  writeFileSync(editPath, newContent);
+  consola.success(`Added agentboard to ${editPath}`);
 
-    // Add run-shell line before TPM init
-    const tpmLine = "run '~/.config/tmux/plugins/tpm/tpm'";
-    const altTpmLine = "run-shell '~/.tmux/plugins/tpm/tpm'";
-    const insertLines = `\n${MARKER}\n${RUN_SHELL_LINE}\n`;
+  reloadTmux();
+  showKeys();
+}
 
-    let newContent: string;
-    if (content.includes(tpmLine)) {
-      newContent = content.replace(tpmLine, `${insertLines}\n${tpmLine}`);
-    } else if (content.includes(altTpmLine)) {
-      newContent = content.replace(altTpmLine, `${insertLines}\n${altTpmLine}`);
-    } else {
-      // No TPM found, append to end
-      newContent = content + insertLines;
-    }
+function uninstall(): void {
+  const confPath = findTmuxConf();
+  if (!confPath) {
+    consola.info("No tmux.conf found.");
+    return;
+  }
 
-    writeFileSync(editPath, newContent);
-    consola.success(`Added agentboard to ${editPath}`);
+  let editPath = confPath;
+  try {
+    editPath = realpathSync(confPath);
+  } catch {
+    // keep confPath
+  }
 
-    this.reloadTmux();
-    this.showKeys();
+  const content = readFileSync(editPath, "utf8");
+  if (!content.includes("agentboard")) {
+    consola.info("agentboard not found in tmux.conf");
+    return;
   }
 
-  private uninstall(): void {
-    const confPath = findTmuxConf();
-    if (!confPath) {
-      consola.info("No tmux.conf found.");
-      return;
-    }
+  const newContent = content
+    .split("\n")
+    .filter((line) => !line.includes("agentboard"))
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n");
 
-    let editPath = confPath;
-    try {
-      editPath = realpathSync(confPath);
-    } catch {
-      // keep confPath
-    }
+  writeFileSync(editPath, newContent);
+  consola.success("Removed agentboard from tmux.conf");
+  reloadTmux();
+}
 
-    const content = readFileSync(editPath, "utf8");
-    if (!content.includes("agentboard")) {
-      consola.info("agentboard not found in tmux.conf");
-      return;
-    }
+function startServer(): void {
+  ensureDeps();
 
-    // Remove the marker line and run-shell line
-    const newContent = content
-      .split("\n")
-      .filter((line) => !line.includes("agentboard"))
-      .join("\n")
-      .replace(/\n{3,}/g, "\n\n");
+  const serverEntry = resolve(PLUGIN_DIR, "apps/server/src/main.ts");
+  consola.info("Starting agentboard server (foreground, Ctrl+C to stop)...");
 
-    writeFileSync(editPath, newContent);
-    consola.success("Removed agentboard from tmux.conf");
-    this.reloadTmux();
-  }
+  execSync(`bun run ${serverEntry}`, {
+    stdio: "inherit",
+    cwd: PLUGIN_DIR,
+    env: {
+      ...process.env,
+      AGENTBOARD_DIR: PLUGIN_DIR,
+    },
+  });
+}
 
-  // Foreground command — blocks until server exits (Ctrl+C to stop)
-  private startServer(): void {
-    this.ensureDeps();
+async function serverAlive(): Promise<boolean> {
+  try {
+    const res = await fetch(`http://${SERVER_HOST}:${SERVER_PORT}/`, {
+      signal: AbortSignal.timeout(500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
 
-    const serverEntry = resolve(PLUGIN_DIR, "apps/server/src/main.ts");
-    consola.info("Starting agentboard server (foreground, Ctrl+C to stop)...");
+async function ensureServerUp(): Promise<boolean> {
+  if (await serverAlive()) return true;
+
+  const serverEntry = resolve(PLUGIN_DIR, "apps/server/src/main.ts");
+  consola.info("Starting agentboard server...");
+  const child = spawn("bun", ["run", serverEntry], {
+    stdio: "ignore",
+    cwd: PLUGIN_DIR,
+    detached: true,
+    env: { ...process.env, AGENTBOARD_DIR: PLUGIN_DIR },
+  });
+  child.unref();
+
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 100));
+    if (await serverAlive()) return true;
+  }
+  return false;
+}
 
-    execSync(`bun run ${serverEntry}`, {
-      stdio: "inherit",
-      cwd: PLUGIN_DIR,
-      env: {
-        ...process.env,
-        AGENTBOARD2_DIR: PLUGIN_DIR,
-      },
+function tmuxDisplay(fmt: string): string {
+  try {
+    const r = spawnSync("tmux", ["display-message", "-p", fmt], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
     });
+    return (r.stdout ?? "").trim();
+  } catch {
+    return "";
   }
+}
 
-  // Foreground command — blocks until TUI exits
-  private startTui(): void {
-    this.ensureDeps();
+function tmuxContext(): string {
+  return tmuxDisplay("#{client_tty}|#{session_name}|#{window_id}");
+}
 
-    const tuiEntry = resolve(PLUGIN_DIR, "apps/tui/src/index.tsx");
+function resetTmuxKeys(): void {
+  spawnSync("tmux", ["switch-client", "-T", "root"], { stdio: "pipe" });
+}
 
-    execSync(`bun run ${tuiEntry}`, {
-      stdio: "inherit",
-      cwd: resolve(PLUGIN_DIR, "apps/tui"),
-      env: {
-        ...process.env,
-        AGENTBOARD2_DIR: PLUGIN_DIR,
-      },
+function findSidebarPane(windowId: string): string | null {
+  try {
+    const r = spawnSync("tmux", ["list-panes", "-t", windowId, "-F", "#{pane_id} #{pane_title}"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
     });
+    for (const line of (r.stdout ?? "").trim().split("\n")) {
+      const [paneId, title] = line.split(" ", 2);
+      if (title === "agentboard-sidebar" && paneId) return paneId;
+    }
+  } catch {}
+  return null;
+}
+
+function tmux(...args: string[]): void {
+  spawnSync("tmux", args, { stdio: "pipe" });
+}
+
+function init(): void {
+  const port = process.env.TT_AGENTBOARD_PORT ?? "4201";
+  const host = process.env.TT_AGENTBOARD_HOST ?? "127.0.0.1";
+
+  // Read tmux options with defaults
+  const keyResult = spawnSync("tmux", ["show-option", "-gqv", "@agentboard-key"], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  const key = (keyResult.stdout ?? "").trim() || DEFAULT_KEY;
+
+  // Export to tmux environment
+  tmux("set-environment", "-g", "TT_AGENTBOARD_PORT", port);
+  tmux("set-environment", "-g", "TT_AGENTBOARD_HOST", host);
+
+  // Bind keybindings via command table "agentboard"
+  tmux("bind-key", "-T", "prefix", key, "switch-client", "-T", "agentboard");
+  tmux("bind-key", "-T", "agentboard", TMUX_BINDINGS.toggle, "run-shell", "tt agentboard run --toggle");
+  tmux("bind-key", "-T", "agentboard", TMUX_BINDINGS.focus, "run-shell", "tt agentboard run --focus");
+
+  // Number keys 1-9 switch to session by index
+  for (let i = 1; i <= 9; i++) {
+    tmux(
+      "bind-key", "-T", "agentboard", String(i), "run-shell",
+      `curl -s -X POST 'http://${host}:${port}/switch-index?index=${i}' -d "$(tmux display-message -p '#{q:client_tty}|#{q:session_name}|#{q:window_id}')" >/dev/null 2>&1 || true`,
+    );
   }
 
-  private showKeys(): void {
-    // Get tmux prefix and agentboard key from tmux
-    let prefix = "C-a";
-    let key = DEFAULT_KEY;
-    try {
-      prefix = execSync("tmux show-option -gv prefix", {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-      }).trim();
-      const ab2Key = execSync(
-        `tmux show-option -gv @agentboard-key 2>/dev/null || echo ${DEFAULT_KEY}`,
-        {
-          encoding: "utf8",
-          stdio: ["pipe", "pipe", "pipe"],
-        },
-      ).trim();
-      if (ab2Key) key = ab2Key;
-    } catch {
-      // use defaults
+  // Hooks (fallback for when server isn't running yet)
+  const hookPost = (path: string, body?: string) => {
+    const bodyArg = body ? ` -d \\"${body}\\"` : "";
+    return `run-shell -b "curl -s -X POST http://${host}:${port}${path}${bodyArg} >/dev/null 2>&1 || true"`;
+  };
+  const focusBody = "#{q:client_tty}|#{q:session_name}|#{q:window_id}";
+  const resizeBody = "#{q:pane_id}|#{q:session_name}|#{q:window_id}|#{q:pane_width}|#{q:window_width}";
+
+  tmux("set-hook", "-g", "client-session-changed", hookPost("/focus", focusBody));
+  tmux("set-hook", "-g", "after-select-window", hookPost("/ensure-sidebar", focusBody));
+  tmux("set-hook", "-g", "after-resize-pane", hookPost("/resize-sidebars", resizeBody));
+}
+
+async function runToggle(): Promise<void> {
+  if (!(await ensureServerUp())) process.exit(0);
+  const ctx = tmuxContext();
+  await fetch(`http://${SERVER_HOST}:${SERVER_PORT}/toggle`, { method: "POST", body: ctx }).catch(() => {});
+  resetTmuxKeys();
+}
+
+async function runFocus(): Promise<void> {
+  const windowId = tmuxDisplay("#{window_id}");
+  if (!windowId) process.exit(0);
+
+  // If sidebar already exists, just focus it
+  const existing = findSidebarPane(windowId);
+  if (existing) {
+    spawnSync("tmux", ["select-pane", "-t", existing], { stdio: "pipe" });
+    resetTmuxKeys();
+    return;
+  }
+
+  // Otherwise, ensure server + toggle sidebar on
+  if (!(await ensureServerUp())) process.exit(0);
+  const ctx = tmuxContext();
+  await fetch(`http://${SERVER_HOST}:${SERVER_PORT}/toggle`, { method: "POST", body: ctx }).catch(() => {});
+
+  // Wait for sidebar pane to appear
+  for (let i = 0; i < 20; i++) {
+    const paneId = findSidebarPane(windowId);
+    if (paneId) {
+      spawnSync("tmux", ["select-pane", "-t", paneId], { stdio: "pipe" });
+      resetTmuxKeys();
+      return;
     }
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  resetTmuxKeys();
+}
 
-    const { toggle, focus } = TMUX_BINDINGS;
-    consola.box(
-      [
-        `${colors.bold("AgentBoard2 Keybindings")}\n`,
-        `${colors.cyan(`tmux (prefix = ${prefix}, C = Ctrl):`)}`,
-        `  ${prefix} ${key} ${toggle}     toggle sidebar`,
-        `  ${prefix} ${key} ${focus}     focus sidebar`,
-        `  ${prefix} ${key} 1-9   jump to session\n`,
-        `${colors.cyan("In sidebar:")}`,
-        `  Tab         cycle sessions`,
-        `  j / ↓       move down`,
-        `  k / ↑       move up`,
-        `  Enter / l   switch to selected session`,
-        `  1-9         jump to session`,
-        `  d           hide session`,
-        `  x           kill session`,
-        `  t           theme picker`,
-        `  r           refresh`,
-        `  q           quit`,
-      ].join("\n"),
-    );
+async function restart(): Promise<void> {
+  ensureDeps();
+
+  // 1. Kill stash sessions left over from hidden sidebars
+  try {
+    const result = spawnSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const sessions = (result.stdout ?? "").trim().split("\n").filter(Boolean);
+    for (const name of sessions) {
+      if (name.startsWith("_ab_stash")) {
+        spawnSync("tmux", ["kill-session", "-t", name], { stdio: "pipe" });
+        consola.info(`Killed stash session: ${name}`);
+      }
+    }
+  } catch {
+    // no tmux or no sessions
   }
 
-  private reloadTmux(): void {
-    try {
-      execSync(
-        "tmux source-file ~/.config/tmux/tmux.conf 2>/dev/null || tmux source-file ~/.tmux.conf 2>/dev/null",
-        {
-          stdio: "pipe",
-        },
-      );
-      consola.success("tmux config reloaded");
-    } catch {
-      consola.info("Reload tmux manually: tmux source-file ~/.config/tmux/tmux.conf");
+  // 2. Ensure server is running
+  if (!(await ensureServerUp())) {
+    consola.error("Failed to start agentboard server");
+    process.exit(1);
+  }
+  consola.success("Server is running");
+
+  // 3. Toggle sidebar on (the server spawns sidebars in all active windows)
+  try {
+    const res = await fetch(`http://${SERVER_HOST}:${SERVER_PORT}/toggle`, {
+      method: "POST",
+      body: "",
+      signal: AbortSignal.timeout(2000),
+    });
+    if (res.ok) {
+      consola.success("Sidebar toggled on for all sessions");
+    } else {
+      consola.warn(`Toggle returned: ${res.status}`);
     }
+  } catch (err) {
+    consola.error("Failed to toggle sidebar:", err);
   }
 }
+
+function startTui(): void {
+  ensureDeps();
+
+  const tuiEntry = resolve(PLUGIN_DIR, "apps/tui/src/index.tsx");
+
+  execSync(`bun run ${tuiEntry}`, {
+    stdio: "inherit",
+    cwd: resolve(PLUGIN_DIR, "apps/tui"),
+    env: {
+      ...process.env,
+      AGENTBOARD_DIR: PLUGIN_DIR,
+    },
+  });
+}
+
+export default defineCommand({
+  meta: { name: "agentboard", description: "AgentBoard — tmux TUI sidebar" },
+  args: {
+    debug: debugArg,
+    subcommand: {
+      type: "positional",
+      required: false,
+      description: "Subcommand: setup, uninstall, server, tui, start, restart, run, keys",
+    },
+    toggle: { type: "boolean", description: "Toggle sidebar (used with 'run')" },
+    focus: { type: "boolean", description: "Focus sidebar (used with 'run')" },
+  },
+  async run({ args }) {
+    switch (args.subcommand) {
+      case "setup":
+        setup();
+        break;
+      case "uninstall":
+        uninstall();
+        break;
+      case "server":
+        startServer();
+        break;
+      case "tui":
+        startTui();
+        break;
+      case "start":
+        startTui();
+        break;
+      case "restart":
+        await restart();
+        break;
+      case "init":
+        init();
+        break;
+      case "run":
+        if (args.toggle) await runToggle();
+        else if (args.focus) await runFocus();
+        else consola.error("Usage: tt agentboard run --toggle | --focus");
+        break;
+      case "keys":
+        showKeys();
+        break;
+      default:
+        showKeys();
+        break;
+    }
+  },
+});