claude-brain 0.30.2 → 0.30.3

package/src/server/middleware/rate-limit.ts

@@ -0,0 +1,53 @@
+import type { Context, Next } from 'hono'
+
+interface RateLimitEntry {
+  count: number
+  resetAt: number
+}
+
+/**
+ * Simple in-memory rate limiter.
+ */
+export function rateLimit(options: {
+  windowMs?: number
+  max?: number
+} = {}) {
+  const windowMs = options.windowMs || 60_000
+  const max = options.max || 100
+  const clients = new Map<string, RateLimitEntry>()
+
+  // Cleanup old entries periodically
+  const cleanup = setInterval(() => {
+    const now = Date.now()
+    for (const [key, entry] of clients) {
+      if (entry.resetAt <= now) clients.delete(key)
+    }
+  }, windowMs)
+  cleanup.unref()
+
+  return async (c: Context, next: Next) => {
+    const clientId = c.req.header('X-Forwarded-For')
+      || c.req.header('X-Real-IP')
+      || 'localhost'
+
+    const now = Date.now()
+    let entry = clients.get(clientId)
+
+    if (!entry || entry.resetAt <= now) {
+      entry = { count: 0, resetAt: now + windowMs }
+      clients.set(clientId, entry)
+    }
+
+    entry.count++
+
+    c.header('X-RateLimit-Limit', max.toString())
+    c.header('X-RateLimit-Remaining', Math.max(0, max - entry.count).toString())
+    c.header('X-RateLimit-Reset', Math.ceil(entry.resetAt / 1000).toString())
+
+    if (entry.count > max) {
+      return c.json({ error: 'Too many requests' }, 429)
+    }
+
+    await next()
+  }
+}

package/src/server/middleware/validate.ts

@@ -0,0 +1,42 @@
+/**
+ * Request Validation Middleware
+ * Phase 1: Security Hardening
+ */
+
+import { z } from 'zod'
+import type { Context } from 'hono'
+
+/**
+ * Validate request body against a Zod schema.
+ * Returns parsed data or sends 400 response.
+ */
+export async function validateBody<T extends z.ZodType>(
+  c: Context,
+  schema: T
+): Promise<z.infer<T> | null> {
+  try {
+    const body = await c.req.json()
+    const result = schema.safeParse(body)
+    if (!result.success) {
+      return null
+    }
+    return result.data
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Validate query parameters against a Zod schema.
+ */
+export function validateQuery<T extends z.ZodType>(
+  c: Context,
+  schema: T
+): z.infer<T> | null {
+  const params = Object.fromEntries(new URL(c.req.url).searchParams)
+  const result = schema.safeParse(params)
+  if (!result.success) {
+    return null
+  }
+  return result.data
+}

package/src/server/pid-manager.ts

@@ -1,136 +1,137 @@
-/**
- * PID file manager for the Claude Brain server.
- * Ensures only one server instance runs at a time.
- * Tracks daemon port and activity for idle watchdog.
- */
-
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs'
-import { execSync } from 'node:child_process'
-import { join } from 'node:path'
-import { getHomePaths } from '@/config/home'
-
-const PID_FILENAME = 'server.pid'
-
-interface PidFileContent {
-  pid: number
-  port: number
-}
-
-export class ServerPidManager {
-  private pidFilePath: string
-  private lastActivityTs: number = Date.now()
-
-  constructor() {
-    const paths = getHomePaths()
-    this.pidFilePath = join(paths.data, PID_FILENAME)
-  }
-
-  /** Record activity — call on every HTTP request or MCP tool call */
-  touchActivity(): void {
-    this.lastActivityTs = Date.now()
-  }
-
-  /** Milliseconds since last activity */
-  getIdleMs(): number {
-    return Date.now() - this.lastActivityTs
-  }
-
-  /**
-   * Get running daemon instance info (PID + port).
-   * Returns null if no daemon is running.
-   * Backward-compatible with old plain-number PID files.
-   */
-  getRunningInstance(): { pid: number; port: number } | null {
-    if (!existsSync(this.pidFilePath)) return null
-
-    try {
-      const raw = readFileSync(this.pidFilePath, 'utf-8').trim()
-
-      let pid: number
-      let port: number
-
-      // Try JSON format first (new)
-      if (raw.startsWith('{')) {
-        const parsed: PidFileContent = JSON.parse(raw)
-        pid = parsed.pid
-        port = parsed.port
-      } else {
-        // Backward compat: old plain-number format
-        pid = parseInt(raw, 10)
-        port = 3000 // default port assumption for old format
-      }
-
-      if (isNaN(pid)) {
-        this.cleanup()
-        return null
-      }
-
-      // Signal 0 tests if process exists without killing it
-      try {
-        process.kill(pid, 0)
-      } catch (signalError: any) {
-        // On Windows, process.kill(pid, 0) can throw unexpected errors
-        // Fall back to tasklist to verify the PID exists
-        if (process.platform === 'win32' && signalError?.code !== 'ESRCH') {
-          try {
-            const result = execSync(`tasklist /FI "PID eq ${pid}" /NH`, {
-              encoding: 'utf-8', stdio: 'pipe', timeout: 3000,
-            })
-            if (!result.includes(String(pid))) {
-              this.cleanup()
-              return null
-            }
-          } catch {
-            this.cleanup()
-            return null
-          }
-        } else {
-          this.cleanup()
-          return null
-        }
-      }
-      return { pid, port }
-    } catch {
-      // Invalid file format, clean up stale PID file
-      this.cleanup()
-      return null
-    }
-  }
-
-  /** Check if another server instance is already running. Returns the PID if alive, null otherwise. */
-  getRunningPid(): number | null {
-    return this.getRunningInstance()?.pid ?? null
-  }
-
-  /** Write the current process PID and port to the PID file. */
-  writePidFile(port?: number): void {
-    const content: PidFileContent = {
-      pid: process.pid,
-      port: port ?? 3000,
-    }
-    writeFileSync(this.pidFilePath, JSON.stringify(content), '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, SIGHUP (non-Windows), and process exit. */
-  registerCleanupHandlers(): void {
-    const doCleanup = () => {
-      this.cleanup()
-    }
-
-    process.on('exit', doCleanup)
-    process.on('SIGINT', doCleanup)
-    process.on('SIGTERM', doCleanup)
-    if (process.platform !== 'win32') {
-      process.on('SIGHUP', doCleanup)
-    }
-  }
-}
+/**
+ * PID file manager for the Claude Brain server.
+ * Ensures only one server instance runs at a time.
+ * Tracks daemon port and activity for idle watchdog.
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import { join } from 'node:path'
+import { getHomePaths } from '@/config/home'
+
+const PID_FILENAME = 'server.pid'
+
+interface PidFileContent {
+  pid: number
+  port: number
+}
+
+export class ServerPidManager {
+  private pidFilePath: string
+  private lastActivityTs: number = Date.now()
+
+  constructor() {
+    const paths = getHomePaths()
+    this.pidFilePath = join(paths.data, PID_FILENAME)
+  }
+
+  /** Record activity — call on every HTTP request or MCP tool call */
+  touchActivity(): void {
+    this.lastActivityTs = Date.now()
+  }
+
+  /** Milliseconds since last activity */
+  getIdleMs(): number {
+    return Date.now() - this.lastActivityTs
+  }
+
+  /**
+   * Get running daemon instance info (PID + port).
+   * Returns null if no daemon is running.
+   * Backward-compatible with old plain-number PID files.
+   */
+  getRunningInstance(): { pid: number; port: number } | null {
+    if (!existsSync(this.pidFilePath)) return null
+
+    try {
+      const raw = readFileSync(this.pidFilePath, 'utf-8').trim()
+
+      let pid: number
+      let port: number
+
+      // Try JSON format first (new)
+      if (raw.startsWith('{')) {
+        const parsed: PidFileContent = JSON.parse(raw)
+        pid = parsed.pid
+        port = parsed.port
+      } else {
+        // Backward compat: old plain-number format
+        pid = parseInt(raw, 10)
+        port = 3000 // default port assumption for old format
+      }
+
+      if (isNaN(pid)) {
+        this.cleanup()
+        return null
+      }
+
+      // Signal 0 tests if process exists without killing it
+      try {
+        process.kill(pid, 0)
+      } catch (signalError: unknown) {
+        // On Windows, process.kill(pid, 0) can throw unexpected errors
+        // Fall back to tasklist to verify the PID exists
+        if (process.platform === 'win32' && (signalError as Record<string, unknown>)?.code !== 'ESRCH') {
+          try {
+            const result = spawnSync('tasklist', ['/FI', `PID eq ${pid}`, '/NH'], {
+              encoding: 'utf-8', stdio: 'pipe', timeout: 3000,
+            })
+            const output = result.stdout || ''
+            if (!output.includes(String(pid))) {
+              this.cleanup()
+              return null
+            }
+          } catch {
+            this.cleanup()
+            return null
+          }
+        } else {
+          this.cleanup()
+          return null
+        }
+      }
+      return { pid, port }
+    } catch {
+      // Invalid file format, clean up stale PID file
+      this.cleanup()
+      return null
+    }
+  }
+
+  /** Check if another server instance is already running. Returns the PID if alive, null otherwise. */
+  getRunningPid(): number | null {
+    return this.getRunningInstance()?.pid ?? null
+  }
+
+  /** Write the current process PID and port to the PID file. */
+  writePidFile(port?: number): void {
+    const content: PidFileContent = {
+      pid: process.pid,
+      port: port ?? 3000,
+    }
+    writeFileSync(this.pidFilePath, JSON.stringify(content), '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, SIGHUP (non-Windows), and process exit. */
+  registerCleanupHandlers(): void {
+    const doCleanup = () => {
+      this.cleanup()
+    }
+
+    process.on('exit', doCleanup)
+    process.on('SIGINT', doCleanup)
+    process.on('SIGTERM', doCleanup)
+    if (process.platform !== 'win32') {
+      process.on('SIGHUP', doCleanup)
+    }
+  }
+}