claude-brain 0.30.2 → 0.30.3

package/src/server/auto-updater.ts

@@ -1,276 +1,283 @@
-/**
- * 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'
-import { killProcessOnPort } from '@/utils/kill-port'
-
-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 using shared utility
-    killProcessOnPort(3000, myPid)
-
-    // 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))
-  }
-}
+/**
+ * Auto-updater for claude-brain.
+ * Checks npm for new versions periodically, auto-updates with ghost process cleanup and fresh restart.
+ */
+
+import { spawnSync, 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'
+import { killProcessOnPort } from '@/utils/kill-port'
+
+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: unknown[]) => void; warn: (...args: unknown[]) => void; error: (...args: unknown[]) => void }
+
+  constructor(config?: Partial<AutoUpdateConfig>, logger?: { info: (...args: unknown[]) => void; warn: (...args: unknown[]) => void; error: (...args: unknown[]) => void }) {
+    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: unknown[]) => console.error('[auto-updater] INFO:', ...args),
+      warn: (...args: unknown[]) => console.error('[auto-updater] WARN:', ...args),
+      error: (...args: unknown[]) => 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 = spawnSync('npm', ['view', 'claude-brain', 'version'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 15_000,
+      })
+      if (result.error || result.status !== 0) {
+        this.logger.warn('Failed to check npm registry for latest version')
+      } else {
+        latestVersion = result.stdout?.trim() || null
+      }
+    } 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
+      const bunResult = spawnSync('bun', ['install', '-g', 'claude-brain@latest'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 120_000,
+      })
+      if (!bunResult.error && bunResult.status === 0) {
+        this.logger.info(`Updated to v${targetVersion} via bun`)
+      } else {
+        const npmResult = spawnSync('npm', ['install', '-g', 'claude-brain@latest'], {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+          timeout: 120_000,
+        })
+        if (!npmResult.error && npmResult.status === 0) {
+          this.logger.info(`Updated to v${targetVersion} via npm`)
+        } else {
+          this.logger.error('Install failed with both bun and npm:', npmResult.stderr || npmResult.error)
+          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 = spawnSync('wmic', [
+          'process', 'where',
+          `commandline like '%claude-brain%' and processid != ${myPid}`,
+          'get', 'processid', '/format:list',
+        ], { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 })
+        const output = result.stdout || ''
+        const pids = output.match(/ProcessId=(\d+)/g)?.map(m => m.split('=')[1]) || []
+        for (const pid of pids) {
+          try { spawnSync('taskkill', ['/F', '/PID', pid!], { stdio: 'pipe', timeout: 5000 }) } catch {}
+        }
+      } else {
+        const result = spawnSync('pgrep', ['-f', 'claude-brain'], {
+          encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+        })
+        const output = result.stdout?.trim() || ''
+        const pids = output.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 using shared utility
+    killProcessOnPort(3000, myPid)
+
+    // 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))
+  }
+}