aisnitch 0.2.4 → 0.2.12

package/README.md

@@ -220,7 +220,7 @@ flowchart LR
 
 | Tool | Strategy | Setup |
 |---|---|---|
-| **Claude Code** | HTTP hooks + JSONL transcript watching + process detection | `aisnitch setup claude-code` |
+| **Claude Code** | Command hooks + JSONL transcript watching + process detection | `aisnitch setup claude-code` |
 | **OpenCode** | Local plugin + process detection | `aisnitch setup opencode` |
 | **Gemini CLI** | Command hooks + `logs.json` watching + process detection | `aisnitch setup gemini-cli` |
 | **Codex** | `codex-tui.log` parsing + process detection | `aisnitch setup codex` |

package/dist/cli/index.cjs

@@ -41,7 +41,7 @@ var import_commander = require("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
@@ -876,9 +876,15 @@ var FileToolSetupBase = class {
 var ClaudeCodeSetup = class extends FileToolSetupBase {
   settingsPath;
   hookUrl;
+  scriptPath;
   constructor(httpPort, dependencies = {}) {
     super("claude-code", dependencies.binaryExists);
     this.settingsPath = dependencies.claudeSettingsPath ?? (0, import_node_path2.join)(dependencies.homeDirectory ?? (0, import_node_os2.homedir)(), ".claude", "settings.json");
+    this.scriptPath = (0, import_node_path2.join)(
+      dependencies.homeDirectory ?? (0, import_node_os2.homedir)(),
+      ".claude",
+      "aisnitch-forward.mjs"
+    );
     this.hookUrl = `http://localhost:${httpPort}/hooks/claude-code`;
   }
   async detect() {
@@ -887,7 +893,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 (0, import_promises2.mkdir)((0, import_node_path2.dirname)(this.settingsPath), { recursive: true });
+    await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(this.scriptPath), { recursive: true });
+    if (currentSettingsContent !== null) {
+      await (0, import_promises2.copyFile)(this.settingsPath, this.getFileBackupPath(this.settingsPath));
+    }
+    if (currentScriptContent !== null) {
+      await (0, import_promises2.copyFile)(this.scriptPath, this.getFileBackupPath(this.scriptPath));
+    }
+    await (0, import_promises2.writeFile)(this.settingsPath, nextSettingsContent, "utf8");
+    await (0, import_promises2.writeFile)(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 = {
@@ -897,15 +945,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 {
@@ -1709,7 +1761,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 }))
@@ -1717,35 +1769,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,
@@ -2260,6 +2390,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)) {
@@ -5037,6 +5170,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,
@@ -5270,6 +5406,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",
@@ -8926,6 +9064,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,
@@ -8936,6 +9076,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),
@@ -9535,6 +9677,7 @@ var Pipeline = class {
 
 // src/tui/index.tsx
 var import_ink13 = require("ink");
+var import_fullscreen_ink = require("fullscreen-ink");
 var import_ws4 = __toESM(require("ws"), 1);
 
 // src/tui/App.tsx
@@ -11443,7 +11586,7 @@ function attachEventBusMonitor(eventBus, output) {
 // src/tui/index.tsx
 var import_jsx_runtime13 = require("react/jsx-runtime");
 async function renderForegroundTui(options) {
-  const app = (0, import_ink13.render)(
+  const ink = (0, import_fullscreen_ink.withFullScreen)(
     /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
       App,
       {
@@ -11465,7 +11608,8 @@ async function renderForegroundTui(options) {
       }
     )
   );
-  await app.waitUntilExit();
+  await ink.start();
+  await ink.waitUntilExit;
 }
 async function renderManagedTui(options) {
   const app = (0, import_ink13.render)(