bashbros 0.1.1 → 0.1.3

package/dist/cli.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+import {
+  DashboardWriter
+} from "./chunk-EYO44OMN.js";
+import {
+  DashboardDB
+} from "./chunk-JYWQT2B4.js";
 import {
   formatAllAgentsInfo,
   formatPermissionsTable
@@ -14,7 +20,7 @@ import {
   UndoStack,
   gateCommand,
   getBashgymIntegration
-} from "./chunk-VVSCAH2B.js";
+} from "./chunk-2RPTM6EQ.js";
 import "./chunk-SG752FZC.js";
 import "./chunk-DLP2O6PN.js";
 import {
@@ -22,9 +28,10 @@ import {
   getDefaultConfig,
   loadConfig
 } from "./chunk-A535VV7N.js";
+import "./chunk-QWZGB4V3.js";
 import {
   allowForSession
-} from "./chunk-GD5VNHIN.js";
+} from "./chunk-FRMAIRQ2.js";
 import {
   RiskScorer
 } from "./chunk-DEAF6PYM.js";
@@ -35,9 +42,6 @@ import {
 import {
   MoltbotHooks
 } from "./chunk-J37RHCFJ.js";
-import {
-  DashboardDB
-} from "./chunk-CSRPOGHY.js";
 import "./chunk-7OCVIDC7.js";
 
 // src/cli.ts
@@ -1014,7 +1018,7 @@ var EgressPatternMatcher = class {
 // src/policy/ward/egress.ts
 var DashboardDB2 = null;
 try {
-  const dbModule = await import("./db-EHQDB5OL.js");
+  const dbModule = await import("./db-SWJUUSFX.js");
   DashboardDB2 = dbModule.DashboardDB;
 } catch {
 }
@@ -1422,6 +1426,10 @@ ${passed} passed, ${failed} failed. Fix issues above.
 
 // src/watch.ts
 import chalk3 from "chalk";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { parse, stringify as stringify2 } from "yaml";
+var dashboardWriter = null;
+var riskScorer = null;
 function cleanup() {
   if (process.stdin.isTTY) {
     process.stdin.setRawMode(false);
@@ -1440,7 +1448,24 @@ async function startWatch(options) {
   console.log(chalk3.dim("  Press Ctrl+C to stop"));
   console.log();
   const bashbros = new BashBros(configPath);
-  bashbros.on("blocked", (command, violations) => {
+  const config = bashbros.getConfig();
+  try {
+    dashboardWriter = new DashboardWriter();
+    riskScorer = new RiskScorer();
+    const sessionId = dashboardWriter.startSession(config.agent, process.cwd());
+    if (options.verbose) {
+      console.log(chalk3.dim(`  Session: ${sessionId}`));
+    }
+  } catch (error) {
+    if (options.verbose) {
+      console.log(chalk3.yellow("  Dashboard recording disabled"));
+    }
+  }
+  let pendingCommand = null;
+  let awaitingPromptResponse = false;
+  function showBlockedPrompt(command, violations) {
+    pendingCommand = command;
+    awaitingPromptResponse = true;
     console.log();
     console.log(chalk3.red("\u{1F6E1}\uFE0F  BashBros blocked a command"));
     console.log();
@@ -1448,12 +1473,72 @@ async function startWatch(options) {
     console.log(chalk3.dim("  Reason:"), violations[0].message);
     console.log(chalk3.dim("  Policy:"), violations[0].rule);
     console.log();
-    console.log(chalk3.dim("  To allow this command:"));
-    console.log(chalk3.cyan(`    bashbros allow "${command}" --once`));
-    console.log(chalk3.cyan(`    bashbros allow "${command}" --persist`));
-    console.log();
+    console.log(chalk3.yellow("  Allow this command?"));
+    console.log(chalk3.cyan("    [y]"), "Allow once");
+    console.log(chalk3.cyan("    [s]"), "Allow for session");
+    console.log(chalk3.cyan("    [p]"), "Allow permanently");
+    console.log(chalk3.cyan("    [n]"), "Block (default)");
+    process.stdout.write(chalk3.dim("\n  Choice: "));
+  }
+  function handlePromptResponse(choice) {
+    if (!pendingCommand) return;
+    const command = pendingCommand;
+    pendingCommand = null;
+    awaitingPromptResponse = false;
+    console.log(choice);
+    switch (choice.toLowerCase()) {
+      case "y":
+        console.log(chalk3.green("  \u2713 Allowed once"));
+        console.log();
+        bashbros.write(command + "\r");
+        break;
+      case "s":
+        allowForSession(command);
+        console.log(chalk3.green("  \u2713 Allowed for session"));
+        console.log();
+        bashbros.write(command + "\r");
+        break;
+      case "p":
+        try {
+          const content = readFileSync2(configPath, "utf-8");
+          const config2 = parse(content);
+          if (!config2.commands) {
+            config2.commands = { allow: [], block: [] };
+          }
+          if (!config2.commands.allow) {
+            config2.commands.allow = [];
+          }
+          if (!config2.commands.allow.includes(command)) {
+            config2.commands.allow.push(command);
+            writeFileSync2(configPath, stringify2(config2));
+          }
+          console.log(chalk3.green("  \u2713 Added to allowlist permanently"));
+          console.log();
+          bashbros.write(command + "\r");
+        } catch (error) {
+          console.log(chalk3.red("  \u2717 Failed to update config"));
+          console.log();
+        }
+        break;
+      case "n":
+      default:
+        console.log(chalk3.yellow("  \u2717 Blocked"));
+        console.log();
+        break;
+    }
+  }
+  bashbros.on("blocked", (command, violations) => {
+    if (dashboardWriter && riskScorer) {
+      const risk = riskScorer.score(command);
+      dashboardWriter.recordCommand(command, false, risk, violations, 0);
+    }
+    showBlockedPrompt(command, violations);
   });
   bashbros.on("allowed", (result) => {
+    if (dashboardWriter && riskScorer) {
+      const risk = riskScorer.score(result.command);
+      dashboardWriter.recordCommand(result.command, true, risk, [], result.duration);
+    }
     if (options.verbose) {
       console.log(chalk3.green("\u2713"), chalk3.dim(result.command));
     }
@@ -1465,6 +1550,10 @@ async function startWatch(options) {
     console.error(chalk3.red("Error:"), error.message);
   });
   bashbros.on("exit", (exitCode) => {
+    if (dashboardWriter) {
+      dashboardWriter.endSession();
+      dashboardWriter.close();
+    }
     cleanup();
     process.exit(exitCode ?? 0);
   });
@@ -1472,14 +1561,32 @@ async function startWatch(options) {
     cleanup();
     console.log();
     console.log(chalk3.yellow("Stopping BashBros..."));
+    if (dashboardWriter) {
+      dashboardWriter.endSession();
+      dashboardWriter.close();
+    }
     bashbros.stop();
     process.exit(0);
   });
   process.on("SIGTERM", () => {
     cleanup();
+    if (dashboardWriter) {
+      dashboardWriter.endSession();
+      dashboardWriter.close();
+    }
     bashbros.stop();
     process.exit(0);
   });
+  process.on("uncaughtException", (error) => {
+    console.error(chalk3.red("Unexpected error:"), error.message);
+    if (dashboardWriter) {
+      dashboardWriter.crashSession();
+      dashboardWriter.close();
+    }
+    cleanup();
+    bashbros.stop();
+    process.exit(1);
+  });
   bashbros.start();
   let commandBuffer = "";
   if (process.stdout.isTTY) {
@@ -1498,11 +1605,31 @@ async function startWatch(options) {
     const str = data.toString();
     for (const char of str) {
       const code = char.charCodeAt(0);
+      if (awaitingPromptResponse) {
+        if (code === 3) {
+          pendingCommand = null;
+          awaitingPromptResponse = false;
+          console.log(chalk3.yellow("Cancelled"));
+          console.log();
+        } else if (char === "\r" || char === "\n") {
+          handlePromptResponse("n");
+        } else if (code >= 32) {
+          handlePromptResponse(char);
+        }
+        continue;
+      }
       if (char === "\r" || char === "\n") {
         const command = commandBuffer.trim();
         commandBuffer = "";
         if (command) {
-          bashbros.execute(command);
+          const violations = bashbros.validateOnly(command);
+          if (violations.length > 0) {
+            bashbros.write("");
+            bashbros.write("\r");
+            bashbros.emit("blocked", command, violations);
+          } else {
+            bashbros.write("\r");
+          }
         } else {
           bashbros.write("\r");
         }
@@ -1533,8 +1660,8 @@ async function startWatch(options) {
 
 // src/allow.ts
 import chalk4 from "chalk";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { parse, stringify as stringify2 } from "yaml";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { parse as parse2, stringify as stringify3 } from "yaml";
 async function handleAllow(command, options) {
   if (options.once) {
     allowForSession(command);
@@ -1549,8 +1676,8 @@ async function handleAllow(command, options) {
       process.exit(1);
     }
     try {
-      const content = readFileSync2(configPath, "utf-8");
-      const config = parse(content);
+      const content = readFileSync3(configPath, "utf-8");
+      const config = parse2(content);
       if (!config.commands) {
         config.commands = { allow: [], block: [] };
       }
@@ -1559,7 +1686,7 @@ async function handleAllow(command, options) {
       }
       if (!config.commands.allow.includes(command)) {
         config.commands.allow.push(command);
-        writeFileSync2(configPath, stringify2(config));
+        writeFileSync3(configPath, stringify3(config));
         console.log(chalk4.green("\u2713"), `Added to allowlist: ${command}`);
         console.log(chalk4.dim(`  Updated ${configPath}`));
       } else {
@@ -1586,6 +1713,16 @@ import { WebSocketServer } from "ws";
 import { createServer } from "http";
 import { fileURLToPath } from "url";
 import { dirname, join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { parse as parse3, stringify as stringify4 } from "yaml";
+function getDefaultDbPath() {
+  const bashbrosDir = join4(homedir4(), ".bashbros");
+  if (!existsSync5(bashbrosDir)) {
+    mkdirSync2(bashbrosDir, { recursive: true });
+  }
+  return join4(bashbrosDir, "dashboard.db");
+}
 var DashboardServer = class {
   app;
   server = null;
@@ -1597,7 +1734,7 @@ var DashboardServer = class {
   constructor(config = {}) {
     this.port = config.port ?? 17800;
     this.bind = config.bind ?? "127.0.0.1";
-    this.db = new DashboardDB(config.dbPath ?? ":memory:");
+    this.db = new DashboardDB(config.dbPath ?? getDefaultDbPath());
     this.app = express();
     this.setupMiddleware();
     this.setupRoutes();
@@ -1696,6 +1833,226 @@ var DashboardServer = class {
         res.status(500).json({ error: "Failed to deny block" });
       }
     });
+    this.app.get("/api/sessions", (req, res) => {
+      try {
+        const filter = {};
+        if (req.query.status) filter.status = req.query.status;
+        if (req.query.agent) filter.agent = req.query.agent;
+        if (req.query.limit) filter.limit = parseInt(req.query.limit, 10);
+        if (req.query.offset) filter.offset = parseInt(req.query.offset, 10);
+        if (req.query.since) filter.since = new Date(req.query.since);
+        if (req.query.until) filter.until = new Date(req.query.until);
+        const sessions = this.db.getSessions(filter);
+        res.json(sessions);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch sessions" });
+      }
+    });
+    this.app.get("/api/sessions/active", (_req, res) => {
+      try {
+        const session = this.db.getActiveSession();
+        if (!session) {
+          res.json(null);
+          return;
+        }
+        res.json(session);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch active session" });
+      }
+    });
+    this.app.get("/api/sessions/:id", (req, res) => {
+      try {
+        const session = this.db.getSession(req.params.id);
+        if (!session) {
+          res.status(404).json({ error: "Session not found" });
+          return;
+        }
+        res.json(session);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch session" });
+      }
+    });
+    this.app.get("/api/sessions/:id/commands", (req, res) => {
+      try {
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 100;
+        const commands = this.db.getCommandsBySession(req.params.id, limit);
+        res.json(commands);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch session commands" });
+      }
+    });
+    this.app.get("/api/sessions/:id/metrics", (req, res) => {
+      try {
+        const session = this.db.getSession(req.params.id);
+        if (!session) {
+          res.status(404).json({ error: "Session not found" });
+          return;
+        }
+        const metrics = this.db.getSessionMetrics(req.params.id);
+        res.json(metrics);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch session metrics" });
+      }
+    });
+    this.app.get("/api/commands/live", (req, res) => {
+      try {
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 20;
+        const commands = this.db.getLiveCommands(limit);
+        res.json(commands);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch live commands" });
+      }
+    });
+    this.app.get("/api/commands", (req, res) => {
+      try {
+        const filter = {};
+        if (req.query.sessionId) filter.sessionId = req.query.sessionId;
+        if (req.query.allowed !== void 0) filter.allowed = req.query.allowed === "true";
+        if (req.query.riskLevel) filter.riskLevel = req.query.riskLevel;
+        if (req.query.afterId) filter.afterId = req.query.afterId;
+        if (req.query.since) filter.since = new Date(req.query.since);
+        if (req.query.limit) filter.limit = parseInt(req.query.limit, 10);
+        if (req.query.offset) filter.offset = parseInt(req.query.offset, 10);
+        const commands = this.db.getCommands(filter);
+        res.json(commands);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch commands" });
+      }
+    });
+    this.app.get("/api/tools/live", (req, res) => {
+      try {
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 50;
+        const tools = this.db.getLiveToolUses(limit);
+        res.json(tools);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch live tool uses" });
+      }
+    });
+    this.app.get("/api/tools", (req, res) => {
+      try {
+        const filter = {};
+        if (req.query.toolName) filter.toolName = req.query.toolName;
+        if (req.query.since) filter.since = new Date(req.query.since);
+        if (req.query.limit) filter.limit = parseInt(req.query.limit, 10);
+        if (req.query.offset) filter.offset = parseInt(req.query.offset, 10);
+        const tools = this.db.getToolUses(filter);
+        res.json(tools);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch tool uses" });
+      }
+    });
+    this.app.get("/api/tools/stats", (_req, res) => {
+      try {
+        const stats = this.db.getToolUseStats();
+        res.json(stats);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch tool use stats" });
+      }
+    });
+    this.app.get("/api/bro/status", (_req, res) => {
+      try {
+        const status = this.db.getLatestBroStatus();
+        res.json(status);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch Bro status" });
+      }
+    });
+    this.app.get("/api/bro/events", (req, res) => {
+      try {
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 100;
+        const sessionId = req.query.sessionId;
+        const events = this.db.getBroEvents(limit, sessionId);
+        res.json(events);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch Bro events" });
+      }
+    });
+    this.app.get("/api/bro/models", async (_req, res) => {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5e3);
+        const response = await fetch("http://localhost:11434/api/tags", {
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (!response.ok) {
+          res.json({ available: false, models: [] });
+          return;
+        }
+        const data = await response.json();
+        const models = data.models?.map((m) => m.name) || [];
+        res.json({ available: true, models });
+      } catch (error) {
+        res.json({ available: false, models: [] });
+      }
+    });
+    this.app.post("/api/bro/model", (req, res) => {
+      try {
+        const { model } = req.body;
+        if (!model) {
+          res.status(400).json({ error: "Model name required" });
+          return;
+        }
+        const controlPath = join4(homedir4(), ".bashbros", "model-control.json");
+        writeFileSync4(controlPath, JSON.stringify({
+          model,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }), "utf-8");
+        res.json({ success: true, model });
+      } catch (error) {
+        res.status(500).json({ error: "Failed to change model" });
+      }
+    });
+    this.app.post("/api/bro/scan", (_req, res) => {
+      try {
+        const controlPath = join4(homedir4(), ".bashbros", "scan-control.json");
+        writeFileSync4(controlPath, JSON.stringify({
+          action: "scan",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }), "utf-8");
+        res.json({ success: true, message: "Scan requested" });
+      } catch (error) {
+        res.status(500).json({ error: "Failed to trigger scan" });
+      }
+    });
+    this.app.get("/api/exposures", (req, res) => {
+      try {
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 100;
+        const exposures = this.db.getRecentExposures(limit);
+        res.json(exposures);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch exposures" });
+      }
+    });
+    this.app.get("/api/config", (_req, res) => {
+      try {
+        const configPath = findConfig();
+        if (!configPath) {
+          res.status(404).json({ error: "No config file found" });
+          return;
+        }
+        const content = readFileSync4(configPath, "utf-8");
+        const config = parse3(content);
+        res.json(config);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load config" });
+      }
+    });
+    this.app.post("/api/config", (req, res) => {
+      try {
+        const configPath = findConfig();
+        if (!configPath) {
+          res.status(404).json({ error: "No config file found" });
+          return;
+        }
+        const config = req.body;
+        const content = stringify4(config);
+        writeFileSync4(configPath, content, "utf-8");
+        res.json({ success: true });
+      } catch (error) {
+        res.status(500).json({ error: "Failed to save config" });
+      }
+    });
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
     const staticPath = join4(__dirname, "static");
@@ -1962,8 +2319,8 @@ program.command("script <description>").description("Generate a shell script fro
   if (script) {
     console.log(chalk5.cyan(script));
     if (options.output) {
-      const { writeFileSync: writeFileSync3 } = await import("fs");
-      writeFileSync3(options.output, script, { mode: 493 });
+      const { writeFileSync: writeFileSync5 } = await import("fs");
+      writeFileSync5(options.output, script, { mode: 493 });
       console.log(chalk5.green(`
 \u2713 Saved to ${options.output}`));
     }
@@ -2079,11 +2436,30 @@ hookCmd.command("status").description("Check Claude Code hook status").action(()
   console.log();
   console.log(`  Claude Code: ${status.claudeInstalled ? chalk5.green("installed") : chalk5.yellow("not found")}`);
   console.log(`  BashBros hooks: ${status.hooksInstalled ? chalk5.green("active") : chalk5.dim("not installed")}`);
+  console.log(`  All-tools recording: ${status.allToolsInstalled ? chalk5.green("active") : chalk5.dim("not installed")}`);
   if (status.hooks.length > 0) {
     console.log(`  Active hooks: ${status.hooks.join(", ")}`);
   }
   console.log();
 });
+hookCmd.command("install-all-tools").description("Install hook to record ALL Claude Code tool uses (not just Bash)").action(() => {
+  const result = ClaudeCodeHooks.installAllTools();
+  if (result.success) {
+    console.log(chalk5.green("\u2713"), result.message);
+  } else {
+    console.log(chalk5.red("\u2717"), result.message);
+    process.exit(1);
+  }
+});
+hookCmd.command("uninstall-all-tools").description("Remove all-tools recording hook").action(() => {
+  const result = ClaudeCodeHooks.uninstallAllTools();
+  if (result.success) {
+    console.log(chalk5.green("\u2713"), result.message);
+  } else {
+    console.log(chalk5.red("\u2717"), result.message);
+    process.exit(1);
+  }
+});
 var moltbotCmd = program.command("moltbot").alias("clawdbot").description("Manage Moltbot/Clawdbot integration");
 moltbotCmd.command("install").description("Install BashBros hooks into Moltbot").action(() => {
   const result = MoltbotHooks.install();
@@ -2223,14 +2599,135 @@ program.command("permissions").description("Show combined permissions view acros
   console.log(formatPermissionsTable(agents));
   console.log();
 });
-program.command("gate <command>").description("Check if a command should be allowed (used by hooks)").action(async (command) => {
+program.command("gate <command>").description("Check if a command should be allowed (used by hooks)").option("-y, --yes", "Skip interactive prompt and block").action(async (command, options) => {
   const result = await gateCommand(command);
   if (!result.allowed) {
-    console.error(`BLOCKED: ${result.reason}`);
-    process.exit(2);
+    if (process.stdin.isTTY && !options.yes) {
+      const { allowForSession: allowForSession2 } = await import("./session-Y4MICATZ.js");
+      const { readFileSync: readFileSync5, writeFileSync: writeFileSync5 } = await import("fs");
+      const { parse: parse4, stringify: stringify5 } = await import("yaml");
+      const { findConfig: findConfig2 } = await import("./config-43SK6SFI.js");
+      console.error();
+      console.error(chalk5.red("\u{1F6E1}\uFE0F  BashBros blocked a command"));
+      console.error();
+      console.error(chalk5.dim("  Command:"), command);
+      console.error(chalk5.dim("  Reason:"), result.reason);
+      console.error();
+      console.error(chalk5.yellow("  Allow this command?"));
+      console.error(chalk5.cyan("    [y]"), "Allow once");
+      console.error(chalk5.cyan("    [s]"), "Allow for session");
+      console.error(chalk5.cyan("    [p]"), "Allow permanently");
+      console.error(chalk5.cyan("    [n]"), "Block (default)");
+      process.stderr.write(chalk5.dim("\n  Choice: "));
+      const choice = await new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.once("data", (data) => {
+          if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+          }
+          const char = data.toString().toLowerCase();
+          console.error(char);
+          resolve(char);
+        });
+      });
+      switch (choice) {
+        case "y":
+          console.error(chalk5.green("  \u2713 Allowed once"));
+          process.exit(0);
+          break;
+        case "s":
+          allowForSession2(command);
+          console.error(chalk5.green("  \u2713 Allowed for session"));
+          process.exit(0);
+          break;
+        case "p":
+          try {
+            const configPath = findConfig2();
+            if (configPath) {
+              const content = readFileSync5(configPath, "utf-8");
+              const config = parse4(content);
+              if (!config.commands) config.commands = { allow: [], block: [] };
+              if (!config.commands.allow) config.commands.allow = [];
+              if (!config.commands.allow.includes(command)) {
+                config.commands.allow.push(command);
+                writeFileSync5(configPath, stringify5(config));
+              }
+              console.error(chalk5.green("  \u2713 Added to allowlist permanently"));
+              process.exit(0);
+            }
+          } catch {
+            console.error(chalk5.red("  \u2717 Failed to update config"));
+          }
+          process.exit(2);
+          break;
+        default:
+          console.error(chalk5.yellow("  \u2717 Blocked"));
+          process.exit(2);
+      }
+    } else {
+      console.error(`Blocked: ${result.reason}`);
+      process.exit(2);
+    }
   }
   process.exit(0);
 });
+program.command("record-tool").description("Record a Claude Code tool execution (used by hooks)").option("--marker <marker>", "Hook marker (ignored, used for identification)").action(async () => {
+  const eventJson = process.env.CLAUDE_HOOK_EVENT || "";
+  if (!eventJson) {
+    return;
+  }
+  try {
+    const event = JSON.parse(eventJson);
+    const events = Array.isArray(event) ? event : [event];
+    const { DashboardWriter: DashboardWriter2 } = await import("./writer-4ZEAKUFD.js");
+    const writer = new DashboardWriter2();
+    for (const evt of events) {
+      const toolName = evt.tool_name || evt.tool || "unknown";
+      const toolInput = evt.tool_input || evt.input || {};
+      const toolOutput = evt.tool_output || evt.output || "";
+      let inputStr;
+      if (typeof toolInput === "string") {
+        inputStr = toolInput;
+      } else if (typeof toolInput === "object") {
+        inputStr = JSON.stringify(toolInput, null, 2);
+      } else {
+        inputStr = String(toolInput);
+      }
+      let outputStr;
+      let exitCode = null;
+      let success = null;
+      if (typeof toolOutput === "object" && toolOutput !== null) {
+        outputStr = (toolOutput.stdout || "") + (toolOutput.stderr || "");
+        exitCode = toolOutput.exit_code ?? toolOutput.exitCode ?? null;
+        if (exitCode !== null) {
+          success = exitCode === 0;
+        }
+      } else {
+        outputStr = String(toolOutput || "");
+      }
+      const repoName = evt.repo?.name ?? null;
+      const repoPath = evt.repo?.path ?? null;
+      writer.recordToolUse({
+        toolName,
+        toolInput: inputStr,
+        toolOutput: outputStr,
+        exitCode,
+        success,
+        cwd: evt.cwd || process.cwd(),
+        repoName,
+        repoPath
+      });
+      const preview = inputStr.substring(0, 40).replace(/\n/g, " ");
+      console.log(`[BashBros] ${toolName}: ${preview}${inputStr.length > 40 ? "..." : ""}`);
+    }
+    writer.close();
+  } catch (e) {
+    console.error(`[BashBros] Error recording tool: ${e instanceof Error ? e.message : e}`);
+  }
+});
 program.command("record <command>").description("Record a command execution (used by hooks)").option("-o, --output <output>", "Command output").option("-e, --exit-code <code>", "Exit code", "0").action(async (command, options) => {
   if (!metricsCollector) metricsCollector = new MetricsCollector();
   if (!costEstimator) costEstimator = new CostEstimator();