cueclaw 0.0.1 → 0.0.2

package/dist/chunk-E7BP6DMO.js

@@ -0,0 +1,10 @@
+// src/logger.ts
+import pino from "pino";
+var logger = pino({
+  level: process.env["LOG_LEVEL"] ?? "info",
+  transport: process.env["NODE_ENV"] === "production" ? void 0 : { target: "pino-pretty", options: { colorize: true } }
+});
+
+export {
+  logger
+};

package/dist/chunk-GMHDL4CG.js

@@ -0,0 +1,250 @@
+import {
+  confirmPlan,
+  executeWorkflow,
+  generatePlan,
+  modifyPlan,
+  rejectPlan
+} from "./chunk-D77G7ABJ.js";
+import {
+  getWorkflow,
+  listWorkflows,
+  updateWorkflowPhase
+} from "./chunk-K4PGB2DU.js";
+import {
+  logger
+} from "./chunk-E7BP6DMO.js";
+
+// src/router.ts
+var CONFIRMATION_TIMEOUT = 10 * 6e4;
+var RATE_LIMIT_WINDOW = 6e4;
+var RATE_LIMIT_MAX = 10;
+var CLEANUP_INTERVAL = 5 * 6e4;
+var MessageRouter = class {
+  constructor(db, config, cwd) {
+    this.db = db;
+    this.config = config;
+    this.cwd = cwd;
+  }
+  channels = /* @__PURE__ */ new Map();
+  pendingConfirmations = /* @__PURE__ */ new Map();
+  messageTimestamps = /* @__PURE__ */ new Map();
+  cleanupTimer = null;
+  registerChannel(channel) {
+    this.channels.set(channel.name, channel);
+  }
+  start() {
+    this.cleanupTimer = setInterval(() => this.cleanupRateLimits(), CLEANUP_INTERVAL);
+  }
+  stop() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+  /** Broadcast a notification to all connected channels (used by MCP handler) */
+  broadcastNotification(message) {
+    for (const channel of this.channels.values()) {
+      if (channel.isConnected()) {
+        channel.sendMessage("broadcast", message).catch((err) => {
+          logger.error({ err, channel: channel.name }, "Failed to broadcast notification");
+        });
+      }
+    }
+  }
+  async handleInbound(channelName, chatJid, message) {
+    const channel = this.channels.get(channelName);
+    if (!channel) {
+      logger.warn({ channelName }, "Message from unknown channel");
+      return;
+    }
+    const text = typeof message === "string" ? message : message.text;
+    if (this.isRateLimited(chatJid)) {
+      await channel.sendMessage(chatJid, "Rate limited, please wait before sending more messages.");
+      return;
+    }
+    if (text.startsWith("/") || text.startsWith("!")) {
+      await this.handleCommand(channel, chatJid, text);
+    } else if (this.hasPendingConfirmation(chatJid)) {
+      await this.handleConfirmation(channel, chatJid, text);
+    } else {
+      await this.handleNewWorkflow(channel, chatJid, text);
+    }
+  }
+  async handleCommand(channel, chatJid, text) {
+    const parts = text.slice(1).split(/\s+/);
+    const command = parts[0]?.toLowerCase();
+    const args = parts.slice(1).join(" ");
+    switch (command) {
+      case "new":
+        if (args) {
+          await this.handleNewWorkflow(channel, chatJid, args);
+        } else {
+          await channel.sendMessage(chatJid, "Send a workflow description to create a new workflow.");
+        }
+        break;
+      case "list": {
+        const workflows = listWorkflows(this.db);
+        if (workflows.length === 0) {
+          await channel.sendMessage(chatJid, "No workflows found.");
+        } else {
+          const lines = workflows.map(
+            (wf) => `${wf.id.slice(0, 8)}  ${wf.phase.padEnd(12)}  ${wf.name}`
+          );
+          await channel.sendMessage(chatJid, `Workflows:
+${lines.join("\n")}`);
+        }
+        break;
+      }
+      case "status": {
+        if (!args) {
+          await channel.sendMessage(chatJid, "Usage: /status <workflow-id>");
+          break;
+        }
+        const wf = getWorkflow(this.db, args);
+        if (!wf) {
+          await channel.sendMessage(chatJid, `Workflow not found: ${args}`);
+        } else {
+          const steps = wf.steps.map((s, i) => `${i + 1}. ${s.description}`).join("\n");
+          await channel.sendMessage(chatJid, `Workflow: ${wf.name}
+Phase: ${wf.phase}
+
+Steps:
+${steps}`);
+        }
+        break;
+      }
+      case "cancel": {
+        if (!args) {
+          await channel.sendMessage(chatJid, "Usage: /cancel <workflow-id>");
+          break;
+        }
+        const wf = getWorkflow(this.db, args);
+        if (!wf) {
+          await channel.sendMessage(chatJid, `Workflow not found: ${args}`);
+        } else {
+          const rejected = rejectPlan(wf);
+          updateWorkflowPhase(this.db, wf.id, rejected.phase);
+          await channel.sendMessage(chatJid, `Workflow cancelled: ${wf.name}`);
+        }
+        break;
+      }
+      case "help":
+        await channel.sendMessage(chatJid, [
+          "Commands:",
+          "/new <description> \u2014 Create a new workflow",
+          "/list \u2014 List all workflows",
+          "/status <id> \u2014 View workflow status",
+          "/cancel <id> \u2014 Cancel a workflow",
+          "/help \u2014 Show this help"
+        ].join("\n"));
+        break;
+      default:
+        await channel.sendMessage(chatJid, `Unknown command: ${command}. Type /help for available commands.`);
+    }
+  }
+  async handleNewWorkflow(channel, chatJid, text) {
+    await channel.sendMessage(chatJid, "Generating execution plan...");
+    channel.setTyping?.(chatJid, true);
+    try {
+      const workflow = await generatePlan(text, this.config);
+      channel.setTyping?.(chatJid, false);
+      this.pendingConfirmations.set(chatJid, {
+        workflowId: workflow.id,
+        workflow,
+        expiresAt: Date.now() + CONFIRMATION_TIMEOUT
+      });
+      await channel.sendConfirmation(chatJid, workflow);
+    } catch (err) {
+      channel.setTyping?.(chatJid, false);
+      const msg = err instanceof Error ? err.message : String(err);
+      await channel.sendMessage(chatJid, `Failed to generate plan: ${msg}`);
+      logger.error({ err, chatJid }, "Plan generation failed");
+    }
+  }
+  async handleConfirmation(channel, chatJid, text) {
+    const pending = this.pendingConfirmations.get(chatJid);
+    if (!pending) return;
+    const lower = text.toLowerCase().trim();
+    if (["yes", "y", "confirm", "1"].includes(lower)) {
+      this.pendingConfirmations.delete(chatJid);
+      const confirmed = confirmPlan(pending.workflow);
+      await channel.sendMessage(chatJid, `Workflow activated: ${confirmed.name} (${confirmed.id})`);
+      channel.setTyping?.(chatJid, true);
+      try {
+        const result = await executeWorkflow({
+          workflow: confirmed,
+          triggerData: null,
+          db: this.db,
+          cwd: this.cwd,
+          onProgress: async (stepId, msg) => {
+            if (typeof msg === "object" && msg?.type === "step_complete") {
+              await channel.sendMessage(chatJid, `Step completed: ${stepId}`);
+            }
+          }
+        });
+        channel.setTyping?.(chatJid, false);
+        await channel.sendMessage(chatJid, `Workflow complete! Status: ${result.status}`);
+      } catch (err) {
+        channel.setTyping?.(chatJid, false);
+        const msg = err instanceof Error ? err.message : String(err);
+        await channel.sendMessage(chatJid, `Workflow failed: ${msg}`);
+      }
+    } else if (["no", "n", "cancel", "3"].includes(lower)) {
+      this.pendingConfirmations.delete(chatJid);
+      rejectPlan(pending.workflow);
+      await channel.sendMessage(chatJid, "Plan cancelled.");
+    } else if (["modify", "m", "2"].includes(lower)) {
+      await channel.sendMessage(chatJid, "Describe your modifications:");
+    } else {
+      this.pendingConfirmations.delete(chatJid);
+      await channel.sendMessage(chatJid, "Modifying plan...");
+      channel.setTyping?.(chatJid, true);
+      try {
+        const modified = await modifyPlan(pending.workflow, text, this.config);
+        channel.setTyping?.(chatJid, false);
+        this.pendingConfirmations.set(chatJid, {
+          workflowId: modified.id,
+          workflow: modified,
+          expiresAt: Date.now() + CONFIRMATION_TIMEOUT
+        });
+        await channel.sendConfirmation(chatJid, modified);
+      } catch (err) {
+        channel.setTyping?.(chatJid, false);
+        const msg = err instanceof Error ? err.message : String(err);
+        await channel.sendMessage(chatJid, `Modification failed: ${msg}`);
+      }
+    }
+  }
+  hasPendingConfirmation(chatJid) {
+    const pending = this.pendingConfirmations.get(chatJid);
+    if (!pending) return false;
+    if (Date.now() > pending.expiresAt) {
+      this.pendingConfirmations.delete(chatJid);
+      return false;
+    }
+    return true;
+  }
+  isRateLimited(chatJid) {
+    const now = Date.now();
+    const timestamps = this.messageTimestamps.get(chatJid) ?? [];
+    const recent = timestamps.filter((t) => now - t < RATE_LIMIT_WINDOW);
+    recent.push(now);
+    this.messageTimestamps.set(chatJid, recent);
+    return recent.length > RATE_LIMIT_MAX;
+  }
+  cleanupRateLimits() {
+    const now = Date.now();
+    for (const [jid, timestamps] of this.messageTimestamps) {
+      const recent = timestamps.filter((t) => now - t < RATE_LIMIT_WINDOW);
+      if (recent.length === 0) {
+        this.messageTimestamps.delete(jid);
+      } else {
+        this.messageTimestamps.set(jid, recent);
+      }
+    }
+  }
+};
+
+export {
+  MessageRouter
+};

package/dist/chunk-JRHM3Z4C.js

@@ -0,0 +1,158 @@
+// src/config.ts
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod/v4";
+
+// 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");
+  }
+};
+
+// src/config.ts
+var ConfigSchema = z.object({
+  claude: z.object({
+    api_key: z.string(),
+    base_url: z.string().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") }).default({ model: "claude-sonnet-4-6" })
+  }),
+  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"];
+  }
+  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");
+  }
+}
+
+export {
+  PlannerError,
+  ExecutorError,
+  ConfigError,
+  cueclawHome,
+  ensureCueclawHome,
+  loadConfig,
+  createDefaultConfig
+};

package/dist/chunk-K4PGB2DU.js

@@ -0,0 +1,140 @@
+import {
+  cueclawHome
+} from "./chunk-JRHM3Z4C.js";
+
+// src/db.ts
+import Database from "better-sqlite3";
+import { join } from "path";
+import { mkdirSync } from "fs";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS workflows (
+  id            TEXT PRIMARY KEY,
+  name          TEXT NOT NULL,
+  description   TEXT NOT NULL,
+  trigger_json  TEXT NOT NULL,
+  steps_json    TEXT NOT NULL,
+  failure_policy_json TEXT NOT NULL,
+  phase         TEXT NOT NULL DEFAULT 'planning',
+  schema_version TEXT NOT NULL DEFAULT '1.0',
+  metadata_json TEXT,
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS workflow_runs (
+  id            TEXT PRIMARY KEY,
+  workflow_id   TEXT NOT NULL REFERENCES workflows(id),
+  trigger_data  TEXT,
+  status        TEXT NOT NULL DEFAULT 'running',
+  started_at    TEXT NOT NULL,
+  completed_at  TEXT,
+  error         TEXT,
+  duration_ms   INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS step_runs (
+  id            TEXT PRIMARY KEY,
+  run_id        TEXT NOT NULL REFERENCES workflow_runs(id),
+  step_id       TEXT NOT NULL,
+  status        TEXT NOT NULL DEFAULT 'pending',
+  output_json   TEXT,
+  error         TEXT,
+  started_at    TEXT,
+  completed_at  TEXT,
+  duration_ms   INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id            TEXT PRIMARY KEY,
+  step_run_id   TEXT NOT NULL REFERENCES step_runs(id),
+  sdk_session_id TEXT,
+  created_at    TEXT NOT NULL,
+  last_used_at  TEXT NOT NULL,
+  is_active     INTEGER NOT NULL DEFAULT 1
+);
+
+CREATE TABLE IF NOT EXISTS trigger_state (
+  workflow_id   TEXT PRIMARY KEY REFERENCES workflows(id),
+  last_result   TEXT,
+  last_check_at TEXT,
+  last_fire_at  TEXT,
+  last_error    TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_workflows_phase ON workflows(phase);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow_id ON workflow_runs(workflow_id);
+CREATE INDEX IF NOT EXISTS idx_step_runs_run_id ON step_runs(run_id);
+CREATE INDEX IF NOT EXISTS idx_step_runs_step_run ON step_runs(step_id, run_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_step_run_id ON sessions(step_run_id);
+`;
+function initDb(dbPath) {
+  const path = dbPath ?? join(cueclawHome(), "db", "cueclaw.db");
+  mkdirSync(join(path, ".."), { recursive: true });
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  return db;
+}
+function runMigrations(db) {
+  db.exec(SCHEMA);
+}
+function rowToWorkflow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    trigger: JSON.parse(row.trigger_json),
+    steps: JSON.parse(row.steps_json),
+    failure_policy: JSON.parse(row.failure_policy_json),
+    phase: row.phase,
+    schema_version: row.schema_version,
+    metadata: row.metadata_json ? JSON.parse(row.metadata_json) : void 0,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+function getWorkflow(db, id) {
+  const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+  return row ? rowToWorkflow(row) : void 0;
+}
+function listWorkflows(db, phase) {
+  const query = phase ? db.prepare("SELECT * FROM workflows WHERE phase = ? ORDER BY updated_at DESC") : db.prepare("SELECT * FROM workflows ORDER BY updated_at DESC");
+  const rows = phase ? query.all(phase) : query.all();
+  return rows.map(rowToWorkflow);
+}
+function updateWorkflowPhase(db, id, phase) {
+  db.prepare("UPDATE workflows SET phase = ?, updated_at = ? WHERE id = ?").run(phase, (/* @__PURE__ */ new Date()).toISOString(), id);
+}
+function insertWorkflowRun(db, run) {
+  db.prepare(`
+    INSERT INTO workflow_runs (id, workflow_id, trigger_data, status, started_at, completed_at, error, duration_ms)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(run.id, run.workflow_id, run.trigger_data, run.status, run.started_at, run.completed_at ?? null, run.error ?? null, run.duration_ms ?? null);
+}
+function updateWorkflowRunStatus(db, id, status, error) {
+  const completedAt = status !== "running" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+  db.prepare("UPDATE workflow_runs SET status = ?, completed_at = ?, error = ? WHERE id = ?").run(status, completedAt, error ?? null, id);
+}
+function insertStepRun(db, stepRun) {
+  db.prepare(`
+    INSERT INTO step_runs (id, run_id, step_id, status, output_json, error, started_at, completed_at, duration_ms)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(stepRun.id, stepRun.run_id, stepRun.step_id, stepRun.status, stepRun.output_json ?? null, stepRun.error ?? null, stepRun.started_at ?? null, stepRun.completed_at ?? null, stepRun.duration_ms ?? null);
+}
+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);
+}
+
+export {
+  initDb,
+  getWorkflow,
+  listWorkflows,
+  updateWorkflowPhase,
+  insertWorkflowRun,
+  updateWorkflowRunStatus,
+  insertStepRun,
+  updateStepRunStatus
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node