the-campfire 0.1.0

package/server/container-manager.ts

@@ -0,0 +1,328 @@
+import { execSync, type ExecSyncOptionsWithStringEncoding } from "node:child_process";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ContainerConfig {
+  /** Docker image to use (e.g. "campfire-dev", "node:22-slim") */
+  image: string;
+  /** Container ports to expose (e.g. [3000, 8080]) */
+  ports: number[];
+  /** Extra volume mounts in "host:container[:opts]" format */
+  volumes?: string[];
+  /** Extra env vars to inject into the container */
+  env?: Record<string, string>;
+}
+
+export interface PortMapping {
+  containerPort: number;
+  hostPort: number;
+}
+
+export interface ContainerInfo {
+  containerId: string;
+  name: string;
+  image: string;
+  portMappings: PortMapping[];
+  hostCwd: string;
+  containerCwd: string;
+  state: "creating" | "running" | "stopped" | "removed";
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const EXEC_OPTS: ExecSyncOptionsWithStringEncoding = {
+  encoding: "utf-8",
+  timeout: 30_000,
+};
+
+function exec(cmd: string, opts?: ExecSyncOptionsWithStringEncoding): string {
+  return execSync(cmd, { ...EXEC_OPTS, ...opts }).trim();
+}
+
+// ---------------------------------------------------------------------------
+// ContainerManager
+// ---------------------------------------------------------------------------
+
+export class ContainerManager {
+  private containers = new Map<string, ContainerInfo>();
+
+  /** Check whether Docker daemon is reachable. */
+  checkDocker(): boolean {
+    try {
+      exec("docker info --format '{{.ServerVersion}}'");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Return Docker version string, or null if unavailable. */
+  getDockerVersion(): string | null {
+    try {
+      return exec("docker version --format '{{.Server.Version}}'");
+    } catch {
+      return null;
+    }
+  }
+
+  /** List images available locally. Returns image:tag strings. */
+  listImages(): string[] {
+    try {
+      const raw = exec("docker images --format '{{.Repository}}:{{.Tag}}'");
+      if (!raw) return [];
+      return raw
+        .split("\n")
+        .filter((l) => l && !l.startsWith("<none>"))
+        .sort();
+    } catch {
+      return [];
+    }
+  }
+
+  /** Check if a specific image exists locally. */
+  imageExists(image: string): boolean {
+    try {
+      exec(`docker image inspect ${shellEscape(image)}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Create and start a container for a session.
+   *
+   * - Mounts `~/.claude` read-only (auth)
+   * - Mounts `hostCwd` at `/workspace`
+   * - Publishes requested ports with auto-assigned host ports (`-p 0:PORT`)
+   */
+  createContainer(
+    sessionId: string,
+    hostCwd: string,
+    config: ContainerConfig,
+  ): ContainerInfo {
+    const name = `campfire-${sessionId.slice(0, 8)}`;
+    const homedir = process.env.HOME || process.env.USERPROFILE || "/root";
+
+    // Validate port numbers
+    for (const port of config.ports) {
+      if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid port number: ${port} (must be 1-65535)`);
+      }
+    }
+
+    // Build docker create args
+    const args: string[] = [
+      "docker", "create",
+      "--name", name,
+      // Ensure host.docker.internal resolves (automatic on Mac/Win Docker
+      // Desktop, but required explicitly on Linux)
+      "--add-host=host.docker.internal:host-gateway",
+      // Note: auth is seeded via `docker cp` (see claude-container-auth.ts /
+      // codex-container-auth.ts) rather than a bind mount, so the container
+      // gets a writable snapshot and cannot mutate the host's ~/.claude.
+      "-v", `${hostCwd}:/workspace`,
+      "-w", "/workspace",
+    ];
+
+    // Port mappings: -p 0:{containerPort}
+    for (const port of config.ports) {
+      args.push("-p", `0:${port}`);
+    }
+
+    // Extra volumes
+    if (config.volumes) {
+      for (const vol of config.volumes) {
+        args.push("-v", vol);
+      }
+    }
+
+    // Environment variables
+    if (config.env) {
+      for (const [k, v] of Object.entries(config.env)) {
+        args.push("-e", `${k}=${v}`);
+      }
+    }
+
+    // Image + default command (keep container alive)
+    args.push(config.image, "sleep", "infinity");
+
+    const info: ContainerInfo = {
+      containerId: "",
+      name,
+      image: config.image,
+      portMappings: [],
+      hostCwd,
+      containerCwd: "/workspace",
+      state: "creating",
+    };
+
+    try {
+      // Create
+      const containerId = exec(args.map(shellEscape).join(" "));
+      info.containerId = containerId;
+
+      // Start
+      exec(`docker start ${shellEscape(containerId)}`);
+      info.state = "running";
+
+      // Resolve actual port mappings
+      info.portMappings = this.resolvePortMappings(containerId, config.ports);
+
+      this.containers.set(sessionId, info);
+      console.log(
+        `[container-manager] Created container ${name} (${containerId.slice(0, 12)}) ` +
+        `ports: ${info.portMappings.map((p) => `${p.containerPort}->${p.hostPort}`).join(", ")}`,
+      );
+
+      return info;
+    } catch (e) {
+      // Cleanup partial creation
+      try { exec(`docker rm -f ${shellEscape(name)}`); } catch { /* ignore */ }
+      info.state = "removed";
+      throw new Error(
+        `Failed to create container: ${e instanceof Error ? e.message : String(e)}`,
+      );
+    }
+  }
+
+  /** Parse `docker port` output to get host port mappings. */
+  private resolvePortMappings(containerId: string, ports: number[]): PortMapping[] {
+    const mappings: PortMapping[] = [];
+    for (const containerPort of ports) {
+      try {
+        const raw = exec(
+          `docker port ${shellEscape(containerId)} ${containerPort}`,
+        );
+        // Output like "0.0.0.0:49152" or "[::]:49152"
+        const match = raw.match(/:(\d+)$/m);
+        if (match) {
+          mappings.push({
+            containerPort,
+            hostPort: parseInt(match[1], 10),
+          });
+        }
+      } catch {
+        console.warn(
+          `[container-manager] Could not resolve port ${containerPort} for ${containerId.slice(0, 12)}`,
+        );
+      }
+    }
+    return mappings;
+  }
+
+  /**
+   * Re-track a container under a new key (e.g. when the real sessionId
+   * is assigned after container creation).
+   */
+  retrack(containerId: string, newSessionId: string): void {
+    for (const [oldKey, info] of this.containers) {
+      if (info.containerId === containerId) {
+        this.containers.delete(oldKey);
+        this.containers.set(newSessionId, info);
+        return;
+      }
+    }
+  }
+
+  /** Stop and remove a container. */
+  removeContainer(sessionId: string): void {
+    const info = this.containers.get(sessionId);
+    if (!info) return;
+
+    try {
+      exec(`docker rm -f ${shellEscape(info.containerId)}`);
+      info.state = "removed";
+      console.log(
+        `[container-manager] Removed container ${info.name} (${info.containerId.slice(0, 12)})`,
+      );
+    } catch (e) {
+      console.warn(
+        `[container-manager] Failed to remove container ${info.name}:`,
+        e instanceof Error ? e.message : String(e),
+      );
+    }
+    this.containers.delete(sessionId);
+  }
+
+  /** Get container info for a session. */
+  getContainer(sessionId: string): ContainerInfo | undefined {
+    return this.containers.get(sessionId);
+  }
+
+  /** List all tracked containers. */
+  listContainers(): ContainerInfo[] {
+    return Array.from(this.containers.values());
+  }
+
+  /**
+   * Re-register a container that was persisted across a server restart.
+   * Verifies the container still exists in Docker before tracking it.
+   */
+  restoreContainer(sessionId: string, info: ContainerInfo): boolean {
+    try {
+      const state = exec(
+        `docker inspect --format '{{.State.Running}}' ${shellEscape(info.containerId)}`,
+      );
+      if (state === "true") {
+        info.state = "running";
+      } else {
+        info.state = "stopped";
+      }
+      this.containers.set(sessionId, info);
+      console.log(
+        `[container-manager] Restored container ${info.name} (${info.containerId.slice(0, 12)}) state=${info.state}`,
+      );
+      return true;
+    } catch {
+      // Container no longer exists in Docker
+      console.warn(
+        `[container-manager] Container ${info.name} (${info.containerId.slice(0, 12)}) no longer exists, skipping restore`,
+      );
+      return false;
+    }
+  }
+
+  /**
+   * Build the campfire-dev Docker image from the Dockerfile.dev.
+   * Returns the build output log. Throws on failure.
+   */
+  buildImage(dockerfilePath: string, tag: string = "campfire-dev:latest"): string {
+    const contextDir = dockerfilePath.replace(/\/[^/]+$/, "") || ".";
+    try {
+      const output = exec(
+        `docker build -t ${shellEscape(tag)} -f ${shellEscape(dockerfilePath)} ${shellEscape(contextDir)}`,
+        { encoding: "utf-8", timeout: 300_000 }, // 5 min for image builds
+      );
+      console.log(`[container-manager] Built image ${tag}`);
+      return output;
+    } catch (e) {
+      throw new Error(
+        `Failed to build image ${tag}: ${e instanceof Error ? e.message : String(e)}`,
+      );
+    }
+  }
+
+  /** Clean up all tracked containers (e.g. on server shutdown). */
+  cleanupAll(): void {
+    for (const [sessionId] of this.containers) {
+      this.removeContainer(sessionId);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Shell escape helper
+// ---------------------------------------------------------------------------
+
+function shellEscape(s: string): string {
+  if (/^[a-zA-Z0-9._\-/:=@]+$/.test(s)) return s;
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// Singleton
+export const containerManager = new ContainerManager();

package/server/cron-scheduler.ts

@@ -0,0 +1,243 @@
+import { Cron } from "croner";
+import type { CronJob, CronJobExecution } from "./cron-types.js";
+import type { CliLauncher, SdkSessionInfo } from "./cli-launcher.js";
+import type { WsBridge } from "./ws-bridge.js";
+import * as cronStore from "./cron-store.js";
+import * as envManager from "./env-manager.js";
+import * as sessionNames from "./session-names.js";
+
+/** Max consecutive failures before auto-disabling a job */
+const MAX_CONSECUTIVE_FAILURES = 5;
+/** Max time to wait for CLI to connect (ms) */
+const CLI_CONNECT_TIMEOUT_MS = 30_000;
+/** Poll interval when waiting for CLI connection */
+const CLI_CONNECT_POLL_MS = 500;
+
+export class CronScheduler {
+  private timers = new Map<string, Cron>();
+  private launcher: CliLauncher;
+  private wsBridge: WsBridge;
+  /** In-memory execution history (last N per job) */
+  private executions = new Map<string, CronJobExecution[]>();
+  private static readonly MAX_EXECUTIONS_PER_JOB = 50;
+
+  constructor(launcher: CliLauncher, wsBridge: WsBridge) {
+    this.launcher = launcher;
+    this.wsBridge = wsBridge;
+  }
+
+  /** Start all enabled jobs from disk. Called once at server startup. */
+  startAll(): void {
+    const jobs = cronStore.listJobs();
+    let started = 0;
+    for (const job of jobs) {
+      if (job.enabled) {
+        this.scheduleJob(job);
+        started++;
+      }
+    }
+    if (started > 0) {
+      console.log(`[cron-scheduler] Started ${started} cron job(s)`);
+    }
+  }
+
+  /** Schedule (or reschedule) a single job. */
+  scheduleJob(job: CronJob): void {
+    this.stopJob(job.id);
+
+    if (!job.enabled) return;
+
+    try {
+      if (job.recurring) {
+        const cronTask = new Cron(job.schedule, {}, () => {
+          this.executeJob(job.id).catch((err) => {
+            console.error(`[cron-scheduler] Unhandled error in job "${job.name}":`, err);
+          });
+        });
+        this.timers.set(job.id, cronTask);
+        console.log(`[cron-scheduler] Scheduled "${job.name}" with cron "${job.schedule}"`);
+      } else {
+        // One-shot: schedule for the specified datetime
+        const targetTime = new Date(job.schedule);
+        if (targetTime.getTime() > Date.now()) {
+          const cronTask = new Cron(targetTime, () => {
+            this.executeJob(job.id)
+              .then(() => {
+                // Auto-disable after one-shot execution
+                cronStore.updateJob(job.id, { enabled: false });
+                this.timers.delete(job.id);
+              })
+              .catch((err) => {
+                console.error(`[cron-scheduler] Unhandled error in one-shot job "${job.name}":`, err);
+              });
+          });
+          this.timers.set(job.id, cronTask);
+          console.log(`[cron-scheduler] Scheduled one-shot "${job.name}" at ${targetTime.toISOString()}`);
+        } else {
+          console.log(`[cron-scheduler] Skipping one-shot "${job.name}" — target time is in the past`);
+        }
+      }
+    } catch (err) {
+      console.error(`[cron-scheduler] Failed to schedule "${job.name}":`, err);
+    }
+  }
+
+  /** Stop a job's timer. */
+  stopJob(jobId: string): void {
+    const timer = this.timers.get(jobId);
+    if (timer) {
+      timer.stop();
+      this.timers.delete(jobId);
+    }
+  }
+
+  /** Execute a job: create a session, send the prompt, track the result. */
+  async executeJob(jobId: string, opts?: { force?: boolean }): Promise<void> {
+    const job = cronStore.getJob(jobId);
+    if (!job) return;
+    if (!job.enabled && !opts?.force) return;
+
+    // Overlap prevention: skip if previous execution is still running
+    if (job.lastSessionId && this.launcher.isAlive(job.lastSessionId)) {
+      console.log(`[cron-scheduler] Skipping "${job.name}" — previous execution still running (${job.lastSessionId})`);
+      return;
+    }
+
+    console.log(`[cron-scheduler] Executing job "${job.name}" (${jobId})`);
+
+    const execution: CronJobExecution = {
+      sessionId: "",
+      jobId,
+      startedAt: Date.now(),
+    };
+
+    try {
+      // Resolve environment variables
+      let envVars: Record<string, string> | undefined;
+      if (job.envSlug) {
+        const env = envManager.getEnv(job.envSlug);
+        if (env) envVars = env.variables;
+      }
+
+      // Launch the session via CliLauncher
+      // For Codex, explicitly set sandbox and internet access for full autonomy
+      const sessionInfo = this.launcher.launch({
+        model: job.model,
+        permissionMode: job.permissionMode,
+        cwd: job.cwd,
+        env: envVars,
+        backendType: job.backendType,
+        codexInternetAccess: job.backendType === "codex" ? (job.codexInternetAccess ?? true) : undefined,
+        codexSandbox: job.backendType === "codex"
+          ? (job.permissionMode === "bypassPermissions" ? "danger-full-access" : "workspace-write")
+          : undefined,
+      });
+
+      execution.sessionId = sessionInfo.sessionId;
+
+      // Tag the session as cron-originated
+      sessionInfo.cronJobId = jobId;
+      sessionInfo.cronJobName = job.name;
+
+      // Set the session name
+      const runLabel = `⏰ ${job.name}`;
+      sessionNames.setName(sessionInfo.sessionId, runLabel);
+
+      // Wait for CLI to connect, then send the prompt
+      await this.waitForCLIConnection(sessionInfo.sessionId);
+
+      // Send the prompt with cron prefix for traceability
+      const fullPrompt = `[cron:${job.id} ${job.name}]\n\n${job.prompt}`;
+      this.wsBridge.injectUserMessage(sessionInfo.sessionId, fullPrompt);
+
+      // Update job tracking
+      cronStore.updateJob(jobId, {
+        lastRunAt: Date.now(),
+        lastSessionId: sessionInfo.sessionId,
+        totalRuns: job.totalRuns + 1,
+        consecutiveFailures: 0,
+      });
+
+      execution.success = true;
+      this.addExecution(jobId, execution);
+
+    } catch (err) {
+      console.error(`[cron-scheduler] Job "${job.name}" failed:`, err);
+      execution.error = err instanceof Error ? err.message : String(err);
+      execution.completedAt = Date.now();
+      this.addExecution(jobId, execution);
+
+      const failures = job.consecutiveFailures + 1;
+      const updates: Partial<CronJob> = {
+        consecutiveFailures: failures,
+        lastRunAt: Date.now(),
+      };
+
+      // Auto-disable after too many failures
+      if (failures >= MAX_CONSECUTIVE_FAILURES) {
+        updates.enabled = false;
+        this.stopJob(jobId);
+        console.warn(`[cron-scheduler] Job "${job.name}" disabled after ${failures} consecutive failures`);
+      }
+
+      cronStore.updateJob(jobId, updates);
+    }
+  }
+
+  /** Manual trigger (run now regardless of schedule, bypasses enabled check). */
+  executeJobManually(jobId: string): void {
+    this.executeJob(jobId, { force: true }).catch((err) => {
+      console.error(`[cron-scheduler] Manual execution of job "${jobId}" failed:`, err);
+    });
+  }
+
+  /** Wait for CLI to be connected (poll up to timeout). */
+  private async waitForCLIConnection(sessionId: string): Promise<void> {
+    const start = Date.now();
+
+    while (Date.now() - start < CLI_CONNECT_TIMEOUT_MS) {
+      const info = this.launcher.getSession(sessionId);
+      if (info && (info.state === "connected" || info.state === "running")) {
+        return;
+      }
+      if (info?.state === "exited") {
+        throw new Error(`CLI process exited before connecting (exit code: ${info.exitCode})`);
+      }
+      await new Promise((r) => setTimeout(r, CLI_CONNECT_POLL_MS));
+    }
+
+    throw new Error(`CLI process did not connect within ${CLI_CONNECT_TIMEOUT_MS / 1000}s`);
+  }
+
+  /** Get next run time for a job. */
+  getNextRunTime(jobId: string): Date | null {
+    const timer = this.timers.get(jobId);
+    if (!timer) return null;
+    return timer.nextRun() || null;
+  }
+
+  /** Get recent executions for a job. */
+  getExecutions(jobId: string): CronJobExecution[] {
+    return this.executions.get(jobId) || [];
+  }
+
+  private addExecution(jobId: string, execution: CronJobExecution): void {
+    if (!this.executions.has(jobId)) {
+      this.executions.set(jobId, []);
+    }
+    const list = this.executions.get(jobId)!;
+    list.push(execution);
+    if (list.length > CronScheduler.MAX_EXECUTIONS_PER_JOB) {
+      list.splice(0, list.length - CronScheduler.MAX_EXECUTIONS_PER_JOB);
+    }
+  }
+
+  /** Stop all timers (for graceful shutdown). */
+  destroy(): void {
+    for (const timer of this.timers.values()) {
+      timer.stop();
+    }
+    this.timers.clear();
+    this.executions.clear();
+  }
+}