claude-brain 0.22.4 → 0.24.0

package/src/server/auto-updater.ts

@@ -0,0 +1,301 @@
+/**
+ * Auto-updater for claude-brain.
+ * Checks npm for new versions periodically, auto-updates with ghost process cleanup and fresh restart.
+ */
+
+import { execSync, spawn } from 'node:child_process'
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'node:fs'
+import { join, dirname, resolve } from 'node:path'
+import { homedir, platform } from 'node:os'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const PACKAGE_ROOT = resolve(__dirname, '..', '..')
+
+interface UpdateCheckResult {
+  currentVersion: string
+  latestVersion: string | null
+  updateAvailable: boolean
+  lastChecked: string
+}
+
+interface AutoUpdateConfig {
+  enabled: boolean
+  checkIntervalHours: number
+  autoRestart: boolean
+}
+
+const DEFAULT_CONFIG: AutoUpdateConfig = {
+  enabled: true,
+  checkIntervalHours: 24,
+  autoRestart: true,
+}
+
+const isWindows = platform() === 'win32'
+
+export class AutoUpdater {
+  private dataDir: string
+  private checkFile: string
+  private config: AutoUpdateConfig
+  private timer: ReturnType<typeof setInterval> | null = null
+  private logger: { info: (...args: any[]) => void; warn: (...args: any[]) => void; error: (...args: any[]) => void }
+
+  constructor(config?: Partial<AutoUpdateConfig>, logger?: any) {
+    this.config = { ...DEFAULT_CONFIG, ...config }
+    this.dataDir = join(homedir(), '.claude-brain', 'data')
+    this.checkFile = join(this.dataDir, 'update-check.json')
+    this.logger = logger ?? {
+      info: (...args: any[]) => console.error('[auto-updater] INFO:', ...args),
+      warn: (...args: any[]) => console.error('[auto-updater] WARN:', ...args),
+      error: (...args: any[]) => console.error('[auto-updater] ERROR:', ...args),
+    }
+  }
+
+  /** Check npm registry for latest version */
+  async check(): Promise<UpdateCheckResult> {
+    const currentVersion = this.getCurrentVersion()
+
+    // Return cached result if checked recently
+    if (!this.shouldCheck()) {
+      try {
+        const cached = JSON.parse(readFileSync(this.checkFile, 'utf-8')) as UpdateCheckResult
+        return { ...cached, currentVersion }
+      } catch {
+        // Corrupted cache, proceed with fresh check
+      }
+    }
+
+    let latestVersion: string | null = null
+    try {
+      const result = execSync('npm view claude-brain version', {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 15_000,
+      })
+      latestVersion = result.trim()
+    } catch {
+      this.logger.warn('Failed to check npm registry for latest version')
+    }
+
+    const updateAvailable = latestVersion !== null && latestVersion !== currentVersion
+    const checkResult: UpdateCheckResult = {
+      currentVersion,
+      latestVersion,
+      updateAvailable,
+      lastChecked: new Date().toISOString(),
+    }
+
+    // Persist check result
+    try {
+      mkdirSync(this.dataDir, { recursive: true })
+      writeFileSync(this.checkFile, JSON.stringify(checkResult, null, 2), 'utf-8')
+    } catch (err) {
+      this.logger.warn('Failed to write update check file:', err)
+    }
+
+    if (updateAvailable) {
+      this.logger.info(`Update available: v${currentVersion} -> v${latestVersion}`)
+    }
+
+    return checkResult
+  }
+
+  /** Perform the update: kill ghosts -> update package -> restart */
+  async performUpdate(targetVersion: string): Promise<boolean> {
+    try {
+      this.logger.info(`Updating claude-brain to v${targetVersion}...`)
+
+      // Kill ghost processes
+      this.killGhostProcesses()
+
+      // Wait for ports to release
+      await this.sleep(2000)
+
+      // Try bun first, fallback to npm
+      try {
+        execSync('bun install -g claude-brain@latest', {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+          timeout: 120_000,
+        })
+        this.logger.info(`Updated to v${targetVersion} via bun`)
+      } catch {
+        try {
+          execSync('npm install -g claude-brain@latest', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 120_000,
+          })
+          this.logger.info(`Updated to v${targetVersion} via npm`)
+        } catch (err) {
+          this.logger.error('Install failed with both bun and npm:', err)
+          return false
+        }
+      }
+
+      if (this.config.autoRestart) {
+        this.restartServer()
+      }
+
+      return true
+    } catch (err) {
+      this.logger.error('Update failed:', err)
+      return false
+    }
+  }
+
+  /** Schedule periodic background checks */
+  schedulePeriodicCheck(): void {
+    if (!this.config.enabled) return
+    if (this.timer) return
+
+    const intervalMs = this.config.checkIntervalHours * 3600 * 1000
+
+    this.timer = setInterval(async () => {
+      try {
+        const result = await this.check()
+        if (result.updateAvailable && result.latestVersion && this.config.enabled) {
+          await this.performUpdate(result.latestVersion)
+        }
+      } catch (err) {
+        this.logger.error('Periodic update check failed:', err)
+      }
+    }, intervalMs)
+
+    // Don't keep the process alive just for the update timer
+    if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {
+      this.timer.unref()
+    }
+
+    this.logger.info(`Scheduled update checks every ${this.config.checkIntervalHours}h`)
+  }
+
+  /** Stop periodic checks */
+  stopPeriodicCheck(): void {
+    if (this.timer) {
+      clearInterval(this.timer)
+      this.timer = null
+    }
+  }
+
+  /** Check if enough time has passed since last check */
+  private shouldCheck(): boolean {
+    if (!existsSync(this.checkFile)) return true
+
+    try {
+      const data = JSON.parse(readFileSync(this.checkFile, 'utf-8')) as UpdateCheckResult
+      if (!data.lastChecked) return true
+
+      const lastChecked = new Date(data.lastChecked).getTime()
+      const intervalMs = this.config.checkIntervalHours * 3600 * 1000
+      return Date.now() - lastChecked >= intervalMs
+    } catch {
+      return true
+    }
+  }
+
+  /** Kill all ghost claude-brain processes */
+  private killGhostProcesses(): void {
+    const myPid = process.pid
+
+    // Kill by pattern
+    try {
+      if (isWindows) {
+        const result = execSync(
+          `wmic process where "commandline like '%claude-brain%' and processid != ${myPid}" get processid /format:list`,
+          { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 }
+        )
+        const pids = result.match(/ProcessId=(\d+)/g)?.map(m => m.split('=')[1]) || []
+        for (const pid of pids) {
+          try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'pipe', timeout: 5000 }) } catch {}
+        }
+      } else {
+        const result = execSync(`pgrep -f "claude-brain"`, {
+          encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+        })
+        const pids = result.trim().split('\n').filter(p => p && Number(p) !== myPid)
+        for (const pid of pids) {
+          try { process.kill(Number(pid), 'SIGKILL') } catch {}
+        }
+      }
+    } catch {
+      // No matching processes — that's fine
+    }
+
+    // Kill by port 3000
+    try {
+      if (isWindows) {
+        const result = execSync(`netstat -ano | findstr :3000 | findstr LISTENING`, {
+          encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+        })
+        const pids = new Set(
+          result.split('\n')
+            .map(line => line.trim().split(/\s+/).pop())
+            .filter(p => p && Number(p) !== myPid)
+        )
+        for (const pid of pids) {
+          try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'pipe', timeout: 5000 }) } catch {}
+        }
+      } else {
+        const raw = execSync(`lsof -ti :3000`, {
+          encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+        }).trim()
+        if (raw) {
+          const pids = raw.split('\n').filter(p => p && Number(p) !== myPid)
+          for (const pid of pids) {
+            try { process.kill(Number(pid), 'SIGKILL') } catch {}
+          }
+        }
+      }
+    } catch {
+      // No process on port — that's fine
+    }
+
+    // Clean up stale PID files
+    const pidPath = join(this.dataDir, 'server.pid')
+    if (existsSync(pidPath)) {
+      try {
+        const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10)
+        if (!isNaN(pid) && pid !== myPid) {
+          try { process.kill(pid, 0) } catch {
+            // Process not running, remove stale PID file
+            try { unlinkSync(pidPath) } catch {}
+          }
+        }
+      } catch {}
+    }
+  }
+
+  /** Spawn a fresh server instance and exit current */
+  private restartServer(): void {
+    this.logger.info('Restarting server with updated version...')
+
+    const child = spawn('claude-brain', ['serve'], {
+      detached: true,
+      stdio: 'ignore',
+    })
+
+    child.unref()
+
+    this.logger.info(`Spawned new server process (PID: ${child.pid}). Exiting current process.`)
+    process.exit(0)
+  }
+
+  /** Get current installed version from package.json */
+  private getCurrentVersion(): string {
+    try {
+      // Use the version from the package that's actually running
+      const pkgPath = join(PACKAGE_ROOT, 'package.json')
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
+        return pkg.version || 'unknown'
+      }
+    } catch {}
+    return 'unknown'
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+}

package/src/server/http-api.ts

@@ -1065,8 +1065,17 @@ export class HttpApiServer {
         port,
         url: `http://localhost:${port}`,
       }, 'HTTP API server started successfully')
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to start HTTP API server')
+    } catch (error: any) {
+      const code = error?.code || error?.message || ''
+      if (String(code).includes('EADDRINUSE') || String(error?.message).includes('EADDRINUSE')) {
+        this.logger.error(
+          { port },
+          `Port ${port} is already in use. Another claude-brain instance may be running. ` +
+          `Kill existing instances with: pkill -f "claude-brain serve"`
+        )
+      } else {
+        this.logger.error({ error }, 'Failed to start HTTP API server')
+      }
       throw error
     }
   }

package/src/server/pid-manager.ts

@@ -0,0 +1,64 @@
+/**
+ * PID file manager for the Claude Brain server.
+ * Ensures only one server instance runs at a time.
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+import { getHomePaths } from '@/config/home'
+
+const PID_FILENAME = 'server.pid'
+
+export class ServerPidManager {
+  private pidFilePath: string
+
+  constructor() {
+    const paths = getHomePaths()
+    this.pidFilePath = join(paths.data, PID_FILENAME)
+  }
+
+  /** Check if another server instance is already running. Returns the PID if alive, null otherwise. */
+  getRunningPid(): number | null {
+    if (!existsSync(this.pidFilePath)) return null
+
+    try {
+      const pid = parseInt(readFileSync(this.pidFilePath, 'utf-8').trim(), 10)
+      if (isNaN(pid)) {
+        this.cleanup()
+        return null
+      }
+      // Signal 0 tests if process exists without killing it
+      process.kill(pid, 0)
+      return pid
+    } catch {
+      // Process not running, clean up stale PID file
+      this.cleanup()
+      return null
+    }
+  }
+
+  /** Write the current process PID to the PID file. */
+  writePidFile(): void {
+    writeFileSync(this.pidFilePath, String(process.pid), 'utf-8')
+  }
+
+  /** Remove the PID file. Safe to call multiple times. */
+  cleanup(): void {
+    try {
+      unlinkSync(this.pidFilePath)
+    } catch {
+      // Already removed or doesn't exist
+    }
+  }
+
+  /** Register cleanup handlers on SIGINT, SIGTERM, and process exit. */
+  registerCleanupHandlers(): void {
+    const doCleanup = () => {
+      this.cleanup()
+    }
+
+    process.on('exit', doCleanup)
+    process.on('SIGINT', doCleanup)
+    process.on('SIGTERM', doCleanup)
+  }
+}