claude-brain 0.24.0 → 0.24.2

package/VERSION

@@ -1 +1 @@
-0.24.0
+0.24.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "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 {
@@ -41,6 +46,37 @@ export async function runServe() {
     console.error(`[claude-brain] Hook auto-install skipped: ${error instanceof Error ? error.message : 'unknown error'}`)
   }
 
+  // Auto-install shell auto-start if not already present (handles bun blocking postinstall)
+  try {
+    const { isAutoStartInstalled, installAutoStart } = await import('@/cli/auto-start')
+    if (!isAutoStartInstalled()) {
+      const result = installAutoStart()
+      if (result.success && result.profilePath) {
+        console.error(`[claude-brain] Auto-start installed in ${result.profilePath}`)
+      }
+    }
+  } catch (error) {
+    // Non-fatal — auto-start is a convenience feature
+  }
+
+  // Auto-install CLAUDE.md if not present (handles bun blocking postinstall)
+  try {
+    const { existsSync, readFileSync, writeFileSync, mkdirSync } = await import('node:fs')
+    const { join, resolve, dirname } = await import('node:path')
+    const { homedir } = await import('node:os')
+    const { fileURLToPath } = await import('node:url')
+    const claudeMdDest = join(homedir(), '.claude', 'CLAUDE.md')
+    const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..')
+    const claudeMdSrc = join(pkgRoot, 'assets', 'CLAUDE.md')
+    if (existsSync(claudeMdSrc) && !existsSync(claudeMdDest)) {
+      mkdirSync(join(homedir(), '.claude'), { recursive: true })
+      writeFileSync(claudeMdDest, readFileSync(claudeMdSrc, 'utf-8'), 'utf-8')
+      console.error('[claude-brain] CLAUDE.md installed to ~/.claude/CLAUDE.md')
+    }
+  } catch {
+    // Non-fatal
+  }
+
   const config = await loadConfig()
 
   if (config.logLevel === 'debug' || config.logLevel === 'info') {
@@ -131,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()) {
+    // Phase 30: Optional LLM compression
+    if (config.compression?.enabled) {
       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')
+        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 activity log pruning')
+        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...')
@@ -276,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')
+  }
 }