@aerostack/gateway 0.13.0 → 0.13.2

package/dist/hook-server.js

@@ -10,7 +10,8 @@
  * Also manages ~/.claude/settings.json hook entries when enabled/disabled.
  */
 import { createServer } from 'node:http';
-import { readFile, writeFile } from 'node:fs/promises';
+import { readFile, writeFile, appendFile, stat } from 'node:fs/promises';
+import { watch } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { info, warn, debug } from './logger.js';
@@ -158,34 +159,93 @@ function handleHookRequest(req, res) {
     });
 }
 // ─── Public API ───────────────────────────────────────────────────────────
+let fileWatcher = null;
+let lastFileSize = 0;
+/** Process new lines appended to the JSONL events file. */
+async function processNewEvents() {
+    try {
+        const st = await stat(HOOK_EVENTS_FILE).catch(() => null);
+        if (!st || st.size <= lastFileSize)
+            return;
+        const content = await readFile(HOOK_EVENTS_FILE, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        // Only process lines we haven't seen (based on byte offset)
+        const newContent = content.slice(lastFileSize);
+        lastFileSize = st.size;
+        const newLines = newContent.split('\n').filter(Boolean);
+        for (const line of newLines) {
+            try {
+                const data = JSON.parse(line);
+                const toolName = data.tool_name ?? '';
+                // Skip read-only tools
+                if (READONLY_TOOLS.has(toolName))
+                    continue;
+                if (!MUTATION_TOOLS.has(toolName) && !bridgeConfig.tools.includes(toolName))
+                    continue;
+                const toolInput = data.tool_input ?? {};
+                const { category, risk } = detectCategory(toolName, toolInput);
+                const summary = summarizeToolInput(toolName, toolInput);
+                addToBatch({
+                    action: `${toolName}: ${summary}`.slice(0, 500),
+                    category,
+                    risk_level: risk,
+                    details: JSON.stringify({ tool: toolName, ...toolInput }).slice(0, 500),
+                });
+                debug(`File hook event: ${toolName}`, { category });
+            }
+            catch { /* skip malformed lines */ }
+        }
+        // Truncate file if it gets too large (>1MB)
+        if (st.size > 1_048_576) {
+            await writeFile(HOOK_EVENTS_FILE, '', 'utf-8');
+            lastFileSize = 0;
+        }
+    }
+    catch { /* file may not exist yet */ }
+}
 export async function startHookServer(flushFn, port = DEFAULT_PORT) {
     batchFlushFn = flushFn;
-    // Find available port (try configured, then increment)
-    return new Promise((resolve, reject) => {
+    // Start HTTP server (still useful for non-Claude clients)
+    const actualPort = await new Promise((resolve, reject) => {
         httpServer = createServer(handleHookRequest);
         httpServer.on('error', (err) => {
             if (err.code === 'EADDRINUSE') {
-                // Try next port
                 info(`Port ${port} in use, trying ${port + 1}`);
                 httpServer.close();
                 startHookServer(flushFn, port + 1).then(resolve).catch(reject);
             }
             else {
-                reject(err);
+                // Non-fatal — file-based hooks still work without HTTP server
+                warn('HTTP hook server failed, using file-based hooks only', { error: err.message });
+                resolve(0);
             }
         });
         httpServer.listen(port, '127.0.0.1', () => {
             serverPort = port;
             info(`Hook server listening on http://127.0.0.1:${port}/hook`);
-            // Start batch flush timer
-            flushTimer = setInterval(() => {
-                flushBatch().catch(err => {
-                    warn('Batch flush failed', { error: err instanceof Error ? err.message : String(err) });
-                });
-            }, BATCH_INTERVAL_MS);
             resolve(port);
         });
     });
+    // Start file watcher for JSONL events (primary hook mechanism — no port conflicts)
+    try {
+        // Touch file so watcher has something to watch
+        await appendFile(HOOK_EVENTS_FILE, '');
+        fileWatcher = watch(HOOK_EVENTS_FILE, () => {
+            processNewEvents().catch(() => { });
+        });
+        info('File watcher started', { path: HOOK_EVENTS_FILE });
+    }
+    catch (err) {
+        warn('File watcher failed', { error: err instanceof Error ? err.message : String(err) });
+    }
+    // Start batch flush timer — also polls JSONL file as safety net for fs.watch misses
+    flushTimer = setInterval(() => {
+        processNewEvents().catch(() => { });
+        flushBatch().catch(err => {
+            warn('Batch flush failed', { error: err instanceof Error ? err.message : String(err) });
+        });
+    }, BATCH_INTERVAL_MS);
+    return actualPort;
 }
 export function stopHookServer() {
     if (flushTimer) {
@@ -194,6 +254,10 @@ export function stopHookServer() {
     }
     // Final flush
     flushBatch().catch(() => { });
+    if (fileWatcher) {
+        fileWatcher.close();
+        fileWatcher = null;
+    }
     if (httpServer) {
         httpServer.close();
         httpServer = null;
@@ -202,7 +266,10 @@ export function stopHookServer() {
 }
 // ─── Claude Code hook management ──────────────────────────────────────────
 const HOOK_MARKER = '/* aerostack-guardian-hook */';
-export async function installClaudeHook(port) {
+/** Path where hook events are written as JSONL (one JSON object per line).
+ *  Use /tmp/ explicitly — macOS tmpdir() returns /var/folders/... which differs between processes. */
+export const HOOK_EVENTS_FILE = '/tmp/aerostack-guardian-events.jsonl';
+export async function installClaudeHook(_port) {
     const settingsPath = join(homedir(), '.claude', 'settings.json');
     try {
         let settings = {};
@@ -215,28 +282,26 @@ export async function installClaudeHook(port) {
         }
         const hooks = (settings.hooks ?? {});
         const preToolUse = (hooks.PreToolUse ?? []);
-        // Check if our hook already exists
-        const existing = preToolUse.findIndex(h => {
+        // Remove any old HTTP-based aerostack hooks
+        const cleaned = preToolUse.filter(h => {
             const innerHooks = (h.hooks ?? []);
-            return innerHooks.some(ih => ih.url?.includes('127.0.0.1') && ih.url?.includes('/hook'));
+            return !innerHooks.some(ih => (ih.url?.includes('127.0.0.1') && ih.url?.includes('/hook')) ||
+                (ih.command?.includes('aerostack-guardian')));
         });
+        // Command hook: reads stdin JSON, appends to JSONL file
+        // No HTTP, no port, no conflicts between sessions
         const hookEntry = {
             matcher: 'Bash|Write|Edit',
             hooks: [{
-                    type: 'http',
-                    url: `http://127.0.0.1:${port}/hook`,
+                    type: 'command',
+                    command: `cat >> ${HOOK_EVENTS_FILE}`,
                 }],
         };
-        if (existing >= 0) {
-            preToolUse[existing] = hookEntry;
-        }
-        else {
-            preToolUse.push(hookEntry);
-        }
-        hooks.PreToolUse = preToolUse;
+        cleaned.push(hookEntry);
+        hooks.PreToolUse = cleaned;
         settings.hooks = hooks;
         await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-        info('Installed Claude Code hook', { port, path: settingsPath });
+        info('Installed Claude Code hook (file-based)', { eventsFile: HOOK_EVENTS_FILE, path: settingsPath });
         return true;
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerostack/gateway",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "stdio-to-HTTP bridge connecting any MCP client to Aerostack Workspaces",
   "author": "Aerostack",
   "license": "MIT",