cueclaw 0.0.3 → 0.1.0

package/dist/{chunk-D77G7ABJ.js → chunk-SEYPA5M2.js}

@@ -4,316 +4,21 @@ import {
   updateStepRunStatus,
   updateWorkflowPhase,
   updateWorkflowRunStatus
-} from "./chunk-K4PGB2DU.js";
+} from "./chunk-G43R5ASK.js";
 import {
-  ConfigError,
-  ExecutorError,
-  PlannerError,
   cueclawHome,
   loadConfig
-} from "./chunk-JRHM3Z4C.js";
+} from "./chunk-RSKXBXSJ.js";
+import {
+  ConfigError,
+  ExecutorError
+} from "./chunk-BVQG3WYO.js";
 import {
   logger
-} from "./chunk-E7BP6DMO.js";
-
-// src/planner.ts
-import Anthropic from "@anthropic-ai/sdk";
-import { z } from "zod/v4";
-import { nanoid } from "nanoid";
-
-// src/workflow.ts
-function validateDAG(steps) {
-  const errors = [];
-  const stepIds = new Set(steps.map((s) => s.id));
-  for (const step of steps) {
-    for (const dep of step.depends_on) {
-      if (!stepIds.has(dep)) {
-        errors.push(`Step "${step.id}" depends on unknown step "${dep}"`);
-      }
-    }
-  }
-  for (const step of steps) {
-    const refs = extractStepRefs(step.inputs);
-    for (const ref of refs) {
-      if (!stepIds.has(ref)) {
-        errors.push(`Step "${step.id}" references unknown step "${ref}" in inputs`);
-      }
-      if (stepIds.has(ref) && !step.depends_on.includes(ref)) {
-        errors.push(`Step "${step.id}" references "$steps.${ref}.output" but does not list "${ref}" in depends_on`);
-      }
-    }
-  }
-  if (hasCycle(steps)) {
-    errors.push("DAG contains a cycle");
-  }
-  return errors;
-}
-function extractStepRefs(obj) {
-  const refs = [];
-  const pattern = /\$steps\.([a-z0-9-]+)\.output/g;
-  function walk(value) {
-    if (typeof value === "string") {
-      let match;
-      while ((match = pattern.exec(value)) !== null) {
-        refs.push(match[1]);
-      }
-      pattern.lastIndex = 0;
-    } else if (Array.isArray(value)) {
-      for (const item of value) walk(item);
-    } else if (value !== null && typeof value === "object") {
-      for (const v of Object.values(value)) walk(v);
-    }
-  }
-  walk(obj);
-  return refs;
-}
-function hasCycle(steps) {
-  const inDegree = /* @__PURE__ */ new Map();
-  const adjacency = /* @__PURE__ */ new Map();
-  for (const step of steps) {
-    inDegree.set(step.id, 0);
-    adjacency.set(step.id, []);
-  }
-  for (const step of steps) {
-    for (const dep of step.depends_on) {
-      if (adjacency.has(dep)) {
-        adjacency.get(dep).push(step.id);
-        inDegree.set(step.id, (inDegree.get(step.id) ?? 0) + 1);
-      }
-    }
-  }
-  const queue = [];
-  for (const [id, deg] of inDegree) {
-    if (deg === 0) queue.push(id);
-  }
-  let processed = 0;
-  while (queue.length > 0) {
-    const current = queue.shift();
-    processed++;
-    for (const neighbor of adjacency.get(current) ?? []) {
-      const newDeg = (inDegree.get(neighbor) ?? 1) - 1;
-      inDegree.set(neighbor, newDeg);
-      if (newDeg === 0) queue.push(neighbor);
-    }
-  }
-  return processed !== steps.length;
-}
-
-// src/planner.ts
-var PlanStepSchema = z.object({
-  id: z.string(),
-  description: z.string(),
-  expected_output: z.string().optional(),
-  agent: z.literal("claude"),
-  inputs: z.record(z.string(), z.any()),
-  depends_on: z.array(z.string())
-});
-var TriggerConfigSchema = z.union([
-  z.object({
-    type: z.literal("poll"),
-    interval_seconds: z.number(),
-    check_script: z.string(),
-    diff_mode: z.enum(["new_items", "any_change"])
-  }),
-  z.object({
-    type: z.literal("cron"),
-    expression: z.string(),
-    timezone: z.string().optional()
-  }),
-  z.object({ type: z.literal("manual") })
-]);
-var FailurePolicySchema = z.object({
-  on_step_failure: z.enum(["stop", "skip_dependents", "ask_user"]),
-  max_retries: z.number(),
-  retry_delay_ms: z.number()
-});
-var PlannerOutputSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  trigger: TriggerConfigSchema,
-  steps: z.array(PlanStepSchema).min(1),
-  failure_policy: FailurePolicySchema
-});
-var plannerOutputJsonSchema = {
-  type: "object",
-  required: ["name", "description", "trigger", "steps", "failure_policy"],
-  properties: {
-    name: { type: "string", description: "Short workflow name" },
-    description: { type: "string", description: "User's original natural language description" },
-    trigger: {
-      type: "object",
-      description: "Trigger configuration",
-      properties: {
-        type: { type: "string", enum: ["poll", "cron", "manual"] },
-        interval_seconds: { type: "number" },
-        check_script: { type: "string" },
-        diff_mode: { type: "string", enum: ["new_items", "any_change"] },
-        expression: { type: "string" },
-        timezone: { type: "string" }
-      },
-      required: ["type"]
-    },
-    steps: {
-      type: "array",
-      items: {
-        type: "object",
-        required: ["id", "description", "agent", "inputs", "depends_on"],
-        properties: {
-          id: { type: "string", description: "kebab-case step ID" },
-          description: { type: "string", description: "Detailed step description for the agent" },
-          expected_output: { type: "string" },
-          agent: { type: "string", enum: ["claude"] },
-          inputs: { type: "object", description: "Step inputs, may use $steps.{id}.output or $trigger_data" },
-          depends_on: { type: "array", items: { type: "string" }, description: "Step IDs this step depends on" }
-        }
-      },
-      minItems: 1
-    },
-    failure_policy: {
-      type: "object",
-      required: ["on_step_failure", "max_retries", "retry_delay_ms"],
-      properties: {
-        on_step_failure: { type: "string", enum: ["stop", "skip_dependents", "ask_user"] },
-        max_retries: { type: "number" },
-        retry_delay_ms: { type: "number" }
-      }
-    }
-  }
-};
-var plannerTool = {
-  name: "create_workflow",
-  description: "Create a workflow definition from the user description. Generate steps as a DAG with proper dependencies.",
-  input_schema: plannerOutputJsonSchema
-};
-function buildPlannerSystemPrompt(config) {
-  const identity = config.identity?.name ? `
-User identity: ${config.identity.name}` : "";
-  return `You are CueClaw Planner. Convert user's natural language into a structured Workflow.
-
-## Execution Environment
-
-All steps are executed by the Claude Agent SDK. The agent has Bash and can use
-any CLI tool installed locally. It auto-loads .claude/skills/.
-You don't need to verify tool availability \u2014 the agent detects at runtime.
-
-## Rules
-
-1. Every step's agent field is "claude" (Claude Agent SDK execution)
-2. Step description uses natural language \u2014 the agent decides which tools to use
-3. depends_on must reference defined step IDs, forming a valid DAG (no cycles)
-4. Step IDs use kebab-case: "fetch-issues", "create-branch"
-5. Use $steps.{id}.output in inputs to reference prior step results
-6. Use $trigger_data in inputs to reference the trigger's output data
-7. Do NOT generate position, phase, schema_version, status, or timestamp fields (framework auto-fills). You MUST generate step id fields.
-8. Trigger check_script can use any shell commands
-9. Step description should be detailed enough for the agent to execute independently \u2014 not just a one-line summary
-10. Input keys use snake_case (e.g., issue_number, repo_path)
-11. Steps must NOT include a status field \u2014 the framework sets all steps to pending automatically
-12. Step output is a plain text string \u2014 downstream agents parse structure themselves
-
-## User Identity
-${identity}`;
-}
-async function generatePlan(userDescription, config) {
-  const anthropic = new Anthropic({ apiKey: config.claude.api_key });
-  const MAX_RETRIES = 2;
-  let retryContext = "";
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    const prompt = retryContext ? `${userDescription}
-
-${retryContext}` : userDescription;
-    logger.debug({ attempt, hasRetryContext: !!retryContext }, "Planner attempt");
-    const response = await anthropic.messages.create({
-      model: config.claude.planner.model,
-      max_tokens: 4096,
-      system: buildPlannerSystemPrompt(config),
-      messages: [{ role: "user", content: prompt }],
-      tools: [plannerTool],
-      tool_choice: { type: "tool", name: "create_workflow" }
-    });
-    const toolBlock = response.content.find((b) => b.type === "tool_use");
-    if (!toolBlock || toolBlock.type !== "tool_use") {
-      throw new PlannerError("Unexpected planner response format: no tool_use block");
-    }
-    const parseResult = PlannerOutputSchema.safeParse(toolBlock.input);
-    if (!parseResult.success) {
-      const errMsg = parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      if (attempt < MAX_RETRIES) {
-        retryContext = `[System] Previous plan had validation issues:
-${errMsg}
-Please fix and try again.`;
-        continue;
-      }
-      throw new PlannerError(`Invalid plan after ${MAX_RETRIES + 1} attempts: ${errMsg}`);
-    }
-    const dagErrors = validateDAG(parseResult.data.steps);
-    if (dagErrors.length > 0) {
-      if (attempt < MAX_RETRIES) {
-        retryContext = `[System] DAG dependency issues:
-${dagErrors.join("\n")}
-Please fix the step dependencies.`;
-        continue;
-      }
-      throw new PlannerError(`DAG validation failed after ${MAX_RETRIES + 1} attempts: ${dagErrors.join(", ")}`);
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return {
-      ...parseResult.data,
-      schema_version: "1.0",
-      id: `wf_${nanoid()}`,
-      phase: "awaiting_confirmation",
-      created_at: now,
-      updated_at: now
-    };
-  }
-  throw new PlannerError("Failed to generate valid plan after retries");
-}
-async function modifyPlan(originalWorkflow, modificationDescription, config) {
-  const plannerOutput = {
-    name: originalWorkflow.name,
-    description: originalWorkflow.description,
-    trigger: originalWorkflow.trigger,
-    steps: originalWorkflow.steps,
-    failure_policy: originalWorkflow.failure_policy
-  };
-  const combinedPrompt = `Here is the current workflow plan:
-\`\`\`json
-${JSON.stringify(plannerOutput, null, 2)}
-\`\`\`
-
-The user wants to modify it as follows:
-${modificationDescription}
-
-Preserve unmodified steps' IDs, descriptions, and dependencies \u2014 only change what the user specified.
-Return the complete modified workflow using the create_workflow tool.`;
-  const result = await generatePlan(combinedPrompt, config);
-  return {
-    ...result,
-    id: originalWorkflow.id,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function confirmPlan(workflow) {
-  if (workflow.phase !== "awaiting_confirmation") {
-    throw new PlannerError(`Cannot confirm workflow in phase "${workflow.phase}"`);
-  }
-  const nextPhase = workflow.trigger.type === "manual" ? "executing" : "active";
-  return {
-    ...workflow,
-    phase: nextPhase,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function rejectPlan(workflow) {
-  return {
-    ...workflow,
-    phase: "planning",
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
+} from "./chunk-QBOYMF4A.js";
 
 // src/executor.ts
-import { nanoid as nanoid4 } from "nanoid";
+import { nanoid as nanoid3 } from "nanoid";
 
 // src/hooks.ts
 function checkBashSafety(command) {
@@ -402,7 +107,7 @@ import {
   mkdirSync
 } from "fs";
 import { join as join2 } from "path";
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid } from "nanoid";
 var IpcWatcher = class {
   constructor(workflowId, _stepId, ipcDir, onMessage, pollInterval = 500) {
     this.workflowId = workflowId;
@@ -451,7 +156,7 @@ var IpcWatcher = class {
   sendToContainer(msg) {
     const inputDir = join2(this.ipcDir, "input");
     mkdirSync(inputDir, { recursive: true });
-    const filename = `${Date.now()}-${nanoid2(6)}.json`;
+    const filename = `${Date.now()}-${nanoid(6)}.json`;
     const tempPath = join2(inputDir, `.${filename}.tmp`);
     const finalPath = join2(inputDir, filename);
     writeFileSync2(tempPath, JSON.stringify(msg));
@@ -744,8 +449,17 @@ function runAgent(opts) {
   }
   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;
+    if (baseUrl !== "https://api.anthropic.com") {
+      process.env["ANTHROPIC_BASE_URL"] = baseUrl;
+    }
     try {
       const { query } = await import("@anthropic-ai/claude-agent-sdk");
+      const permMode = config.claude.executor.skip_permissions ? "dangerously-skip-permissions" : "default";
       const q = query({
         prompt: opts.prompt,
         options: {
@@ -763,7 +477,7 @@ function runAgent(opts) {
             "WebFetch"
           ],
           settingSources: ["project"],
-          permissionMode: "default"
+          permissionMode: permMode
         }
       });
       let sessionId;
@@ -802,6 +516,11 @@ function runAgent(opts) {
       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 {
@@ -813,11 +532,11 @@ function runAgent(opts) {
 }
 
 // src/session.ts
-import { nanoid as nanoid3 } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
 function createSession(db, stepRunId, sdkSessionId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const session = {
-    id: `sess_${nanoid3()}`,
+    id: `sess_${nanoid2()}`,
     step_run_id: stepRunId,
     sdk_session_id: sdkSessionId,
     created_at: now,
@@ -881,7 +600,7 @@ function hasSkipMarker(inputs) {
   return false;
 }
 async function executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress) {
-  const stepRunId = `sr_${nanoid4()}`;
+  const stepRunId = `sr_${nanoid3()}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stepRun = {
     id: stepRunId,
@@ -927,7 +646,7 @@ async function executeStepWithRetry(step, resolvedInputs, runId, db, cwd, policy
 }
 async function executeWorkflow(opts) {
   const { workflow, triggerData, db, cwd, onStepFailure, onProgress, signal } = opts;
-  const runId = `run_${nanoid4()}`;
+  const runId = `run_${nanoid3()}`;
   const run = {
     id: runId,
     workflow_id: workflow.id,
@@ -946,6 +665,7 @@ async function executeWorkflow(opts) {
       if (signal?.aborted) {
         for (const id of remaining) {
           completed.set(id, { status: "skipped", error: "Aborted" });
+          onProgress?.(id, { status: "skipped" });
         }
         remaining.clear();
         runFailed = true;
@@ -967,7 +687,7 @@ async function executeWorkflow(opts) {
         if (depsFailed && workflow.failure_policy.on_step_failure !== "ask_user") {
           remaining.delete(id);
           completed.set(id, { status: "skipped" });
-          const skipRunId = `sr_${nanoid4()}`;
+          const skipRunId = `sr_${nanoid3()}`;
           insertStepRun(db, { id: skipRunId, run_id: runId, step_id: id, status: "skipped" });
           continue;
         }
@@ -975,7 +695,7 @@ async function executeWorkflow(opts) {
         if (hasSkipMarker(resolvedInputs)) {
           remaining.delete(id);
           completed.set(id, { status: "skipped" });
-          const skipRunId = `sr_${nanoid4()}`;
+          const skipRunId = `sr_${nanoid3()}`;
           insertStepRun(db, { id: skipRunId, run_id: runId, step_id: id, status: "skipped" });
           continue;
         }
@@ -1005,7 +725,7 @@ async function executeWorkflow(opts) {
           if (policy === "stop") {
             for (const remainingId of remaining) {
               completed.set(remainingId, { status: "skipped" });
-              const skipRunId = `sr_${nanoid4()}`;
+              const skipRunId = `sr_${nanoid3()}`;
               insertStepRun(db, { id: skipRunId, run_id: runId, step_id: remainingId, status: "skipped" });
             }
             remaining.clear();
@@ -1017,7 +737,7 @@ async function executeWorkflow(opts) {
             if (decision === "stop") {
               for (const remainingId of remaining) {
                 completed.set(remainingId, { status: "skipped" });
-                const skipRunId = `sr_${nanoid4()}`;
+                const skipRunId = `sr_${nanoid3()}`;
                 insertStepRun(db, { id: skipRunId, run_id: runId, step_id: remainingId, status: "skipped" });
               }
               remaining.clear();
@@ -1043,9 +763,7 @@ async function executeWorkflow(opts) {
 }
 
 export {
-  generatePlan,
-  modifyPlan,
-  confirmPlan,
-  rejectPlan,
+  resolveValue,
+  resolveInputs,
   executeWorkflow
 };

package/dist/{daemon-TWVEMRCU.js → chunk-W274JWEK.js}

@@ -1,18 +1,9 @@
-import {
-  MessageRouter
-} from "./chunk-GMHDL4CG.js";
 import {
   executeWorkflow
-} from "./chunk-D77G7ABJ.js";
-import {
-  initDb
-} from "./chunk-K4PGB2DU.js";
-import {
-  loadConfig
-} from "./chunk-JRHM3Z4C.js";
+} from "./chunk-SEYPA5M2.js";
 import {
   logger
-} from "./chunk-E7BP6DMO.js";
+} from "./chunk-QBOYMF4A.js";
 
 // src/trigger-loop.ts
 import { CronExpressionParser } from "cron-parser";
@@ -233,76 +224,6 @@ var TriggerLoop = class {
   }
 };
 
-// src/daemon.ts
-async function startDaemon() {
-  const config = loadConfig();
-  const db = initDb();
-  const cwd = process.cwd();
-  const router = new MessageRouter(db, config, cwd);
-  if (config.whatsapp?.enabled) {
-    try {
-      const { WhatsAppChannel } = await import("./whatsapp-36XWDSJ5.js");
-      const wa = new WhatsAppChannel(
-        config.whatsapp.auth_dir ?? `${process.env["HOME"]}/.cueclaw/auth/whatsapp`,
-        config.whatsapp.allowed_jids ?? [],
-        (jid, msg) => router.handleInbound("whatsapp", jid, msg)
-      );
-      router.registerChannel(wa);
-      await wa.connect();
-      logger.info("WhatsApp channel started");
-    } catch (err) {
-      logger.error({ err }, "Failed to start WhatsApp channel");
-    }
-  }
-  if (config.telegram?.enabled) {
-    try {
-      const { TelegramChannel } = await import("./telegram-BTTWEETO.js");
-      const tg = new TelegramChannel(
-        config.telegram.token,
-        config.telegram.allowed_users ?? [],
-        (jid, msg) => router.handleInbound("telegram", jid, msg)
-      );
-      router.registerChannel(tg);
-      await tg.connect();
-      logger.info("Telegram channel started");
-    } catch (err) {
-      logger.error({ err }, "Failed to start Telegram channel");
-    }
-  }
-  await recoverRunningWorkflows(db, router);
-  const maxConcurrent = 5;
-  const triggerLoop = new TriggerLoop(db, router, cwd, maxConcurrent);
-  triggerLoop.start();
-  router.start();
-  logger.info("Daemon started");
-  const shutdown = () => {
-    logger.info("Shutting down daemon...");
-    triggerLoop.stop();
-    router.stop();
-    db.close();
-    process.exit(0);
-  };
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-}
-async function recoverRunningWorkflows(db, router) {
-  const interruptedRuns = db.prepare(
-    "SELECT id, workflow_id FROM workflow_runs WHERE status = 'running'"
-  ).all();
-  if (interruptedRuns.length === 0) return;
-  logger.warn({ count: interruptedRuns.length }, "Recovering interrupted workflow runs");
-  for (const run of interruptedRuns) {
-    db.prepare(
-      "UPDATE workflow_runs SET status = 'failed', error = ?, completed_at = ? WHERE id = ?"
-    ).run("Daemon restarted during execution", (/* @__PURE__ */ new Date()).toISOString(), run.id);
-    db.prepare(
-      "UPDATE step_runs SET status = 'failed', error = ? WHERE run_id = ? AND status = 'running'"
-    ).run("Daemon restarted during execution", run.id);
-    router.broadcastNotification(
-      `Workflow ${run.workflow_id} was interrupted by daemon restart (run ${run.id})`
-    );
-  }
-}
 export {
-  startDaemon
+  TriggerLoop
 };