cueclaw 0.1.2 → 0.1.3

package/dist/chunk-FAT2VKMJ.js

@@ -1,232 +0,0 @@
-import {
-  executeWorkflow
-} from "./chunk-SEYPA5M2.js";
-import {
-  logger
-} from "./chunk-QBOYMF4A.js";
-
-// src/trigger-loop.ts
-import { CronExpressionParser } from "cron-parser";
-
-// src/trigger.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var CHECK_SCRIPT_TIMEOUT = 3e4;
-async function evaluatePollTrigger(workflow, trigger, db) {
-  let stdout;
-  try {
-    const result = await execFileAsync("sh", ["-c", trigger.check_script], {
-      timeout: CHECK_SCRIPT_TIMEOUT,
-      encoding: "utf-8"
-    });
-    stdout = result.stdout.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(async () => {
-        try {
-          const result = await 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
-    };
-  }
-};
-
-export {
-  TriggerLoop
-};

package/dist/chunk-IB6TU7TP.js

@@ -1,310 +0,0 @@
-import {
-  confirmPlan,
-  generatePlan,
-  modifyPlan,
-  rejectPlan
-} from "./chunk-WE5J7GMR.js";
-import {
-  createAnthropicClient
-} from "./chunk-DVQFSFIZ.js";
-import {
-  executeWorkflow
-} from "./chunk-SEYPA5M2.js";
-import {
-  getWorkflow,
-  insertWorkflow,
-  listWorkflows,
-  updateWorkflowPhase
-} from "./chunk-G43R5ASK.js";
-import {
-  logger
-} from "./chunk-QBOYMF4A.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;
-    }
-  }
-  /** Disconnect all registered channels */
-  async disconnectAll() {
-    await Promise.allSettled(
-      [...this.channels.values()].map((c) => c.disconnect())
-    );
-  }
-  /** 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.pendingConfirmations.has(chatJid)) {
-      const pending = this.pendingConfirmations.get(chatJid);
-      if (Date.now() > pending.expiresAt) {
-        this.pendingConfirmations.delete(chatJid);
-        await channel.sendMessage(chatJid, "Your pending plan has expired. Send a new description to start over.");
-      } else {
-        await this.handleConfirmation(channel, chatJid, text);
-      }
-    } else {
-      await this.classifyAndRoute(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 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);
-    try {
-      const workflow = await generatePlan(text, this.config);
-      insertWorkflow(this.db, workflow);
-      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);
-        insertWorkflow(this.db, modified);
-        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}`);
-      }
-    }
-  }
-  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-QBOYMF4A.js

@@ -1,42 +0,0 @@
-// 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/daemon-WOR4GE5C.js

@@ -1,96 +0,0 @@
-import {
-  TriggerLoop
-} from "./chunk-FAT2VKMJ.js";
-import {
-  MessageRouter
-} from "./chunk-IB6TU7TP.js";
-import "./chunk-WE5J7GMR.js";
-import "./chunk-DVQFSFIZ.js";
-import "./chunk-ZCK3IFLC.js";
-import "./chunk-SEYPA5M2.js";
-import {
-  initDb
-} from "./chunk-G43R5ASK.js";
-import {
-  loadConfig
-} from "./chunk-RSKXBXSJ.js";
-import "./chunk-BVQG3WYO.js";
-import {
-  logger
-} from "./chunk-QBOYMF4A.js";
-
-// 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-HFMOFSFI.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-EFPHL4HC.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();
-      tg.onCallback((wfId, action, chatId) => router.handleCallbackAction("telegram", chatId, wfId, action));
-      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 = async () => {
-    logger.info("Shutting down daemon...");
-    triggerLoop.stop();
-    router.stop();
-    await router.disconnectAll();
-    db.close();
-    process.exit(0);
-  };
-  process.on("SIGTERM", () => void shutdown());
-  process.on("SIGINT", () => void 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/logger-HD23RPWS.js

@@ -1,12 +0,0 @@
-import {
-  createChildLogger,
-  enableTuiLogging,
-  logger,
-  onLogLine
-} from "./chunk-QBOYMF4A.js";
-export {
-  createChildLogger,
-  enableTuiLogging,
-  logger,
-  onLogLine
-};