the-campfire 0.1.0

package/server/routes/commands-routes.ts

@@ -0,0 +1,94 @@
+import type { Hono } from "hono";
+import type { RouteDeps } from "./route-deps.js";
+import { discoverCommandsAndSkills, readCommandContent } from "../commands-discovery.js";
+
+// Cache for CLI-reported slash commands (populated on first request)
+let cachedCliCommands: string[] | null = null;
+let fetchingCliCommands = false;
+
+function findCommandsFromSessions(wsBridge: RouteDeps["wsBridge"]): string[] | null {
+  const sessions = wsBridge.getAllSessions();
+  for (const session of sessions) {
+    if (session.slash_commands && session.slash_commands.length > 0) {
+      return session.slash_commands;
+    }
+  }
+  return null;
+}
+
+async function fetchCommandsViaTempSession(launcher: RouteDeps["launcher"], wsBridge: RouteDeps["wsBridge"]): Promise<string[]> {
+  const tempSession = launcher.launch({
+    permissionMode: "default",
+    cwd: process.cwd(),
+    backendType: "claude",
+  });
+
+  const startTime = Date.now();
+  let commands: string[] = [];
+  while (Date.now() - startTime < 30_000) {
+    await new Promise((r) => setTimeout(r, 500));
+    const allSessions = wsBridge.getAllSessions();
+    const tempState = allSessions.find((s) => s.session_id === tempSession.sessionId);
+    if (tempState?.slash_commands && tempState.slash_commands.length > 0) {
+      commands = tempState.slash_commands;
+      break;
+    }
+  }
+
+  await launcher.kill(tempSession.sessionId).catch(() => {});
+  return commands;
+}
+
+export function registerCommandsRoutes(api: Hono, deps: RouteDeps): void {
+  const { launcher, wsBridge } = deps;
+
+  // Discover custom commands and skills for a given working directory
+  api.get("/commands", (c) => {
+    const cwd = c.req.query("cwd") || undefined;
+    return c.json(discoverCommandsAndSkills(cwd));
+  });
+
+  // Read a specific command's full content
+  api.get("/commands/read", (c) => {
+    const path = c.req.query("path");
+    if (!path) return c.json({ error: "path is required" }, 400);
+    const content = readCommandContent(path);
+    if (content === null) return c.json({ error: "File not found" }, 404);
+    return c.json({ path, content });
+  });
+
+  // Get slash commands from the CLI (dynamic, not hardcoded).
+  // Tries existing sessions first, then spins up a temporary one.
+  api.get("/commands/slash", async (c) => {
+    // 1. Try existing sessions
+    const fromSession = findCommandsFromSessions(wsBridge);
+    if (fromSession) {
+      cachedCliCommands = fromSession;
+      return c.json({ commands: fromSession, source: "session" });
+    }
+
+    // 2. Return cache
+    if (cachedCliCommands) return c.json({ commands: cachedCliCommands, source: "cache" });
+
+    // 3. Wait if another request is already fetching
+    if (fetchingCliCommands) {
+      for (let i = 0; i < 60; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        if (cachedCliCommands) return c.json({ commands: cachedCliCommands, source: "cache" });
+      }
+      return c.json({ commands: [], source: "timeout" });
+    }
+
+    // 4. Spin up temp session
+    fetchingCliCommands = true;
+    try {
+      const commands = await fetchCommandsViaTempSession(launcher, wsBridge);
+      if (commands.length > 0) cachedCliCommands = commands;
+      return c.json({ commands, source: commands.length > 0 ? "fetched" : "empty" });
+    } catch {
+      return c.json({ commands: [], source: "error" });
+    } finally {
+      fetchingCliCommands = false;
+    }
+  });
+}

package/server/routes/cron-routes.ts

@@ -0,0 +1,100 @@
+import type { Hono } from "hono";
+import type { RouteDeps } from "./route-deps.js";
+import * as cronStore from "../cron-store.js";
+
+export function registerCronRoutes(api: Hono, deps: RouteDeps): void {
+  const { cronScheduler } = deps;
+
+  api.get("/cron/jobs", (c) => {
+    const jobs = cronStore.listJobs();
+    const enriched = jobs.map((j) => ({
+      ...j,
+      nextRunAt: cronScheduler?.getNextRunTime(j.id)?.getTime() ?? null,
+    }));
+    return c.json(enriched);
+  });
+
+  api.get("/cron/jobs/:id", (c) => {
+    const job = cronStore.getJob(c.req.param("id"));
+    if (!job) return c.json({ error: "Job not found" }, 404);
+    return c.json({
+      ...job,
+      nextRunAt: cronScheduler?.getNextRunTime(job.id)?.getTime() ?? null,
+    });
+  });
+
+  api.post("/cron/jobs", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const job = cronStore.createJob({
+        name: body.name || "",
+        prompt: body.prompt || "",
+        schedule: body.schedule || "",
+        recurring: body.recurring ?? true,
+        backendType: body.backendType || "claude",
+        model: body.model || "",
+        cwd: body.cwd || "",
+        envSlug: body.envSlug,
+        enabled: body.enabled ?? true,
+        permissionMode: body.permissionMode || "bypassPermissions",
+        codexInternetAccess: body.codexInternetAccess,
+      });
+      if (job.enabled) cronScheduler?.scheduleJob(job);
+      return c.json(job, 201);
+    } catch (e: unknown) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 400);
+    }
+  });
+
+  api.put("/cron/jobs/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const allowed: Record<string, unknown> = {};
+      for (const key of ["name", "prompt", "schedule", "recurring", "backendType", "model", "cwd", "envSlug", "enabled", "permissionMode", "codexInternetAccess"] as const) {
+        if (key in body) allowed[key] = body[key];
+      }
+      const job = cronStore.updateJob(id, allowed);
+      if (!job) return c.json({ error: "Job not found" }, 404);
+      if (job.id !== id) cronScheduler?.stopJob(id);
+      cronScheduler?.scheduleJob(job);
+      return c.json(job);
+    } catch (e: unknown) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 400);
+    }
+  });
+
+  api.delete("/cron/jobs/:id", (c) => {
+    const id = c.req.param("id");
+    cronScheduler?.stopJob(id);
+    const deleted = cronStore.deleteJob(id);
+    if (!deleted) return c.json({ error: "Job not found" }, 404);
+    return c.json({ ok: true });
+  });
+
+  api.post("/cron/jobs/:id/toggle", (c) => {
+    const id = c.req.param("id");
+    const job = cronStore.getJob(id);
+    if (!job) return c.json({ error: "Job not found" }, 404);
+    const updated = cronStore.updateJob(id, { enabled: !job.enabled });
+    if (updated?.enabled) {
+      cronScheduler?.scheduleJob(updated);
+    } else {
+      cronScheduler?.stopJob(id);
+    }
+    return c.json(updated);
+  });
+
+  api.post("/cron/jobs/:id/run", (c) => {
+    const id = c.req.param("id");
+    const job = cronStore.getJob(id);
+    if (!job) return c.json({ error: "Job not found" }, 404);
+    cronScheduler?.executeJobManually(id);
+    return c.json({ ok: true, message: "Job triggered" });
+  });
+
+  api.get("/cron/jobs/:id/executions", (c) => {
+    const id = c.req.param("id");
+    return c.json(cronScheduler?.getExecutions(id) ?? []);
+  });
+}

package/server/routes/env-routes.ts

@@ -0,0 +1,50 @@
+import type { Hono } from "hono";
+import type { RouteDeps } from "./route-deps.js";
+import * as envManager from "../env-manager.js";
+
+export function registerEnvRoutes(api: Hono, _deps: RouteDeps): void {
+  api.get("/envs", (c) => {
+    try {
+      return c.json(envManager.listEnvs());
+    } catch (e: unknown) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
+    }
+  });
+
+  api.get("/envs/:slug", (c) => {
+    const env = envManager.getEnv(c.req.param("slug"));
+    if (!env) return c.json({ error: "Environment not found" }, 404);
+    return c.json(env);
+  });
+
+  api.post("/envs", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const env = envManager.createEnv(body.name, body.variables || {});
+      return c.json(env, 201);
+    } catch (e: unknown) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 400);
+    }
+  });
+
+  api.put("/envs/:slug", async (c) => {
+    const slug = c.req.param("slug");
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const env = envManager.updateEnv(slug, {
+        name: body.name,
+        variables: body.variables,
+      });
+      if (!env) return c.json({ error: "Environment not found" }, 404);
+      return c.json(env);
+    } catch (e: unknown) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 400);
+    }
+  });
+
+  api.delete("/envs/:slug", (c) => {
+    const deleted = envManager.deleteEnv(c.req.param("slug"));
+    if (!deleted) return c.json({ error: "Environment not found" }, 404);
+    return c.json({ ok: true });
+  });
+}

package/server/routes/folder-routes.ts

@@ -0,0 +1,56 @@
+import type { Hono } from "hono";
+import type { RouteDeps } from "./route-deps.js";
+import * as sessionFolders from "../session-folders.js";
+
+export function registerFolderRoutes(api: Hono, _deps: RouteDeps): void {
+  // List all folders
+  api.get("/folders", (c) => {
+    return c.json(sessionFolders.listFolders());
+  });
+
+  // Create a folder
+  api.post("/folders", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.name || typeof body.name !== "string") {
+      return c.json({ error: "name is required" }, 400);
+    }
+    const folder = sessionFolders.createFolder(body.name.trim(), body.color);
+    return c.json(folder);
+  });
+
+  // Update a folder
+  api.patch("/folders/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json().catch(() => ({}));
+    const folder = sessionFolders.updateFolder(id, {
+      name: body.name,
+      color: body.color,
+    });
+    if (!folder) return c.json({ error: "Folder not found" }, 404);
+    return c.json(folder);
+  });
+
+  // Delete a folder
+  api.delete("/folders/:id", (c) => {
+    const id = c.req.param("id");
+    const ok = sessionFolders.deleteFolder(id);
+    if (!ok) return c.json({ error: "Folder not found" }, 404);
+    return c.json({ ok: true });
+  });
+
+  // Add session to folder
+  api.post("/folders/:id/sessions/:sessionId", (c) => {
+    const folderId = c.req.param("id");
+    const sessionId = c.req.param("sessionId");
+    const ok = sessionFolders.addSessionToFolder(folderId, sessionId);
+    if (!ok) return c.json({ error: "Folder not found" }, 404);
+    return c.json({ ok: true });
+  });
+
+  // Remove session from any folder
+  api.delete("/folders/sessions/:sessionId", (c) => {
+    const sessionId = c.req.param("sessionId");
+    sessionFolders.removeSessionFromFolder(sessionId);
+    return c.json({ ok: true });
+  });
+}