aisnitch 0.2.24 → 0.2.26

package/README.md

@@ -82,10 +82,16 @@ brew install aisnitch
 ### 2. Run
 
 ```bash
-aisnitch start
+aisnitch
 ```
 
-That's it! The dashboard opens with live events from all configured tools.
+That's it! `aisnitch` (no argument) starts the daemon, launches the dashboard server in the background, and opens the web dashboard in your browser.
+
+Want the in-terminal TUI instead?
+
+```bash
+aisnitch start
+```
 
 **No AI tools yet?** Try the demo mode:
 
@@ -222,8 +228,8 @@ brew upgrade aisnitch
 Open a beautiful real-time dashboard in your browser:
 
 ```bash
-aisnitch fs                    # Open dashboard (auto-starts daemon if needed)
-aisnitch fs --daemon           # Start daemon + open dashboard
+aisnitch                       # Default: start daemon + dashboard + open browser
+aisnitch fs                    # Same as `aisnitch`
 aisnitch fs --dashboard-port 8080  # Custom port
 aisnitch fs --no-browser       # Just start the server
 ```
@@ -336,12 +342,12 @@ aisnitch start --type agent.coding # Filter by event type
 aisnitch start --view full-data    # Show full JSON
 ```
 
-### Web Dashboard
+### Web Dashboard (Default)
 
 ```bash
-aisnitch fs                        # Open web dashboard
-aisnitch fs --daemon               # Start daemon + open
-aisnitch fs --dashboard-port 8080 # Custom port
+aisnitch                           # Default: daemon + dashboard + browser
+aisnitch fs                        # Explicit form (same effect)
+aisnitch fs --dashboard-port 8080  # Custom port
 aisnitch fs --no-browser           # Server only
 ```
 

package/dist/cli/index.cjs

@@ -771,7 +771,7 @@ var import_commander = require("commander");
 
 // src/package-info.ts
 var AISNITCH_PACKAGE_NAME = "aisnitch";
-var AISNITCH_VERSION = "0.2.24";
+var AISNITCH_VERSION = "0.2.26";
 var AISNITCH_DESCRIPTION = "Universal bridge for AI coding tool activity \u2014 capture, normalize, stream.";
 
 // src/core/events/schema.ts
@@ -1360,6 +1360,7 @@ var AutoUpdateConfigSchema = import_zod2.z.strictObject({
 var ConfigSchema = import_zod2.z.strictObject({
   wsPort: import_zod2.z.number().int().min(1024).max(65535).default(4820),
   httpPort: import_zod2.z.number().int().min(1024).max(65535).default(4821),
+  dashboardPort: import_zod2.z.number().int().min(1024).max(65535).default(5174),
   /**
    * 📖 This is intentionally a partial record because most users will only
    * override a couple of adapters instead of all supported tools at once.
@@ -1378,6 +1379,7 @@ var ConfigSchema = import_zod2.z.strictObject({
 var DEFAULT_CONFIG = {
   wsPort: 4820,
   httpPort: 4821,
+  dashboardPort: 5174,
   adapters: {},
   autoUpdate: {
     enabled: true,
@@ -14168,6 +14170,10 @@ function Header({
                 ] }) }),
                 daemon ? /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_jsx_runtime6.Fragment, { children: [
                   /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ink6.Text, { color: connected ? TUI_THEME.success : TUI_THEME.warning, children: connected ? `\u25CF ${connectionLabel}` : `\u25CB ${connectionLabel}` }),
+                  /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_ink6.Text, { color: TUI_THEME.success, children: [
+                    "Web ",
+                    daemon.dashboardUrl
+                  ] }),
                   /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_ink6.Text, { color: TUI_THEME.muted, children: [
                     "WS ",
                     daemon.wsUrl
@@ -14360,7 +14366,7 @@ function StatusBar({
 }) {
   const streamState = streamFrozen ? `Frozen +${pendingEventCount}` : latestEvent?.type ?? "Live";
   const focusLabel = focusPanel === "events" ? "events" : viewMode === "full-data" ? "inspector" : "sessions";
-  const daemonLabel = daemon === void 0 ? null : daemon.busyAction ? `Daemon ${daemon.busyAction}` : daemon.active ? `Daemon active \xB7 ${daemon.wsUrl}` : `Daemon not active \xB7 ${daemon.wsUrl}`;
+  const daemonLabel = daemon === void 0 ? null : daemon.busyAction ? `Daemon ${daemon.busyAction}` : daemon.active ? `Daemon active \xB7 Web ${daemon.dashboardUrl}` : `Daemon not active \xB7 Web ${daemon.dashboardUrl}`;
   return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(
     import_ink10.Box,
     {
@@ -15945,6 +15951,7 @@ var DAEMON_READY_TIMEOUT_MS = 4e3;
 var DAEMON_READY_POLL_INTERVAL_MS = 100;
 var DAEMON_STOP_TIMEOUT_MS = 4e3;
 var DAEMON_LOG_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_DASHBOARD_PORT = 5174;
 var LAUNCH_AGENT_LABEL = "com.aisnitch.daemon";
 async function resolveNodeExecutable() {
   try {
@@ -15960,6 +15967,40 @@ function formatSpawnError(error) {
   }
   return String(error);
 }
+async function pathExists(path2) {
+  try {
+    await (0, import_promises22.access)(path2, import_node_fs7.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveDashboardDistPath() {
+  if (process.env.AISNITCH_DASHBOARD_DIST) {
+    const overridePath = process.env.AISNITCH_DASHBOARD_DIST;
+    if (await pathExists((0, import_node_path22.join)(overridePath, "index.html"))) {
+      return overridePath;
+    }
+    throw new Error(
+      `Fullscreen dashboard assets are missing at ${overridePath}. Reinstall AISnitch or run \`pnpm --filter aisnitch-fullscreen-dashboard build\` from the repository checkout.`
+    );
+  }
+  const cliEntryPath = process.argv[1] ? await (0, import_promises22.realpath)(process.argv[1]).catch(() => process.argv[1] ?? "") : "";
+  const moduleDirectory = (0, import_node_path22.dirname)(cliEntryPath);
+  const packageRoot = (0, import_node_path22.dirname)((0, import_node_path22.dirname)(moduleDirectory));
+  const candidates = [
+    (0, import_node_path22.join)(packageRoot, "examples", "fullscreen-dashboard", "dist"),
+    (0, import_node_path22.join)(process.cwd(), "examples", "fullscreen-dashboard", "dist")
+  ];
+  for (const candidate of candidates) {
+    if (await pathExists((0, import_node_path22.join)(candidate, "index.html"))) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    "Fullscreen dashboard assets are missing. Reinstall AISnitch or run `pnpm --filter aisnitch-fullscreen-dashboard build` from the repository checkout."
+  );
+}
 function createCliRuntime(dependencies = {}) {
   const output = dependencies.output ?? createProcessOutput();
   const fetchImplementation = dependencies.fetch ?? globalThis.fetch;
@@ -15985,6 +16026,7 @@ function createCliRuntime(dependencies = {}) {
     const config = ConfigSchema.parse({
       ...baseConfig,
       ...isStartCliOptions(options) ? {
+        dashboardPort: options.dashboardPort ?? baseConfig.dashboardPort,
         httpPort: options.httpPort ?? baseConfig.httpPort,
         logLevel: options.logLevel ?? baseConfig.logLevel,
         wsPort: options.wsPort ?? baseConfig.wsPort
@@ -16008,6 +16050,149 @@ function createCliRuntime(dependencies = {}) {
       return null;
     }
   }
+  async function fetchOk(url) {
+    try {
+      const response = await fetchImplementation(url);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async function waitForDashboardReady(port) {
+    const dashboardUrl = `http://127.0.0.1:${port}`;
+    for (let i = 0; i < 100; i++) {
+      if (await fetchOk(dashboardUrl)) {
+        return true;
+      }
+      await sleep(100);
+    }
+    return false;
+  }
+  async function startDashboardServerProcess(port) {
+    const dashboardUrl = `http://127.0.0.1:${port}`;
+    if (await fetchOk(dashboardUrl)) {
+      return {
+        kill: () => void 0,
+        pid: void 0
+      };
+    }
+    const distPath = await resolveDashboardDistPath();
+    const nodeExecutable = await resolveNodeExecutable();
+    const serverProcess = spawnImplementation(nodeExecutable, [
+      "-e",
+      buildDashboardServerScript(distPath, port)
+    ], {
+      cwd: distPath,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let serverOutput = "";
+    let serverSpawnError;
+    serverProcess.on("error", (error) => {
+      serverSpawnError = error;
+      serverOutput += `Dashboard server process failed: ${formatSpawnError(error)}
+`;
+    });
+    serverProcess.stdout?.on("data", (data) => {
+      serverOutput += data.toString();
+    });
+    serverProcess.stderr?.on("data", (data) => {
+      serverOutput += data.toString();
+    });
+    for (let i = 0; i < 100; i++) {
+      if (await fetchOk(dashboardUrl)) {
+        return {
+          kill: () => {
+            if (serverProcess.pid !== void 0) {
+              try {
+                process.kill(serverProcess.pid, "SIGTERM");
+              } catch {
+              }
+            }
+          },
+          pid: serverProcess.pid
+        };
+      }
+      if (serverSpawnError !== void 0) {
+        throw new Error(
+          `Failed to start dashboard server process with ${nodeExecutable}: ${formatSpawnError(serverSpawnError)}`
+        );
+      }
+      await sleep(100);
+    }
+    throw new Error(
+      `Failed to start dashboard server at ${dashboardUrl}. Server output: ${serverOutput}`
+    );
+  }
+  function buildDashboardServerScript(distPath, port) {
+    return `
+import { createReadStream } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { extname, join, normalize, resolve } from 'node:path';
+
+const distPath = ${JSON.stringify(distPath)};
+const port = ${port};
+const root = resolve(distPath);
+const contentTypes = new Map([
+  ['.css', 'text/css; charset=utf-8'],
+  ['.html', 'text/html; charset=utf-8'],
+  ['.js', 'text/javascript; charset=utf-8'],
+  ['.json', 'application/json; charset=utf-8'],
+  ['.map', 'application/json; charset=utf-8'],
+  ['.svg', 'image/svg+xml'],
+]);
+
+function safePath(url) {
+  const parsed = new URL(url ?? '/', 'http://127.0.0.1');
+  const pathname = parsed.pathname === '/' ? '/index.html' : parsed.pathname;
+  const decoded = decodeURIComponent(pathname);
+  const normalized = normalize(decoded).replace(/^[/\\]+/, '');
+  const absolute = resolve(join(root, normalized));
+
+  if (absolute !== root && !absolute.startsWith(root + '/')) {
+    return null;
+  }
+
+  return absolute;
+}
+
+await stat(join(root, 'index.html'));
+
+const server = createServer(async (request, response) => {
+  const requestedPath = safePath(request.url);
+
+  if (requestedPath === null) {
+    response.writeHead(403, { 'content-type': 'text/plain; charset=utf-8' });
+    response.end('Forbidden');
+    return;
+  }
+
+  try {
+    const fileStat = await stat(requestedPath);
+    const filePath = fileStat.isFile() ? requestedPath : join(root, 'index.html');
+    const contentType = contentTypes.get(extname(filePath)) ?? 'application/octet-stream';
+
+    response.writeHead(200, { 'content-type': contentType });
+    createReadStream(filePath).pipe(response);
+  } catch {
+    response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+    createReadStream(join(root, 'index.html')).pipe(response);
+  }
+});
+
+server.on('error', (error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});
+
+await new Promise((resolveListen, rejectListen) => {
+  server.once('error', rejectListen);
+  server.listen(port, '127.0.0.1', resolveListen);
+});
+
+process.stdin.resume();
+`;
+  }
   async function ensureDaemonNotRunning(options) {
     const pathOptions = toPathOptions2(options);
     await cleanupStaleDaemonFiles(pathOptions);
@@ -16041,7 +16226,10 @@ function createCliRuntime(dependencies = {}) {
     if (child.pid === void 0) {
       throw new Error("Failed to obtain the AISnitch daemon PID.");
     }
-    return await waitForDaemonReady(daemonPathOptions);
+    return await waitForDaemonReady(
+      daemonPathOptions,
+      options.dashboardPort ?? DEFAULT_DASHBOARD_PORT
+    );
   }
   async function stopDetachedDaemon(options) {
     const pathOptions = toPathOptions2(options);
@@ -16072,6 +16260,7 @@ function createCliRuntime(dependencies = {}) {
         consumerCount: snapshot.health?.consumers ?? 0,
         daemon: {
           active: snapshot.running,
+          dashboardUrl: `http://127.0.0.1:${snapshot.dashboardPort}`,
           httpUrl: `http://127.0.0.1:${snapshot.httpPort}/health`,
           pid: snapshot.daemonPid,
           socketPath: snapshot.socketPath,
@@ -16112,7 +16301,7 @@ function createCliRuntime(dependencies = {}) {
     await (0, import_promises22.rm)(backupPath, { force: true });
     await (0, import_promises22.rename)(logFilePath, backupPath);
   }
-  async function waitForDaemonReady(pathOptions) {
+  async function waitForDaemonReady(pathOptions, dashboardPort = DEFAULT_DASHBOARD_PORT) {
     const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
     while (Date.now() < deadline) {
       const daemonState = await readDaemonState(pathOptions);
@@ -16121,6 +16310,7 @@ function createCliRuntime(dependencies = {}) {
         if (health !== null) {
           return {
             configuredAdapters: [],
+            dashboardPort,
             daemonPid: daemonState.pid,
             health,
             httpPort: daemonState.httpPort,
@@ -16221,6 +16411,7 @@ function createCliRuntime(dependencies = {}) {
       ...pathOptions
     });
     startMockEmitter(pipeline, options);
+    const dashboardServer = daemonMode ? await startDashboardServerProcess(config.dashboardPort) : null;
     if (daemonMode) {
       const daemonPathOptions = toPathOptions2(options);
       await writePid(process.pid, daemonPathOptions);
@@ -16257,6 +16448,7 @@ function createCliRuntime(dependencies = {}) {
         wsServer: pipeline.getWsServer(),
         eventBus: pipeline.getEventBus(),
         cleanupFns: daemonMode ? [async () => {
+          dashboardServer?.kill();
           await Promise.all([
             removePid(toPathOptions2(options)),
             removeDaemonState(toPathOptions2(options))
@@ -16333,16 +16525,16 @@ function createCliRuntime(dependencies = {}) {
       const snapshot = await startDetachedDaemon(options);
       output.stdout(
         `AISnitch daemon started (PID: ${snapshot.daemonPid ?? "unknown"}) on ws://${"127.0.0.1"}:${snapshot.wsPort}
+Dashboard: http://127.0.0.1:${snapshot.dashboardPort}
 `
       );
       return;
     }
     let initialSnapshot = await getStatusSnapshot(options);
+    if (!initialSnapshot.running) {
+      initialSnapshot = await startDetachedDaemon(options);
+    }
     if (options.mock) {
-      if (!initialSnapshot.running) {
-        await startDetachedDaemon(options);
-        initialSnapshot = await getStatusSnapshot(options);
-      }
       output.stdout(
         `Starting mock scenario ${options.mock} (${options.mockSpeed ?? 1}x, ${options.mockDuration ?? 60}s${options.mockLoop ? ", loop" : ""}).
 `
@@ -16402,6 +16594,8 @@ function createCliRuntime(dependencies = {}) {
     output.stdout(`WebSocket port: ${snapshot.wsPort}
 `);
     output.stdout(`HTTP port: ${snapshot.httpPort}
+`);
+    output.stdout(`Dashboard: http://127.0.0.1:${snapshot.dashboardPort}
 `);
     output.stdout(`Socket path: ${snapshot.socketPath ?? "none"}
 `);
@@ -16458,126 +16652,49 @@ function createCliRuntime(dependencies = {}) {
     });
   }
   async function fullscreen(options) {
-    const snapshot = await getStatusSnapshot(options);
-    if (!snapshot.running && options.daemon) {
+    let snapshot = await getStatusSnapshot(options);
+    if (!snapshot.running) {
       output.stdout("Starting daemon...\n");
-      await startDetachedDaemon(options);
-    }
-    if (!snapshot.running && !options.daemon) {
-      throw new Error(
-        "AISnitch daemon is not running. Start one with `aisnitch start --daemon` or use `aisnitch fs --daemon` to start and open the dashboard."
-      );
-    }
-    for (let i = 0; i < 20; i++) {
-      const health = await fetchHealth(snapshot.httpPort);
-      if (health) break;
-      await new Promise((resolve2) => setTimeout(resolve2, 200).unref());
+      snapshot = await startDetachedDaemon({
+        ...options,
+        dashboardPort: options.dashboardPort
+      });
     }
-    const dashboardPort = options.dashboardPort ?? 5174;
+    const dashboardPort = options.dashboardPort ?? snapshot.dashboardPort;
     const dashboardUrl = `http://127.0.0.1:${dashboardPort}`;
-    const distPath = (0, import_node_path22.join)(process.cwd(), "examples", "fullscreen-dashboard", "dist");
-    output.stdout(`Starting dashboard server on port ${dashboardPort}...
-`);
-    const nodeExecutable = await resolveNodeExecutable();
-    const viteProcess = spawnImplementation(nodeExecutable, [
-      "-e",
-      `
-import { createServer } from 'vite';
-import path from 'path';
-
-const distPath = '${distPath}';
-const port = ${dashboardPort};
-
-const server = await createServer({
-  root: distPath,
-  server: {
-    port,
-    strictPort: true,
-    allowedHosts: true,
-  },
-  preview: {
-    port,
-    strictPort: true,
-  },
-});
-
-await server.listen();
-console.log('READY');
-
-process.stdin.resume();
+    if (!await waitForDashboardReady(dashboardPort)) {
+      output.stdout(
+        `Dashboard not reachable at ${dashboardUrl}, starting a standalone server...
 `
-    ], {
-      cwd: distPath,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let serverOutput = "";
-    let serverSpawnError;
-    viteProcess.on("error", (error) => {
-      serverSpawnError = error;
-      serverOutput += `Dashboard server process failed: ${formatSpawnError(error)}
-`;
-    });
-    viteProcess.stdout?.on("data", (data) => {
-      serverOutput += data.toString();
-    });
-    viteProcess.stderr?.on("data", (data) => {
-      serverOutput += data.toString();
-    });
-    let serverReady = false;
-    for (let i = 0; i < 100; i++) {
-      await new Promise((resolve2) => setTimeout(resolve2, 100).unref());
+      );
       try {
-        const response = await fetchImplementation(dashboardUrl);
-        if (response.ok) {
-          serverReady = true;
-          break;
-        }
-      } catch {
-      }
-      if (serverSpawnError !== void 0) {
-        break;
+        await startDashboardServerProcess(dashboardPort);
+      } catch (error) {
+        throw new Error(
+          `Dashboard did not become reachable at ${dashboardUrl}: ${error instanceof Error ? error.message : "unknown error"}`,
+          { cause: error }
+        );
       }
-      if (!viteProcess.pid) break;
-    }
-    if (!serverReady) {
-      output.stdout(`Server output: ${serverOutput}
-`);
-      if (serverSpawnError !== void 0) {
+      if (!await waitForDashboardReady(dashboardPort)) {
         throw new Error(
-          `Failed to start dashboard server process with ${nodeExecutable}: ${formatSpawnError(serverSpawnError)}`
+          `Dashboard did not become reachable at ${dashboardUrl}.`
         );
       }
-      throw new Error("Failed to start dashboard server");
     }
     output.stdout(`Dashboard ready at ${dashboardUrl}
 `);
     if (!options.noBrowser) {
       output.stdout("Opening browser...\n");
-      const openModule = await openPromise;
-      await openModule.default(dashboardUrl);
+      try {
+        const openModule = await openPromise;
+        await openModule.default(dashboardUrl);
+      } catch (error) {
+        output.stderr(
+          `Failed to open browser automatically (${error instanceof Error ? error.message : "unknown error"}). Open ${dashboardUrl} manually.
+`
+        );
+      }
     }
-    output.stdout("Press Ctrl+C to stop\n");
-    await new Promise((resolve2) => {
-      const shutdown = () => {
-        process.off("SIGINT", handleSigint);
-        process.off("SIGTERM", handleSigterm);
-        if (viteProcess.pid !== void 0) {
-          try {
-            process.kill(viteProcess.pid, "SIGTERM");
-          } catch {
-          }
-        }
-        resolve2();
-      };
-      const handleSigint = () => {
-        shutdown();
-      };
-      const handleSigterm = () => {
-        shutdown();
-      };
-      process.once("SIGINT", handleSigint);
-      process.once("SIGTERM", handleSigterm);
-    });
   }
   async function logger2(options) {
     const snapshot = await getStatusSnapshot(options);
@@ -16844,6 +16961,7 @@ process.stdin.resume();
     const health = running && daemonState !== null ? await fetchHealth(daemonState.httpPort) : null;
     return {
       configuredAdapters: getEnabledAdapters(config),
+      dashboardPort: config.dashboardPort ?? DEFAULT_DASHBOARD_PORT,
       daemonPid,
       health,
       httpPort: daemonState?.httpPort ?? config.httpPort,
@@ -17078,13 +17196,13 @@ function createProgram(dependencies = {}) {
     "after",
     `
 Examples:
-  aisnitch start
+  aisnitch                       (default: starts daemon + dashboard server, opens browser)
+  aisnitch fs --dashboard-port 8080
+  aisnitch fs --no-browser
+  aisnitch start                 (TUI dashboard)
   aisnitch start --daemon
   aisnitch start --view full-data
   aisnitch start --mock
-  aisnitch fs
-  aisnitch fs --daemon
-  aisnitch fs --dashboard-port 8080
   aisnitch status
   aisnitch attach
   aisnitch attach --view full-data
@@ -17127,7 +17245,7 @@ function addCommonOptions(command) {
 }
 function addStartCommand(program, runtime) {
   addCommonOptions(
-    program.command("start", { isDefault: true }).description("Open the AISnitch dashboard and manage the daemon").option("--daemon", "Run AISnitch as a detached daemon").option(
+    program.command("start").description("Open the AISnitch TUI dashboard and manage the daemon").option("--daemon", "Run AISnitch as a detached daemon").option(
       "--mock [tool]",
       'Inject deterministic mock events (defaults to "all" when no tool is specified)',
       wrapOptionParser(parseMockToolSelection)
@@ -17159,6 +17277,10 @@ function addStartCommand(program, runtime) {
       "--http-port <port>",
       "Override the HTTP hook port",
       wrapOptionParser(parsePortOption)
+    ).option(
+      "--dashboard-port <port>",
+      "Override the web dashboard port",
+      wrapOptionParser(parsePortOption)
     ).option(
       "--log-level <level>",
       "Override the runtime log level",
@@ -17243,9 +17365,9 @@ function addAttachCommand(program, runtime) {
 }
 function addFullscreenCommand(program, runtime) {
   addCommonOptions(
-    program.command("fs").description("Open the fullscreen web dashboard in browser (starts daemon if needed with --daemon)").alias("fullscreen").option(
+    program.command("fs", { isDefault: true }).description("Start the daemon, the dashboard server, and open the web dashboard in browser").alias("fullscreen").option(
       "--daemon",
-      "Start the daemon automatically if not running"
+      "Deprecated: daemon is now started automatically when needed"
     ).option(
       "--dashboard-port <port>",
       "Port for the dashboard server (default: 5174)",