the-campfire 0.1.0

package/server/routes/linear-routes.ts

@@ -0,0 +1,254 @@
+import type { Hono } from "hono";
+import type { RouteDeps } from "./route-deps.js";
+import { getSettings } from "../settings-manager.js";
+import * as linearProjectManager from "../linear-project-manager.js";
+import * as sessionLinearIssues from "../session-linear-issues.js";
+
+export function registerLinearRoutes(api: Hono, _deps: RouteDeps): void {
+  api.get("/linear/connection", async (c) => {
+    const { linearApiKey } = getSettings();
+    if (!linearApiKey?.trim()) {
+      return c.json({ connected: false });
+    }
+    try {
+      const res = await fetch("https://api.linear.app/graphql", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": linearApiKey,
+        },
+        body: JSON.stringify({
+          query: `query { viewer { id name email } teams { nodes { id key name } } }`,
+        }),
+      });
+      const data = await res.json() as { data?: { viewer?: { name: string; email: string }; teams?: { nodes: Array<{ id: string; key: string; name: string }> } }; errors?: unknown[] };
+      if (data.errors || !data.data?.viewer) {
+        return c.json({ connected: false });
+      }
+      return c.json({
+        connected: true,
+        viewer: data.data.viewer,
+        teams: data.data.teams?.nodes ?? [],
+      });
+    } catch {
+      return c.json({ connected: false });
+    }
+  });
+
+  api.get("/linear/issues", async (c) => {
+    const { linearApiKey } = getSettings();
+    if (!linearApiKey?.trim()) {
+      return c.json({ error: "Linear API key not configured" }, 401);
+    }
+    const query = c.req.query("query") ?? "";
+    const limit = Math.min(parseInt(c.req.query("limit") ?? "10", 10), 50);
+    try {
+      const res = await fetch("https://api.linear.app/graphql", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": linearApiKey,
+        },
+        body: JSON.stringify({
+          query: `
+            query SearchIssues($query: String!, $first: Int!) {
+              issueSearch(query: $query, first: $first) {
+                nodes {
+                  id
+                  identifier
+                  title
+                  url
+                  state { name }
+                  team { id key name }
+                }
+              }
+            }
+          `,
+          variables: { query, first: limit },
+        }),
+      });
+      const data = await res.json() as { data?: { issueSearch?: { nodes: unknown[] } }; errors?: unknown[] };
+      if (data.errors) {
+        return c.json({ error: "Linear API error" }, 502);
+      }
+      return c.json({ issues: data.data?.issueSearch?.nodes ?? [] });
+    } catch (e) {
+      return c.json({ error: "Failed to reach Linear API" }, 502);
+    }
+  });
+
+  api.get("/linear/teams", async (c) => {
+    const { linearApiKey } = getSettings();
+    if (!linearApiKey?.trim()) {
+      return c.json({ error: "Linear API key not configured" }, 401);
+    }
+    try {
+      const res = await fetch("https://api.linear.app/graphql", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": linearApiKey,
+        },
+        body: JSON.stringify({
+          query: `query { teams { nodes { id key name } } }`,
+        }),
+      });
+      const data = await res.json() as { data?: { teams?: { nodes: unknown[] } }; errors?: unknown[] };
+      if (data.errors) {
+        return c.json({ error: "Linear API error" }, 502);
+      }
+      return c.json({ teams: data.data?.teams?.nodes ?? [] });
+    } catch {
+      return c.json({ error: "Failed to reach Linear API" }, 502);
+    }
+  });
+
+  api.get("/linear/team/:id/states", async (c) => {
+    const { linearApiKey } = getSettings();
+    if (!linearApiKey?.trim()) {
+      return c.json({ error: "Linear API key not configured" }, 401);
+    }
+    const teamId = c.req.param("id");
+    try {
+      const res = await fetch("https://api.linear.app/graphql", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": linearApiKey,
+        },
+        body: JSON.stringify({
+          query: `
+            query TeamStates($teamId: String!) {
+              team(id: $teamId) {
+                states { nodes { id name type position } }
+              }
+            }
+          `,
+          variables: { teamId },
+        }),
+      });
+      const data = await res.json() as { data?: { team?: { states?: { nodes: unknown[] } } }; errors?: unknown[] };
+      if (data.errors) {
+        return c.json({ error: "Linear API error" }, 502);
+      }
+      return c.json({ states: data.data?.team?.states?.nodes ?? [] });
+    } catch {
+      return c.json({ error: "Failed to reach Linear API" }, 502);
+    }
+  });
+
+  api.get("/linear/projects", async (c) => {
+    const { linearApiKey } = getSettings();
+    if (!linearApiKey?.trim()) {
+      return c.json({ error: "Linear API key not configured" }, 401);
+    }
+    try {
+      const res = await fetch("https://api.linear.app/graphql", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": linearApiKey,
+        },
+        body: JSON.stringify({
+          query: `query { projects { nodes { id name state } } }`,
+        }),
+      });
+      const data = await res.json() as { data?: { projects?: { nodes: unknown[] } }; errors?: unknown[] };
+      if (data.errors) {
+        return c.json({ error: "Linear API error" }, 502);
+      }
+      return c.json({ projects: data.data?.projects?.nodes ?? [] });
+    } catch {
+      return c.json({ error: "Failed to reach Linear API" }, 502);
+    }
+  });
+
+  api.post("/linear/issues/:id/transition", async (c) => {
+    const { linearApiKey } = getSettings();
+    if (!linearApiKey?.trim()) {
+      return c.json({ error: "Linear API key not configured" }, 401);
+    }
+    const issueId = c.req.param("id");
+    const body = await c.req.json().catch(() => ({}));
+    const { stateId } = body;
+    if (!stateId) return c.json({ error: "stateId is required" }, 400);
+    try {
+      const res = await fetch("https://api.linear.app/graphql", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": linearApiKey,
+        },
+        body: JSON.stringify({
+          query: `
+            mutation TransitionIssue($issueId: String!, $stateId: String!) {
+              issueUpdate(id: $issueId, input: { stateId: $stateId }) {
+                success
+                issue { id identifier state { name } }
+              }
+            }
+          `,
+          variables: { issueId, stateId },
+        }),
+      });
+      const data = await res.json() as { data?: { issueUpdate?: { success: boolean; issue?: unknown } }; errors?: unknown[] };
+      if (data.errors) {
+        return c.json({ error: "Linear API error" }, 502);
+      }
+      return c.json({ ok: data.data?.issueUpdate?.success ?? false, issue: data.data?.issueUpdate?.issue });
+    } catch {
+      return c.json({ error: "Failed to reach Linear API" }, 502);
+    }
+  });
+
+  // ─── Project-repo mapping ──────────────────────────────────────────
+  api.get("/linear/project-mapping", (c) => {
+    const repoRoot = c.req.query("repoRoot");
+    if (repoRoot) {
+      const mapping = linearProjectManager.getProjectForRepo(repoRoot);
+      return c.json({ mapping });
+    }
+    return c.json({ mappings: linearProjectManager.listMappings() });
+  });
+
+  api.post("/linear/project-mapping", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const { repoRoot, teamId, teamKey, teamName, projectId, projectName } = body;
+    if (!repoRoot || !teamId || !teamKey || !teamName) {
+      return c.json({ error: "repoRoot, teamId, teamKey, and teamName are required" }, 400);
+    }
+    const mapping = linearProjectManager.setProjectForRepo(repoRoot, {
+      teamId, teamKey, teamName, projectId, projectName,
+    });
+    return c.json({ mapping });
+  });
+
+  api.delete("/linear/project-mapping", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const { repoRoot } = body;
+    if (!repoRoot) return c.json({ error: "repoRoot is required" }, 400);
+    const removed = linearProjectManager.removeProjectMapping(repoRoot);
+    if (!removed) return c.json({ error: "No mapping found" }, 404);
+    return c.json({ ok: true });
+  });
+
+  // ─── Session-issue linking ──────────────────────────────────────────
+  api.post("/linear/session/:id/link-issue", async (c) => {
+    const sessionId = c.req.param("id");
+    const body = await c.req.json().catch(() => ({}));
+    const { issueId, identifier, title, url, state, teamKey } = body;
+    if (!issueId || !identifier || !title) {
+      return c.json({ error: "issueId, identifier, and title are required" }, 400);
+    }
+    const linked = sessionLinearIssues.linkIssueToSession(sessionId, {
+      issueId, identifier, title, url: url || "", state: state || "", teamKey: teamKey || "",
+    });
+    return c.json({ linked });
+  });
+
+  api.get("/linear/session/:id/issue", (c) => {
+    const sessionId = c.req.param("id");
+    const issue = sessionLinearIssues.getLinkedIssue(sessionId);
+    return c.json({ issue });
+  });
+}

package/server/routes/monitor-routes.ts

@@ -0,0 +1,11 @@
+import type { Hono } from "hono";
+import type { RouteDeps } from "./route-deps.js";
+
+export function registerMonitorRoutes(api: Hono, deps: RouteDeps): void {
+  const { protocolMonitor } = deps;
+
+  api.get("/monitor/stats", (c) => {
+    if (!protocolMonitor) return c.json({ error: "Monitor not available" }, 500);
+    return c.json(protocolMonitor.getSnapshot());
+  });
+}

package/server/routes/orchestrator-routes.ts

@@ -0,0 +1,210 @@
+import { randomUUID } from "node:crypto";
+import type { Hono } from "hono";
+import type { RouteDeps } from "./route-deps.js";
+import type { Pipeline, PipelineStage } from "../orchestrator-types.js";
+import {
+  listPipelines, getPipeline, savePipeline, deletePipeline,
+  listRuns, getRun, deleteRun,
+} from "../orchestrator-store.js";
+import { executePipeline, cancelRun, isRunActive } from "../orchestrator-executor.js";
+
+export function registerOrchestratorRoutes(api: Hono, deps: RouteDeps): void {
+  // ─── Pipelines CRUD ──────────────────────────────────────────────────
+
+  api.get("/orchestrator/pipelines", (c) => {
+    return c.json(listPipelines());
+  });
+
+  api.get("/orchestrator/pipelines/:id", (c) => {
+    const pipeline = getPipeline(c.req.param("id"));
+    if (!pipeline) return c.json({ error: "Pipeline not found" }, 404);
+    return c.json(pipeline);
+  });
+
+  api.post("/orchestrator/pipelines", async (c) => {
+    const body = await c.req.json<{ name: string; description?: string; cwd: string; stages: Omit<PipelineStage, "id">[] }>();
+    if (!body.name || !body.cwd || !body.stages?.length) {
+      return c.json({ error: "name, cwd, and stages are required" }, 400);
+    }
+
+    const pipeline: Pipeline = {
+      id: randomUUID(),
+      name: body.name,
+      description: body.description,
+      cwd: body.cwd,
+      stages: body.stages.map((s) => ({ ...s, id: randomUUID() })),
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+
+    savePipeline(pipeline);
+    return c.json(pipeline, 201);
+  });
+
+  api.put("/orchestrator/pipelines/:id", async (c) => {
+    const id = c.req.param("id");
+    const existing = getPipeline(id);
+    if (!existing) return c.json({ error: "Pipeline not found" }, 404);
+
+    const body = await c.req.json<Partial<Pipeline>>();
+    const updated: Pipeline = {
+      ...existing,
+      name: body.name || existing.name,
+      description: body.description ?? existing.description,
+      cwd: body.cwd || existing.cwd,
+      stages: body.stages || existing.stages,
+      updatedAt: Date.now(),
+    };
+
+    savePipeline(updated);
+    return c.json(updated);
+  });
+
+  api.delete("/orchestrator/pipelines/:id", (c) => {
+    const ok = deletePipeline(c.req.param("id"));
+    if (!ok) return c.json({ error: "Pipeline not found" }, 404);
+    return c.json({ ok: true });
+  });
+
+  // ─── Runs ────────────────────────────────────────────────────────────
+
+  api.get("/orchestrator/runs", (c) => {
+    const pipelineId = c.req.query("pipeline_id");
+    return c.json(listRuns(pipelineId || undefined));
+  });
+
+  api.get("/orchestrator/runs/:id", (c) => {
+    const run = getRun(c.req.param("id"));
+    if (!run) return c.json({ error: "Run not found" }, 404);
+    return c.json(run);
+  });
+
+  api.delete("/orchestrator/runs/:id", (c) => {
+    const ok = deleteRun(c.req.param("id"));
+    if (!ok) return c.json({ error: "Run not found" }, 404);
+    return c.json({ ok: true });
+  });
+
+  // ─── Execute a pipeline ──────────────────────────────────────────────
+
+  api.post("/orchestrator/pipelines/:id/run", async (c) => {
+    const pipeline = getPipeline(c.req.param("id"));
+    if (!pipeline) return c.json({ error: "Pipeline not found" }, 404);
+
+    // Create session helper that uses the existing launcher
+    const createSession = async (opts: {
+      cwd: string;
+      backend: string;
+      model?: string;
+      permissionMode?: string;
+      prompt?: string;
+    }) => {
+      try {
+        const info = deps.launcher.launch({
+          cwd: opts.cwd,
+          backendType: (opts.backend || "claude") as "claude" | "codex",
+          model: opts.model,
+          permissionMode: opts.permissionMode,
+        });
+        const sessionId = info.sessionId;
+
+        // Wait for CLI to connect (max 15s)
+        for (let i = 0; i < 30; i++) {
+          await new Promise((r) => setTimeout(r, 500));
+          const session = deps.wsBridge.getSession(sessionId);
+          if (session?.cliSocket || session?.adapter) {
+            // Send the prompt
+            if (opts.prompt) {
+              deps.wsBridge.injectUserMessage(sessionId, opts.prompt);
+            }
+            return { sessionId };
+          }
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    };
+
+    // Session status helper — checks launcher state + session history for completion
+    const getSessionStatus = (sessionId: string) => {
+      const launchInfo = deps.launcher.getSession(sessionId);
+      const session = deps.wsBridge.getSession(sessionId);
+      if (!launchInfo && !session) return null;
+
+      // Determine status from launcher state
+      const launcherState = launchInfo?.state || "starting";
+      let status = "running";
+      if (launcherState === "exited") {
+        status = "idle";
+      } else if (session) {
+        // Check if there's a recent result message (indicates turn completed)
+        const history = session.messageHistory;
+        const lastEntry = history[history.length - 1] as Record<string, unknown> | undefined;
+        if (lastEntry?.type === "result") {
+          status = "idle";
+        }
+      }
+
+      // Extract last assistant message text
+      let lastMessage = "";
+      if (session) {
+        const assistantMsgs = session.messageHistory.filter(
+          (m: Record<string, unknown>) => (m as { type?: string }).type === "assistant",
+        );
+        const lastMsg = assistantMsgs[assistantMsgs.length - 1] as
+          | { message?: { content?: unknown } }
+          | undefined;
+        if (lastMsg?.message?.content) {
+          const content = lastMsg.message.content;
+          if (typeof content === "string") {
+            lastMessage = content;
+          } else if (Array.isArray(content)) {
+            lastMessage = (content as Array<{ type: string; text?: string }>)
+              .filter((b) => b.type === "text" && b.text)
+              .map((b) => b.text!)
+              .join("\n");
+          }
+        }
+      }
+
+      return {
+        status,
+        cost: session?.state.total_cost_usd || 0,
+        lastMessage,
+      };
+    };
+
+    // Execute asynchronously — return the run ID immediately
+    const runPromise = executePipeline(pipeline, createSession, getSessionStatus);
+
+    // Return early with the run (in pending state initially, then running)
+    const earlyRun = await Promise.race([
+      runPromise,
+      new Promise<null>((resolve) => setTimeout(() => resolve(null), 500)),
+    ]);
+
+    if (earlyRun) {
+      return c.json(earlyRun, 201);
+    }
+
+    // Run started but not yet complete — get the ID from the store
+    const runs = listRuns(pipeline.id);
+    const latest = runs[0];
+    if (latest) {
+      return c.json(latest, 202);
+    }
+
+    return c.json({ error: "Failed to start pipeline run" }, 500);
+  });
+
+  // Cancel a running pipeline
+  api.post("/orchestrator/runs/:id/cancel", (c) => {
+    const runId = c.req.param("id");
+    if (!isRunActive(runId)) {
+      return c.json({ error: "Run is not active" }, 400);
+    }
+    const ok = cancelRun(runId);
+    return c.json({ ok });
+  });
+}

package/server/routes/prompt-routes.ts

@@ -0,0 +1,47 @@
+import type { Hono } from "hono";
+import type { RouteDeps } from "./route-deps.js";
+
+export function registerPromptRoutes(api: Hono, _deps: RouteDeps): void {
+  api.get("/prompts", async (c) => {
+    const { listPrompts } = await import("../prompt-manager.js");
+    const cwd = c.req.query("cwd");
+    return c.json(listPrompts(cwd ? { cwd } : undefined));
+  });
+
+  api.post("/prompts", async (c) => {
+    const { createPrompt } = await import("../prompt-manager.js");
+    const body = await c.req.json().catch(() => ({})) as Record<string, unknown>;
+    if (typeof body.name !== "string" || !body.name.trim()) {
+      return c.json({ error: "name is required" }, 400);
+    }
+    if (typeof body.content !== "string" || !body.content.trim()) {
+      return c.json({ error: "content is required" }, 400);
+    }
+    const scope = body.scope === "project" ? "project" : "global";
+    const projectPath = scope === "project" && typeof body.projectPath === "string" ? body.projectPath : undefined;
+    const prompt = createPrompt(body.name.trim(), body.content.trim(), scope, projectPath);
+    return c.json(prompt, 201);
+  });
+
+  api.put("/prompts/:id", async (c) => {
+    const { updatePrompt } = await import("../prompt-manager.js");
+    const id = c.req.param("id");
+    const body = await c.req.json().catch(() => ({})) as Record<string, unknown>;
+    const updates: Record<string, unknown> = {};
+    if (typeof body.name === "string") updates.name = body.name.trim();
+    if (typeof body.content === "string") updates.content = body.content.trim();
+    if (body.scope === "global" || body.scope === "project") updates.scope = body.scope;
+    if (typeof body.projectPath === "string") updates.projectPath = body.projectPath;
+    const updated = updatePrompt(id, updates as Parameters<typeof updatePrompt>[1]);
+    if (!updated) return c.json({ error: "Prompt not found" }, 404);
+    return c.json(updated);
+  });
+
+  api.delete("/prompts/:id", async (c) => {
+    const { deletePrompt } = await import("../prompt-manager.js");
+    const id = c.req.param("id");
+    const deleted = deletePrompt(id);
+    if (!deleted) return c.json({ error: "Prompt not found" }, 404);
+    return c.json({ ok: true });
+  });
+}

package/server/routes/race-routes.ts

@@ -0,0 +1,103 @@
+import type { Hono } from "hono";
+import { execFileSync } from "node:child_process";
+import type { RouteDeps } from "./route-deps.js";
+import type { BackendType } from "../session-types.js";
+import { RaceController } from "../race-controller.js";
+import { deleteRace, getRace, listRaces } from "../race-store.js";
+
+const VALID_BACKENDS = new Set<BackendType>(["claude", "codex", "goose", "aider", "openhands", "openclaw", "opencode"]);
+
+export function registerRaceRoutes(api: Hono, deps: RouteDeps): void {
+  const controller = new RaceController(deps.launcher, deps.wsBridge);
+
+  api.post("/races", async (c) => {
+    const body = await c.req.json<{
+      prompt?: string;
+      backends?: string[];
+      repoRoot?: string;
+      baseBranch?: string;
+      modelByBackend?: Partial<Record<BackendType, string>>;
+      envSlug?: string;
+      env?: Record<string, string>;
+    }>().catch(() => ({} as {
+      prompt?: string;
+      backends?: string[];
+      repoRoot?: string;
+      baseBranch?: string;
+      modelByBackend?: Partial<Record<BackendType, string>>;
+      envSlug?: string;
+      env?: Record<string, string>;
+    }));
+
+    const prompt = body.prompt?.trim() || "";
+    const backends = (body.backends ?? []).filter((backend: string): backend is BackendType => VALID_BACKENDS.has(backend as BackendType));
+    if (!prompt) return c.json({ error: "prompt is required" }, 400);
+    if (backends.length < 2) return c.json({ error: "Select at least two valid backends" }, 400);
+    if (!body.repoRoot) return c.json({ error: "repoRoot is required" }, 400);
+
+    try {
+      const race = controller.startRace({
+        prompt,
+        backends,
+        repoRoot: body.repoRoot,
+        baseBranch: body.baseBranch,
+        modelByBackend: body.modelByBackend,
+        envSlug: body.envSlug,
+        env: body.env,
+      });
+      return c.json(race, 201);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+
+  api.get("/races", (c) => c.json(listRaces()));
+
+  api.get("/races/:id", (c) => {
+    const race = getRace(c.req.param("id"));
+    if (!race) return c.json({ error: "Race not found" }, 404);
+    return c.json(race);
+  });
+
+  api.get("/races/:id/entries/:entryId/diff", (c) => {
+    const race = getRace(c.req.param("id"));
+    if (!race) return c.json({ error: "Race not found" }, 404);
+    const entry = race.entries.find((item) => item.id === c.req.param("entryId"));
+    if (!entry) return c.json({ error: "Race entry not found" }, 404);
+    try {
+      const diff = execFileSync("git", ["diff", "--", "."], {
+        cwd: entry.worktreePath,
+        encoding: "utf-8",
+        timeout: 20_000,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      return c.json({ diff, files: entry.filesChanged ?? [] });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+
+  api.post("/races/:id/pick", async (c) => {
+    const body = await c.req.json<{ sessionId?: string }>().catch(() => ({} as { sessionId?: string }));
+    if (!body.sessionId) return c.json({ error: "sessionId is required" }, 400);
+    try {
+      const race = controller.pickWinner(c.req.param("id"), body.sessionId);
+      if (!race) return c.json({ error: "Race not found" }, 404);
+      return c.json(race);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+
+  api.post("/races/:id/cancel", async (c) => {
+    const race = await controller.cancelRace(c.req.param("id"));
+    if (!race) return c.json({ error: "Race not found" }, 404);
+    return c.json(race);
+  });
+
+  api.delete("/races/:id", (c) => {
+    const ok = deleteRace(c.req.param("id"));
+    if (!ok) return c.json({ error: "Race not found" }, 404);
+    return c.json({ ok: true });
+  });
+}