aisnitch 0.2.4 → 0.2.12

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
@@ -843,9 +843,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 +860,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 +912,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,7 +1728,7 @@ 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 }))
@@ -1684,35 +1736,113 @@ function ensureClaudeAISnitchHook(groups, hookEventName, hookUrl) {
   const matcher = hookEventName === "FileChanged" ? CLAUDE_FILE_CHANGED_MATCHER : void 0;
   const matchingGroup = clonedGroups.find((group) => group.matcher === matcher);
   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)]
+    hooks: [createClaudeAISnitchHook(hookEventName, hookUrl, scriptPath)]
   } : {
     matcher,
-    hooks: [createClaudeAISnitchHook(hookUrl)]
+    hooks: [createClaudeAISnitchHook(hookEventName, hookUrl, scriptPath)]
   };
   clonedGroups.push(nextGroup);
   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 +2357,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)) {
@@ -5006,6 +5139,9 @@ var ClaudeCodeAdapter = class extends BaseAdapter {
     });
     const context = {
       cwd: getString(payload, "cwd"),
+      // 📖 Pass process.env so the context detector can detect the terminal
+      // from TERM_PROGRAM, ITERM_SESSION_ID, etc. — hooks don't carry env vars
+      env: this.env ?? process.env,
       hookPayload: payload,
       pid: getNumber(payload, "pid"),
       sessionId,
@@ -5239,6 +5375,8 @@ function extractClaudeTranscriptObservations(payload, transcriptPath) {
   const tokensUsed = extractTokenUsage(payload);
   const rawPayload = payload;
   const sharedContext = {
+    // 📖 Pass process.env so terminal detection works from transcript path too
+    env: process.env,
     hookPayload: rawPayload,
     sessionId,
     source: "aisnitch://adapters/claude-code/transcript",
@@ -8895,6 +9033,8 @@ var OpenCodeAdapter = class extends BaseAdapter {
     });
     const context = {
       cwd: extractOpenCodeCwd(payload),
+      // 📖 Pass process.env so the context detector can detect the terminal
+      env: this.env ?? process.env,
       hookPayload: payload,
       pid: getNumber5(payload, "pid"),
       sessionId,
@@ -8905,6 +9045,8 @@ var OpenCodeAdapter = class extends BaseAdapter {
       cwd: context.cwd,
       errorMessage: extractOpenCodeErrorMessage(payload),
       errorType: extractOpenCodeErrorType(payload),
+      // 📖 Extract model from payload — OpenCode may send it as "model" or nested in properties
+      model: getString7(payload, "model") ?? getString7(getRecord6(payload.properties), "model"),
       project: extractOpenCodeProject(payload),
       raw: payload,
       toolInput: extractOpenCodeToolInput(payload),
@@ -9504,6 +9646,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
@@ -11412,7 +11555,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,
       {
@@ -11434,7 +11577,8 @@ async function renderForegroundTui(options) {
       }
     )
   );
-  await app.waitUntilExit();
+  await ink.start();
+  await ink.waitUntilExit;
 }
 async function renderManagedTui(options) {
   const app = render(