@digitalpresence/cliclaw 0.1.2 → 0.2.1

package/src/cron/ralph-wiggum.ts

@@ -1,15 +1,14 @@
-import { query, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";
-import { existsSync, mkdirSync, writeFileSync, readFileSync, realpathSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join } from "path";
 import type { AgentStore, CronJobConfig } from "@digitalpresence/cliclaw-auth";
 import { getProgressFilePath, ensureCronDirs, writeRunningMarker, clearRunningMarker } from "./progress.js";
 import { cronLog } from "./logger.js";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
 const CONTINUE_MARKER = "NEEDS_MORE_ITERATIONS";
+const CONTAINER_IMAGE = "cliclaw-agent";
+const CONTAINER_TIMEOUT_MS = 300_000; // 5 minutes per iteration
 
 export type TranscriptBlock =
   | { type: "assistant"; content: string }
@@ -22,6 +21,81 @@ export interface RalphWiggumResult {
   transcript: TranscriptBlock[];
 }
 
+function loadTaskContent(store: AgentStore, agentName: string, job: CronJobConfig): string {
+  const taskFilePath = join(store.workspacePath(agentName), "cron-tasks", job.taskFile);
+  if (existsSync(taskFilePath)) {
+    return readFileSync(taskFilePath, "utf-8");
+  }
+  return `Task file not found: ${job.taskFile}`;
+}
+
+/**
+ * Run a single iteration inside a Docker container.
+ * Returns parsed NDJSON events.
+ */
+async function runContainerIteration(
+  instancePath: string,
+  prompt: string,
+  sessionId?: string,
+): Promise<{ events: any[]; exitCode: number }> {
+  // Write session.json
+  writeFileSync(
+    join(instancePath, "session.json"),
+    JSON.stringify({ prompt, ...(sessionId ? { sessionId } : {}) }),
+    "utf-8",
+  );
+
+  const args = [
+    "run", "--rm", "-i",
+    "-v", `${instancePath}:/instance`,
+    "--network=host",
+    "--cpus=2", "--memory=2g",
+  ];
+
+  // Pass API key
+  if (process.env.ANTHROPIC_API_KEY) {
+    args.push("-e", `ANTHROPIC_API_KEY=${process.env.ANTHROPIC_API_KEY}`);
+  }
+
+  args.push(CONTAINER_IMAGE);
+
+  return new Promise((resolve) => {
+    const child = spawn("docker", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+    }, CONTAINER_TIMEOUT_MS);
+
+    const events: any[] = [];
+    const rl = createInterface({ input: child.stdout! });
+
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+        // skip malformed lines
+      }
+    });
+
+    let stderr = "";
+    child.stderr!.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      rl.close();
+      if (stderr.trim()) {
+        console.error(`[ralph-wiggum] container stderr: ${stderr.trim()}`);
+      }
+      resolve({ events, exitCode: code ?? 1 });
+    });
+  });
+}
+
 export async function executeRalphWiggumLoop(
   store: AgentStore,
   agentName: string,
@@ -31,29 +105,33 @@ export async function executeRalphWiggumLoop(
   ensureCronDirs(agentName, job.id);
   writeRunningMarker(agentName, job.id, startedAt ?? new Date().toISOString());
 
-  const workspacePath = store.workspacePath(agentName);
-  const progressFile = getProgressFilePath(agentName, job.id);
-
-  try {
-    // Ensure cliclaw CLI is in PATH
-    const cleanEnv = { ...process.env };
-    delete cleanEnv.CLAUDECODE;
-
-    const monorepoRoot = join(__dirname, "..", "..", "..");
-    const binScript = join(monorepoRoot, "packages", "cliclaw", "dist", "cli.js");
-    if (existsSync(binScript)) {
-      const resolvedBin = realpathSync(binScript);
-      const localBin = join(workspacePath, ".bin");
-      if (!existsSync(localBin)) mkdirSync(localBin, { recursive: true });
-      const wrapper = join(localBin, "cliclaw");
-      writeFileSync(wrapper, `#!/bin/sh\nexec node "${resolvedBin}" "$@"\n`, { mode: 0o755 });
-      cleanEnv.PATH = `${localBin}:${cleanEnv.PATH ?? ""}`;
+  // Use the cron instance path
+  const instancesDir = join(store.workspacePath(agentName), "..", "..", "instances");
+  const cronInstancePath = join(instancesDir, agentName, "_cron");
+
+  // Ensure cron instance exists with necessary files
+  if (!existsSync(cronInstancePath)) {
+    mkdirSync(join(cronInstancePath, "workspace"), { recursive: true });
+    mkdirSync(join(cronInstancePath, "memory"), { recursive: true });
+
+    // Copy template files
+    const agentDir = store.workspacePath(agentName);
+    for (const file of ["SOUL.md", "ROLE.md"]) {
+      const src = join(agentDir, file);
+      if (existsSync(src)) {
+        writeFileSync(join(cronInstancePath, file), readFileSync(src, "utf-8"));
+      }
     }
+  }
 
-    let totalCostUsd = 0;
-    let sessionId: string | undefined;
-    const transcript: TranscriptBlock[] = [];
+  const progressFile = getProgressFilePath(agentName, job.id);
+  const taskContent = loadTaskContent(store, agentName, job);
+
+  let totalCostUsd = 0;
+  let sessionId: string | undefined;
+  const transcript: TranscriptBlock[] = [];
 
+  try {
     for (let iteration = 1; iteration <= job.maxIterations; iteration++) {
       cronLog("info", `Iteration ${iteration}/${job.maxIterations}`, agentName, job.id);
 
@@ -70,47 +148,31 @@ export async function executeRalphWiggumLoop(
         prompt = [
           `You are executing a scheduled task. Here are your instructions:`,
           ``,
-          `${job.task}`,
+          taskContent,
           ``,
-          `Write your output/progress to: ${progressFile}`,
+          `Write your output/progress to: /instance/workspace/progress.md`,
           ``,
-          `If you CANNOT finish the task in this iteration and need to be re-invoked, write "${CONTINUE_MARKER}" anywhere in ${progressFile}. Otherwise, just complete the task normally — no special signal is needed.`,
+          `If you CANNOT finish the task in this iteration and need to be re-invoked, write "${CONTINUE_MARKER}" anywhere in the progress file. Otherwise, just complete the task normally — no special signal is needed.`,
         ].join("\n");
       } else {
         prompt = [
-          `You are continuing a scheduled task. Read your progress file at: ${progressFile}`,
+          `You are continuing a scheduled task. Read your progress file at: /instance/workspace/progress.md`,
           `Continue from where you left off.`,
           ``,
-          `Original task: ${job.task}`,
+          `Original task:`,
+          taskContent,
           ``,
-          `If you CANNOT finish the task in this iteration and need to be re-invoked, write "${CONTINUE_MARKER}" anywhere in ${progressFile}. Otherwise, just complete the task normally — no special signal is needed.`,
+          `If you CANNOT finish the task in this iteration and need to be re-invoked, write "${CONTINUE_MARKER}" anywhere in the progress file. Otherwise, just complete the task normally — no special signal is needed.`,
         ].join("\n");
       }
 
-      const conversation = query({
-        prompt,
-        options: {
-          cwd: workspacePath,
-          env: cleanEnv,
-          systemPrompt: { type: "preset" as const, preset: "claude_code" as const },
-          settingSources: ["project"],
-          includePartialMessages: true,
-          allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
-          ...(sessionId ? { resume: sessionId } : {}),
-        },
-      });
+      const { events } = await runContainerIteration(cronInstancePath, prompt, sessionId);
 
+      // Process events into transcript
       let currentToolInput = "";
-
-      for await (const event of conversation) {
-        const msg = event as SDKMessage;
-
-        if (msg.type === "stream_event" && (msg as any).event) {
-          const streamEvent = (msg as any).event as {
-            type: string;
-            content_block?: { type: string; name?: string; id?: string };
-            delta?: { type: string; text?: string; partial_json?: string };
-          };
+      for (const event of events) {
+        if (event.type === "stream_event" && event.event) {
+          const streamEvent = event.event;
 
           if (streamEvent.type === "content_block_start" && streamEvent.content_block?.type === "tool_use") {
             transcript.push({ type: "tool", name: streamEvent.content_block.name ?? "unknown", done: false });
@@ -137,26 +199,32 @@ export async function executeRalphWiggumLoop(
             }
             currentToolInput = "";
           }
-        } else if ((msg as any).type === "tool_result") {
+        } else if (event.type === "tool_result") {
           const lastTool = [...transcript].reverse().find((b) => b.type === "tool" && !b.done);
           if (lastTool && lastTool.type === "tool") {
             lastTool.done = true;
           }
-        } else if (msg.type === "result") {
-          if ("total_cost_usd" in msg) {
-            totalCostUsd += (msg.total_cost_usd as number) ?? 0;
+        } else if (event.type === "result") {
+          if (event.total_cost_usd) {
+            totalCostUsd += event.total_cost_usd;
           }
-          if (msg.session_id) {
-            sessionId = msg.session_id;
+          if (event.session_id) {
+            sessionId = event.session_id;
           }
         }
       }
 
       // Check if the agent needs more iterations by reading the progress file
-      const needsMore = existsSync(progressFile) &&
+      // In container mode, progress is written to workspace/progress.md
+      const containerProgressFile = join(cronInstancePath, "workspace", "progress.md");
+      const needsMore = existsSync(containerProgressFile) &&
+        readFileSync(containerProgressFile, "utf-8").includes(CONTINUE_MARKER);
+
+      // Also check the original progress file location
+      const needsMoreOriginal = existsSync(progressFile) &&
         readFileSync(progressFile, "utf-8").includes(CONTINUE_MARKER);
 
-      if (!needsMore) {
+      if (!needsMore && !needsMoreOriginal) {
         cronLog("info", `Task completed at iteration ${iteration}`, agentName, job.id);
         return { completed: true, iterations: iteration, totalCostUsd, transcript };
       }