the-campfire 0.1.0

package/server/proactive-keepalive.ts

@@ -0,0 +1,121 @@
+/**
+ * Proactive Keepalive — auto-relaunches crashed CLI sessions.
+ *
+ * When a CLI process exits unexpectedly, this module schedules a relaunch
+ * with exponential backoff. Ensures autonomous sessions (agents, cron jobs)
+ * stay alive even without a browser connected.
+ *
+ * Excludes: intentional kills, archived sessions, clean exits (code 0).
+ *
+ * Stability window: the attempt counter is only reset after the CLI has been
+ * connected for at least STABILITY_WINDOW_MS. This prevents infinite
+ * relaunch loops when a session connects briefly then crashes immediately.
+ */
+
+import type { CliLauncher } from "./cli-launcher.js";
+
+const BASE_DELAY_MS = Number(process.env.CAMPFIRE_KEEPALIVE_DELAY_MS) || 3_000;
+const MAX_ATTEMPTS = Number(process.env.CAMPFIRE_KEEPALIVE_MAX_ATTEMPTS) || 3;
+const STABILITY_WINDOW_MS = 30_000;
+
+export class ProactiveKeepalive {
+  private readonly launcher: CliLauncher;
+  private readonly timers = new Map<string, ReturnType<typeof setTimeout>>();
+  private readonly attempts = new Map<string, number>();
+  private readonly intentionalKills = new Set<string>();
+  /** Tracks when each session was last relaunched by keepalive. */
+  private readonly launchTimes = new Map<string, number>();
+  private destroyed = false;
+
+  constructor(launcher: CliLauncher) {
+    this.launcher = launcher;
+
+    // Listen for CLI process exits
+    launcher.onSessionExited((sessionId, exitCode) => {
+      this.handleExit(sessionId, exitCode);
+    });
+  }
+
+  /** Mark a session as intentionally killed (don't auto-relaunch). */
+  markIntentionalKill(sessionId: string): void {
+    this.intentionalKills.add(sessionId);
+    this.cancelTimer(sessionId);
+  }
+
+  /** Cancel a pending relaunch timer. */
+  cancelTimer(sessionId: string): void {
+    const timer = this.timers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(sessionId);
+    }
+  }
+
+  /** Stop all timers (graceful shutdown). */
+  destroy(): void {
+    this.destroyed = true;
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+    this.attempts.clear();
+    this.launchTimes.clear();
+  }
+
+  private handleExit(sessionId: string, exitCode: number | null): void {
+    if (this.destroyed) return;
+
+    // Skip intentional kills
+    if (this.intentionalKills.has(sessionId)) {
+      this.intentionalKills.delete(sessionId);
+      return;
+    }
+
+    // Skip clean exits (user typed /exit or session completed normally)
+    if (exitCode === 0) return;
+
+    // Skip archived sessions
+    const info = this.launcher.getSession(sessionId);
+    if (!info) return;
+    if (info.archived) return;
+
+    // Only reset the attempt counter if the CLI was stable for the
+    // full stability window. This prevents infinite loops when a
+    // session connects briefly then immediately crashes (e.g. missing
+    // --resume session ID or empty prompt).
+    const launchTime = this.launchTimes.get(sessionId);
+    if (launchTime && Date.now() - launchTime >= STABILITY_WINDOW_MS) {
+      this.attempts.delete(sessionId);
+    }
+
+    // Check attempt count
+    const attempt = (this.attempts.get(sessionId) || 0) + 1;
+    if (attempt > MAX_ATTEMPTS) {
+      console.warn(`[keepalive] Session ${sessionId} exceeded max relaunch attempts (${MAX_ATTEMPTS}), giving up`);
+      this.attempts.delete(sessionId);
+      this.launchTimes.delete(sessionId);
+      return;
+    }
+    this.attempts.set(sessionId, attempt);
+
+    // Exponential backoff: 3s → 6s → 12s
+    const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+    console.log(`[keepalive] Session ${sessionId} exited (code=${exitCode}), scheduling relaunch #${attempt} in ${delay}ms`);
+
+    const timer = setTimeout(async () => {
+      this.timers.delete(sessionId);
+      if (this.destroyed) return;
+      try {
+        const success = await this.launcher.relaunch(sessionId);
+        if (success) {
+          console.log(`[keepalive] Session ${sessionId} relaunched successfully (attempt #${attempt})`);
+          this.launchTimes.set(sessionId, Date.now());
+        }
+      } catch (err) {
+        console.error(`[keepalive] Failed to relaunch session ${sessionId}:`, err);
+      }
+    }, delay);
+
+    this.timers.set(sessionId, timer);
+  }
+}

package/server/prompt-manager.ts

@@ -0,0 +1,103 @@
+import {
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  existsSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+export interface Prompt {
+  id: string;
+  name: string;
+  content: string;
+  scope: "global" | "project";
+  projectPath?: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+const PROMPTS_FILE = join(homedir(), ".campfire", "prompts.json");
+
+function ensureDir(): void {
+  mkdirSync(dirname(PROMPTS_FILE), { recursive: true });
+}
+
+function loadAll(): Prompt[] {
+  try {
+    if (!existsSync(PROMPTS_FILE)) return [];
+    const raw = readFileSync(PROMPTS_FILE, "utf-8");
+    return JSON.parse(raw) as Prompt[];
+  } catch {
+    return [];
+  }
+}
+
+function saveAll(prompts: Prompt[]): void {
+  ensureDir();
+  writeFileSync(PROMPTS_FILE, JSON.stringify(prompts, null, 2), "utf-8");
+}
+
+/** Returns true if the prompt should be visible in the given cwd. */
+export function visibleForCwd(prompt: Prompt, cwd?: string): boolean {
+  if (prompt.scope === "global") return true;
+  if (!cwd || !prompt.projectPath) return false;
+  return cwd.startsWith(prompt.projectPath);
+}
+
+export function listPrompts(opts?: { cwd?: string }): Prompt[] {
+  const all = loadAll();
+  if (!opts?.cwd) return all;
+  return all.filter((p) => visibleForCwd(p, opts.cwd));
+}
+
+export function getPrompt(id: string): Prompt | undefined {
+  return loadAll().find((p) => p.id === id);
+}
+
+export function createPrompt(
+  name: string,
+  content: string,
+  scope: "global" | "project",
+  projectPath?: string,
+): Prompt {
+  const all = loadAll();
+  const prompt: Prompt = {
+    id: randomUUID(),
+    name,
+    content,
+    scope,
+    projectPath: scope === "project" ? projectPath : undefined,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+  all.push(prompt);
+  saveAll(all);
+  return prompt;
+}
+
+export function updatePrompt(
+  id: string,
+  updates: Partial<Pick<Prompt, "name" | "content" | "scope" | "projectPath">>,
+): Prompt | undefined {
+  const all = loadAll();
+  const idx = all.findIndex((p) => p.id === id);
+  if (idx === -1) return undefined;
+  all[idx] = {
+    ...all[idx],
+    ...updates,
+    updatedAt: Date.now(),
+  };
+  saveAll(all);
+  return all[idx];
+}
+
+export function deletePrompt(id: string): boolean {
+  const all = loadAll();
+  const idx = all.findIndex((p) => p.id === id);
+  if (idx === -1) return false;
+  all.splice(idx, 1);
+  saveAll(all);
+  return true;
+}

package/server/protocol-monitor.ts

@@ -0,0 +1,197 @@
+/**
+ * Protocol Monitor — real-time message tracking and health metrics.
+ *
+ * Tracks message counts, rates, errors, and protocol drift across
+ * all sessions and backends. Provides a rolling 5-minute window
+ * of statistics for the dashboard.
+ */
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface MessageEvent {
+  sessionId: string;
+  backendType: string;
+  direction: "in" | "out";
+  channel: "cli" | "browser";
+  messageType: string;
+  timestamp: number;
+}
+
+export interface DriftEvent {
+  sessionId: string;
+  backendType: string;
+  direction: "in" | "out";
+  messageType: string;
+  details: string;
+  timestamp: number;
+}
+
+export interface SessionStats {
+  sessionId: string;
+  backendType: string;
+  messageCount: number;
+  errorCount: number;
+  messagesPerMinute: number;
+  lastMessageAt: number;
+  messageTypes: Record<string, number>;
+}
+
+export interface MonitorSnapshot {
+  uptime: number;
+  totalMessages: number;
+  totalErrors: number;
+  globalMessagesPerMinute: number;
+  activeSessions: number;
+  sessionStats: SessionStats[];
+  recentDrifts: DriftEvent[];
+  messageTypeGlobal: Record<string, number>;
+  backendBreakdown: Record<string, { messages: number; errors: number }>;
+}
+
+// ─── Constants ──────────────────────────────────────────────────────────────
+
+const WINDOW_MS = 5 * 60 * 1000; // 5-minute rolling window
+const MAX_DRIFTS = 50;
+const MAX_EVENTS_PER_SESSION = 500;
+
+// ─── Monitor ────────────────────────────────────────────────────────────────
+
+export class ProtocolMonitor {
+  private readonly startedAt = Date.now();
+  private readonly sessionEvents = new Map<string, MessageEvent[]>();
+  private readonly sessionBackends = new Map<string, string>();
+  private readonly drifts: DriftEvent[] = [];
+  private readonly driftSeen = new Set<string>();
+  private totalMessages = 0;
+  private totalErrors = 0;
+
+  /** Record a message passing through the bridge. */
+  recordMessage(
+    sessionId: string,
+    direction: "in" | "out",
+    channel: "cli" | "browser",
+    messageType: string,
+    backendType?: string,
+  ): void {
+    const now = Date.now();
+    this.totalMessages++;
+
+    if (backendType) {
+      this.sessionBackends.set(sessionId, backendType);
+    }
+
+    const event: MessageEvent = {
+      sessionId,
+      backendType: backendType || this.sessionBackends.get(sessionId) || "unknown",
+      direction,
+      channel,
+      messageType,
+      timestamp: now,
+    };
+
+    let events = this.sessionEvents.get(sessionId);
+    if (!events) {
+      events = [];
+      this.sessionEvents.set(sessionId, events);
+    }
+    events.push(event);
+
+    // Cap per-session events to prevent memory bloat
+    if (events.length > MAX_EVENTS_PER_SESSION) {
+      events.splice(0, events.length - MAX_EVENTS_PER_SESSION);
+    }
+
+    // Track errors
+    if (messageType === "error" || messageType === "parse_error") {
+      this.totalErrors++;
+    }
+  }
+
+  /** Report a protocol drift (unexpected message format). */
+  reportDrift(
+    sessionId: string,
+    backendType: string,
+    direction: "in" | "out",
+    messageType: string,
+    details: string,
+  ): void {
+    const key = `${backendType}:${direction}:${messageType}`;
+    if (this.driftSeen.has(key)) return;
+    this.driftSeen.add(key);
+
+    const drift: DriftEvent = {
+      sessionId,
+      backendType,
+      direction,
+      messageType,
+      details,
+      timestamp: Date.now(),
+    };
+
+    this.drifts.push(drift);
+    if (this.drifts.length > MAX_DRIFTS) {
+      this.drifts.shift();
+    }
+
+    console.warn(`[protocol-monitor] Drift detected: ${backendType} ${direction} ${messageType} — ${details}`);
+  }
+
+  /** Get a snapshot of current metrics. */
+  getSnapshot(): MonitorSnapshot {
+    const now = Date.now();
+    const windowStart = now - WINDOW_MS;
+
+    const sessionStats: SessionStats[] = [];
+    const messageTypeGlobal: Record<string, number> = {};
+    const backendBreakdown: Record<string, { messages: number; errors: number }> = {};
+    let windowMessages = 0;
+    let activeSessions = 0;
+
+    for (const [sessionId, events] of this.sessionEvents) {
+      const recentEvents = events.filter((e) => e.timestamp >= windowStart);
+      if (recentEvents.length === 0) continue;
+
+      activeSessions++;
+      const bt = this.sessionBackends.get(sessionId) || "unknown";
+      const typeCount: Record<string, number> = {};
+      let errors = 0;
+
+      for (const e of recentEvents) {
+        typeCount[e.messageType] = (typeCount[e.messageType] || 0) + 1;
+        messageTypeGlobal[e.messageType] = (messageTypeGlobal[e.messageType] || 0) + 1;
+        if (e.messageType === "error" || e.messageType === "parse_error") errors++;
+      }
+
+      windowMessages += recentEvents.length;
+
+      if (!backendBreakdown[bt]) backendBreakdown[bt] = { messages: 0, errors: 0 };
+      backendBreakdown[bt].messages += recentEvents.length;
+      backendBreakdown[bt].errors += errors;
+
+      const elapsed = Math.max(1, (now - recentEvents[0].timestamp) / 60_000);
+      sessionStats.push({
+        sessionId,
+        backendType: bt,
+        messageCount: recentEvents.length,
+        errorCount: errors,
+        messagesPerMinute: Math.round(recentEvents.length / elapsed),
+        lastMessageAt: recentEvents.at(-1)?.timestamp ?? now,
+        messageTypes: typeCount,
+      });
+    }
+
+    sessionStats.sort((a, b) => b.lastMessageAt - a.lastMessageAt);
+
+    return {
+      uptime: now - this.startedAt,
+      totalMessages: this.totalMessages,
+      totalErrors: this.totalErrors,
+      globalMessagesPerMinute: WINDOW_MS > 0 ? Math.round((windowMessages / WINDOW_MS) * 60_000) : 0,
+      activeSessions,
+      sessionStats,
+      recentDrifts: [...this.drifts].reverse(),
+      messageTypeGlobal,
+      backendBreakdown,
+    };
+  }
+}