cueclaw 0.0.3 → 0.1.0

package/dist/chunk-BVQG3WYO.js

@@ -0,0 +1,29 @@
+// src/types.ts
+var CueclawError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "CueclawError";
+  }
+};
+var PlannerError = class extends CueclawError {
+  constructor(message) {
+    super(message, "PLANNER_ERROR");
+  }
+};
+var ExecutorError = class extends CueclawError {
+  constructor(message) {
+    super(message, "EXECUTOR_ERROR");
+  }
+};
+var ConfigError = class extends CueclawError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR");
+  }
+};
+
+export {
+  PlannerError,
+  ExecutorError,
+  ConfigError
+};

package/dist/chunk-DVQFSFIZ.js

@@ -0,0 +1,14 @@
+// src/anthropic-client.ts
+import Anthropic from "@anthropic-ai/sdk";
+var ANTHROPIC_OFFICIAL = "https://api.anthropic.com";
+function createAnthropicClient(config) {
+  const isThirdParty = config.claude.base_url !== ANTHROPIC_OFFICIAL;
+  return new Anthropic({
+    ...isThirdParty ? { authToken: config.claude.api_key, apiKey: "" } : { apiKey: config.claude.api_key },
+    baseURL: config.claude.base_url
+  });
+}
+
+export {
+  createAnthropicClient
+};

package/dist/{chunk-GMHDL4CG.js → chunk-F3EQAFH4.js}

@@ -1,18 +1,23 @@
 import {
   confirmPlan,
-  executeWorkflow,
   generatePlan,
   modifyPlan,
   rejectPlan
-} from "./chunk-D77G7ABJ.js";
+} from "./chunk-WE5J7GMR.js";
+import {
+  createAnthropicClient
+} from "./chunk-DVQFSFIZ.js";
+import {
+  executeWorkflow
+} from "./chunk-SEYPA5M2.js";
 import {
   getWorkflow,
   listWorkflows,
   updateWorkflowPhase
-} from "./chunk-K4PGB2DU.js";
+} from "./chunk-G43R5ASK.js";
 import {
   logger
-} from "./chunk-E7BP6DMO.js";
+} from "./chunk-QBOYMF4A.js";
 
 // src/router.ts
 var CONFIRMATION_TIMEOUT = 10 * 6e4;
@@ -67,7 +72,7 @@ var MessageRouter = class {
     } else if (this.hasPendingConfirmation(chatJid)) {
       await this.handleConfirmation(channel, chatJid, text);
     } else {
-      await this.handleNewWorkflow(channel, chatJid, text);
+      await this.classifyAndRoute(channel, chatJid, text);
     }
   }
   async handleCommand(channel, chatJid, text) {
@@ -142,6 +147,55 @@ ${steps}`);
         await channel.sendMessage(chatJid, `Unknown command: ${command}. Type /help for available commands.`);
     }
   }
+  async handleCallbackAction(channelName, chatId, _workflowId, action) {
+    const actionMap = {
+      confirm: "yes",
+      modify: "modify",
+      cancel: "no"
+    };
+    const mappedText = actionMap[action] ?? action;
+    await this.handleInbound(channelName, chatId, { text: mappedText, sender: chatId });
+  }
+  async classifyAndRoute(channel, chatJid, text) {
+    try {
+      const client = createAnthropicClient(this.config);
+      const response = await client.messages.create({
+        model: this.config.claude.planner.model,
+        max_tokens: 512,
+        system: "You are a router for CueClaw, a workflow automation tool. Classify the user message and call the appropriate tool. Use create_workflow_request if the user wants to automate a task, set up a workflow, schedule something, or perform an action that requires multiple steps. Use chat_reply for greetings, questions about capabilities, casual conversation, or anything that is not a workflow request.",
+        messages: [{ role: "user", content: text }],
+        tools: [
+          {
+            name: "create_workflow_request",
+            description: "The user wants to create an automation workflow",
+            input_schema: { type: "object", properties: {} }
+          },
+          {
+            name: "chat_reply",
+            description: "Reply to casual conversation or questions",
+            input_schema: {
+              type: "object",
+              properties: {
+                message: { type: "string", description: "The reply to send to the user" }
+              },
+              required: ["message"]
+            }
+          }
+        ],
+        tool_choice: { type: "any" }
+      });
+      const toolUse = response.content.find((b) => b.type === "tool_use");
+      if (toolUse && toolUse.type === "tool_use" && toolUse.name === "chat_reply") {
+        const input = toolUse.input;
+        await channel.sendMessage(chatJid, input.message ?? "I'm CueClaw, a workflow automation tool. Send me a task description and I'll create a plan for you!");
+      } else {
+        await this.handleNewWorkflow(channel, chatJid, text);
+      }
+    } catch (err) {
+      logger.error({ err, chatJid }, "Classification failed, falling back to workflow");
+      await this.handleNewWorkflow(channel, chatJid, text);
+    }
+  }
   async handleNewWorkflow(channel, chatJid, text) {
     await channel.sendMessage(chatJid, "Generating execution plan...");
     channel.setTyping?.(chatJid, true);

package/dist/{chunk-K4PGB2DU.js → chunk-G43R5ASK.js}

@@ -1,6 +1,6 @@
 import {
   cueclawHome
-} from "./chunk-JRHM3Z4C.js";
+} from "./chunk-RSKXBXSJ.js";
 
 // src/db.ts
 import Database from "better-sqlite3";
@@ -95,6 +95,24 @@ function rowToWorkflow(row) {
     updated_at: row.updated_at
   };
 }
+function insertWorkflow(db, workflow) {
+  db.prepare(`
+    INSERT INTO workflows (id, name, description, trigger_json, steps_json, failure_policy_json, phase, schema_version, metadata_json, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    workflow.id,
+    workflow.name,
+    workflow.description,
+    JSON.stringify(workflow.trigger),
+    JSON.stringify(workflow.steps),
+    JSON.stringify(workflow.failure_policy),
+    workflow.phase,
+    workflow.schema_version,
+    workflow.metadata ? JSON.stringify(workflow.metadata) : null,
+    workflow.created_at,
+    workflow.updated_at
+  );
+}
 function getWorkflow(db, id) {
   const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
   return row ? rowToWorkflow(row) : void 0;
@@ -107,6 +125,22 @@ function listWorkflows(db, phase) {
 function updateWorkflowPhase(db, id, phase) {
   db.prepare("UPDATE workflows SET phase = ?, updated_at = ? WHERE id = ?").run(phase, (/* @__PURE__ */ new Date()).toISOString(), id);
 }
+function deleteWorkflow(db, id) {
+  const del = db.transaction(() => {
+    const runIds = db.prepare("SELECT id FROM workflow_runs WHERE workflow_id = ?").all(id);
+    for (const run of runIds) {
+      const stepRunIds = db.prepare("SELECT id FROM step_runs WHERE run_id = ?").all(run.id);
+      for (const sr of stepRunIds) {
+        db.prepare("DELETE FROM sessions WHERE step_run_id = ?").run(sr.id);
+      }
+      db.prepare("DELETE FROM step_runs WHERE run_id = ?").run(run.id);
+    }
+    db.prepare("DELETE FROM workflow_runs WHERE workflow_id = ?").run(id);
+    db.prepare("DELETE FROM trigger_state WHERE workflow_id = ?").run(id);
+    db.prepare("DELETE FROM workflows WHERE id = ?").run(id);
+  });
+  del();
+}
 function insertWorkflowRun(db, run) {
   db.prepare(`
     INSERT INTO workflow_runs (id, workflow_id, trigger_data, status, started_at, completed_at, error, duration_ms)
@@ -127,14 +161,24 @@ function updateStepRunStatus(db, id, status, output, error) {
   const completedAt = status === "succeeded" || status === "failed" || status === "skipped" ? (/* @__PURE__ */ new Date()).toISOString() : null;
   db.prepare("UPDATE step_runs SET status = ?, output_json = ?, error = ?, completed_at = ? WHERE id = ?").run(status, output ?? null, error ?? null, completedAt, id);
 }
+function getStepRunsByRunId(db, runId) {
+  return db.prepare("SELECT * FROM step_runs WHERE run_id = ?").all(runId);
+}
+function getWorkflowRunsByWorkflowId(db, workflowId) {
+  return db.prepare("SELECT * FROM workflow_runs WHERE workflow_id = ? ORDER BY started_at DESC").all(workflowId);
+}
 
 export {
   initDb,
+  insertWorkflow,
   getWorkflow,
   listWorkflows,
   updateWorkflowPhase,
+  deleteWorkflow,
   insertWorkflowRun,
   updateWorkflowRunStatus,
   insertStepRun,
-  updateStepRunStatus
+  updateStepRunStatus,
+  getStepRunsByRunId,
+  getWorkflowRunsByWorkflowId
 };

package/dist/chunk-KRNAXOQ4.js

@@ -0,0 +1,46 @@
+import {
+  createAnthropicClient
+} from "./chunk-DVQFSFIZ.js";
+
+// src/setup-environment.ts
+import { execFileSync } from "child_process";
+function checkEnvironment() {
+  const nodeVersion = process.version;
+  let docker = false;
+  let dockerVersion;
+  let dockerRunning = false;
+  try {
+    const version = execFileSync("docker", ["--version"], { encoding: "utf-8" }).trim();
+    docker = true;
+    dockerVersion = version;
+  } catch {
+  }
+  if (docker) {
+    try {
+      execFileSync("docker", ["info"], { encoding: "utf-8", stdio: "pipe" });
+      dockerRunning = true;
+    } catch {
+    }
+  }
+  return { docker, dockerVersion, dockerRunning, nodeVersion };
+}
+
+// src/setup-auth.ts
+async function validateAuth(config) {
+  try {
+    const client = createAnthropicClient(config);
+    await client.messages.create({
+      model: "claude-haiku-4-5-20251001",
+      max_tokens: 10,
+      messages: [{ role: "user", content: "ping" }]
+    });
+    return { valid: true };
+  } catch (err) {
+    return { valid: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+export {
+  checkEnvironment,
+  validateAuth
+};

package/dist/{service-BHFOM6E2.js → chunk-PZZ6FBGB.js}

@@ -1,9 +1,9 @@
 import {
   cueclawHome
-} from "./chunk-JRHM3Z4C.js";
+} from "./chunk-RSKXBXSJ.js";
 import {
   logger
-} from "./chunk-E7BP6DMO.js";
+} from "./chunk-QBOYMF4A.js";
 
 // src/service.ts
 import { writeFileSync, existsSync, unlinkSync, mkdirSync } from "fs";
@@ -38,14 +38,30 @@ function uninstallService() {
     return { success: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
+function stopService() {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      execFileSync("launchctl", ["stop", SERVICE_LABEL], { stdio: "pipe" });
+      return { success: true };
+    } else if (platform === "linux") {
+      execFileSync("systemctl", ["--user", "stop", "cueclaw"], { stdio: "pipe" });
+      return { success: true };
+    } else {
+      return { success: false, error: `Unsupported platform: ${platform}` };
+    }
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
 function getServiceStatus() {
   const platform = process.platform;
   try {
     if (platform === "darwin") {
-      const output = execFileSync("launchctl", ["list", SERVICE_LABEL], { encoding: "utf-8" });
-      return output.includes(SERVICE_LABEL) ? "running" : "stopped";
+      const output = execFileSync("launchctl", ["list", SERVICE_LABEL], { encoding: "utf-8", stdio: "pipe" });
+      return output.includes('"PID"') ? "running" : "stopped";
     } else if (platform === "linux") {
-      const output = execFileSync("systemctl", ["--user", "is-active", "cueclaw"], { encoding: "utf-8" }).trim();
+      const output = execFileSync("systemctl", ["--user", "is-active", "cueclaw"], { encoding: "utf-8", stdio: "pipe" }).trim();
       return output === "active" ? "running" : "stopped";
     }
   } catch {
@@ -146,8 +162,10 @@ function uninstallSystemd() {
   logger.info("Uninstalled systemd service");
   return { success: true };
 }
+
 export {
-  getServiceStatus,
   installService,
-  uninstallService
+  uninstallService,
+  stopService,
+  getServiceStatus
 };

package/dist/chunk-QBOYMF4A.js

@@ -0,0 +1,42 @@
+// src/logger.ts
+import pino from "pino";
+import { PassThrough } from "stream";
+var listeners = /* @__PURE__ */ new Set();
+var tuiStream = new PassThrough();
+tuiStream.on("data", (chunk) => {
+  for (const raw of chunk.toString().split("\n")) {
+    if (!raw.trim()) continue;
+    try {
+      const obj = JSON.parse(raw);
+      const lvl = (pino.levels.labels[obj.level] ?? "INFO").toUpperCase();
+      const mod = obj.module ? ` [${obj.module}]` : "";
+      const msg = obj.msg ?? "";
+      for (const fn of listeners) fn(`${lvl}${mod} ${msg}`);
+    } catch {
+      for (const fn of listeners) fn(raw);
+    }
+  }
+});
+var logger = pino({
+  level: process.env["LOG_LEVEL"] ?? "info",
+  transport: process.env["NODE_ENV"] === "production" ? void 0 : { target: "pino-pretty", options: { colorize: true } }
+});
+function enableTuiLogging() {
+  logger = pino({ level: process.env["LOG_LEVEL"] ?? "info" }, tuiStream);
+}
+function onLogLine(fn) {
+  listeners.add(fn);
+  return () => {
+    listeners.delete(fn);
+  };
+}
+function createChildLogger(bindings) {
+  return logger.child(bindings);
+}
+
+export {
+  logger,
+  enableTuiLogging,
+  onLogLine,
+  createChildLogger
+};

package/dist/chunk-RSKXBXSJ.js

@@ -0,0 +1,247 @@
+import {
+  ConfigError
+} from "./chunk-BVQG3WYO.js";
+
+// src/config.ts
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { z } from "zod/v4";
+var ConfigSchema = z.object({
+  claude: z.object({
+    api_key: z.string(),
+    base_url: z.url().default("https://api.anthropic.com"),
+    planner: z.object({ model: z.string().default("claude-sonnet-4-6") }).default({ model: "claude-sonnet-4-6" }),
+    executor: z.object({
+      model: z.string().default("claude-sonnet-4-6"),
+      api_key: z.string().optional(),
+      base_url: z.url().optional(),
+      skip_permissions: z.boolean().default(false)
+    }).default({ model: "claude-sonnet-4-6", skip_permissions: false })
+  }),
+  identity: z.object({ name: z.string() }).optional(),
+  whatsapp: z.object({
+    enabled: z.boolean().default(false),
+    auth_dir: z.string().default("~/.cueclaw/auth/whatsapp"),
+    allowed_jids: z.array(z.string()).default([])
+  }).optional(),
+  telegram: z.object({
+    enabled: z.boolean().default(false),
+    token: z.string().optional(),
+    allowed_users: z.array(z.string()).default([])
+  }).optional(),
+  logging: z.object({
+    level: z.enum(["debug", "info", "warn", "error"]).default("info"),
+    dir: z.string().default("~/.cueclaw/logs")
+  }).optional(),
+  container: z.object({
+    enabled: z.boolean().default(false),
+    image: z.string().default("cueclaw-agent:latest"),
+    timeout: z.number().default(18e5),
+    max_output_size: z.number().default(10485760),
+    idle_timeout: z.number().default(18e5),
+    network: z.enum(["none", "host", "bridge"]).default("none")
+  }).optional()
+});
+function cueclawHome() {
+  return join(homedir(), ".cueclaw");
+}
+function ensureCueclawHome() {
+  const home = cueclawHome();
+  const dirs = [home, join(home, "db"), join(home, "logs"), join(home, "auth")];
+  for (const dir of dirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function interpolateEnvVars(value) {
+  return value.replace(/\$\{(\w+)\}/g, (_match, name) => {
+    return process.env[name] ?? "";
+  });
+}
+function interpolateObject(obj) {
+  if (typeof obj === "string") return interpolateEnvVars(obj);
+  if (Array.isArray(obj)) return obj.map(interpolateObject);
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = interpolateObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function loadYamlFile(path) {
+  if (!existsSync(path)) return null;
+  const content = readFileSync(path, "utf-8");
+  const parsed = parseYaml(content);
+  return parsed && typeof parsed === "object" ? parsed : null;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && result[key] !== null && typeof result[key] === "object" && !Array.isArray(result[key])) {
+      result[key] = deepMerge(result[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function loadConfig() {
+  const globalPath = join(cueclawHome(), "config.yaml");
+  const localPath = join(process.cwd(), ".cueclaw", "config.yaml");
+  let merged = {};
+  const globalConfig = loadYamlFile(globalPath);
+  if (globalConfig) merged = deepMerge(merged, globalConfig);
+  const localConfig = loadYamlFile(localPath);
+  if (localConfig) merged = deepMerge(merged, localConfig);
+  if (process.env["ANTHROPIC_API_KEY"]) {
+    merged.claude = merged.claude ?? {};
+    merged.claude.api_key = process.env["ANTHROPIC_API_KEY"];
+  }
+  if (process.env["ANTHROPIC_BASE_URL"]) {
+    merged.claude = merged.claude ?? {};
+    merged.claude.base_url = process.env["ANTHROPIC_BASE_URL"];
+  }
+  if (process.env["TELEGRAM_BOT_TOKEN"]) {
+    merged.telegram = merged.telegram ?? {};
+    merged.telegram.token = process.env["TELEGRAM_BOT_TOKEN"];
+    merged.telegram.enabled = true;
+  }
+  merged = interpolateObject(merged);
+  const result = ConfigSchema.safeParse(merged);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ConfigError(`Invalid configuration:
+${issues}`);
+  }
+  return result.data;
+}
+var DEFAULT_CONFIG = `# CueClaw Configuration
+# See docs/config.md for all options
+
+claude:
+  api_key: \${ANTHROPIC_API_KEY}
+  planner:
+    model: claude-sonnet-4-6
+  executor:
+    model: claude-sonnet-4-6
+
+logging:
+  level: info
+`;
+function createDefaultConfig() {
+  const configPath = join(cueclawHome(), "config.yaml");
+  if (!existsSync(configPath)) {
+    ensureCueclawHome();
+    writeFileSync(configPath, DEFAULT_CONFIG, "utf-8");
+  }
+}
+function needsOnboarding() {
+  const configPath = join(cueclawHome(), "config.yaml");
+  if (!existsSync(configPath)) return true;
+  const raw = loadYamlFile(configPath);
+  if (!raw) return true;
+  const apiKey = raw.claude?.api_key;
+  if (!apiKey || typeof apiKey !== "string") {
+    return !process.env["ANTHROPIC_API_KEY"];
+  }
+  const resolved = interpolateEnvVars(apiKey);
+  return !resolved;
+}
+function validateConfig() {
+  const issues = [];
+  const configPath = join(cueclawHome(), "config.yaml");
+  if (!existsSync(configPath)) {
+    issues.push({ field: "config", severity: "error", message: "Config file not found. Run setup to create one." });
+    if (!process.env["ANTHROPIC_API_KEY"]) {
+      return { valid: false, issues };
+    }
+    issues.length = 0;
+    return { valid: true, issues };
+  }
+  const raw = loadYamlFile(configPath);
+  if (!raw) {
+    issues.push({ field: "config", severity: "error", message: "Config file is empty or invalid YAML." });
+    if (!process.env["ANTHROPIC_API_KEY"]) {
+      return { valid: false, issues };
+    }
+    issues.length = 0;
+    return { valid: true, issues };
+  }
+  const claude = raw.claude;
+  const rawApiKey = claude?.api_key;
+  const resolvedKey = rawApiKey ? interpolateEnvVars(rawApiKey) : process.env["ANTHROPIC_API_KEY"];
+  if (!resolvedKey) {
+    issues.push({ field: "claude.api_key", severity: "error", message: "API key is missing. Set it in config or ANTHROPIC_API_KEY env var." });
+  }
+  const baseUrl = claude?.base_url;
+  if (baseUrl && baseUrl !== "https://api.anthropic.com") {
+    try {
+      new URL(baseUrl);
+    } catch {
+      issues.push({ field: "claude.base_url", severity: "error", message: `Invalid base URL: "${baseUrl}"` });
+    }
+  }
+  const telegram = raw.telegram;
+  if (telegram?.enabled === true) {
+    const token = telegram.token ?? process.env["TELEGRAM_BOT_TOKEN"];
+    if (!token) {
+      issues.push({ field: "telegram.token", severity: "warning", message: "Telegram is enabled but no bot token is configured." });
+    }
+  }
+  const whatsapp = raw.whatsapp;
+  if (whatsapp?.enabled === true) {
+    const authDir = whatsapp.auth_dir;
+    if (authDir && !existsSync(authDir.replace("~", homedir()))) {
+      issues.push({ field: "whatsapp.auth_dir", severity: "warning", message: `WhatsApp auth directory does not exist: ${authDir}` });
+    }
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  return { valid: !hasErrors, issues };
+}
+function loadExistingConfig() {
+  const configPath = join(cueclawHome(), "config.yaml");
+  const raw = loadYamlFile(configPath);
+  if (!raw) return {};
+  const claude = raw.claude;
+  const container = raw.container;
+  const telegram = raw.telegram;
+  const whatsapp = raw.whatsapp;
+  const rawKey = claude?.api_key;
+  const resolvedKey = rawKey ? interpolateEnvVars(rawKey) : void 0;
+  const envTelegramToken = process.env["TELEGRAM_BOT_TOKEN"];
+  const telegramToken = telegram?.token ?? envTelegramToken;
+  const telegramEnabled = telegram?.enabled === true || !!envTelegramToken || void 0;
+  return {
+    apiKey: resolvedKey || void 0,
+    baseUrl: claude?.base_url && claude.base_url !== "https://api.anthropic.com" ? claude.base_url : void 0,
+    containerEnabled: container?.enabled === true ? true : void 0,
+    telegramEnabled,
+    telegramToken: telegramToken || void 0,
+    whatsappEnabled: whatsapp?.enabled === true ? true : void 0
+  };
+}
+function writeConfig(updates) {
+  ensureCueclawHome();
+  const configPath = join(cueclawHome(), "config.yaml");
+  let existing = {};
+  if (existsSync(configPath)) {
+    const loaded = loadYamlFile(configPath);
+    if (loaded) existing = loaded;
+  }
+  const merged = deepMerge(existing, updates);
+  writeFileSync(configPath, stringifyYaml(merged), "utf-8");
+}
+
+export {
+  cueclawHome,
+  ensureCueclawHome,
+  loadConfig,
+  createDefaultConfig,
+  needsOnboarding,
+  validateConfig,
+  loadExistingConfig,
+  writeConfig
+};