the-campfire 0.1.0

package/server/orchestrator-executor.ts

@@ -0,0 +1,184 @@
+/**
+ * OrchestratorExecutor — Runs pipelines by sequentially creating sessions for each stage.
+ *
+ * Each stage:
+ * 1. Creates a new session via the REST API internal helper
+ * 2. Sends the stage prompt (optionally with previous stage context)
+ * 3. Waits for the session to complete (polls status)
+ * 4. Records the result and moves to the next stage
+ */
+
+import { randomUUID } from "node:crypto";
+import type { Pipeline, PipelineRun, StageResult } from "./orchestrator-types.js";
+import { saveRun } from "./orchestrator-store.js";
+
+interface SessionCreateFn {
+  (opts: {
+    cwd: string;
+    backend: string;
+    model?: string;
+    permissionMode?: string;
+    prompt?: string;
+  }): Promise<{ sessionId: string } | null>;
+}
+
+interface SessionStatusFn {
+  (sessionId: string): { status: string; cost?: number; lastMessage?: string } | null;
+}
+
+// Active runs so we can cancel them
+const activeRuns = new Map<string, { cancelled: boolean }>();
+
+export function cancelRun(runId: string): boolean {
+  const run = activeRuns.get(runId);
+  if (run) {
+    run.cancelled = true;
+    return true;
+  }
+  return false;
+}
+
+export function isRunActive(runId: string): boolean {
+  return activeRuns.has(runId);
+}
+
+export async function executePipeline(
+  pipeline: Pipeline,
+  createSession: SessionCreateFn,
+  getSessionStatus: SessionStatusFn,
+): Promise<PipelineRun> {
+  const runId = randomUUID();
+  const run: PipelineRun = {
+    id: runId,
+    pipelineId: pipeline.id,
+    pipelineName: pipeline.name,
+    cwd: pipeline.cwd,
+    status: "running",
+    stageResults: pipeline.stages.map((s) => ({
+      stageId: s.id,
+      status: "pending",
+    })),
+    startedAt: Date.now(),
+    totalCostUsd: 0,
+    totalDurationMs: 0,
+  };
+
+  const control = { cancelled: false };
+  activeRuns.set(runId, control);
+  saveRun(run);
+
+  let previousOutput = "";
+
+  for (let i = 0; i < pipeline.stages.length; i++) {
+    if (control.cancelled) {
+      // Mark remaining stages as skipped
+      for (let j = i; j < pipeline.stages.length; j++) {
+        run.stageResults[j].status = "skipped";
+      }
+      run.status = "cancelled";
+      break;
+    }
+
+    const stage = pipeline.stages[i];
+    const result = run.stageResults[i];
+    result.status = "running";
+    result.startedAt = Date.now();
+    saveRun(run);
+
+    try {
+      // Build the prompt, optionally including previous stage output
+      let fullPrompt = stage.prompt;
+      if (stage.inheritContext && previousOutput) {
+        fullPrompt = `Context from previous stage:\n\n${previousOutput}\n\n---\n\n${stage.prompt}`;
+      }
+
+      // Create a session for this stage
+      const session = await createSession({
+        cwd: pipeline.cwd,
+        backend: stage.backend,
+        model: stage.model,
+        permissionMode: stage.permissionMode || "bypassPermissions",
+        prompt: fullPrompt,
+      });
+
+      if (!session) {
+        result.status = "failed";
+        result.error = "Failed to create session";
+        result.completedAt = Date.now();
+        result.durationMs = result.completedAt - (result.startedAt || result.completedAt);
+        run.status = "failed";
+        saveRun(run);
+        break;
+      }
+
+      result.sessionId = session.sessionId;
+      saveRun(run);
+
+      // Poll for session completion (max 30 minutes per stage)
+      const maxWait = 30 * 60 * 1000;
+      const pollInterval = 3000;
+      const deadline = Date.now() + maxWait;
+
+      while (Date.now() < deadline && !control.cancelled) {
+        await sleep(pollInterval);
+
+        const status = getSessionStatus(session.sessionId);
+        if (!status) continue;
+
+        if (status.status === "idle" || status.status === "completed") {
+          result.status = "completed";
+          result.costUsd = status.cost || 0;
+          result.outputSummary = status.lastMessage?.slice(0, 500) || "";
+          previousOutput = result.outputSummary;
+          break;
+        }
+
+        if (status.status === "error" || status.status === "failed") {
+          result.status = "failed";
+          result.error = status.lastMessage || "Session failed";
+          break;
+        }
+      }
+
+      if (result.status === "running") {
+        // Timed out or cancelled
+        result.status = control.cancelled ? "skipped" : "failed";
+        result.error = control.cancelled ? "Cancelled" : "Timed out (30 min)";
+      }
+    } catch (err) {
+      result.status = "failed";
+      result.error = err instanceof Error ? err.message : String(err);
+    }
+
+    result.completedAt = Date.now();
+    result.durationMs = result.completedAt - (result.startedAt || result.completedAt);
+    run.totalCostUsd += result.costUsd || 0;
+
+    if (result.status === "failed") {
+      // Mark remaining stages as skipped
+      for (let j = i + 1; j < pipeline.stages.length; j++) {
+        run.stageResults[j].status = "skipped";
+      }
+      run.status = "failed";
+      saveRun(run);
+      break;
+    }
+
+    saveRun(run);
+  }
+
+  if (run.status === "running") {
+    run.status = "completed";
+  }
+
+  run.completedAt = Date.now();
+  run.totalDurationMs = run.completedAt - run.startedAt;
+  activeRuns.delete(runId);
+  saveRun(run);
+
+  return run;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/server/orchestrator-store.ts

@@ -0,0 +1,106 @@
+/**
+ * OrchestratorStore — File-based persistence for pipelines and runs.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { Pipeline, PipelineRun } from "./orchestrator-types.js";
+
+const STORE_DIR = join(homedir(), ".campfire", "orchestrator");
+const PIPELINES_DIR = join(STORE_DIR, "pipelines");
+const RUNS_DIR = join(STORE_DIR, "runs");
+
+function ensureDirs(): void {
+  mkdirSync(PIPELINES_DIR, { recursive: true });
+  mkdirSync(RUNS_DIR, { recursive: true });
+}
+
+// ─── Pipelines ─────────────────────────────────────────────────────────────
+
+export function listPipelines(): Pipeline[] {
+  ensureDirs();
+  try {
+    const files = readdirSync(PIPELINES_DIR).filter((f) => f.endsWith(".json"));
+    return files
+      .map((f) => {
+        try {
+          return JSON.parse(readFileSync(join(PIPELINES_DIR, f), "utf-8")) as Pipeline;
+        } catch {
+          return null;
+        }
+      })
+      .filter((p): p is Pipeline => p !== null)
+      .sort((a, b) => b.updatedAt - a.updatedAt);
+  } catch {
+    return [];
+  }
+}
+
+export function getPipeline(id: string): Pipeline | null {
+  ensureDirs();
+  try {
+    return JSON.parse(readFileSync(join(PIPELINES_DIR, `${id}.json`), "utf-8")) as Pipeline;
+  } catch {
+    return null;
+  }
+}
+
+export function savePipeline(pipeline: Pipeline): void {
+  ensureDirs();
+  writeFileSync(join(PIPELINES_DIR, `${pipeline.id}.json`), JSON.stringify(pipeline, null, 2));
+}
+
+export function deletePipeline(id: string): boolean {
+  try {
+    unlinkSync(join(PIPELINES_DIR, `${id}.json`));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Runs ──────────────────────────────────────────────────────────────────
+
+export function listRuns(pipelineId?: string): PipelineRun[] {
+  ensureDirs();
+  try {
+    const files = readdirSync(RUNS_DIR).filter((f) => f.endsWith(".json"));
+    return files
+      .map((f) => {
+        try {
+          return JSON.parse(readFileSync(join(RUNS_DIR, f), "utf-8")) as PipelineRun;
+        } catch {
+          return null;
+        }
+      })
+      .filter((r): r is PipelineRun => r !== null)
+      .filter((r) => !pipelineId || r.pipelineId === pipelineId)
+      .sort((a, b) => b.startedAt - a.startedAt);
+  } catch {
+    return [];
+  }
+}
+
+export function getRun(id: string): PipelineRun | null {
+  ensureDirs();
+  try {
+    return JSON.parse(readFileSync(join(RUNS_DIR, `${id}.json`), "utf-8")) as PipelineRun;
+  } catch {
+    return null;
+  }
+}
+
+export function saveRun(run: PipelineRun): void {
+  ensureDirs();
+  writeFileSync(join(RUNS_DIR, `${run.id}.json`), JSON.stringify(run, null, 2));
+}
+
+export function deleteRun(id: string): boolean {
+  try {
+    unlinkSync(join(RUNS_DIR, `${id}.json`));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/server/orchestrator-types.ts

@@ -0,0 +1,86 @@
+/**
+ * Orchestrator Types — Multi-stage pipeline engine for chaining AI sessions.
+ *
+ * A Pipeline defines an ordered sequence of Stages (e.g., implement → test → review).
+ * Each stage spawns a child session and passes context from the previous stage.
+ */
+
+export interface PipelineStage {
+  /** Unique stage ID (uuid) */
+  id: string;
+  /** Display name, e.g. "Implement feature" */
+  name: string;
+  /** Prompt to send to the agent for this stage */
+  prompt: string;
+  /** Backend to use: "claude" | "codex" | "goose" | "aider" */
+  backend: string;
+  /** Model override (optional) */
+  model?: string;
+  /** Permission mode for this stage */
+  permissionMode?: string;
+  /** Whether to pass the previous stage's output as context */
+  inheritContext?: boolean;
+}
+
+export interface Pipeline {
+  /** Unique pipeline ID (uuid) */
+  id: string;
+  /** Display name */
+  name: string;
+  /** Description of what this pipeline does */
+  description?: string;
+  /** Working directory */
+  cwd: string;
+  /** Ordered list of stages */
+  stages: PipelineStage[];
+  /** Created timestamp (ms) */
+  createdAt: number;
+  /** Last modified timestamp (ms) */
+  updatedAt: number;
+}
+
+export type StageStatus = "pending" | "running" | "completed" | "failed" | "skipped";
+
+export interface StageResult {
+  stageId: string;
+  status: StageStatus;
+  /** Child session ID created for this stage */
+  sessionId?: string;
+  /** Stage start time (ms) */
+  startedAt?: number;
+  /** Stage end time (ms) */
+  completedAt?: number;
+  /** Duration in ms */
+  durationMs?: number;
+  /** Cost for this stage */
+  costUsd?: number;
+  /** Error message if failed */
+  error?: string;
+  /** Summary output from the session (last assistant message) */
+  outputSummary?: string;
+}
+
+export type PipelineRunStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+
+export interface PipelineRun {
+  /** Unique run ID */
+  id: string;
+  /** Pipeline ID */
+  pipelineId: string;
+  /** Pipeline name snapshot */
+  pipelineName: string;
+  /** Working directory */
+  cwd: string;
+  /** Overall run status */
+  status: PipelineRunStatus;
+  /** Per-stage results */
+  stageResults: StageResult[];
+  /** Run start time */
+  startedAt: number;
+  /** Run end time */
+  completedAt?: number;
+  /** Total cost across all stages */
+  totalCostUsd: number;
+  /** Total duration */
+  totalDurationMs: number;
+}

package/server/path-resolver.ts

@@ -0,0 +1,168 @@
+/**
+ * PATH discovery and binary resolution for service environments.
+ *
+ * When Campfire runs as a macOS launchd or Linux systemd service, it inherits
+ * a restricted PATH that omits directories from version managers (nvm, fnm, volta,
+ * mise, etc.) and user-local installs (~/.local/bin, ~/.cargo/bin). This module
+ * captures the user's real shell PATH at runtime and provides binary resolution
+ * that works regardless of how the server was started.
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Capture the user's full interactive shell PATH by spawning a login shell.
+ * This picks up all version manager initializations (nvm, fnm, volta, mise, etc.).
+ * Falls back to probing common directories if shell sourcing fails.
+ */
+export function captureUserShellPath(): string {
+  try {
+    const shell = process.env.SHELL || "/bin/bash";
+    const captured = execSync(
+      `${shell} -lic 'echo "___PATH_START___$PATH___PATH_END___"'`,
+      {
+        encoding: "utf-8",
+        timeout: 10_000,
+        env: { HOME: homedir(), USER: process.env.USER, SHELL: shell },
+      },
+    );
+    const match = captured.match(/___PATH_START___(.+)___PATH_END___/);
+    if (match?.[1]) {
+      return match[1];
+    }
+  } catch {
+    // Shell sourcing failed (timeout, compinit prompt, etc.)
+  }
+
+  return buildFallbackPath();
+}
+
+/**
+ * Build a PATH by probing common binary installation directories.
+ * Used as fallback when shell-sourcing fails.
+ */
+export function buildFallbackPath(): string {
+  const home = homedir();
+  const candidates = [
+    // Standard system paths
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+    // Bun
+    join(home, ".bun", "bin"),
+    // Claude CLI / user-local installs
+    join(home, ".local", "bin"),
+    // Cargo / Rust
+    join(home, ".cargo", "bin"),
+    // Volta (Node version manager)
+    join(home, ".volta", "bin"),
+    // mise (formerly rtx)
+    join(home, ".local", "share", "mise", "shims"),
+    // pyenv
+    join(home, ".pyenv", "bin"),
+    join(home, ".pyenv", "shims"),
+    // Go
+    join(home, "go", "bin"),
+    "/usr/local/go/bin",
+    // Deno
+    join(home, ".deno", "bin"),
+  ];
+
+  // Probe nvm-managed node versions
+  const nvmDir = process.env.NVM_DIR || join(home, ".nvm");
+  const nvmVersionsDir = join(nvmDir, "versions", "node");
+  if (existsSync(nvmVersionsDir)) {
+    try {
+      for (const v of readdirSync(nvmVersionsDir)) {
+        candidates.push(join(nvmVersionsDir, v, "bin"));
+      }
+    } catch { /* ignore */ }
+  }
+
+  // fnm (Fast Node Manager) — versions stored in fnm multishell or XDG data
+  const fnmDir = join(home, "Library", "Application Support", "fnm", "node-versions");
+  if (existsSync(fnmDir)) {
+    try {
+      for (const v of readdirSync(fnmDir)) {
+        candidates.push(join(fnmDir, v, "installation", "bin"));
+      }
+    } catch { /* ignore */ }
+  }
+
+  return [...new Set(candidates.filter((dir) => existsSync(dir)))].join(":");
+}
+
+// ─── Enriched PATH (cached) ───────────────────────────────────────────────────
+
+let _cachedPath: string | null = null;
+
+/**
+ * Returns an enriched PATH that merges the user's shell PATH (or probed common
+ * directories) with the current process PATH. Deduplicates entries.
+ * Result is cached after the first call.
+ */
+export function getEnrichedPath(): string {
+  if (_cachedPath) return _cachedPath;
+
+  const currentPath = process.env.PATH || "";
+  const userPath = captureUserShellPath();
+
+  // Merge: user shell PATH first (takes precedence), then current process PATH
+  const allDirs = [...userPath.split(":"), ...currentPath.split(":")];
+  const seen = new Set<string>();
+  const deduped: string[] = [];
+  for (const dir of allDirs) {
+    if (dir && !seen.has(dir)) {
+      seen.add(dir);
+      deduped.push(dir);
+    }
+  }
+
+  _cachedPath = deduped.join(":");
+  return _cachedPath;
+}
+
+/** Reset the cached PATH (for testing). */
+export function _resetPathCache(): void {
+  _cachedPath = null;
+}
+
+// ─── Binary resolution ────────────────────────────────────────────────────────
+
+/**
+ * Resolve a binary name to an absolute path using the enriched PATH.
+ * Returns null if the binary is not found anywhere.
+ */
+export function resolveBinary(name: string): string | null {
+  if (name.startsWith("/")) {
+    return existsSync(name) ? name : null;
+  }
+
+  const enrichedPath = getEnrichedPath();
+  try {
+    const resolved = execSync(`which ${name.replace(/[^a-zA-Z0-9._@/-]/g, "")}`, {
+
+      encoding: "utf-8",
+      timeout: 5_000,
+      env: { ...process.env, PATH: enrichedPath },
+    }).trim();
+    return resolved || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Returns a PATH string suitable for embedding in service definitions
+ * (plist/systemd unit). Captures the user's shell PATH at install time.
+ */
+export function getServicePath(): string {
+  return getEnrichedPath();
+}

package/server/pr-poller.ts

@@ -0,0 +1,162 @@
+import { fetchPRInfoAsync, computeAdaptiveTTL, type GitHubPRInfo } from "./github-pr.js";
+import type { WsBridge } from "./ws-bridge.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+interface WatchedPR {
+  cwd: string;
+  branch: string;
+  /** Sessions interested in this PR (same cwd:branch may be shared) */
+  sessionIds: Set<string>;
+  lastData: GitHubPRInfo | null;
+  timer: ReturnType<typeof setTimeout> | null;
+  lastFetchTime: number;
+  currentInterval: number;
+  fetching: boolean;
+}
+
+// ─── PR Poller ───────────────────────────────────────────────────────────────
+
+/**
+ * Server-side poller that fetches GitHub PR status at adaptive intervals
+ * and pushes updates to browsers via WebSocket.
+ *
+ * One timer per unique cwd:branch — shared across sessions on the same branch.
+ */
+export class PRPoller {
+  private watched = new Map<string, WatchedPR>();
+  private wsBridge: WsBridge;
+  /** Reverse index: sessionId → cwd:branch key (a session can only watch one PR at a time) */
+  private sessionToKey = new Map<string, string>();
+
+  constructor(wsBridge: WsBridge) {
+    this.wsBridge = wsBridge;
+  }
+
+  /**
+   * Start watching a PR for a session.
+   * Returns cached data immediately if available.
+   * Triggers an async fetch if cache is stale or missing.
+   */
+  watch(sessionId: string, cwd: string, branch: string): GitHubPRInfo | null {
+    const key = `${cwd}:${branch}`;
+
+    // If this session was watching a different PR, unregister from the old one
+    const prevKey = this.sessionToKey.get(sessionId);
+    if (prevKey && prevKey !== key) {
+      this.unwatchKey(sessionId, prevKey);
+    }
+    this.sessionToKey.set(sessionId, key);
+
+    const existing = this.watched.get(key);
+    if (existing) {
+      existing.sessionIds.add(sessionId);
+      // If cache is stale, trigger a refresh
+      if (Date.now() - existing.lastFetchTime > existing.currentInterval) {
+        this.fetchAndBroadcast(key);
+      }
+      return existing.lastData;
+    }
+
+    // New watch — create entry and fetch immediately
+    const entry: WatchedPR = {
+      cwd,
+      branch,
+      sessionIds: new Set([sessionId]),
+      lastData: null,
+      timer: null,
+      lastFetchTime: 0,
+      currentInterval: 10_000, // start aggressive for fast initial load
+      fetching: false,
+    };
+    this.watched.set(key, entry);
+    this.fetchAndBroadcast(key);
+
+    return null;
+  }
+
+  /** Stop watching for a specific session. */
+  unwatch(sessionId: string): void {
+    const key = this.sessionToKey.get(sessionId);
+    if (!key) return;
+    this.sessionToKey.delete(sessionId);
+    this.unwatchKey(sessionId, key);
+  }
+
+  /** Get current cached data for a cwd:branch pair (for REST fallback). */
+  getCached(cwd: string, branch: string): { available: boolean; pr: GitHubPRInfo | null } | null {
+    const key = `${cwd}:${branch}`;
+    const entry = this.watched.get(key);
+    if (!entry) return null;
+    return { available: true, pr: entry.lastData };
+  }
+
+  /** Stop all timers (for testing / cleanup). */
+  destroy(): void {
+    for (const entry of this.watched.values()) {
+      if (entry.timer) clearTimeout(entry.timer);
+    }
+    this.watched.clear();
+    this.sessionToKey.clear();
+  }
+
+  // ─── Internal ──────────────────────────────────────────────────────────
+
+  private unwatchKey(sessionId: string, key: string): void {
+    const entry = this.watched.get(key);
+    if (!entry) return;
+    entry.sessionIds.delete(sessionId);
+    if (entry.sessionIds.size === 0) {
+      if (entry.timer) clearTimeout(entry.timer);
+      this.watched.delete(key);
+    }
+  }
+
+  private async fetchAndBroadcast(key: string): Promise<void> {
+    const entry = this.watched.get(key);
+    if (!entry) return;
+
+    // Prevent concurrent fetches for the same key
+    if (entry.fetching) return;
+    entry.fetching = true;
+
+    // Clear existing timer (will be rescheduled after fetch)
+    if (entry.timer) {
+      clearTimeout(entry.timer);
+      entry.timer = null;
+    }
+
+    try {
+      const prInfo = await fetchPRInfoAsync(entry.cwd, entry.branch);
+      // Re-check entry still exists (may have been unwatched during async fetch)
+      const current = this.watched.get(key);
+      if (!current) return;
+
+      current.lastData = prInfo;
+      current.lastFetchTime = Date.now();
+      current.currentInterval = computeAdaptiveTTL(prInfo);
+
+      // Push to all sessions watching this PR
+      for (const sessionId of current.sessionIds) {
+        this.wsBridge.broadcastToSession(sessionId, {
+          type: "pr_status_update",
+          pr: prInfo,
+          available: true,
+        });
+      }
+    } catch {
+      // On error, use a moderate interval
+      const current = this.watched.get(key);
+      if (current) {
+        current.currentInterval = 30_000;
+      }
+    } finally {
+      const current = this.watched.get(key);
+      if (current) {
+        current.fetching = false;
+        // Schedule next fetch
+        current.timer = setTimeout(() => this.fetchAndBroadcast(key), current.currentInterval);
+      }
+    }
+  }
+}