cueclaw 0.0.1 → 0.0.2

package/dist/cli.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import {
+  initDb,
+  listWorkflows
+} from "./chunk-K4PGB2DU.js";
+import {
+  createDefaultConfig,
+  ensureCueclawHome,
+  loadConfig
+} from "./chunk-JRHM3Z4C.js";
+import {
+  logger
+} from "./chunk-E7BP6DMO.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/env.ts
+import { readFileSync, existsSync } from "fs";
+import { parse } from "dotenv";
+var secrets = {};
+function loadSecrets(envPath = ".env") {
+  if (!existsSync(envPath)) return;
+  const content = readFileSync(envPath, "utf-8");
+  secrets = parse(content);
+}
+
+// src/cli.ts
+var program = new Command().name("cueclaw").description("Orchestrate agent workflows with natural language").version("0.0.1");
+program.command("info").description("Show loaded config, paths, versions").action(() => {
+  try {
+    const config = loadConfig();
+    logger.info({
+      model_planner: config.claude.planner.model,
+      model_executor: config.claude.executor.model,
+      whatsapp: config.whatsapp?.enabled ?? false,
+      telegram: config.telegram?.enabled ?? false,
+      container: config.container?.enabled ?? false,
+      log_level: config.logging?.level ?? "info"
+    }, "CueClaw configuration");
+  } catch (err) {
+    logger.error({ err }, "Failed to load config");
+    process.exit(1);
+  }
+});
+var configCmd = program.command("config").description("Manage configuration");
+configCmd.command("get").argument("[key]", "Config key (dot notation)").description("Get config value").action((key) => {
+  try {
+    const config = loadConfig();
+    if (!key) {
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+    const parts = key.split(".");
+    let value = config;
+    for (const part of parts) {
+      if (value === null || value === void 0) break;
+      value = value[part];
+    }
+    console.log(value !== void 0 ? JSON.stringify(value, null, 2) : "Key not found");
+  } catch (err) {
+    logger.error({ err }, "Failed to load config");
+    process.exit(1);
+  }
+});
+program.command("new").description("Create a new workflow interactively").action(() => {
+  console.log("Workflow creation coming in Phase 1");
+});
+program.command("list").description("List all workflows").action(() => {
+  try {
+    ensureCueclawHome();
+    const db = initDb();
+    const workflows = listWorkflows(db);
+    if (workflows.length === 0) {
+      console.log("No workflows found.");
+      return;
+    }
+    for (const wf of workflows) {
+      console.log(`  ${wf.id}  ${wf.phase.padEnd(22)}  ${wf.name}`);
+    }
+    db.close();
+  } catch (err) {
+    logger.error({ err }, "Failed to list workflows");
+    process.exit(1);
+  }
+});
+program.command("status").argument("[workflow-id]", "Workflow ID").description("View workflow status").action(() => {
+  console.log("Status view coming in Phase 1");
+});
+program.command("pause").argument("<workflow-id>", "Workflow ID").description("Pause a workflow").action(() => {
+  console.log("Pause coming in Phase 1");
+});
+program.command("resume").argument("<workflow-id>", "Workflow ID").description("Resume a paused workflow").action(() => {
+  console.log("Resume coming in Phase 1");
+});
+program.command("delete").argument("<workflow-id>", "Workflow ID").description("Delete a workflow").action(() => {
+  console.log("Delete coming in Phase 1");
+});
+var daemonCmd = program.command("daemon").description("Manage background daemon");
+daemonCmd.command("start").option("--detach", "Run in background").description("Start the daemon").action(async () => {
+  try {
+    const { startDaemon } = await import("./daemon-TWVEMRCU.js");
+    await startDaemon();
+  } catch (err) {
+    logger.error({ err }, "Daemon failed");
+    process.exit(1);
+  }
+});
+daemonCmd.command("stop").description("Stop the daemon").action(() => {
+  console.log("Use launchctl unload (macOS) or systemctl --user stop cueclaw (Linux)");
+});
+daemonCmd.command("install").description("Install system service").action(async () => {
+  const { installService } = await import("./service-BHFOM6E2.js");
+  const result = installService();
+  if (result.success) {
+    console.log("Service installed successfully.");
+  } else {
+    console.log(`Install failed: ${result.error}`);
+    process.exit(1);
+  }
+});
+daemonCmd.command("uninstall").description("Remove system service").action(async () => {
+  const { uninstallService } = await import("./service-BHFOM6E2.js");
+  const result = uninstallService();
+  if (result.success) {
+    console.log("Service uninstalled successfully.");
+  } else {
+    console.log(`Uninstall failed: ${result.error}`);
+    process.exit(1);
+  }
+});
+daemonCmd.command("status").description("View daemon status").action(async () => {
+  const { getServiceStatus } = await import("./service-BHFOM6E2.js");
+  const status = getServiceStatus();
+  console.log(`Daemon status: ${status}`);
+});
+daemonCmd.command("logs").description("View daemon logs").action(async () => {
+  const { join } = await import("path");
+  const { cueclawHome } = await import("./config-HMHM7UAZ.js");
+  const logPath = join(cueclawHome(), "logs", "daemon.log");
+  const { existsSync: existsSync2 } = await import("fs");
+  if (!existsSync2(logPath)) {
+    console.log("No daemon log file found.");
+    return;
+  }
+  const { spawn } = await import("child_process");
+  spawn("tail", ["-f", logPath], { stdio: "inherit" });
+});
+var botCmd = program.command("bot").description("Manage bot channels");
+botCmd.command("start").description("Start all configured bot channels").action(async () => {
+  try {
+    const config = loadConfig();
+    const db = initDb();
+    const { MessageRouter } = await import("./router-36O66FDW.js");
+    const router = new MessageRouter(db, config, process.cwd());
+    if (config.whatsapp?.enabled) {
+      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");
+    }
+    if (config.telegram?.enabled) {
+      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");
+    }
+    router.start();
+    console.log("Bot channels started. Press Ctrl+C to stop.");
+  } catch (err) {
+    logger.error({ err }, "Failed to start bot channels");
+    process.exit(1);
+  }
+});
+botCmd.command("status").description("View channel connection status").action(() => {
+  const config = loadConfig();
+  console.log(`WhatsApp: ${config.whatsapp?.enabled ? "enabled" : "disabled"}`);
+  console.log(`Telegram: ${config.telegram?.enabled ? "enabled" : "disabled"}`);
+});
+program.command("setup").description("First-run setup: validate Docker, build container, smoke test").action(async () => {
+  try {
+    const config = loadConfig();
+    const { runSetup } = await import("./setup-QZUEJUIN.js");
+    await runSetup(config, process.cwd());
+  } catch (err) {
+    logger.error({ err }, "Setup failed");
+    process.exit(1);
+  }
+});
+program.command("tui").description("Start interactive TUI").option("--no-banner", "Skip the startup banner").action(async (opts) => {
+  try {
+    const React = await import("react");
+    const { render } = await import("ink");
+    const { App } = await import("./app-UJ4M3TPW.js");
+    render(React.createElement(App, { noBanner: opts.banner === false, cwd: process.cwd() }));
+  } catch (err) {
+    logger.error({ err }, "Failed to start TUI");
+    process.exit(1);
+  }
+});
+program.action(async () => {
+  try {
+    const React = await import("react");
+    const { render } = await import("ink");
+    const { App } = await import("./app-UJ4M3TPW.js");
+    render(React.createElement(App, { cwd: process.cwd() }));
+  } catch (err) {
+    logger.error({ err }, "Failed to start TUI");
+    process.exit(1);
+  }
+});
+loadSecrets();
+ensureCueclawHome();
+createDefaultConfig();
+program.parse();

package/dist/config-HMHM7UAZ.js

@@ -0,0 +1,12 @@
+import {
+  createDefaultConfig,
+  cueclawHome,
+  ensureCueclawHome,
+  loadConfig
+} from "./chunk-JRHM3Z4C.js";
+export {
+  createDefaultConfig,
+  cueclawHome,
+  ensureCueclawHome,
+  loadConfig
+};

package/dist/daemon-TWVEMRCU.js

@@ -0,0 +1,308 @@
+import {
+  MessageRouter
+} from "./chunk-GMHDL4CG.js";
+import {
+  executeWorkflow
+} from "./chunk-D77G7ABJ.js";
+import {
+  initDb
+} from "./chunk-K4PGB2DU.js";
+import {
+  loadConfig
+} from "./chunk-JRHM3Z4C.js";
+import {
+  logger
+} from "./chunk-E7BP6DMO.js";
+
+// src/trigger-loop.ts
+import { CronExpressionParser } from "cron-parser";
+
+// src/trigger.ts
+import { execFileSync } from "child_process";
+var CHECK_SCRIPT_TIMEOUT = 3e4;
+function evaluatePollTrigger(workflow, trigger, db) {
+  let stdout;
+  try {
+    stdout = execFileSync("sh", ["-c", trigger.check_script], {
+      timeout: CHECK_SCRIPT_TIMEOUT,
+      encoding: "utf-8"
+    }).trim();
+  } catch (err) {
+    logger.error({ workflowId: workflow.id, err }, "Poll check_script failed");
+    db.prepare(
+      "INSERT OR REPLACE INTO trigger_state (workflow_id, last_error, last_check_at) VALUES (?, ?, ?)"
+    ).run(workflow.id, err instanceof Error ? err.message : String(err), (/* @__PURE__ */ new Date()).toISOString());
+    return null;
+  }
+  const state = db.prepare(
+    "SELECT last_result FROM trigger_state WHERE workflow_id = ?"
+  ).get(workflow.id);
+  let triggerData = null;
+  if (trigger.diff_mode === "new_items") {
+    const newItems = diffNewItems(state?.last_result ?? null, stdout);
+    if (newItems.length > 0) triggerData = newItems.join("\n");
+  } else {
+    if (state?.last_result !== stdout) triggerData = stdout;
+  }
+  db.prepare(
+    "INSERT OR REPLACE INTO trigger_state (workflow_id, last_result, last_check_at) VALUES (?, ?, ?)"
+  ).run(workflow.id, stdout, (/* @__PURE__ */ new Date()).toISOString());
+  if (!triggerData) return null;
+  logger.info({ workflowId: workflow.id }, "Poll trigger fired");
+  return { workflowId: workflow.id, data: triggerData };
+}
+function diffNewItems(oldOutput, newOutput) {
+  if (!oldOutput) return newOutput ? newOutput.split("\n").filter(Boolean) : [];
+  const oldLines = new Set(oldOutput.split("\n").filter(Boolean));
+  return newOutput.split("\n").filter((line) => line && !oldLines.has(line));
+}
+
+// src/group-queue.ts
+var GroupQueue = class {
+  constructor(maxConcurrent = 5) {
+    this.maxConcurrent = maxConcurrent;
+  }
+  running = 0;
+  runningByWorkflow = /* @__PURE__ */ new Set();
+  queue = [];
+  async enqueue(workflowId, task) {
+    return new Promise((resolve, reject) => {
+      const wrappedTask = async () => {
+        try {
+          await task();
+          resolve();
+        } catch (e) {
+          reject(e);
+        }
+      };
+      if (this.running >= this.maxConcurrent || this.runningByWorkflow.has(workflowId)) {
+        this.queue.push({ workflowId, task: wrappedTask });
+        logger.debug({ workflowId, queueLength: this.queue.length }, "Task queued");
+      } else {
+        this.running++;
+        this.runningByWorkflow.add(workflowId);
+        wrappedTask().finally(() => {
+          this.running--;
+          this.runningByWorkflow.delete(workflowId);
+          this.processNext();
+        });
+      }
+    });
+  }
+  processNext() {
+    const idx = this.queue.findIndex((item) => !this.runningByWorkflow.has(item.workflowId));
+    if (idx === -1 || this.running >= this.maxConcurrent) return;
+    const next = this.queue.splice(idx, 1)[0];
+    this.running++;
+    this.runningByWorkflow.add(next.workflowId);
+    next.task().finally(() => {
+      this.running--;
+      this.runningByWorkflow.delete(next.workflowId);
+      this.processNext();
+    });
+  }
+  get pendingCount() {
+    return this.queue.length;
+  }
+  get activeCount() {
+    return this.running;
+  }
+};
+
+// src/trigger-loop.ts
+var TriggerLoop = class {
+  constructor(db, router, cwd, maxConcurrent = 5) {
+    this.db = db;
+    this.router = router;
+    this.cwd = cwd;
+    this.queue = new GroupQueue(maxConcurrent);
+  }
+  intervals = /* @__PURE__ */ new Map();
+  queue;
+  log = logger.child({ module: "trigger-loop" });
+  start() {
+    const rows = this.db.prepare(
+      "SELECT * FROM workflows WHERE phase = 'active'"
+    ).all();
+    for (const row of rows) {
+      const workflow = this.rowToWorkflow(row);
+      this.registerTrigger(workflow);
+    }
+    this.log.info({ count: rows.length }, "Trigger loop started");
+  }
+  registerTrigger(workflow) {
+    this.unregisterTrigger(workflow.id);
+    const trigger = workflow.trigger;
+    if (trigger.type === "poll") {
+      const interval = setInterval(() => {
+        try {
+          const result = evaluatePollTrigger(workflow, trigger, this.db);
+          if (result) {
+            this.executeTrigger(workflow, result.data);
+          }
+        } catch (err) {
+          this.log.error({ workflowId: workflow.id, err }, "Poll trigger error");
+        }
+      }, trigger.interval_seconds * 1e3);
+      this.intervals.set(workflow.id, interval);
+      this.log.info({ workflowId: workflow.id, intervalSeconds: trigger.interval_seconds }, "Registered poll trigger");
+    }
+    if (trigger.type === "cron") {
+      const interval = setInterval(() => {
+        try {
+          const expr = CronExpressionParser.parse(trigger.expression, {
+            tz: trigger.timezone ?? "UTC"
+          });
+          const prev = expr.prev().toDate();
+          const now = /* @__PURE__ */ new Date();
+          if (now.getTime() - prev.getTime() < 6e4) {
+            const state = this.db.prepare(
+              "SELECT last_fire_at FROM trigger_state WHERE workflow_id = ?"
+            ).get(workflow.id);
+            const lastFire = state?.last_fire_at ? new Date(state.last_fire_at).getTime() : 0;
+            if (prev.getTime() <= lastFire) return;
+            this.db.prepare(
+              "INSERT OR REPLACE INTO trigger_state (workflow_id, last_fire_at) VALUES (?, ?)"
+            ).run(workflow.id, prev.toISOString());
+            this.executeTrigger(workflow, (/* @__PURE__ */ new Date()).toISOString());
+          }
+        } catch (err) {
+          this.log.error({ workflowId: workflow.id, err }, "Cron evaluation failed");
+        }
+      }, 6e4);
+      this.intervals.set(workflow.id, interval);
+      this.log.info({ workflowId: workflow.id, expression: trigger.expression }, "Registered cron trigger");
+    }
+  }
+  unregisterTrigger(workflowId) {
+    const interval = this.intervals.get(workflowId);
+    if (interval) {
+      clearInterval(interval);
+      this.intervals.delete(workflowId);
+    }
+  }
+  executeTrigger(workflow, triggerData) {
+    this.queue.enqueue(workflow.id, async () => {
+      this.log.info({ workflowId: workflow.id }, "Executing triggered workflow");
+      try {
+        await executeWorkflow({
+          workflow,
+          triggerData,
+          db: this.db,
+          cwd: this.cwd,
+          onProgress: (_stepId, msg) => {
+            if (typeof msg === "object" && msg?.type === "step_complete") {
+              this.router.broadcastNotification(`Step completed: ${_stepId} (${workflow.name})`);
+            }
+          }
+        });
+        this.router.broadcastNotification(`Workflow complete: ${workflow.name}`);
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        this.log.error({ workflowId: workflow.id, err }, "Triggered execution failed");
+        this.router.broadcastNotification(`Workflow failed: ${workflow.name} \u2014 ${errMsg}`);
+      }
+    }).catch((err) => {
+      this.log.error({ workflowId: workflow.id, err }, "Queue execution error");
+    });
+  }
+  stop() {
+    for (const interval of this.intervals.values()) {
+      clearInterval(interval);
+    }
+    this.intervals.clear();
+    this.log.info("Trigger loop stopped");
+  }
+  get registeredCount() {
+    return this.intervals.size;
+  }
+  rowToWorkflow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      steps: JSON.parse(row.steps_json),
+      trigger: JSON.parse(row.trigger_json),
+      failure_policy: JSON.parse(row.failure_policy_json),
+      phase: row.phase,
+      schema_version: "1.0",
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      metadata: row.metadata_json ? JSON.parse(row.metadata_json) : void 0
+    };
+  }
+};
+
+// 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
+};

package/dist/router-36O66FDW.js

@@ -0,0 +1,10 @@
+import {
+  MessageRouter
+} from "./chunk-GMHDL4CG.js";
+import "./chunk-D77G7ABJ.js";
+import "./chunk-K4PGB2DU.js";
+import "./chunk-JRHM3Z4C.js";
+import "./chunk-E7BP6DMO.js";
+export {
+  MessageRouter
+};