the-campfire 0.1.0

package/server/sub-session-manager.ts

@@ -0,0 +1,263 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import type { CliLauncher } from "./cli-launcher.js";
+import type { WsBridge } from "./ws-bridge.js";
+import type { BackendType, BrowserIncomingMessage, CLIResultMessage, SubAgentUpdate } from "./session-types.js";
+import { generateSessionTitle } from "./auto-namer.js";
+import * as sessionNames from "./session-names.js";
+
+export interface SubSessionOptions {
+  timeoutMs?: number;
+  toolUseId?: string;
+  name?: string;
+  description?: string;
+  model?: string;
+  permissionMode?: string;
+}
+
+export interface SubSessionResult {
+  sessionId: string;
+  backendType: BackendType;
+  text: string;
+  filesChanged: string[];
+  costUsd: number;
+  durationMs: number;
+  error?: string;
+}
+
+const DEFAULT_TIMEOUT_MS = 300_000;
+const POLL_MS = 500;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function gitLines(args: string[], cwd: string): string[] {
+  try {
+    const out = execFileSync("git", args, { cwd, encoding: "utf-8", timeout: 10_000, stdio: ["ignore", "pipe", "ignore"] });
+    return out.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export function getChangedFiles(cwd: string): string[] {
+  const names = new Set<string>();
+  for (const file of gitLines(["diff", "--name-only"], cwd)) names.add(file);
+  for (const file of gitLines(["diff", "--name-only", "--cached"], cwd)) names.add(file);
+  for (const line of gitLines(["ls-files", "--others", "--exclude-standard"], cwd)) names.add(line);
+  return Array.from(names).sort();
+}
+
+function textFromContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => {
+      if (!block || typeof block !== "object") return "";
+      const typed = block as { type?: string; text?: string; content?: unknown };
+      if (typed.type === "text" && typeof typed.text === "string") return typed.text;
+      if (typed.type === "tool_result") return textFromContent(typed.content);
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function extractAssistantText(messages: BrowserIncomingMessage[]): string {
+  const chunks: string[] = [];
+  for (const msg of messages) {
+    if (msg.type !== "assistant") continue;
+    const text = textFromContent(msg.message.content);
+    if (text) chunks.push(text);
+  }
+  return chunks.join("\n\n").trim();
+}
+
+function findResult(messages: BrowserIncomingMessage[], afterIndex: number): CLIResultMessage | null {
+  for (const msg of messages.slice(afterIndex)) {
+    if (msg.type === "result") return msg.data;
+  }
+  return null;
+}
+
+function inheritedEnv(env: Record<string, string> | undefined): Record<string, string> | undefined {
+  if (!env || Object.keys(env).length === 0) return undefined;
+  return { ...env };
+}
+
+export class SubSessionManager {
+  private readonly childrenByParent = new Map<string, Set<string>>();
+
+  constructor(
+    private readonly launcher: CliLauncher,
+    private readonly wsBridge: WsBridge,
+  ) {}
+
+  getChildSessions(parentSessionId: string): string[] {
+    return Array.from(this.childrenByParent.get(parentSessionId) ?? []);
+  }
+
+  async spawnSubSession(
+    parentSessionId: string,
+    backendType: BackendType,
+    prompt: string,
+    cwd: string,
+    opts: SubSessionOptions = {},
+  ): Promise<SubSessionResult> {
+    const startedAt = Date.now();
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const toolUseId = opts.toolUseId ?? `subagent-${randomUUID()}`;
+    const name = opts.name ?? `Ask ${backendType}`;
+    const description = opts.description ?? prompt.slice(0, 160);
+
+    const runningUpdate: SubAgentUpdate = {
+      parentSessionId,
+      toolUseId,
+      backendType,
+      name,
+      description,
+      status: "running",
+      startedAt,
+    };
+    this.wsBridge.broadcastSubAgentUpdate(parentSessionId, runningUpdate);
+
+    const parentSession = this.launcher.getSession(parentSessionId);
+    const info = this.launcher.launch({
+      cwd,
+      backendType,
+      model: opts.model,
+      permissionMode: opts.permissionMode ?? "bypassPermissions",
+      env: inheritedEnv(parentSession?.sessionEnv),
+      parentSessionId,
+      orchestrationRole: "subagent",
+    });
+    this.wsBridge.markSessionOrchestration(info.sessionId, {
+      parentSessionId,
+      role: "subagent",
+      detectedEnvironment: info.detectedEnvironment,
+    });
+    this.trackChild(parentSessionId, info.sessionId);
+
+    this.wsBridge.broadcastSubAgentUpdate(parentSessionId, {
+      ...runningUpdate,
+      sessionId: info.sessionId,
+    });
+
+    let error: string | undefined;
+    try {
+      await this.waitForConnection(info.sessionId, Math.min(15_000, timeoutMs));
+      const session = this.wsBridge.getSession(info.sessionId);
+      const startIndex = session?.messageHistory.length ?? 0;
+      this.wsBridge.injectUserMessage(info.sessionId, prompt);
+
+      const result = await this.waitForResult(info.sessionId, startIndex, timeoutMs - (Date.now() - startedAt));
+      if (result.is_error) {
+        error = result.errors?.join("\n") || result.result || "Sub-agent returned an error result.";
+      }
+
+      const resultSession = this.wsBridge.getSession(info.sessionId);
+      const messages = resultSession?.messageHistory ?? [];
+      const text = extractAssistantText(messages) || result.result || "";
+      const filesChanged = getChangedFiles(cwd);
+      const costUsd = result.total_cost_usd || resultSession?.state.total_cost_usd || 0;
+      const durationMs = Date.now() - startedAt;
+      if (costUsd > 0) this.wsBridge.addSubAgentCost(parentSessionId, costUsd);
+
+      const finalResult: SubSessionResult = {
+        sessionId: info.sessionId,
+        backendType,
+        text,
+        filesChanged,
+        costUsd,
+        durationMs,
+        error,
+      };
+      const completedUpdate: SubAgentUpdate = {
+        ...runningUpdate,
+        sessionId: info.sessionId,
+        status: error ? "failed" : "completed",
+        completedAt: Date.now(),
+        costUsd,
+        durationMs,
+        filesChanged,
+        summary: text.slice(0, 500),
+        error,
+      };
+      this.wsBridge.broadcastSubAgentUpdate(parentSessionId, completedUpdate);
+      void this.applyGeneratedSubAgentName(parentSessionId, info.sessionId, completedUpdate, prompt, opts.model ?? backendType);
+      return finalResult;
+    } catch (err) {
+      const isTimeout = err instanceof Error && err.message.includes("Timed out");
+      error = err instanceof Error ? err.message : String(err);
+      this.wsBridge.broadcastSubAgentUpdate(parentSessionId, {
+        ...runningUpdate,
+        sessionId: info.sessionId,
+        status: isTimeout ? "timeout" : "failed",
+        completedAt: Date.now(),
+        durationMs: Date.now() - startedAt,
+        filesChanged: getChangedFiles(cwd),
+        error,
+      });
+      return {
+        sessionId: info.sessionId,
+        backendType,
+        text: "",
+        filesChanged: getChangedFiles(cwd),
+        costUsd: 0,
+        durationMs: Date.now() - startedAt,
+        error,
+      };
+    } finally {
+      await this.launcher.kill(info.sessionId).catch(() => false);
+      this.launcher.markSessionExited(info.sessionId, error ? 1 : 0);
+    }
+  }
+
+  private trackChild(parentSessionId: string, childSessionId: string): void {
+    let children = this.childrenByParent.get(parentSessionId);
+    if (!children) {
+      children = new Set();
+      this.childrenByParent.set(parentSessionId, children);
+    }
+    children.add(childSessionId);
+  }
+
+  private async applyGeneratedSubAgentName(
+    parentSessionId: string,
+    childSessionId: string,
+    completedUpdate: SubAgentUpdate,
+    prompt: string,
+    model: string,
+  ): Promise<void> {
+    const existing = sessionNames.getName(childSessionId);
+    const title = existing ?? await generateSessionTitle(prompt, model, { timeoutMs: 15_000 });
+    if (!title) return;
+    if (!existing) sessionNames.setName(childSessionId, title);
+    this.wsBridge.broadcastNameUpdate(childSessionId, title);
+    this.wsBridge.broadcastSubAgentUpdate(parentSessionId, {
+      ...completedUpdate,
+      name: title,
+    });
+  }
+
+  private async waitForConnection(sessionId: string, timeoutMs: number): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (this.wsBridge.isCliConnected(sessionId)) return;
+      await sleep(POLL_MS);
+    }
+    throw new Error(`Timed out waiting for sub-session ${sessionId} to connect.`);
+  }
+
+  private async waitForResult(sessionId: string, startIndex: number, timeoutMs: number): Promise<CLIResultMessage> {
+    const deadline = Date.now() + Math.max(timeoutMs, 1);
+    while (Date.now() < deadline) {
+      const session = this.wsBridge.getSession(sessionId);
+      const result = session ? findResult(session.messageHistory as BrowserIncomingMessage[], startIndex) : null;
+      if (result) return result;
+      await sleep(POLL_MS);
+    }
+    throw new Error(`Timed out waiting for sub-session ${sessionId} to finish.`);
+  }
+}

package/server/terminal-manager.ts

@@ -0,0 +1,185 @@
+import type { ServerWebSocket } from "bun";
+import { existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import type { SocketData } from "./ws-bridge.js";
+
+/** Bun's PTY terminal handle exposed on proc when spawned with `terminal` option */
+interface BunTerminalHandle {
+  write(data: string): void;
+  resize(cols: number, rows: number): void;
+  close(): void;
+}
+
+interface TerminalInstance {
+  id: string;
+  cwd: string;
+  proc: ReturnType<typeof Bun.spawn>;
+  terminal: BunTerminalHandle;
+  browserSockets: Set<ServerWebSocket<SocketData>>;
+  cols: number;
+  rows: number;
+  orphanTimer: ReturnType<typeof setTimeout> | null;
+}
+
+function resolveShell(): string {
+  if (process.env.SHELL && existsSync(process.env.SHELL)) return process.env.SHELL;
+  if (existsSync("/bin/bash")) return "/bin/bash";
+  return "/bin/sh";
+}
+
+export class TerminalManager {
+  private instance: TerminalInstance | null = null;
+
+  /** Spawn a new global terminal in the given directory */
+  spawn(cwd: string, cols = 80, rows = 24): string {
+    // Kill existing instance if any
+    if (this.instance) {
+      this.kill();
+    }
+
+    const id = randomUUID();
+    const shell = resolveShell();
+    const sockets = new Set<ServerWebSocket<SocketData>>();
+
+    const proc = Bun.spawn([shell, "-l"], {
+      cwd,
+      env: { ...process.env, TERM: "xterm-256color", CLAUDECODE: undefined },
+      terminal: {
+        cols,
+        rows,
+        data: (_terminal, data) => {
+          // Broadcast raw PTY output as binary to all connected browsers
+          for (const ws of sockets) {
+            try {
+              ws.sendBinary(data);
+            } catch {
+              // socket may have closed
+            }
+          }
+        },
+        exit: () => {
+          // PTY stream closed — get exit code from proc
+          const inst = this.instance;
+          if (inst && inst.id === id) {
+            const exitMsg = JSON.stringify({ type: "exit", exitCode: proc.exitCode ?? 0 });
+            for (const ws of inst.browserSockets) {
+              try {
+                ws.send(exitMsg);
+              } catch {
+                // socket may have closed
+              }
+            }
+          }
+        },
+      },
+    });
+
+    // Extract the terminal handle from the proc — Bun attaches it when spawned with `terminal` option
+    const terminal = (proc as any).terminal as BunTerminalHandle;
+    this.instance = { id, cwd, proc, terminal, browserSockets: sockets, cols, rows, orphanTimer: null };
+    console.log(`[terminal] Spawned terminal ${id} in ${cwd} (${shell}, ${cols}x${rows})`);
+
+    // Handle process exit
+    proc.exited.then((exitCode) => {
+      if (this.instance?.id === id) {
+        console.log(`[terminal] Terminal ${id} exited with code ${exitCode}`);
+      }
+    });
+
+    return id;
+  }
+
+  /** Handle a message from a browser WebSocket */
+  handleBrowserMessage(_ws: ServerWebSocket<SocketData>, msg: string | Buffer): void {
+    if (!this.instance) return;
+    try {
+      const str = typeof msg === "string" ? msg : msg.toString();
+      const parsed = JSON.parse(str);
+      if (parsed.type === "input" && typeof parsed.data === "string") {
+        this.instance.terminal.write(parsed.data);
+      } else if (parsed.type === "resize" && typeof parsed.cols === "number" && typeof parsed.rows === "number") {
+        this.resize(parsed.cols, parsed.rows);
+      }
+    } catch {
+      // Malformed message, ignore
+    }
+  }
+
+  /** Resize the PTY */
+  resize(cols: number, rows: number): void {
+    if (!this.instance) return;
+    this.instance.cols = cols;
+    this.instance.rows = rows;
+    try {
+      this.instance.terminal.resize(cols, rows);
+    } catch {
+      // resize not available or failed
+    }
+  }
+
+  /** Kill the terminal process and clean up */
+  kill(): void {
+    if (!this.instance) return;
+    const inst = this.instance;
+    this.instance = null;
+
+    if (inst.orphanTimer) {
+      clearTimeout(inst.orphanTimer);
+    }
+
+    try {
+      inst.proc.kill();
+    } catch {
+      // process may have already exited
+    }
+
+    // SIGKILL fallback if SIGTERM doesn't work within 2 seconds
+    const pid = inst.proc.pid;
+    setTimeout(() => {
+      try {
+        process.kill(pid, 0); // check if still alive
+        inst.proc.kill(9); // SIGKILL
+      } catch {
+        // already dead, good
+      }
+    }, 2_000);
+
+    console.log(`[terminal] Killed terminal ${inst.id}`);
+  }
+
+  /** Get current terminal info */
+  getInfo(): { id: string; cwd: string } | null {
+    if (!this.instance) return null;
+    return { id: this.instance.id, cwd: this.instance.cwd };
+  }
+
+  /** Attach a browser WebSocket to the terminal */
+  addBrowserSocket(ws: ServerWebSocket<SocketData>): void {
+    if (!this.instance) return;
+
+    // Cancel orphan kill timer if any
+    if (this.instance.orphanTimer) {
+      clearTimeout(this.instance.orphanTimer);
+      this.instance.orphanTimer = null;
+    }
+
+    this.instance.browserSockets.add(ws);
+  }
+
+  /** Remove a browser WebSocket from the terminal */
+  removeBrowserSocket(ws: ServerWebSocket<SocketData>): void {
+    if (!this.instance) return;
+    this.instance.browserSockets.delete(ws);
+
+    // If no browsers remain, start a grace timer to kill the orphaned terminal
+    if (this.instance.browserSockets.size === 0) {
+      const id = this.instance.id;
+      this.instance.orphanTimer = setTimeout(() => {
+        if (this.instance?.id === id && this.instance.browserSockets.size === 0) {
+          console.log(`[terminal] No browsers connected, killing orphaned terminal ${id}`);
+          this.kill();
+        }
+      }, 5_000);
+    }
+  }
+}

package/server/update-checker.ts

@@ -0,0 +1,114 @@
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Read current version from package.json
+const packageJsonPath = resolve(__dirname, "..", "package.json");
+const currentVersion: string = JSON.parse(
+  readFileSync(packageJsonPath, "utf-8"),
+).version;
+
+const NPM_REGISTRY_URL = "https://registry.npmjs.org/the-campfire/latest";
+const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const INITIAL_DELAY_MS = 10_000; // 10 seconds after boot
+
+interface UpdateState {
+  currentVersion: string;
+  latestVersion: string | null;
+  lastChecked: number;
+  isServiceMode: boolean;
+  checking: boolean;
+  updateInProgress: boolean;
+}
+
+const state: UpdateState = {
+  currentVersion,
+  latestVersion: null,
+  lastChecked: 0,
+  isServiceMode: false,
+  checking: false,
+  updateInProgress: false,
+};
+
+export function getUpdateState(): Readonly<UpdateState> {
+  return { ...state };
+}
+
+export function getCurrentVersion(): string {
+  return currentVersion;
+}
+
+export async function checkForUpdate(): Promise<void> {
+  if (state.checking) return;
+  state.checking = true;
+  try {
+    const res = await fetch(NPM_REGISTRY_URL, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (res.ok) {
+      const data = (await res.json()) as { version: string };
+      state.latestVersion = data.version;
+      state.lastChecked = Date.now();
+      if (isUpdateAvailable()) {
+        console.log(
+          `[update-checker] Update available: ${currentVersion} -> ${state.latestVersion}`,
+        );
+      }
+    }
+  } catch (err) {
+    console.warn(
+      "[update-checker] Failed to check for updates:",
+      err instanceof Error ? err.message : String(err),
+    );
+  } finally {
+    state.checking = false;
+  }
+}
+
+export function setServiceMode(isService: boolean): void {
+  state.isServiceMode = isService;
+}
+
+export function setUpdateInProgress(inProgress: boolean): void {
+  state.updateInProgress = inProgress;
+}
+
+export function isUpdateAvailable(): boolean {
+  if (!state.latestVersion) return false;
+  return isNewerVersion(state.latestVersion, currentVersion);
+}
+
+/** Simple semver comparison: returns true if a > b */
+export function isNewerVersion(a: string, b: string): boolean {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return true;
+    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+  }
+  return false;
+}
+
+let intervalId: ReturnType<typeof setInterval> | null = null;
+
+export function startPeriodicCheck(): void {
+  // Initial check after a short delay
+  setTimeout(() => {
+    checkForUpdate();
+  }, INITIAL_DELAY_MS);
+
+  // Periodic checks
+  intervalId = setInterval(() => {
+    checkForUpdate();
+  }, CHECK_INTERVAL_MS);
+}
+
+export function stopPeriodicCheck(): void {
+  if (intervalId) {
+    clearInterval(intervalId);
+    intervalId = null;
+  }
+}