claude-brain 0.24.1 → 0.25.0

package/VERSION

@@ -1 +1 @@
-0.24.1
+0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/scripts/postinstall.mjs

@@ -342,7 +342,7 @@ function buildAutoStartSnippet(profilePath) {
       'if (Get-Command claude-brain -ErrorAction SilentlyContinue) {',
       '  $listening = Get-NetTCPConnection -LocalPort 3000 -ErrorAction SilentlyContinue',
       '  if (-not $listening) {',
-      '    Start-Process -NoNewWindow -FilePath "claude-brain" -ArgumentList "serve" -WindowStyle Hidden',
+      '    Start-Process -NoNewWindow -FilePath "claude-brain" -ArgumentList "serve","--http-only" -WindowStyle Hidden',
       '  }',
       '}',
       AUTO_END_MARKER,
@@ -350,9 +350,9 @@ function buildAutoStartSnippet(profilePath) {
   }
   return [
     AUTO_START_MARKER,
-    '# Auto-start claude-brain server if not already running',
+    '# Auto-start claude-brain HTTP server if not already running',
     '(command -v claude-brain >/dev/null 2>&1 && ! lsof -ti :3000 >/dev/null 2>&1) && {',
-    '  nohup claude-brain serve >/dev/null 2>&1 &',
+    '  nohup claude-brain serve --http-only >/dev/null 2>&1 &',
     '  disown 2>/dev/null',
     '}',
     AUTO_END_MARKER,

package/src/cli/auto-start.ts

@@ -32,9 +32,9 @@ export interface AutoStartResult {
 function buildUnixSnippet(port: number): string {
   return [
     START_MARKER,
-    '# Auto-start claude-brain server if not already running',
+    '# Auto-start claude-brain HTTP server if not already running',
     `(command -v claude-brain >/dev/null 2>&1 && ! lsof -ti :${port} >/dev/null 2>&1) && {`,
-    '  nohup claude-brain serve >/dev/null 2>&1 &',
+    '  nohup claude-brain serve --http-only >/dev/null 2>&1 &',
     '  disown 2>/dev/null',
     '}',
     END_MARKER,
@@ -48,9 +48,9 @@ function buildUnixSnippet(port: number): string {
 function buildFishSnippet(port: number): string {
   return [
     START_MARKER,
-    '# Auto-start claude-brain server if not already running',
+    '# Auto-start claude-brain HTTP server if not already running',
     `if command -v claude-brain >/dev/null 2>&1; and not lsof -ti :${port} >/dev/null 2>&1`,
-    '  nohup claude-brain serve >/dev/null 2>&1 &',
+    '  nohup claude-brain serve --http-only >/dev/null 2>&1 &',
     'end',
     END_MARKER,
   ].join('\n')
@@ -66,7 +66,7 @@ function buildPowerShellSnippet(port: number): string {
     `  $port = ${port}`,
     '  $listening = Get-NetTCPConnection -LocalPort $port -ErrorAction SilentlyContinue',
     '  if (-not $listening) {',
-    '    Start-Process -NoNewWindow -FilePath "claude-brain" -ArgumentList "serve" -WindowStyle Hidden',
+    '    Start-Process -NoNewWindow -FilePath "claude-brain" -ArgumentList "serve","--http-only" -WindowStyle Hidden',
     '  }',
     '}',
     END_MARKER,

package/src/cli/commands/serve.ts

@@ -18,17 +18,22 @@ export async function runServe() {
   // Auto-initialize home directory on first run
   ensureHomeDirectory()
 
-  // Singleton check: prevent multiple server instances
+  // --http-only: run HTTP server + services but no MCP stdio transport.
+  // Used by auto-start background process (stdin is /dev/null, no Claude Code attached).
+  const httpOnly = process.argv.includes('--http-only')
+
+  // Determine instance role:
+  // - httpOnly → always primary (background HTTP daemon)
+  // - otherwise → secondary if primary is already running (Claude Code MCP session)
   const pidManager = new ServerPidManager()
   const existingPid = pidManager.getRunningPid()
-  if (existingPid) {
-    console.error(`[claude-brain] Server already running (PID: ${existingPid}). Exiting.`)
-    process.exit(0)
-  }
+  const isSecondaryInstance = !httpOnly && !!existingPid
 
-  // Write PID file and register cleanup handlers
-  pidManager.writePidFile()
-  pidManager.registerCleanupHandlers()
+  if (!isSecondaryInstance) {
+    // Primary instance: write PID file and register cleanup
+    pidManager.writePidFile()
+    pidManager.registerCleanupHandlers()
+  }
 
   // Auto-install Claude Code hooks (idempotent, non-fatal)
   try {
@@ -162,141 +167,147 @@ export async function runServe() {
     await shutdownServices()
   })
 
-  // Clean up PID file during graceful shutdown
-  cleanup.register(async () => {
-    pidManager.cleanup()
-  })
+  // ── Primary instance only: HTTP server + background services ──
+  // Secondary instances (when auto-start already running) only start MCP stdio
+  if (!isSecondaryInstance) {
+    // Clean up PID file during graceful shutdown
+    cleanup.register(async () => {
+      pidManager.cleanup()
+    })
 
-  // Start HTTP API server alongside MCP server
-  const { HttpApiServer } = await import('@/server/http-api')
-  const httpServer = new HttpApiServer(config, logger)
+    // Start HTTP API server alongside MCP server
+    const { HttpApiServer } = await import('@/server/http-api')
+    const httpServer = new HttpApiServer(config, logger)
 
-  cleanup.register(async () => {
-    await httpServer.stop()
-  })
+    cleanup.register(async () => {
+      await httpServer.stop()
+    })
 
-  // Phase 21: Use session tracker from services (promoted from local creation)
-  {
-    const { getSessionTracker } = await import('@/server/services')
-    const sessionTracker = getSessionTracker()
-    if (sessionTracker) {
-      httpServer.setSessionTracker(sessionTracker)
-      mainLogger.info('Session tracker wired to HTTP server')
+    // Phase 21: Use session tracker from services (promoted from local creation)
+    {
+      const { getSessionTracker } = await import('@/server/services')
+      const sessionTracker = getSessionTracker()
+      if (sessionTracker) {
+        httpServer.setSessionTracker(sessionTracker)
+        mainLogger.info('Session tracker wired to HTTP server')
+      }
     }
-  }
 
-  // Phase 28: Wire code intelligence to HTTP server
-  {
-    const { getCodeIndexer, getCodeQuery } = await import('@/server/services')
-    const codeIndexer = getCodeIndexer()
-    const codeQuery = getCodeQuery()
-    if (codeIndexer && codeQuery) {
-      httpServer.setCodeIntelligence(codeIndexer, codeQuery)
-      mainLogger.info('Code intelligence wired to HTTP server')
+    // Phase 28: Wire code intelligence to HTTP server
+    {
+      const { getCodeIndexer, getCodeQuery } = await import('@/server/services')
+      const codeIndexer = getCodeIndexer()
+      const codeQuery = getCodeQuery()
+      if (codeIndexer && codeQuery) {
+        httpServer.setCodeIntelligence(codeIndexer, codeQuery)
+        mainLogger.info('Code intelligence wired to HTTP server')
+      }
     }
-  }
 
-  // Phase 29: Wire code linker to HTTP server
-  {
-    const { getCodeLinker } = await import('@/server/services')
-    const codeLinker = getCodeLinker()
-    if (codeLinker) {
-      httpServer.setCodeLinker(codeLinker)
-      mainLogger.info('Code linker wired to HTTP server')
+    // Phase 29: Wire code linker to HTTP server
+    {
+      const { getCodeLinker } = await import('@/server/services')
+      const codeLinker = getCodeLinker()
+      if (codeLinker) {
+        httpServer.setCodeLinker(codeLinker)
+        mainLogger.info('Code linker wired to HTTP server')
+      }
     }
-  }
 
-  // Phase 30: Activity log pruning on startup + periodic cleanup
-  {
-    const memory = getMemoryService()
-    if (memory?.isInitialized()) {
-      try {
-        const { startPeriodicPruning } = await import('@/memory/pruning')
-        const db = memory.database.getDb()
-        const stopPruning = startPeriodicPruning(db, logger, 30)
-        cleanup.register(async () => {
-          stopPruning()
-          mainLogger.info('Activity log pruning stopped')
-        })
-        mainLogger.info('Activity log pruning initialized')
-      } catch (error) {
-        mainLogger.warn({ error }, 'Failed to initialize activity log pruning')
+    // Phase 30: Activity log pruning on startup + periodic cleanup
+    {
+      const memory = getMemoryService()
+      if (memory?.isInitialized()) {
+        try {
+          const { startPeriodicPruning } = await import('@/memory/pruning')
+          const db = memory.database.getDb()
+          const stopPruning = startPeriodicPruning(db, logger, 30)
+          cleanup.register(async () => {
+            stopPruning()
+            mainLogger.info('Activity log pruning stopped')
+          })
+          mainLogger.info('Activity log pruning initialized')
+        } catch (error) {
+          mainLogger.warn({ error }, 'Failed to initialize activity log pruning')
+        }
       }
     }
-  }
 
-  // Phase 30: Optional LLM compression
-  if (config.compression?.enabled) {
-    try {
-      const { ObservationCompressor } = await import('@/memory/compression')
-      const { getBrainRouter } = await import('@/routing/router')
-      const compressor = new ObservationCompressor(config.compression, logger)
-      const router = getBrainRouter(logger)
-      router.setCompressor(compressor)
-      mainLogger.info({ provider: config.compression.provider, model: config.compression.model }, 'LLM compression enabled')
-    } catch (error) {
-      mainLogger.warn({ error }, 'Failed to initialize LLM compression')
+    // Phase 30: Optional LLM compression
+    if (config.compression?.enabled) {
+      try {
+        const { ObservationCompressor } = await import('@/memory/compression')
+        const { getBrainRouter } = await import('@/routing/router')
+        const compressor = new ObservationCompressor(config.compression, logger)
+        const router = getBrainRouter(logger)
+        router.setCompressor(compressor)
+        mainLogger.info({ provider: config.compression.provider, model: config.compression.model }, 'LLM compression enabled')
+      } catch (error) {
+        mainLogger.warn({ error }, 'Failed to initialize LLM compression')
+      }
     }
-  }
-
-  // Phase 31: Auto-update checker
-  let autoUpdater: InstanceType<typeof import('@/server/auto-updater').AutoUpdater> | null = null
-  if (config.autoUpdate?.enabled !== false) {
-    try {
-      const { AutoUpdater } = await import('@/server/auto-updater')
-      autoUpdater = new AutoUpdater(
-        {
-          enabled: config.autoUpdate?.enabled ?? true,
-          checkIntervalHours: config.autoUpdate?.checkIntervalHours ?? 24,
-          autoRestart: config.autoUpdate?.autoRestart ?? true,
-        },
-        mainLogger
-      )
-
-      // Check for updates on startup (non-blocking)
-      autoUpdater.check().then(result => {
-        if (result.updateAvailable && result.latestVersion) {
-          mainLogger.info(
-            { current: result.currentVersion, latest: result.latestVersion },
-            'Update available! Run: claude-brain update'
-          )
-        }
-      }).catch(() => {})
 
-      // Schedule periodic checks
-      autoUpdater.schedulePeriodicCheck()
+    // Phase 31: Auto-update checker
+    let autoUpdater: InstanceType<typeof import('@/server/auto-updater').AutoUpdater> | null = null
+    if (config.autoUpdate?.enabled !== false) {
+      try {
+        const { AutoUpdater } = await import('@/server/auto-updater')
+        autoUpdater = new AutoUpdater(
+          {
+            enabled: config.autoUpdate?.enabled ?? true,
+            checkIntervalHours: config.autoUpdate?.checkIntervalHours ?? 24,
+            autoRestart: config.autoUpdate?.autoRestart ?? true,
+          },
+          mainLogger
+        )
+
+        // Check for updates on startup (non-blocking)
+        autoUpdater.check().then(result => {
+          if (result.updateAvailable && result.latestVersion) {
+            mainLogger.info(
+              { current: result.currentVersion, latest: result.latestVersion },
+              'Update available! Run: claude-brain update'
+            )
+          }
+        }).catch(() => {})
+
+        // Schedule periodic checks
+        autoUpdater.schedulePeriodicCheck()
 
-      cleanup.register(async () => {
-        autoUpdater?.stopPeriodicCheck()
-        mainLogger.info('Auto-updater stopped')
-      })
+        cleanup.register(async () => {
+          autoUpdater?.stopPeriodicCheck()
+          mainLogger.info('Auto-updater stopped')
+        })
 
-      mainLogger.info('Auto-updater initialized')
-    } catch (error) {
-      mainLogger.warn({ error }, 'Failed to initialize auto-updater')
+        mainLogger.info('Auto-updater initialized')
+      } catch (error) {
+        mainLogger.warn({ error }, 'Failed to initialize auto-updater')
+      }
     }
-  }
-
-  // Start HTTP server after MCP server is ready
-  setTimeout(async () => {
-    try {
-      await httpServer.start()
-      mainLogger.info({ port: config.port }, 'HTTP API server started')
 
-      // Drain hook queue after HTTP server is ready
+    // Start HTTP server after MCP server is ready
+    setTimeout(async () => {
       try {
-        const { drainQueue } = await import('@/hooks/queue')
-        const drained = await drainQueue(config.port)
-        if (drained > 0) {
-          mainLogger.info({ drained }, 'Drained hook queue')
+        await httpServer.start()
+        mainLogger.info({ port: config.port }, 'HTTP API server started')
+
+        // Drain hook queue after HTTP server is ready
+        try {
+          const { drainQueue } = await import('@/hooks/queue')
+          const drained = await drainQueue(config.port)
+          if (drained > 0) {
+            mainLogger.info({ drained }, 'Drained hook queue')
+          }
+        } catch (error) {
+          mainLogger.debug({ error }, 'No hook queue to drain')
         }
       } catch (error) {
-        mainLogger.debug({ error }, 'No hook queue to drain')
+        mainLogger.error({ error }, 'Failed to start HTTP API server')
       }
-    } catch (error) {
-      mainLogger.error({ error }, 'Failed to start HTTP API server')
-    }
-  }, 2000)
+    }, 2000)
+  } else {
+    mainLogger.info({ existingPid }, 'Secondary instance — HTTP server already running, starting MCP stdio only')
+  }
 
   const shutdown = async (signal: string) => {
     mainLogger.info({ signal }, 'Shutting down...')
@@ -307,7 +318,14 @@ export async function runServe() {
   process.on('SIGTERM', () => shutdown('SIGTERM'))
   process.on('SIGINT', () => shutdown('SIGINT'))
 
-  await mcpServer.start()
-
-  mainLogger.info('Claude Brain MCP server ready and listening for connections')
+  if (httpOnly) {
+    // HTTP-only mode: no MCP stdio. Keep process alive for HTTP server.
+    mainLogger.info('HTTP-only mode — MCP stdio disabled (background daemon)')
+    // Keep the event loop alive with a long interval
+    const keepAlive = setInterval(() => {}, 60_000 * 60)
+    cleanup.register(async () => { clearInterval(keepAlive) })
+  } else {
+    await mcpServer.start()
+    mainLogger.info('Claude Brain MCP server ready and listening for connections')
+  }
 }

package/src/hooks/installer.ts

@@ -22,6 +22,11 @@ export function getContextHookScriptPath(): string {
   return join(getClaudeBrainHome(), 'hooks', 'context-hook.ts')
 }
 
+/** Get the path where the interceptor-hook script should be installed */
+export function getInterceptorHookScriptPath(): string {
+  return join(getClaudeBrainHome(), 'hooks', 'interceptor-hook.ts')
+}
+
 /** Read Claude Code settings.json, creating if needed */
 function readSettings(): Record<string, any> {
   if (!existsSync(CLAUDE_SETTINGS_PATH)) return {}
@@ -47,8 +52,12 @@ function writeSettings(settings: Record<string, any>): void {
 /** Build the hook command string, embedding the port so hooks work regardless of env.
  * BUG-006: settings.json syncs across platforms. We use --port arg instead of
  * platform-specific env var syntax (VAR=val on Unix, set VAR=val on Windows). */
-function buildHookCommand(event: string, script: 'brain-hook' | 'context-hook' = 'brain-hook'): string {
-  const scriptPath = script === 'context-hook' ? getContextHookScriptPath() : getHookScriptPath()
+function buildHookCommand(event: string, script: 'brain-hook' | 'context-hook' | 'interceptor-hook' = 'brain-hook'): string {
+  const scriptPath = script === 'context-hook'
+    ? getContextHookScriptPath()
+    : script === 'interceptor-hook'
+      ? getInterceptorHookScriptPath()
+      : getHookScriptPath()
   const port = process.env.PORT || process.env.CLAUDE_BRAIN_PORT || '3000'
 
   return `bun "${scriptPath}" --event ${event} --port ${port} # ${HOOK_MARKER}`
@@ -108,6 +117,23 @@ export function installHooks(): { installed: boolean; message: string } {
     }],
   })
 
+  // PreToolUse interceptor — blocks Glob/Grep when code index has results
+  if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = []
+  settings.hooks.PreToolUse.push({
+    matcher: 'Glob',
+    hooks: [{
+      type: 'command',
+      command: buildHookCommand('PreToolUse', 'interceptor-hook'),
+    }],
+  })
+  settings.hooks.PreToolUse.push({
+    matcher: 'Grep',
+    hooks: [{
+      type: 'command',
+      command: buildHookCommand('PreToolUse', 'interceptor-hook'),
+    }],
+  })
+
   writeSettings(settings)
 
   // Copy hook script to install location
@@ -167,6 +193,16 @@ export function uninstallHooks(): { uninstalled: boolean; message: string } {
       }
     }
 
+    // Remove our entries from PreToolUse
+    if (Array.isArray(settings.hooks.PreToolUse)) {
+      settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+        (entry: any) => !isOurHookEntry(entry)
+      )
+      if (settings.hooks.PreToolUse.length === 0) {
+        delete settings.hooks.PreToolUse
+      }
+    }
+
     // Clean up empty hooks object
     if (Object.keys(settings.hooks).length === 0) {
       delete settings.hooks
@@ -209,6 +245,7 @@ function isOurHookEntry(entry: any): boolean {
 const HOOK_FILES = [
   'brain-hook.ts',
   'context-hook.ts',
+  'interceptor-hook.ts',
   'capture.ts',
   'queue.ts',
   'types.ts',

package/src/hooks/interceptor-hook.ts

@@ -0,0 +1,200 @@
+#!/usr/bin/env bun
+/**
+ * Code Intelligence Interceptor — PreToolUse Hook
+ *
+ * Intercepts Glob and Grep calls, queries the code index,
+ * and blocks the tool when confident results exist.
+ *
+ * CRITICAL CONSTRAINTS:
+ * - Must complete in <3s (PreToolUse timeout)
+ * - Stderr = message shown to Claude when blocking
+ * - Exit 0 = allow tool, exit non-zero = block tool
+ * - NEVER write to stdout (corrupts JSON-RPC)
+ */
+
+interface HookStdin {
+  session_id: string
+  tool_name: string
+  tool_input: Record<string, any>
+  cwd?: string
+}
+
+interface SymbolResult {
+  symbol: string
+  type: string
+  filePath: string
+  lineStart: number
+  lineEnd?: number
+  signature?: string
+  confidence: number
+}
+
+async function main(): Promise<void> {
+  const rawInput = await readStdin()
+  if (!rawInput.trim()) { process.exit(0); return }
+
+  let input: HookStdin
+  try { input = JSON.parse(rawInput) }
+  catch { process.exit(0); return }
+
+  // Only intercept Glob and Grep
+  if (!['Glob', 'Grep'].includes(input.tool_name)) {
+    process.exit(0)
+    return
+  }
+
+  // Extract search intent from tool input
+  const searchTerm = extractSearchIntent(input)
+  if (!searchTerm) { process.exit(0); return }
+
+  // Detect project from cwd
+  const project = detectProject(input.cwd)
+  if (!project) { process.exit(0); return }
+
+  // Read port from --port arg or env
+  const portIdx = process.argv.indexOf('--port')
+  const portArg = portIdx >= 0 ? process.argv[portIdx + 1] : undefined
+  const port = parseInt(portArg || process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+
+  try {
+    const params = new URLSearchParams({
+      query: searchTerm,
+      project,
+      limit: '10',
+    })
+
+    const res = await fetch(
+      `http://localhost:${port}/api/code/search?${params}`,
+      { signal: AbortSignal.timeout(2000) }
+    )
+
+    if (!res.ok) { process.exit(0); return }
+
+    const data = await res.json() as { data?: SymbolResult[] }
+    const results: SymbolResult[] = Array.isArray(data.data) ? data.data : (data.data as any) || []
+
+    // Only block if we have confident results
+    if (results.length > 0 && results[0].confidence > 0.7) {
+      const message = formatResults(results, input.tool_name, searchTerm)
+      process.stderr.write(message)
+      process.exit(2) // non-zero = BLOCK
+    } else {
+      process.exit(0) // let original tool run
+    }
+  } catch {
+    // Any error = let original tool run (safe fallback)
+    process.exit(0)
+  }
+}
+
+function extractSearchIntent(input: HookStdin): string | null {
+  const toolInput = input.tool_input
+
+  if (input.tool_name === 'Glob') {
+    const pattern = toolInput.pattern || ''
+    if (isGenericGlob(pattern)) return null
+    return extractGlobKeyword(pattern)
+  }
+
+  if (input.tool_name === 'Grep') {
+    const pattern = toolInput.pattern || ''
+    if (isComplexRegex(pattern)) return null
+    return pattern
+  }
+
+  return null
+}
+
+/** Returns true for patterns like "**\/*.ts", "**\/*.js" that match too broadly */
+function isGenericGlob(pattern: string): boolean {
+  return /^\*\*\/\*\.\w+$/.test(pattern)
+}
+
+/** Extract the meaningful keyword from a glob pattern */
+function extractGlobKeyword(pattern: string): string | null {
+  const cleaned = pattern
+    .replace(/\*\*/g, '')
+    .replace(/\*/g, '')
+    .replace(/\//g, ' ')
+    .replace(/\.\w+$/g, '') // remove extension
+    .trim()
+
+  const words = cleaned.split(/\s+/).filter(w => w.length >= 3)
+  return words.length > 0 ? words.join(' ') : null
+}
+
+/** Returns true for patterns that are complex regex, not simple symbol names */
+function isComplexRegex(pattern: string): boolean {
+  // Simple word-like patterns are fine to intercept
+  if (/^\w+$/.test(pattern)) return false
+  // Patterns with regex meta-chars are complex
+  return /[\\()[\]{}|^$+?]/.test(pattern)
+}
+
+function detectProject(cwd?: string): string | null {
+  if (!cwd) return null
+  const segments = cwd.split('/').filter(Boolean)
+  return segments[segments.length - 1] || null
+}
+
+function formatResults(
+  results: SymbolResult[],
+  toolName: string,
+  searchTerm: string
+): string {
+  const lines: string[] = [
+    `Code index found ${results.length} match${results.length === 1 ? '' : 'es'} for "${searchTerm}" (skip ${toolName}, use Read directly):`,
+    '',
+  ]
+
+  for (const r of results.slice(0, 8)) {
+    const sig = r.signature ? ` ${r.signature}` : ''
+    const lineRange = r.lineEnd
+      ? `${r.lineStart}-${r.lineEnd}`
+      : `${r.lineStart}`
+    lines.push(
+      `  ${r.symbol} (${r.type})${sig} → ${r.filePath}:${lineRange}`
+    )
+  }
+
+  if (results.length > 8) {
+    lines.push(`  ... and ${results.length - 8} more`)
+  }
+
+  // Add actionable tip
+  lines.push('')
+  const top = results[0]!
+  const offset = Math.max(1, top.lineStart - 5)
+  const limit = ((top.lineEnd || top.lineStart) + 20) - top.lineStart + 10
+  lines.push(
+    `Tip: Read("${top.filePath}", offset=${offset}, limit=${limit}) for the ${top.type} body.`
+  )
+
+  return lines.join('\n')
+}
+
+/** Read all of stdin as a string */
+function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    const stdin = process.stdin
+
+    stdin.on('data', (chunk: Buffer) => chunks.push(chunk))
+    stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')))
+    stdin.on('error', reject)
+
+    // Timeout after 2 seconds
+    setTimeout(() => {
+      stdin.destroy()
+      resolve(Buffer.concat(chunks).toString('utf-8'))
+    }, 2000)
+  })
+}
+
+// Execute when run directly
+const isDirectRun = process.argv[1]?.includes('interceptor-hook')
+if (isDirectRun) {
+  main().catch(() => process.exit(0))
+}
+
+export { main }