@towles/tool 0.0.94 → 0.0.96

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towles/tool",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "homepage": "https://github.com/ChrisTowles/towles-tool#readme",
   "bugs": {

package/src/commands/agentboard.ts

@@ -1,333 +1,280 @@
-import { Args, Flags } from "@oclif/core";
-import { execSync, spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { resolve, join } from "node:path";
-import { networkInterfaces } from "node:os";
+import { Args } from "@oclif/core";
+import { execSync } 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 prompts from "prompts";
 import { BaseCommand } from "./base.js";
 
-function getLocalIp(): string {
-  const nets = networkInterfaces();
-  for (const ifaces of Object.values(nets)) {
-    if (!ifaces) continue;
-    for (const iface of ifaces) {
-      if (iface.family === "IPv4" && !iface.internal) {
-        return iface.address;
-      }
+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 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) {
+    try {
+      const real = existsSync(path) ? path : null;
+      if (real) return real;
+    } catch {
+      continue;
     }
   }
-  return "localhost";
+  return null;
 }
 
-export default class Agentboard extends BaseCommand {
-  static override aliases = ["ag"];
-  static override description = "Start AgentBoard — agentic workflow orchestration IDE";
+export default class Agentboard2 extends BaseCommand {
+  static override aliases = ["ag2"];
+  static override description = "AgentBoard2 — opensessions-style tmux TUI sidebar";
 
   static override examples = [
     {
-      description: "Start AgentBoard on default port",
-      command: "<%= config.bin %> agentboard",
-    },
-    {
-      description: "Start on a custom port",
-      command: "<%= config.bin %> ag --port 3000",
+      description: "Install agentboard into tmux",
+      command: "<%= config.bin %> agentboard setup",
     },
     {
-      description: "Start without opening browser",
-      command: "<%= config.bin %> ag --no-open",
+      description: "Uninstall from tmux",
+      command: "<%= config.bin %> agentboard uninstall",
     },
     {
-      description: "Attach to a running card tmux session",
-      command: "<%= config.bin %> ag attach 42",
+      description: "Launch the server",
+      command: "<%= config.bin %> agentboard server",
     },
     {
-      description: "Selectively clear database (interactive)",
-      command: "<%= config.bin %> ag reset",
-    },
-    {
-      description: "Delete entire database without prompting",
-      command: "<%= config.bin %> ag reset --all",
+      description: "Launch the TUI directly",
+      command: "<%= config.bin %> agentboard tui",
     },
   ];
 
-  static override flags = {
-    port: Flags.string({
-      char: "p",
-      description: "Port to serve on",
-      default: "4200",
-    }),
-    open: Flags.boolean({
-      description: "Open browser after starting",
-      default: true,
-      allowNo: true,
-    }),
-    "data-dir": Flags.string({
-      char: "d",
-      description: "Directory for AgentBoard data (SQLite DB, artifacts)",
-      env: "AGENTBOARD_DATA_DIR",
-    }),
-    lan: Flags.boolean({
-      description: "Listen on all interfaces (0.0.0.0) for LAN access. Default: localhost only.",
-      default: false,
-    }),
-    all: Flags.boolean({
-      description: "Reset entire database without prompting (for tt ag reset --all)",
-      default: false,
-    }),
-  };
-
   static override args = {
     subcommand: Args.string({
-      description: "Subcommand (attach, reset)",
-      required: false,
-    }),
-    cardId: Args.string({
-      description: "Card ID for attach subcommand",
+      description: "Subcommand: setup, uninstall, server, tui, keys",
       required: false,
+      options: ["setup", "uninstall", "server", "tui", "start", "keys"],
     }),
   };
 
   async run(): Promise<void> {
-    const { args, flags } = await this.parse(Agentboard);
-
-    if (args.subcommand === "attach") {
-      if (!args.cardId) {
-        this.error("Card ID is required for attach subcommand");
-      }
-      execSync(`tmux attach-session -t card-${args.cardId}`, {
-        stdio: "inherit",
-      });
-      return;
+    const { args } = await this.parse(Agentboard2);
+
+    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;
     }
+  }
 
-    if (args.subcommand === "reset") {
-      const defaultDataDir = resolve(
-        process.env.XDG_CONFIG_HOME ?? resolve(process.env.HOME ?? "~", ".config"),
-        "towles-tool",
-        "agentboard",
-      );
-      const dataDir = flags["data-dir"] ? resolve(flags["data-dir"]) : defaultDataDir;
-      const dbPath = join(dataDir, "agentboard.db");
+  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");
+    }
 
-      if (!existsSync(dbPath)) {
-        consola.info("No database found — nothing to reset.");
-        return;
-      }
+    // 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" });
+    }
+  }
 
-      if (flags.all) {
-        await this.resetEntireDatabase(dbPath);
-        return;
-      }
+  private setup(): void {
+    this.ensureDeps();
 
-      await this.selectiveClear(dbPath);
+    // 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 agentboardDir = resolve(import.meta.dirname, "../../plugins/tt-agentboard");
-    const port = flags.port;
-    const defaultDataDir = resolve(
-      process.env.XDG_CONFIG_HOME ?? resolve(process.env.HOME ?? "~", ".config"),
-      "towles-tool",
-      "agentboard",
-    );
-    const dataDir = flags["data-dir"] ? resolve(flags["data-dir"]) : defaultDataDir;
-    const localIp = getLocalIp();
-    const dbPath = join(dataDir, "agentboard.db");
-    const isFirstRun = !existsSync(dbPath);
-
-    const lanMode = flags.lan;
-    const host = lanMode ? "0.0.0.0" : "127.0.0.1";
-
-    const lines = [`AgentBoard\n\n  Local:   http://localhost:${port}`];
-    if (lanMode) {
-      lines.push(`  Network: http://${localIp}:${port}`);
-    } else {
-      lines.push(`  Network: disabled (use --lan to enable)`);
+    // If it's a symlink, resolve to the real file for editing
+    let editPath = confPath;
+    try {
+      editPath = realpathSync(confPath);
+    } catch {
+      // keep confPath
     }
-    lines.push(`  Data:    ${dataDir}`);
-    consola.box(lines.join("\n"));
-
-    if (isFirstRun) {
-      consola.info("First run detected — a new database will be created at startup.");
-      consola.info(
-        "Setup checklist:\n" +
-          "  1. Ensure tmux is installed (sudo apt install tmux / brew install tmux)\n" +
-          "  2. Set GITHUB_TOKEN for GitHub features (optional)\n" +
-          "  3. Open the board → Workspaces → Add a workspace slot\n" +
-          "  4. Create your first card and drag it to In Progress",
-      );
+
+    // Check if already installed
+    const content = readFileSync(editPath, "utf8");
+    if (content.includes("agentboard.tmux")) {
+      consola.success("Already installed in tmux.conf");
+      this.reloadTmux();
+      return;
     }
 
-    const proc = spawn("pnpm", ["dev", "--port", port], {
-      cwd: agentboardDir,
-      stdio: "inherit",
-      env: {
-        ...process.env,
-        NUXT_DEV_HOST: host,
-        AGENTBOARD_DATA_DIR: dataDir,
-        AGENTBOARD_LAN: lanMode ? "1" : "0",
-      },
-    });
+    // 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`;
 
-    if (flags.open) {
-      setTimeout(() => {
-        try {
-          execSync(`xdg-open http://localhost:${port}`, { stdio: "ignore" });
-        } catch {
-          consola.debug("Could not open browser automatically");
-        }
-      }, 2000);
+    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;
     }
 
-    proc.on("exit", (code) => process.exit(code ?? 0));
-  }
+    writeFileSync(editPath, newContent);
+    consola.success(`Added agentboard to ${editPath}`);
 
-  private async resetEntireDatabase(dbPath: string): Promise<void> {
-    const walPath = `${dbPath}-wal`;
-    const shmPath = `${dbPath}-shm`;
-    consola.warn(`This will delete: ${dbPath}`);
-    const { unlinkSync } = await import("node:fs");
-    for (const f of [dbPath, walPath, shmPath]) {
-      if (existsSync(f)) {
-        unlinkSync(f);
-      }
-    }
-    consola.success("Database reset. Start AgentBoard to create a fresh DB.");
+    this.reloadTmux();
+    this.showKeys();
   }
 
-  private async selectiveClear(dbPath: string): Promise<void> {
-    const { createRequire } = await import("node:module");
-    const require = createRequire(import.meta.url);
-    const Database = require("better-sqlite3");
-    const sqlite = new Database(dbPath) as {
-      pragma(stmt: string): void;
-      prepare(sql: string): {
-        get(): unknown;
-        run(): { changes: number };
-      };
-      close(): void;
-    };
-    sqlite.pragma("foreign_keys = ON");
-
-    const counts = {
-      doneCards: sqlite.prepare("SELECT COUNT(*) as c FROM cards WHERE column = 'done'").get() as {
-        c: number;
-      },
-      failedCards: sqlite
-        .prepare("SELECT COUNT(*) as c FROM cards WHERE status = 'failed'")
-        .get() as { c: number },
-      allCards: sqlite.prepare("SELECT COUNT(*) as c FROM cards").get() as { c: number },
-      workflowRuns: sqlite.prepare("SELECT COUNT(*) as c FROM workflow_runs").get() as {
-        c: number;
-      },
-      cardEvents: sqlite.prepare("SELECT COUNT(*) as c FROM card_events").get() as { c: number },
-      agentLogs: sqlite.prepare("SELECT COUNT(*) as c FROM agent_logs").get() as { c: number },
-    };
-
-    const choices = [
-      {
-        title: `Completed cards ${colors.dim(`(${counts.doneCards.c} cards in "done" column + events/runs)`)}`,
-        value: "done_cards",
-        disabled: counts.doneCards.c === 0,
-      },
-      {
-        title: `Failed cards ${colors.dim(`(${counts.failedCards.c} cards with "failed" status + events/runs)`)}`,
-        value: "failed_cards",
-        disabled: counts.failedCards.c === 0,
-      },
-      {
-        title: `Execution history ${colors.dim(`(${counts.workflowRuns.c} workflow runs, step runs, ${counts.agentLogs.c} agent logs)`)}`,
-        value: "execution_history",
-        disabled: counts.workflowRuns.c === 0,
-      },
-      {
-        title: `Event logs ${colors.dim(`(${counts.cardEvents.c} card events)`)}`,
-        value: "event_logs",
-        disabled: counts.cardEvents.c === 0,
-      },
-      {
-        title: `All cards ${colors.dim(`(${counts.allCards.c} cards — keeps repos, boards, slots)`)}`,
-        value: "all_cards",
-        disabled: counts.allCards.c === 0,
-      },
-      {
-        title: colors.red(`Everything (delete entire database)`),
-        value: "everything",
-      },
-    ];
-
-    const result = await prompts(
-      {
-        name: "selected",
-        message: "What would you like to clear?",
-        type: "multiselect",
-        choices,
-        instructions: false,
-        hint: "- Space to select, Enter to confirm",
-      },
-      {
-        onCancel: () => {
-          consola.info(colors.dim("Canceled"));
-          process.exit(0);
-        },
-      },
-    );
-
-    const selected: string[] = result.selected;
-    if (!selected || selected.length === 0) {
-      consola.info("Nothing selected.");
-      sqlite.close();
+  private uninstall(): void {
+    const confPath = findTmuxConf();
+    if (!confPath) {
+      consola.info("No tmux.conf found.");
       return;
     }
 
-    if (selected.includes("everything")) {
-      sqlite.close();
-      await this.resetEntireDatabase(dbPath);
+    let editPath = confPath;
+    try {
+      editPath = realpathSync(confPath);
+    } catch {
+      // keep confPath
+    }
+
+    const content = readFileSync(editPath, "utf8");
+    if (!content.includes("agentboard")) {
+      consola.info("agentboard not found in tmux.conf");
       return;
     }
 
-    let totalDeleted = 0;
+    // 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");
 
-    if (selected.includes("done_cards")) {
-      // Cascade deletes handle events, dependencies, workflow_runs, step_runs, agent_logs
-      const deleted = sqlite.prepare("DELETE FROM cards WHERE column = 'done'").run();
-      consola.success(`Cleared ${deleted.changes} completed card(s)`);
-      totalDeleted += deleted.changes;
-    }
+    writeFileSync(editPath, newContent);
+    consola.success("Removed agentboard from tmux.conf");
+    this.reloadTmux();
+  }
 
-    if (selected.includes("failed_cards")) {
-      const deleted = sqlite.prepare("DELETE FROM cards WHERE status = 'failed'").run();
-      consola.success(`Cleared ${deleted.changes} failed card(s)`);
-      totalDeleted += deleted.changes;
-    }
+  // Foreground command — blocks until server exits (Ctrl+C to stop)
+  private startServer(): void {
+    this.ensureDeps();
 
-    if (selected.includes("execution_history")) {
-      // agent_logs and step_runs cascade from workflow_runs
-      const deleted = sqlite.prepare("DELETE FROM workflow_runs").run();
-      consola.success(`Cleared ${deleted.changes} workflow run(s) and associated logs`);
-      totalDeleted += deleted.changes;
-    }
+    const serverEntry = resolve(PLUGIN_DIR, "apps/server/src/main.ts");
+    consola.info("Starting agentboard server (foreground, Ctrl+C to stop)...");
 
-    if (selected.includes("event_logs")) {
-      const deleted = sqlite.prepare("DELETE FROM card_events").run();
-      consola.success(`Cleared ${deleted.changes} event log(s)`);
-      totalDeleted += deleted.changes;
-    }
+    execSync(`bun run ${serverEntry}`, {
+      stdio: "inherit",
+      cwd: PLUGIN_DIR,
+      env: {
+        ...process.env,
+        AGENTBOARD2_DIR: PLUGIN_DIR,
+      },
+    });
+  }
+
+  // Foreground command — blocks until TUI exits
+  private startTui(): void {
+    this.ensureDeps();
 
-    if (selected.includes("all_cards")) {
-      const deleted = sqlite.prepare("DELETE FROM cards").run();
-      consola.success(`Cleared ${deleted.changes} card(s)`);
-      totalDeleted += deleted.changes;
+    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,
+        AGENTBOARD2_DIR: PLUGIN_DIR,
+      },
+    });
+  }
+
+  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
     }
 
-    sqlite.close();
+    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"),
+    );
+  }
 
-    if (totalDeleted === 0) {
-      consola.info("Nothing to clear.");
-    } else {
-      consola.success("Done.");
+  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");
     }
   }
 }