cueclaw 0.1.2 → 0.1.4

package/dist/{chunk-SEYPA5M2.js → chunk-3HV3MHME.js}

@@ -4,18 +4,23 @@ import {
   updateStepRunStatus,
   updateWorkflowPhase,
   updateWorkflowRunStatus
-} from "./chunk-G43R5ASK.js";
+} from "./chunk-HKZ6IN7X.js";
 import {
   cueclawHome,
+  getDefaultImage,
   loadConfig
-} from "./chunk-RSKXBXSJ.js";
+} from "./chunk-5TV4LNC3.js";
 import {
   ConfigError,
   ExecutorError
 } from "./chunk-BVQG3WYO.js";
 import {
+  isDev
+} from "./chunk-ZCK3IFLC.js";
+import {
+  createExecutionLogger,
   logger
-} from "./chunk-QBOYMF4A.js";
+} from "./chunk-KBLMQZ3P.js";
 
 // src/executor.ts
 import { nanoid as nanoid3 } from "nanoid";
@@ -239,7 +244,7 @@ async function runContainerAgent(opts) {
   mkdirSync2(opts.workDir, { recursive: true });
   mkdirSync2(join3(opts.ipcDir, "input"), { recursive: true });
   mkdirSync2(join3(opts.ipcDir, "output"), { recursive: true });
-  const image = config.container?.image ?? "cueclaw-agent:latest";
+  const image = config.container?.image ?? getDefaultImage();
   const network = config.container?.network ?? "none";
   const volumeMounts = buildVolumeMounts(opts);
   const dockerArgs = [
@@ -292,7 +297,8 @@ function buildVolumeMounts(opts) {
   return mounts;
 }
 async function spawnContainer(dockerArgs, opts, config) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
+    logger.info({ containerName: opts.containerName, image: dockerArgs[dockerArgs.length - 1] }, "Starting container");
     const proc = spawn("docker", dockerArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -348,8 +354,9 @@ async function spawnContainer(dockerArgs, opts, config) {
     proc.on("close", (code) => {
       clearTimeout(hardTimer);
       clearInterval(idleCheck);
+      logger.info({ containerName: opts.containerName, exitCode: code }, "Container exited");
       if (truncated) {
-        resolve({ status: "failed", error: "Container output size cap exceeded" });
+        resolve2({ status: "failed", error: "Container output size cap exceeded" });
         return;
       }
       const startIdx = stdout.indexOf(OUTPUT_START_MARKER);
@@ -358,7 +365,7 @@ async function spawnContainer(dockerArgs, opts, config) {
         resultBuffer = stdout.slice(startIdx + OUTPUT_START_MARKER.length + 1, endIdx).trim();
       }
       if (code !== 0 && !resultBuffer) {
-        resolve({
+        resolve2({
           status: "failed",
           error: stderr || `Container exited with code ${code}`
         });
@@ -366,16 +373,16 @@ async function spawnContainer(dockerArgs, opts, config) {
       }
       try {
         const parsed = JSON.parse(resultBuffer);
-        resolve({
+        resolve2({
           status: "succeeded",
           output: parsed.result ?? null,
           sessionId: parsed.sessionId
         });
       } catch {
         if (resultBuffer) {
-          resolve({ status: "succeeded", output: resultBuffer });
+          resolve2({ status: "succeeded", output: resultBuffer });
         } else {
-          resolve({
+          resolve2({
             status: "failed",
             error: stderr || "No output captured from container"
           });
@@ -385,7 +392,8 @@ async function spawnContainer(dockerArgs, opts, config) {
     proc.on("error", (err) => {
       clearTimeout(hardTimer);
       clearInterval(idleCheck);
-      resolve({
+      logger.error({ containerName: opts.containerName, err }, "Docker spawn error");
+      resolve2({
         status: "failed",
         error: `Docker spawn error: ${err.message}`
       });
@@ -393,6 +401,7 @@ async function spawnContainer(dockerArgs, opts, config) {
   });
 }
 function gracefulStop(containerName) {
+  logger.debug({ containerName }, "Gracefully stopping container");
   try {
     spawn("docker", ["stop", containerName]);
   } catch {
@@ -418,44 +427,123 @@ function prepareContainerOpts(workflowId, stepId, runId, prompt, cwd, allowedToo
   };
 }
 
+// src/container-runtime.ts
+import { execFileSync } from "child_process";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync3 } from "fs";
+var cached;
+var imageCache = /* @__PURE__ */ new Map();
+function isDockerAvailable() {
+  if (cached !== void 0) return cached;
+  try {
+    execFileSync("docker", ["info"], { encoding: "utf-8", stdio: "pipe" });
+    cached = true;
+  } catch {
+    cached = false;
+  }
+  return cached;
+}
+function isDockerImageAvailable(image) {
+  const hit = imageCache.get(image);
+  if (hit !== void 0) return hit;
+  try {
+    execFileSync("docker", ["image", "inspect", image], { encoding: "utf-8", stdio: "pipe" });
+    imageCache.set(image, true);
+    return true;
+  } catch {
+    imageCache.set(image, false);
+    return false;
+  }
+}
+function ensureDockerImage(image) {
+  if (isDockerImageAvailable(image)) return true;
+  if (isDev) {
+    return buildDevImage(image);
+  }
+  logger.info({ image }, "Docker image not found locally, attempting pull");
+  try {
+    execFileSync("docker", ["pull", image], { encoding: "utf-8", stdio: "pipe", timeout: 3e5 });
+    imageCache.set(image, true);
+    logger.info({ image }, "Docker image pulled successfully");
+    return true;
+  } catch (err) {
+    logger.warn({ image, err }, "Failed to pull Docker image");
+    return false;
+  }
+}
+function buildDevImage(image) {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const projectRoot = resolve(thisDir, "..");
+  const buildScript = resolve(projectRoot, "container", "build.sh");
+  if (!existsSync3(buildScript)) {
+    logger.warn({ buildScript }, "container/build.sh not found, cannot auto-build");
+    return false;
+  }
+  logger.info({ image }, "Dev mode: auto-building container image via container/build.sh");
+  try {
+    execFileSync("bash", [buildScript], {
+      encoding: "utf-8",
+      stdio: "inherit",
+      cwd: resolve(projectRoot, "container")
+    });
+    imageCache.set(image, true);
+    logger.info({ image }, "Dev mode: container image built successfully");
+    return true;
+  } catch (err) {
+    logger.warn({ image, err }, "Dev mode: container image build failed");
+    return false;
+  }
+}
+
 // src/agent-runner.ts
 function runAgent(opts) {
   const config = loadConfig();
-  if (config.container?.enabled && opts.workflowId && opts.stepId && opts.runId) {
-    const containerOpts = prepareContainerOpts(
-      opts.workflowId,
-      opts.stepId,
-      opts.runId,
-      opts.prompt,
-      opts.cwd,
-      opts.allowedTools
-    );
-    const resultPromise2 = runContainerAgent({
-      ...containerOpts,
-      signal: opts.signal,
-      onProgress: opts.onProgress
-    });
-    return {
-      resultPromise: resultPromise2,
-      abort: () => {
-        try {
-          import("child_process").then(({ spawn: spawn2 }) => {
-            spawn2("docker", ["stop", containerOpts.containerName]);
-          });
-        } catch {
+  const containerEnabled = config.container?.enabled ?? false;
+  if (containerEnabled && opts.workflowId && opts.stepId && opts.runId) {
+    if (!isDockerAvailable()) {
+      logger.warn({ stepId: opts.stepId }, "Docker not available, falling back to local execution");
+    } else if (!ensureDockerImage(config.container?.image ?? getDefaultImage())) {
+      logger.warn({ stepId: opts.stepId, image: config.container?.image ?? getDefaultImage() }, "Docker image not available (pull failed), falling back to local execution");
+    } else {
+      logger.info({ stepId: opts.stepId, mode: "container" }, "Running agent in container mode");
+      const containerOpts = prepareContainerOpts(
+        opts.workflowId,
+        opts.stepId,
+        opts.runId,
+        opts.prompt,
+        opts.cwd,
+        opts.allowedTools
+      );
+      const resultPromise2 = runContainerAgent({
+        ...containerOpts,
+        signal: opts.signal,
+        onProgress: opts.onProgress
+      });
+      return {
+        resultPromise: resultPromise2,
+        abort: () => {
+          try {
+            import("child_process").then(({ spawn: spawn2 }) => {
+              spawn2("docker", ["stop", containerOpts.containerName]);
+            });
+          } catch {
+          }
         }
-      }
-    };
+      };
+    }
   }
+  logger.info({ stepId: opts.stepId, mode: "local" }, "Running agent in local mode");
   let aborted = false;
   const resultPromise = (async () => {
     const authToken = config.claude.executor.api_key ?? config.claude.api_key;
     const baseUrl = config.claude.executor.base_url ?? config.claude.base_url;
-    const prevAuthToken = process.env["ANTHROPIC_AUTH_TOKEN"];
-    const prevBaseUrl = process.env["ANTHROPIC_BASE_URL"];
-    process.env["ANTHROPIC_AUTH_TOKEN"] = authToken;
+    const stepEnv = { ...process.env };
+    if (authToken) stepEnv["ANTHROPIC_AUTH_TOKEN"] = authToken;
     if (baseUrl !== "https://api.anthropic.com") {
-      process.env["ANTHROPIC_BASE_URL"] = baseUrl;
+      stepEnv["ANTHROPIC_BASE_URL"] = baseUrl;
+    } else {
+      delete stepEnv["ANTHROPIC_BASE_URL"];
     }
     try {
       const { query } = await import("@anthropic-ai/claude-agent-sdk");
@@ -477,7 +565,8 @@ function runAgent(opts) {
             "WebFetch"
           ],
           settingSources: ["project"],
-          permissionMode: permMode
+          permissionMode: permMode,
+          env: stepEnv
         }
       });
       let sessionId;
@@ -511,16 +600,13 @@ function runAgent(opts) {
         }
         opts.onProgress?.(message);
       }
+      logger.debug({ stepId: opts.stepId, status: "succeeded" }, "Agent completed");
       return { status: "succeeded", output: result, sessionId };
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       logger.error({ err, stepId: opts.stepId }, "Agent execution failed");
       return { status: "failed", error: errorMsg };
     } finally {
-      if (prevAuthToken !== void 0) process.env["ANTHROPIC_AUTH_TOKEN"] = prevAuthToken;
-      else delete process.env["ANTHROPIC_AUTH_TOKEN"];
-      if (prevBaseUrl !== void 0) process.env["ANTHROPIC_BASE_URL"] = prevBaseUrl;
-      else delete process.env["ANTHROPIC_BASE_URL"];
     }
   })();
   return {
@@ -547,13 +633,22 @@ function createSession(db, stepRunId, sdkSessionId) {
     INSERT INTO sessions (id, step_run_id, sdk_session_id, created_at, last_used_at, is_active)
     VALUES (?, ?, ?, ?, ?, ?)
   `).run(session.id, session.step_run_id, session.sdk_session_id ?? null, session.created_at, session.last_used_at, 1);
+  logger.debug({ sessionId: session.id, stepRunId }, "Session created");
   return session;
 }
 function deactivateSession(db, sessionId) {
   db.prepare("UPDATE sessions SET is_active = 0, last_used_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), sessionId);
+  logger.debug({ sessionId }, "Session deactivated");
 }
 function updateSessionSdkId(db, sessionId, sdkSessionId) {
   db.prepare("UPDATE sessions SET sdk_session_id = ?, last_used_at = ? WHERE id = ?").run(sdkSessionId, (/* @__PURE__ */ new Date()).toISOString(), sessionId);
+  logger.debug({ sessionId, sdkSessionId }, "Session SDK ID updated");
+}
+function cleanupStaleSessions(db, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
+  const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+  const result = db.prepare("DELETE FROM sessions WHERE is_active = 0 AND last_used_at < ?").run(cutoff);
+  logger.info({ deletedCount: result.changes, cutoff }, "Stale sessions cleaned up");
+  return result.changes;
 }
 
 // src/executor.ts
@@ -599,7 +694,7 @@ function hasSkipMarker(inputs) {
   }
   return false;
 }
-async function executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress) {
+async function executeStepOnce(step, resolvedInputs, workflowId, runId, db, cwd, onProgress, execLogger) {
   const stepRunId = `sr_${nanoid3()}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stepRun = {
@@ -610,6 +705,7 @@ async function executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress)
     started_at: now
   };
   insertStepRun(db, stepRun);
+  execLogger?.info({ stepId: step.id, stepRunId, attempt: "start" }, `Step started: ${step.id}`);
   const inputContext = Object.keys(resolvedInputs).length > 0 ? `
 
 Inputs:
@@ -618,7 +714,7 @@ ${JSON.stringify(resolvedInputs, null, 2)}` : "";
   const handle = runAgent({
     prompt,
     cwd,
-    workflowId: step.id,
+    workflowId,
     stepId: step.id,
     runId,
     onProgress: onProgress ? (msg) => onProgress(step.id, msg) : void 0
@@ -628,15 +724,21 @@ ${JSON.stringify(resolvedInputs, null, 2)}` : "";
     const session = createSession(db, stepRunId, result.sessionId);
     updateSessionSdkId(db, session.id, result.sessionId);
     deactivateSession(db, session.id);
+    execLogger?.debug({ stepId: step.id, sessionId: session.id }, "Session stored");
   }
   updateStepRunStatus(db, stepRunId, result.status, result.output ?? void 0, result.error);
+  if (result.status === "failed") {
+    execLogger?.error({ stepId: step.id, stepRunId, error: result.error }, `Step failed: ${step.id}`);
+  } else {
+    execLogger?.info({ stepId: step.id, stepRunId, status: result.status }, `Step completed: ${step.id}`);
+  }
   return result;
 }
-async function executeStepWithRetry(step, resolvedInputs, runId, db, cwd, policy, onProgress) {
+async function executeStepWithRetry(step, resolvedInputs, workflowId, runId, db, cwd, policy, onProgress, execLogger) {
   const maxRetries = policy.max_retries ?? 0;
   let delay = policy.retry_delay_ms ?? 5e3;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const result = await executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress);
+    const result = await executeStepOnce(step, resolvedInputs, workflowId, runId, db, cwd, onProgress, execLogger);
     if (result.status !== "failed" || attempt === maxRetries) return result;
     logger.info({ stepId: step.id, attempt, delay }, "Retrying step");
     await new Promise((r) => setTimeout(r, delay));
@@ -656,6 +758,8 @@ async function executeWorkflow(opts) {
   };
   insertWorkflowRun(db, run);
   updateWorkflowPhase(db, workflow.id, "executing");
+  const execLogger = createExecutionLogger(workflow.id, runId);
+  execLogger.info({ workflowId: workflow.id, runId, steps: workflow.steps.length }, "Workflow execution started");
   const completed = /* @__PURE__ */ new Map();
   const remaining = new Set(workflow.steps.map((s) => s.id));
   const stepMap = new Map(workflow.steps.map((s) => [s.id, s]));
@@ -663,6 +767,7 @@ async function executeWorkflow(opts) {
   try {
     while (remaining.size > 0) {
       if (signal?.aborted) {
+        execLogger.warn({ workflowId: workflow.id, runId, remainingSteps: remaining.size }, "Execution aborted via signal");
         for (const id of remaining) {
           completed.set(id, { status: "skipped", error: "Aborted" });
           onProgress?.(id, { status: "skipped" });
@@ -676,6 +781,7 @@ async function executeWorkflow(opts) {
         return step.depends_on.every((dep) => completed.has(dep));
       });
       if (ready.length === 0) {
+        execLogger.error({ workflowId: workflow.id, runId, remaining: [...remaining] }, "Deadlock detected");
         throw new ExecutorError("Deadlock: no ready steps but remaining steps exist");
       }
       const executable = [];
@@ -685,6 +791,7 @@ async function executeWorkflow(opts) {
           (dep) => completed.get(dep)?.status === "failed" || completed.get(dep)?.status === "skipped"
         );
         if (depsFailed && workflow.failure_policy.on_step_failure !== "ask_user") {
+          execLogger.debug({ stepId: id, reason: "dependency_failed" }, "Step skipped");
           remaining.delete(id);
           completed.set(id, { status: "skipped" });
           const skipRunId = `sr_${nanoid3()}`;
@@ -693,6 +800,7 @@ async function executeWorkflow(opts) {
         }
         const resolvedInputs = resolveInputs(step.inputs, completed, triggerData);
         if (hasSkipMarker(resolvedInputs)) {
+          execLogger.debug({ stepId: id, reason: "skip_marker" }, "Step skipped");
           remaining.delete(id);
           completed.set(id, { status: "skipped" });
           const skipRunId = `sr_${nanoid3()}`;
@@ -709,20 +817,38 @@ async function executeWorkflow(opts) {
           const result = await executeStepWithRetry(
             step,
             resolvedInputs,
+            workflow.id,
             runId,
             db,
             cwd,
             workflow.failure_policy,
-            onProgress
+            onProgress,
+            execLogger
           );
           return { stepId: step.id, result };
         })
       );
       for (const { stepId, result } of results) {
         completed.set(stepId, result);
-        if (result.status === "failed") {
-          const policy = workflow.failure_policy.on_step_failure;
-          if (policy === "stop") {
+      }
+      for (const { stepId, result } of results) {
+        if (result.status !== "failed") continue;
+        const policy = workflow.failure_policy.on_step_failure;
+        if (policy === "stop") {
+          execLogger.warn({ stepId, policy: "stop" }, "Stop policy triggered, skipping remaining steps");
+          for (const remainingId of remaining) {
+            completed.set(remainingId, { status: "skipped" });
+            const skipRunId = `sr_${nanoid3()}`;
+            insertStepRun(db, { id: skipRunId, run_id: runId, step_id: remainingId, status: "skipped" });
+          }
+          remaining.clear();
+          runFailed = true;
+          break;
+        }
+        if (policy === "ask_user" && onStepFailure) {
+          const decision = await onStepFailure(stepMap.get(stepId), result.error ?? "Unknown error");
+          execLogger.info({ stepId, decision }, "ask_user decision received");
+          if (decision === "stop") {
             for (const remainingId of remaining) {
               completed.set(remainingId, { status: "skipped" });
               const skipRunId = `sr_${nanoid3()}`;
@@ -732,18 +858,11 @@ async function executeWorkflow(opts) {
             runFailed = true;
             break;
           }
-          if (policy === "ask_user" && onStepFailure) {
-            const decision = await onStepFailure(stepMap.get(stepId), result.error ?? "Unknown error");
-            if (decision === "stop") {
-              for (const remainingId of remaining) {
-                completed.set(remainingId, { status: "skipped" });
-                const skipRunId = `sr_${nanoid3()}`;
-                insertStepRun(db, { id: skipRunId, run_id: runId, step_id: remainingId, status: "skipped" });
-              }
-              remaining.clear();
-              runFailed = true;
-              break;
-            }
+          if (decision === "retry") {
+            remaining.add(stepId);
+            completed.delete(stepId);
+            execLogger.info({ stepId }, "Re-queuing step for retry");
+            continue;
           }
         }
       }
@@ -759,10 +878,12 @@ async function executeWorkflow(opts) {
   } else {
     updateWorkflowPhase(db, workflow.id, "active");
   }
+  execLogger.info({ workflowId: workflow.id, runId, status: finalStatus }, "Workflow execution finished");
   return { runId, status: finalStatus, results: completed };
 }
 
 export {
+  cleanupStaleSessions,
   resolveValue,
   resolveInputs,
   executeWorkflow