aisnitch 0.2.5 → 0.2.13

package/dist/cli/index.js

@@ -8,7 +8,7 @@ import { Command, InvalidArgumentError } from "commander";
 
 // src/package-info.ts
 var AISNITCH_PACKAGE_NAME = "aisnitch";
-var AISNITCH_VERSION = "0.2.3";
+var AISNITCH_VERSION = "0.2.12";
 var AISNITCH_DESCRIPTION = "Universal bridge for AI coding tool activity \u2014 capture, normalize, stream.";
 
 // src/core/events/schema.ts
@@ -723,7 +723,6 @@ var ANSI_RESET = "\x1B[0m";
 var ANSI_RED = "\x1B[31m";
 var ANSI_GREEN = "\x1B[32m";
 var ANSI_CYAN = "\x1B[36m";
-var CLAUDE_FILE_CHANGED_MATCHER = ".*";
 var CLAUDE_CODE_HOOK_EVENTS = [
   "SessionStart",
   "UserPromptSubmit",
@@ -734,15 +733,12 @@ var CLAUDE_CODE_HOOK_EVENTS = [
   "Notification",
   "SubagentStart",
   "SubagentStop",
-  "TaskCreated",
   "TaskCompleted",
   "Stop",
   "StopFailure",
   "TeammateIdle",
   "InstructionsLoaded",
   "ConfigChange",
-  "CwdChanged",
-  "FileChanged",
   "WorktreeCreate",
   "WorktreeRemove",
   "PreCompact",
@@ -843,9 +839,15 @@ var FileToolSetupBase = class {
 var ClaudeCodeSetup = class extends FileToolSetupBase {
   settingsPath;
   hookUrl;
+  scriptPath;
   constructor(httpPort, dependencies = {}) {
     super("claude-code", dependencies.binaryExists);
     this.settingsPath = dependencies.claudeSettingsPath ?? join2(dependencies.homeDirectory ?? homedir2(), ".claude", "settings.json");
+    this.scriptPath = join2(
+      dependencies.homeDirectory ?? homedir2(),
+      ".claude",
+      "aisnitch-forward.mjs"
+    );
     this.hookUrl = `http://localhost:${httpPort}/hooks/claude-code`;
   }
   async detect() {
@@ -854,7 +856,49 @@ var ClaudeCodeSetup = class extends FileToolSetupBase {
   getConfigPath() {
     return this.settingsPath;
   }
+  async computeDiff() {
+    const currentSettingsContent = await readOptionalFile(this.settingsPath);
+    const currentScriptContent = await readOptionalFile(this.scriptPath);
+    const nextSettingsContent = this.buildNextSettingsContent(currentSettingsContent);
+    const nextScriptContent = buildClaudeForwardScriptSource();
+    return [
+      renderColoredDiff(
+        this.settingsPath,
+        currentSettingsContent,
+        nextSettingsContent
+      ),
+      "",
+      renderColoredDiff(
+        this.scriptPath,
+        currentScriptContent,
+        nextScriptContent
+      )
+    ].join("\n");
+  }
+  async apply() {
+    const currentSettingsContent = await readOptionalFile(this.settingsPath);
+    const currentScriptContent = await readOptionalFile(this.scriptPath);
+    const nextSettingsContent = this.buildNextSettingsContent(currentSettingsContent);
+    const nextScriptContent = buildClaudeForwardScriptSource();
+    await mkdir2(dirname2(this.settingsPath), { recursive: true });
+    await mkdir2(dirname2(this.scriptPath), { recursive: true });
+    if (currentSettingsContent !== null) {
+      await copyFile(this.settingsPath, this.getFileBackupPath(this.settingsPath));
+    }
+    if (currentScriptContent !== null) {
+      await copyFile(this.scriptPath, this.getFileBackupPath(this.scriptPath));
+    }
+    await writeFile2(this.settingsPath, nextSettingsContent, "utf8");
+    await writeFile2(this.scriptPath, nextScriptContent, "utf8");
+  }
+  async revert() {
+    await restoreBackupOrRemove(this.settingsPath);
+    await restoreBackupOrRemove(this.scriptPath);
+  }
   buildNextContent(currentContent) {
+    return Promise.resolve(this.buildNextSettingsContent(currentContent));
+  }
+  buildNextSettingsContent(currentContent) {
     const parsedSettings = parseClaudeSettings(currentContent);
     const currentHooks = parsedSettings.hooks ?? {};
     const nextHooks = {
@@ -864,15 +908,19 @@ var ClaudeCodeSetup = class extends FileToolSetupBase {
       nextHooks[hookEventName] = ensureClaudeAISnitchHook(
         currentHooks[hookEventName] ?? [],
         hookEventName,
-        this.hookUrl
+        this.hookUrl,
+        this.scriptPath
       );
     }
     const nextSettings = {
       ...parsedSettings,
       hooks: nextHooks
     };
-    return Promise.resolve(`${JSON.stringify(nextSettings, null, 2)}
-`);
+    return `${JSON.stringify(nextSettings, null, 2)}
+`;
+  }
+  getFileBackupPath(path) {
+    return `${path}.bak`;
   }
 };
 var OpenCodeSetup = class extends FileToolSetupBase {
@@ -1676,43 +1724,116 @@ async function defaultConfirm(_diff, prompt) {
     readlineInterface.close();
   }
 }
-function ensureClaudeAISnitchHook(groups, hookEventName, hookUrl) {
+function ensureClaudeAISnitchHook(groups, hookEventName, hookUrl, scriptPath) {
   const clonedGroups = groups.map((group) => ({
     ...group,
     hooks: group.hooks.map((handler) => ({ ...handler }))
   }));
-  const matcher = hookEventName === "FileChanged" ? CLAUDE_FILE_CHANGED_MATCHER : void 0;
-  const matchingGroup = clonedGroups.find((group) => group.matcher === matcher);
+  const matchingGroup = clonedGroups.find((group) => group.matcher === void 0);
   if (matchingGroup) {
-    const existingHook = matchingGroup.hooks.find((handler) => isClaudeAISnitchHook(handler, hookUrl));
+    matchingGroup.hooks = matchingGroup.hooks.filter(
+      (handler) => !isLegacyClaudeAISnitchHttpHook(handler, hookUrl)
+    );
+    const existingHook = matchingGroup.hooks.find(
+      (handler) => isClaudeAISnitchHook(handler, hookEventName, hookUrl, scriptPath)
+    );
     if (existingHook) {
       if (existingHook.async !== true) {
         existingHook.async = true;
       }
       return clonedGroups;
     }
-    matchingGroup.hooks.push(createClaudeAISnitchHook(hookUrl));
+    matchingGroup.hooks.push(
+      createClaudeAISnitchHook(hookEventName, hookUrl, scriptPath)
+    );
     return clonedGroups;
   }
-  const nextGroup = matcher === void 0 ? {
-    hooks: [createClaudeAISnitchHook(hookUrl)]
-  } : {
-    matcher,
-    hooks: [createClaudeAISnitchHook(hookUrl)]
-  };
-  clonedGroups.push(nextGroup);
+  clonedGroups.push({
+    hooks: [createClaudeAISnitchHook(hookEventName, hookUrl, scriptPath)]
+  });
   return clonedGroups;
 }
-function createClaudeAISnitchHook(hookUrl) {
+function createClaudeAISnitchHook(hookEventName, hookUrl, scriptPath) {
   return {
     async: true,
-    type: "http",
-    url: hookUrl
+    command: buildClaudeForwardCommand(hookEventName, hookUrl, scriptPath),
+    type: "command"
   };
 }
-function isClaudeAISnitchHook(handler, hookUrl) {
+function isClaudeAISnitchHook(handler, hookEventName, hookUrl, scriptPath) {
+  return handler.type === "command" && typeof handler.command === "string" && handler.command === buildClaudeForwardCommand(hookEventName, hookUrl, scriptPath);
+}
+function isLegacyClaudeAISnitchHttpHook(handler, hookUrl) {
   return handler.type === "http" && handler.url === hookUrl;
 }
+function buildClaudeForwardCommand(hookEventName, hookUrl, scriptPath) {
+  return `node ${shellEscapeSingle(scriptPath)} ${hookEventName} ${shellEscapeSingle(hookUrl)}`;
+}
+function buildClaudeForwardScriptSource() {
+  return `#!/usr/bin/env node
+/**
+ * AISnitch Claude Code hook bridge
+ *
+ * \u{1F4D6} Claude Code currently exposes command hooks fed through stdin JSON.
+ * This bridge keeps the Claude config valid while still forwarding every
+ * selected hook event into the local AISnitch HTTP receiver.
+ */
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function readInput() {
+  const chunks = [];
+
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+  }
+
+  return chunks.join("");
+}
+
+async function main() {
+  const hookEventName = process.argv[2] ?? "unknown";
+  const endpoint = process.argv[3] ?? "http://localhost:4821/hooks/claude-code";
+  const rawInput = await readInput();
+  let payload = {};
+
+  if (rawInput.trim().length > 0) {
+    try {
+      const parsedPayload = JSON.parse(rawInput);
+
+      if (isRecord(parsedPayload)) {
+        payload = parsedPayload;
+      }
+    } catch {
+      payload = {
+        raw: rawInput
+      };
+    }
+  }
+
+  try {
+    await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        ...payload,
+        hook_event_name: hookEventName
+      })
+    });
+  } catch {
+    // Claude hooks must stay fire-and-forget for observability only.
+  }
+}
+
+void main().catch(() => {
+  // Never bubble hook bridge failures back into Claude Code itself.
+});
+`;
+}
 function ensureGeminiAISnitchHook(groups, hookUrl) {
   const clonedGroups = groups.map((group) => ({
     ...group,
@@ -2227,6 +2348,9 @@ async function readOptionalFile(path) {
     throw error;
   }
 }
+function shellEscapeSingle(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
 async function restoreBackupOrRemove(path) {
   const backupPath = `${path}.bak`;
   if (await fileExists(backupPath)) {
@@ -9513,6 +9637,7 @@ var Pipeline = class {
 
 // src/tui/index.tsx
 import { render } from "ink";
+import { withFullScreen } from "fullscreen-ink";
 import WebSocket4 from "ws";
 
 // src/tui/App.tsx
@@ -11421,7 +11546,7 @@ function attachEventBusMonitor(eventBus, output) {
 // src/tui/index.tsx
 import { jsx as jsx13 } from "react/jsx-runtime";
 async function renderForegroundTui(options) {
-  const app = render(
+  const ink = withFullScreen(
     /* @__PURE__ */ jsx13(
       App,
       {
@@ -11443,7 +11568,8 @@ async function renderForegroundTui(options) {
       }
     )
   );
-  await app.waitUntilExit();
+  await ink.start();
+  await ink.waitUntilExit;
 }
 async function renderManagedTui(options) {
   const app = render(