ai-agent-session-center 2.0.2 → 2.0.3

package/server/mqReader.ts

@@ -0,0 +1,349 @@
+// mqReader.ts — File-based JSONL message queue reader
+// Hooks append JSON lines to a queue file; this module watches it and processes events.
+//
+// Performance: fs.watch() for instant notification + 500ms fallback poll.
+// Atomicity: POSIX guarantees atomic append for writes <= PIPE_BUF (4096 bytes).
+// Our enriched hook JSON is typically 300-800 bytes.
+
+import {
+  existsSync, mkdirSync, writeFileSync,
+  openSync, readSync, closeSync, fstatSync, watch,
+} from 'fs';
+import type { FSWatcher } from 'fs';
+import { join } from 'path';
+import { processHookEvent } from './hookProcessor.js';
+import log from './logger.js';
+
+// Use /tmp on macOS/Linux (matches the hardcoded path in dashboard-hook.sh).
+// os.tmpdir() on macOS returns /var/folders/... which hooks can't predict.
+// On Windows, hooks use $env:TEMP which matches os.tmpdir().
+const QUEUE_DIR = process.platform === 'win32'
+  ? join(process.env.TEMP || process.env.TMP || 'C:\\Temp', 'claude-session-center')
+  : '/tmp/claude-session-center';
+const QUEUE_FILE = join(QUEUE_DIR, 'queue.jsonl');
+const POLL_INTERVAL_MS = 500;
+const DEBOUNCE_MS = 10;
+const TRUNCATE_THRESHOLD = 1 * 1024 * 1024; // 1 MB
+
+// Internal state
+let watcher: FSWatcher | null = null;
+let pollTimer: ReturnType<typeof setInterval> | null = null;
+let healthCheckTimer: ReturnType<typeof setInterval> | null = null;
+let lastByteOffset = 0;
+let partialLine = '';
+let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+let running = false;
+let lastWatchEventAt = 0;
+let lastKnownFileSize = 0;
+const HEALTH_CHECK_INTERVAL_MS = 5000;
+
+// Stats
+const mqStats = {
+  linesProcessed: 0,
+  linesErrored: 0,
+  truncations: 0,
+  lastProcessedAt: null as number | null,
+  startedAt: null as number | null,
+};
+
+interface MqReaderOptions {
+  resumeOffset?: number;
+}
+
+/**
+ * Start the MQ reader. Called once from server startup.
+ * Creates queue directory/file and begins watching.
+ */
+export function startMqReader(options?: MqReaderOptions): void {
+  if (running) return;
+  running = true;
+  mqStats.startedAt = Date.now();
+
+  // Ensure queue directory exists
+  mkdirSync(QUEUE_DIR, { recursive: true });
+
+  // Create queue file if it doesn't exist (but don't truncate existing)
+  if (!existsSync(QUEUE_FILE)) {
+    writeFileSync(QUEUE_FILE, '');
+  }
+
+  // Resume from snapshot offset or start from current EOF
+  if (options?.resumeOffset != null && options.resumeOffset >= 0) {
+    // Clamp to file size in case file was truncated externally
+    try {
+      const fd = openSync(QUEUE_FILE, 'r');
+      const stat = fstatSync(fd);
+      closeSync(fd);
+      lastByteOffset = Math.min(options.resumeOffset, stat.size);
+    } catch {
+      lastByteOffset = 0;
+    }
+    log.info('mq', `Resuming from offset ${lastByteOffset} (snapshot)`);
+  } else {
+    // No snapshot — skip existing data (already stale), start from EOF
+    try {
+      const fd = openSync(QUEUE_FILE, 'r');
+      const stat = fstatSync(fd);
+      closeSync(fd);
+      lastByteOffset = stat.size;
+    } catch {
+      lastByteOffset = 0;
+    }
+  }
+  partialLine = '';
+
+  // Initialize lastKnownFileSize so the health check doesn't false-alarm
+  // on the first tick (file already has data from before the reader started).
+  try {
+    const initFd = openSync(QUEUE_FILE, 'r');
+    lastKnownFileSize = fstatSync(initFd).size;
+    closeSync(initFd);
+  } catch {
+    lastKnownFileSize = 0;
+  }
+
+  log.info('mq', `Queue reader started: ${QUEUE_FILE}`);
+
+  // Do an immediate read to process any events written while the server was down
+  readNewLines();
+
+  // Start fs.watch for instant notification
+  try {
+    watcher = watch(QUEUE_FILE, (eventType) => {
+      if (eventType === 'change') {
+        lastWatchEventAt = Date.now();
+        scheduleRead();
+      }
+    });
+    watcher.on('error', (err: Error) => {
+      log.warn('mq', `fs.watch error: ${err.message}, relying on poll`);
+      watcher = null;
+    });
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.warn('mq', `fs.watch failed: ${msg}, using poll only`);
+  }
+
+  // Fallback poll (catches events fs.watch may miss)
+  pollTimer = setInterval(() => {
+    readNewLines();
+  }, POLL_INTERVAL_MS);
+
+  // Health check: detect when fs.watch silently stops delivering events
+  // If no watch events for HEALTH_CHECK_INTERVAL_MS but the file has grown, trigger a manual read
+  lastWatchEventAt = Date.now();
+  healthCheckTimer = setInterval(() => {
+    if (!watcher) return; // Already relying on poll only
+    try {
+      const fd = openSync(QUEUE_FILE, 'r');
+      const stat = fstatSync(fd);
+      closeSync(fd);
+      const currentSize = stat.size;
+      const timeSinceWatch = Date.now() - lastWatchEventAt;
+      if (timeSinceWatch > HEALTH_CHECK_INTERVAL_MS && currentSize > lastKnownFileSize) {
+        log.warn('mq', `fs.watch stale (${Math.round(timeSinceWatch / 1000)}s silent, file grew ${currentSize - lastKnownFileSize} bytes), triggering manual read`);
+        readNewLines();
+      }
+      lastKnownFileSize = currentSize;
+    } catch {
+      // File may not exist yet, ignore
+    }
+  }, HEALTH_CHECK_INTERVAL_MS);
+}
+
+/** Debounced read scheduler — coalesces rapid fs.watch events */
+function scheduleRead(): void {
+  if (debounceTimer) return;
+  debounceTimer = setTimeout(() => {
+    debounceTimer = null;
+    readNewLines();
+  }, DEBOUNCE_MS);
+}
+
+/**
+ * Core read loop: reads from lastByteOffset to current EOF,
+ * processes complete JSON lines, retains any partial trailing line.
+ */
+function readNewLines(): void {
+  let fd: number | undefined;
+  try {
+    fd = openSync(QUEUE_FILE, 'r');
+    const fileStat = fstatSync(fd);
+    const fileSize = fileStat.size;
+
+    // File was truncated externally or is smaller than our offset
+    if (fileSize < lastByteOffset) {
+      log.info('mq', 'Detected external truncation, resetting offset');
+      lastByteOffset = 0;
+      partialLine = '';
+    }
+
+    if (fileSize <= lastByteOffset) {
+      closeSync(fd);
+      return;
+    }
+
+    // Read the new chunk
+    const bytesToRead = fileSize - lastByteOffset;
+    const buffer = Buffer.alloc(bytesToRead);
+    const bytesRead = readSync(fd, buffer, 0, bytesToRead, lastByteOffset);
+    closeSync(fd);
+    fd = undefined;
+
+    if (bytesRead === 0) return;
+
+    const chunk = buffer.toString('utf-8', 0, bytesRead);
+    const combined = partialLine + chunk;
+    const lines = combined.split('\n');
+
+    // Last element is either '' (if chunk ended with \n) or a partial line
+    partialLine = lines.pop() || '';
+
+    // Process each complete line
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      try {
+        const hookData = JSON.parse(trimmed);
+        processHookEvent(hookData, 'mq');
+        mqStats.linesProcessed++;
+      } catch (err: unknown) {
+        mqStats.linesErrored++;
+        const msg = err instanceof Error ? err.message : String(err);
+        log.warn('mq', `Parse error: ${msg} — line: ${trimmed.substring(0, 100)}`);
+      }
+    }
+
+    // Update offset: advance by bytes consumed (exclude held-back partial)
+    const partialBytes = Buffer.byteLength(partialLine, 'utf-8');
+    lastByteOffset = lastByteOffset + bytesRead - partialBytes;
+    mqStats.lastProcessedAt = Date.now();
+
+    // Truncate if file grew too large and we've fully caught up
+    if (lastByteOffset > TRUNCATE_THRESHOLD && partialLine === '') {
+      truncateQueue();
+    }
+  } catch (err: unknown) {
+    if (fd != null) {
+      try { closeSync(fd); } catch { /* ignore */ }
+    }
+    const e = err as NodeJS.ErrnoException;
+    if (e.code !== 'ENOENT') {
+      log.warn('mq', `Read error: ${e.message}`);
+    } else {
+      // Queue file deleted — recreate it
+      try { writeFileSync(QUEUE_FILE, ''); } catch { /* ignore */ }
+      lastByteOffset = 0;
+      partialLine = '';
+    }
+  }
+}
+
+/** Truncate the queue file after all lines have been processed.
+ *  Checks if file grew since our last read to avoid losing events
+ *  written between the read and truncation.
+ */
+function truncateQueue(): void {
+  let fd: number | undefined;
+  try {
+    fd = openSync(QUEUE_FILE, 'r+');
+    const stat = fstatSync(fd);
+    // If file grew since our last read, read the new data first
+    if (stat.size > lastByteOffset) {
+      const newBytes = stat.size - lastByteOffset;
+      const buffer = Buffer.alloc(newBytes);
+      const bytesRead = readSync(fd, buffer, 0, newBytes, lastByteOffset);
+      if (bytesRead > 0) {
+        const chunk = buffer.toString('utf-8', 0, bytesRead);
+        const combined = partialLine + chunk;
+        const lines = combined.split('\n');
+        partialLine = lines.pop() || '';
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const hookData = JSON.parse(trimmed);
+            processHookEvent(hookData, 'mq');
+            mqStats.linesProcessed++;
+          } catch (err: unknown) {
+            mqStats.linesErrored++;
+            const msg = err instanceof Error ? err.message : String(err);
+            log.warn('mq', `Parse error during truncation: ${msg}`);
+          }
+        }
+      }
+    }
+    // Now truncate — write remaining partial line (if any) to start of file
+    closeSync(fd);
+    fd = undefined;
+    writeFileSync(QUEUE_FILE, partialLine);
+    lastByteOffset = Buffer.byteLength(partialLine, 'utf-8');
+    partialLine = '';
+    mqStats.truncations++;
+    log.info('mq', 'Queue file truncated (all events processed)');
+  } catch (err: unknown) {
+    if (fd != null) {
+      try { closeSync(fd); } catch { /* ignore */ }
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    log.warn('mq', `Truncation error: ${msg}`);
+  }
+}
+
+/** Stop the MQ reader. Called during server shutdown. */
+export function stopMqReader(): void {
+  running = false;
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+  }
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+  if (healthCheckTimer) {
+    clearInterval(healthCheckTimer);
+    healthCheckTimer = null;
+  }
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  }
+  // Final read to flush remaining lines
+  readNewLines();
+  log.info('mq', `Queue reader stopped. Processed: ${mqStats.linesProcessed}, Errors: ${mqStats.linesErrored}`);
+}
+
+export interface MqStatsResult {
+  linesProcessed: number;
+  linesErrored: number;
+  truncations: number;
+  lastProcessedAt: number | null;
+  startedAt: number | null;
+  queueFile: string;
+  running: boolean;
+  currentOffset: number;
+  hasPartialLine: boolean;
+}
+
+/** Get MQ reader stats for the API. */
+export function getMqStats(): MqStatsResult {
+  return {
+    ...mqStats,
+    queueFile: QUEUE_FILE,
+    running,
+    currentOffset: lastByteOffset,
+    hasPartialLine: partialLine.length > 0,
+  };
+}
+
+/** Get the current byte offset (used by snapshot persistence). */
+export function getMqOffset(): number {
+  return lastByteOffset;
+}
+
+/** Get the queue file path (used by install-hooks logging). */
+export function getQueueFilePath(): string {
+  return QUEUE_FILE;
+}

package/server/portManager.ts

@@ -0,0 +1,55 @@
+/**
+ * @module portManager
+ * Resolves the server listen port (--port flag > PORT env > config > 3333) and provides
+ * killPortProcess() to detect and terminate processes occupying the target port via lsof/netstat.
+ */
+import { execSync } from 'child_process';
+import type { ServerConfig } from '../src/types/settings.js';
+
+/**
+ * Resolve which port to listen on.
+ * Priority: --port flag > PORT env > config file > 3333
+ */
+export function resolvePort(cliArgs: string[], config: ServerConfig): number {
+  const portArgIdx = cliArgs.indexOf('--port');
+  if (portArgIdx >= 0 && cliArgs[portArgIdx + 1]) {
+    const p = parseInt(cliArgs[portArgIdx + 1], 10);
+    if (p > 0) return p;
+  }
+  if (process.env.PORT) {
+    const p = parseInt(process.env.PORT, 10);
+    if (p > 0) return p;
+  }
+  return config.port || 3333;
+}
+
+/**
+ * Kill any process currently occupying the given port.
+ */
+export function killPortProcess(port: number): void {
+  try {
+    if (process.platform === 'win32') {
+      const output = execSync(
+        `netstat -ano | findstr :${port} | findstr LISTENING`,
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+      );
+      const pids = [...new Set(
+        output.trim().split('\n')
+          .map(line => line.trim().split(/\s+/).pop())
+          .filter(Boolean)
+      )];
+      for (const pid of pids) {
+        try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'pipe' }); } catch { /* already dead */ }
+      }
+    } else {
+      // macOS & Linux
+      const output = execSync(`lsof -ti:${port}`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+      const pids = output.trim().split('\n').filter(Boolean);
+      for (const pid of pids) {
+        try { process.kill(Number(pid), 'SIGTERM'); } catch { /* already dead */ }
+      }
+    }
+  } catch {
+    // No process found on port — nothing to kill
+  }
+}

package/server/processMonitor.ts

@@ -0,0 +1,239 @@
+/**
+ * @module processMonitor
+ * Periodically checks whether session PIDs are still alive via process.kill(pid, 0).
+ * Auto-ends sessions whose processes have died (e.g., terminal closed abruptly).
+ * Also provides findClaudeProcess() with cached PID, pgrep, and lsof fallbacks.
+ */
+import { execSync } from 'child_process';
+import { getTerminalForSession } from './sshManager.js';
+import { SESSION_STATUS, ANIMATION_STATE, WS_TYPES } from './constants.js';
+import { PROCESS_CHECK_INTERVAL } from './config.js';
+import log from './logger.js';
+import type { Session } from '../src/types/session.js';
+import type { ServerMessage } from '../src/types/websocket.js';
+
+// Validate PID as a positive integer. Returns the validated number or null.
+function validatePid(pid: unknown): number | null {
+  const n = parseInt(String(pid), 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+let livenessInterval: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Start the process liveness monitor.
+ * Periodically checks if session PIDs are still alive and auto-ends dead sessions.
+ */
+export function startMonitoring(
+  sessions: Map<string, Session>,
+  pidToSession: Map<number, string>,
+  clearApprovalTimerFn: (sessionId: string, session: Session) => void,
+  handleTeamMemberEndFn: (sessionId: string) => void,
+  broadcastFn: (data: ServerMessage) => Promise<void>,
+): void {
+  if (livenessInterval) return;
+
+  livenessInterval = setInterval(async () => {
+    for (const [id, session] of sessions) {
+      if (session.status === SESSION_STATUS.ENDED) continue;
+      if (!session.cachedPid) continue;
+      const monitorPid = validatePid(session.cachedPid);
+      if (!monitorPid) {
+        session.cachedPid = null;
+        continue;
+      }
+
+      // Skip sessions with active terminal — the PTY is the source of truth
+      if (session.terminalId && getTerminalForSession(id)) continue;
+
+      try {
+        process.kill(monitorPid, 0); // signal 0 = liveness check, doesn't kill
+      } catch {
+        // Process is dead — auto-end this session
+        log.info('session', `processMonitor: pid=${session.cachedPid} is dead -> ending session=${id.slice(0, 8)}`);
+
+        session.status = SESSION_STATUS.ENDED;
+        session.animationState = ANIMATION_STATE.DEATH;
+        session.lastActivityAt = Date.now();
+        session.endedAt = Date.now();
+
+        session.events.push({
+          type: 'SessionEnd',
+          timestamp: Date.now(),
+          detail: 'Session ended (process exited)',
+        });
+        if (session.events.length > 50) session.events.shift();
+
+        // Release PID cache
+        pidToSession.delete(session.cachedPid);
+        session.cachedPid = null;
+
+        // Clear any pending tool timer
+        clearApprovalTimerFn(id, session);
+
+        // Team cleanup
+        handleTeamMemberEndFn(id);
+
+        // Broadcast to connected browsers
+        try {
+          await broadcastFn({ type: WS_TYPES.SESSION_UPDATE, session: { ...session } });
+        } catch (e: unknown) {
+          log.warn('session', `processMonitor broadcast failed: ${(e as Error).message}`);
+        }
+
+        // SSH sessions: keep in memory as historical (disconnected), preserve terminal ref for resume
+        if (session.source === 'ssh') {
+          session.isHistorical = true;
+          session.lastTerminalId = session.terminalId;
+          session.terminalId = null;
+        } else {
+          setTimeout(() => sessions.delete(id), 10000);
+        }
+      }
+    }
+  }, PROCESS_CHECK_INTERVAL);
+}
+
+/**
+ * Stop the process liveness monitor.
+ */
+export function stopMonitoring(): void {
+  if (livenessInterval) {
+    clearInterval(livenessInterval);
+    livenessInterval = null;
+  }
+}
+
+/**
+ * Find the Claude process PID for a given session.
+ * Uses cached PID first, then falls back to pgrep/lsof.
+ */
+export function findClaudeProcess(
+  sessionId: string,
+  projectPath: string,
+  sessions: Map<string, Session>,
+  pidToSession: Map<number, string>,
+): number | null {
+  const session = sessionId ? sessions.get(sessionId) : null;
+  if (session?.cachedPid) {
+    const validCachedPid = validatePid(session.cachedPid);
+    if (validCachedPid) {
+      try {
+        process.kill(validCachedPid, 0); // signal 0 = liveness check
+        log.debug('findProcess', `session=${sessionId?.slice(0, 8)} -> cached pid=${validCachedPid}`);
+        return validCachedPid;
+      } catch {
+        log.debug('findProcess', `session=${sessionId?.slice(0, 8)} cached pid=${validCachedPid} is dead, re-scanning`);
+        pidToSession.delete(validCachedPid);
+        session.cachedPid = null;
+      }
+    } else {
+      session.cachedPid = null;
+    }
+  }
+
+  const myPid = process.pid;
+  log.debug('findProcess', `session=${sessionId?.slice(0, 8)} projectPath=${projectPath}`);
+
+  const claimedPids = new Set<number>();
+  for (const [pid, sid] of pidToSession) {
+    if (sid !== sessionId) claimedPids.add(pid);
+  }
+  if (claimedPids.size > 0) {
+    log.debug('findProcess', `PIDs claimed by other sessions: [${[...claimedPids].join(', ')}]`);
+  }
+
+  try {
+    if (process.platform === 'win32') {
+      if (!projectPath) return null;
+      const psScript = `
+        $procs = Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like '*claude*' -and $_.ProcessId -ne ${myPid} }
+        foreach ($p in $procs) {
+          try {
+            $proc = Get-Process -Id $p.ProcessId -ErrorAction Stop
+            if ($proc.Path) {
+              $cwd = (Get-Process -Id $p.ProcessId).Path | Split-Path
+            }
+          } catch {}
+        }
+        if ($procs.Count -gt 0) { $procs[0].ProcessId }
+      `;
+      const out = execSync(
+        `powershell -NoProfile -Command "${psScript.replace(/"/g, '\\"')}"`,
+        { encoding: 'utf-8', timeout: 5000 }
+      );
+      const pid = validatePid(out.trim());
+      if (pid) cachePid(pid, sessionId, session, pidToSession);
+      return pid || null;
+    } else {
+      const pidsOut = execSync(`pgrep -f claude 2>/dev/null || true`, { encoding: 'utf-8', timeout: 5000 });
+      const pids = pidsOut.trim().split('\n')
+        .map(p => validatePid(p.trim()))
+        .filter((p): p is number => p !== null && p !== myPid);
+
+      log.debug('findProcess', `pgrep found ${pids.length} claude pids: [${pids.join(', ')}]`);
+
+      if (pids.length === 0) return null;
+
+      if (projectPath) {
+        for (const pid of pids) {
+          if (claimedPids.has(pid)) {
+            log.debug('findProcess', `pid=${pid} SKIP (claimed by session ${pidToSession.get(pid)?.slice(0, 8)})`);
+            continue;
+          }
+          try {
+            let cwd: string;
+            if (process.platform === 'darwin') {
+              const out = execSync(`lsof -a -d cwd -Fn -p ${pid} 2>/dev/null | grep '^n'`, { encoding: 'utf-8', timeout: 3000 });
+              cwd = out.trim().replace(/^n/, '');
+            } else {
+              cwd = execSync(`readlink /proc/${pid}/cwd 2>/dev/null`, { encoding: 'utf-8', timeout: 3000 }).trim();
+            }
+            const match = cwd === projectPath;
+            log.debug('findProcess', `pid=${pid} cwd="${cwd}" ${match ? 'MATCH' : 'no match'}`);
+            if (match) {
+              cachePid(pid, sessionId, session, pidToSession);
+              return pid;
+            }
+          } catch (e: unknown) {
+            log.debug('findProcess', `pid=${pid} cwd lookup failed: ${(e as Error).message?.split('\n')[0]}`);
+            continue;
+          }
+        }
+        log.debug('findProcess', `no cwd match found, trying tty fallback`);
+      }
+
+      for (const pid of pids) {
+        if (claimedPids.has(pid)) continue;
+        try {
+          const tty = execSync(`ps -o tty= -p ${pid}`, { encoding: 'utf-8', timeout: 3000 }).trim();
+          log.debug('findProcess', `fallback pid=${pid} tty=${tty || 'NONE'}`);
+          if (tty && tty !== '??' && tty !== '?') {
+            log.debug('findProcess', `FALLBACK returning pid=${pid} (first unclaimed with tty)`);
+            cachePid(pid, sessionId, session, pidToSession);
+            return pid;
+          }
+        } catch { continue; }
+      }
+
+      const unclaimed = pids.find(p => !claimedPids.has(p));
+      log.debug('findProcess', `last resort returning pid=${unclaimed || 'null'}`);
+      if (unclaimed) cachePid(unclaimed, sessionId, session, pidToSession);
+      return unclaimed || null;
+    }
+  } catch (e: unknown) {
+    log.error('findProcess', `ERROR: ${(e as Error).message}`);
+  }
+  return null;
+}
+
+function cachePid(
+  pid: number,
+  sessionId: string,
+  session: Session | null | undefined,
+  pidToSession: Map<number, string>,
+): void {
+  pidToSession.set(pid, sessionId);
+  if (session) session.cachedPid = pid;
+  log.debug('findProcess', `CACHED pid=${pid} -> session=${sessionId?.slice(0, 8)}`);
+}

package/server/serverConfig.ts

@@ -0,0 +1,29 @@
+// serverConfig.ts — Loads user config from data/server-config.json
+// Falls back to defaults if file is missing (first run without wizard)
+
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import type { ServerConfig } from '../src/types/settings.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CONFIG_PATH = join(__dirname, '..', 'data', 'server-config.json');
+
+const DEFAULTS: ServerConfig = {
+  port: 3333,
+  hookDensity: 'medium',
+  debug: false,
+  processCheckInterval: 15000,
+  sessionHistoryHours: 24,
+  enabledClis: ['claude'],
+  passwordHash: null,
+};
+
+let userConfig: Partial<ServerConfig> = {};
+try {
+  userConfig = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+} catch {
+  // No config file yet — use defaults
+}
+
+export const config: ServerConfig = { ...DEFAULTS, ...userConfig };