cueclaw 0.0.1 → 0.0.2

package/dist/service-BHFOM6E2.js

@@ -0,0 +1,153 @@
+import {
+  cueclawHome
+} from "./chunk-JRHM3Z4C.js";
+import {
+  logger
+} from "./chunk-E7BP6DMO.js";
+
+// src/service.ts
+import { writeFileSync, existsSync, unlinkSync, mkdirSync } from "fs";
+import { join } from "path";
+import { execFileSync } from "child_process";
+var SERVICE_LABEL = "com.cueclaw";
+function installService() {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      return installLaunchd();
+    } else if (platform === "linux") {
+      return installSystemd();
+    } else {
+      return { success: false, error: `Unsupported platform: ${platform}` };
+    }
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function uninstallService() {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      return uninstallLaunchd();
+    } else if (platform === "linux") {
+      return uninstallSystemd();
+    } 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";
+    } else if (platform === "linux") {
+      const output = execFileSync("systemctl", ["--user", "is-active", "cueclaw"], { encoding: "utf-8" }).trim();
+      return output === "active" ? "running" : "stopped";
+    }
+  } catch {
+    return "stopped";
+  }
+  return "unknown";
+}
+function installLaunchd() {
+  const home = process.env["HOME"];
+  if (!home) return { success: false, error: "HOME not set" };
+  const plistDir = join(home, "Library", "LaunchAgents");
+  mkdirSync(plistDir, { recursive: true });
+  const plistPath = join(plistDir, `${SERVICE_LABEL}.plist`);
+  const logDir = join(cueclawHome(), "logs");
+  mkdirSync(logDir, { recursive: true });
+  const nodePath = process.execPath;
+  const cliPath = join(process.cwd(), "dist", "cli.js");
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${cliPath}</string>
+    <string>daemon</string>
+    <string>start</string>
+  </array>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(logDir, "daemon.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(logDir, "daemon.log")}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+</dict>
+</plist>`;
+  writeFileSync(plistPath, plist);
+  execFileSync("launchctl", ["load", plistPath]);
+  logger.info({ plistPath }, "Installed launchd service");
+  return { success: true };
+}
+function uninstallLaunchd() {
+  const home = process.env["HOME"];
+  if (!home) return { success: false, error: "HOME not set" };
+  const plistPath = join(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+  if (!existsSync(plistPath)) return { success: false, error: "Service not installed" };
+  try {
+    execFileSync("launchctl", ["unload", plistPath]);
+  } catch {
+  }
+  unlinkSync(plistPath);
+  logger.info("Uninstalled launchd service");
+  return { success: true };
+}
+function installSystemd() {
+  const home = process.env["HOME"];
+  if (!home) return { success: false, error: "HOME not set" };
+  const serviceDir = join(home, ".config", "systemd", "user");
+  mkdirSync(serviceDir, { recursive: true });
+  const servicePath = join(serviceDir, "cueclaw.service");
+  const nodePath = process.execPath;
+  const cliPath = join(process.cwd(), "dist", "cli.js");
+  const service = `[Unit]
+Description=CueClaw Daemon
+After=network.target
+
+[Service]
+ExecStart=${nodePath} ${cliPath} daemon start
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target`;
+  writeFileSync(servicePath, service);
+  execFileSync("systemctl", ["--user", "daemon-reload"]);
+  execFileSync("systemctl", ["--user", "enable", "--now", "cueclaw"]);
+  logger.info({ servicePath }, "Installed systemd service");
+  return { success: true };
+}
+function uninstallSystemd() {
+  const home = process.env["HOME"];
+  if (!home) return { success: false, error: "HOME not set" };
+  const servicePath = join(home, ".config", "systemd", "user", "cueclaw.service");
+  if (!existsSync(servicePath)) return { success: false, error: "Service not installed" };
+  try {
+    execFileSync("systemctl", ["--user", "disable", "--now", "cueclaw"]);
+  } catch {
+  }
+  unlinkSync(servicePath);
+  execFileSync("systemctl", ["--user", "daemon-reload"]);
+  logger.info("Uninstalled systemd service");
+  return { success: true };
+}
+export {
+  getServiceStatus,
+  installService,
+  uninstallService
+};

package/dist/setup-QZUEJUIN.js

@@ -0,0 +1,154 @@
+import {
+  logger
+} from "./chunk-E7BP6DMO.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
+import Anthropic from "@anthropic-ai/sdk";
+async function validateAuth(config) {
+  try {
+    const client = new Anthropic({ apiKey: config.claude.api_key });
+    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) };
+  }
+}
+
+// src/setup-container.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { join } from "path";
+function buildContainer(projectRoot) {
+  const buildScript = join(projectRoot, "container", "build.sh");
+  try {
+    execFileSync2("bash", [buildScript], {
+      encoding: "utf-8",
+      stdio: "inherit",
+      cwd: join(projectRoot, "container")
+    });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function checkContainerImage(imageName) {
+  try {
+    const result = execFileSync2("docker", ["image", "inspect", imageName], {
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    return result.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/setup-verify.ts
+import { execFileSync as execFileSync3 } from "child_process";
+function runSmokeTest(imageName) {
+  try {
+    const result = execFileSync3("docker", [
+      "run",
+      "--rm",
+      "--network",
+      "none",
+      "--user",
+      "1000:1000",
+      imageName,
+      "node",
+      "-e",
+      'console.log("cueclaw-smoke-ok")'
+    ], {
+      encoding: "utf-8",
+      timeout: 3e4,
+      stdio: "pipe"
+    });
+    if (result.includes("cueclaw-smoke-ok")) {
+      return { success: true };
+    }
+    return { success: false, error: "Smoke test output mismatch" };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// src/setup.ts
+async function runSetup(config, projectRoot) {
+  console.log("CueClaw Setup\n");
+  console.log("Checking environment...");
+  const env = checkEnvironment();
+  console.log(`  Node.js: ${env.nodeVersion}`);
+  if (!env.docker) {
+    console.log("  Docker: NOT INSTALLED");
+    console.log("\n  Docker is required for container isolation.");
+    console.log("  Install Docker: https://docs.docker.com/get-docker/");
+    console.log("  You can still use CueClaw in local mode (container.enabled: false)");
+    return;
+  }
+  console.log(`  Docker: ${env.dockerVersion}`);
+  if (!env.dockerRunning) {
+    console.log("  Docker daemon: NOT RUNNING");
+    console.log("  Please start Docker and try again.");
+    return;
+  }
+  console.log("  Docker daemon: running");
+  console.log("\nValidating API key...");
+  const auth = await validateAuth(config);
+  if (!auth.valid) {
+    console.log(`  API key validation failed: ${auth.error}`);
+    console.log("  Check your ANTHROPIC_API_KEY in ~/.cueclaw/config.yaml or .env");
+    return;
+  }
+  console.log("  API key: valid");
+  const imageName = config.container?.image ?? "cueclaw-agent:latest";
+  if (!checkContainerImage(imageName)) {
+    console.log("\nBuilding container image...");
+    const build = buildContainer(projectRoot);
+    if (!build.success) {
+      console.log(`  Build failed: ${build.error}`);
+      return;
+    }
+    console.log(`  Image built: ${imageName}`);
+  } else {
+    console.log(`
+Container image: ${imageName} (exists)`);
+  }
+  console.log("\nRunning smoke test...");
+  const smoke = runSmokeTest(imageName);
+  if (!smoke.success) {
+    console.log(`  Smoke test failed: ${smoke.error}`);
+    logger.warn({ error: smoke.error }, "Setup smoke test failed");
+    return;
+  }
+  console.log("  Smoke test: passed");
+  console.log("\nSetup complete. Run `cueclaw daemon install` to start the background service.");
+}
+export {
+  runSetup
+};

package/dist/telegram-BTTWEETO.js

@@ -0,0 +1,120 @@
+import {
+  logger
+} from "./chunk-E7BP6DMO.js";
+
+// src/channels/telegram.ts
+import { Bot, InlineKeyboard } from "grammy";
+var TELEGRAM_MAX_MESSAGE_LENGTH = 4096;
+var TelegramChannel = class {
+  constructor(token, allowedUsers = [], onInbound) {
+    this.allowedUsers = allowedUsers;
+    this.bot = new Bot(token);
+    this.onInbound = onInbound ?? null;
+  }
+  name = "telegram";
+  bot;
+  connected = false;
+  onInbound = null;
+  callbackHandler = null;
+  /** Set a handler for inline keyboard callback actions (confirm/modify/cancel) */
+  onCallback(handler) {
+    this.callbackHandler = handler;
+  }
+  async connect() {
+    this.bot.on("message:text", (ctx) => {
+      const jid = String(ctx.chat.id);
+      if (!this.isAllowed(jid)) return;
+      const newMsg = {
+        text: ctx.message.text,
+        sender: String(ctx.from?.id ?? "unknown")
+      };
+      this.onInbound?.(jid, newMsg);
+    });
+    this.bot.on("callback_query:data", async (ctx) => {
+      await ctx.answerCallbackQuery();
+      const data = ctx.callbackQuery.data;
+      const chatId = String(ctx.callbackQuery.message?.chat.id ?? "");
+      const [action, workflowId] = data.split(":");
+      if (action && workflowId && chatId) {
+        this.callbackHandler?.(workflowId, action, chatId);
+      }
+    });
+    this.bot.catch((err) => {
+      logger.error({ err: err.error }, "Telegram bot error");
+    });
+    await this.bot.start();
+    this.connected = true;
+    logger.info("Telegram bot connected");
+  }
+  async disconnect() {
+    await this.bot.stop();
+    this.connected = false;
+  }
+  async sendMessage(jid, text) {
+    const chunks = chunkMessage(text);
+    for (const chunk of chunks) {
+      await this.bot.api.sendMessage(Number(jid), chunk);
+    }
+  }
+  async sendConfirmation(jid, workflow) {
+    const steps = workflow.steps.map((s, i) => `${i + 1}. ${s.description}`).join("\n");
+    const trigger = workflow.trigger.type === "manual" ? "manual" : workflow.trigger.type === "cron" ? `cron (${workflow.trigger.expression})` : `poll (${workflow.trigger.interval_seconds}s)`;
+    const text = [
+      `Workflow: ${escapeMdV2(workflow.name)}`,
+      `Trigger: ${escapeMdV2(trigger)}`,
+      "",
+      "*Steps:*",
+      escapeMdV2(steps)
+    ].join("\n");
+    const keyboard = new InlineKeyboard().text("Confirm", `confirm:${workflow.id}`).text("Modify", `modify:${workflow.id}`).text("Cancel", `cancel:${workflow.id}`);
+    await this.bot.api.sendMessage(Number(jid), text, {
+      reply_markup: keyboard,
+      parse_mode: "MarkdownV2"
+    });
+  }
+  isConnected() {
+    return this.connected;
+  }
+  ownsJid(jid) {
+    return /^-?\d+$/.test(jid);
+  }
+  async setTyping(jid, _isTyping) {
+    try {
+      await this.bot.api.sendChatAction(Number(jid), "typing");
+    } catch {
+    }
+  }
+  isAllowed(jid) {
+    if (this.allowedUsers.length === 0) return true;
+    return this.allowedUsers.includes(jid);
+  }
+};
+function escapeMdV2(text) {
+  return text.replace(/[_*[\]()~`>#+\-=|{}.!\\]/g, "\\$&");
+}
+function chunkMessage(text) {
+  if (text.length <= TELEGRAM_MAX_MESSAGE_LENGTH) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= TELEGRAM_MAX_MESSAGE_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    let breakAt = remaining.lastIndexOf("\n", TELEGRAM_MAX_MESSAGE_LENGTH);
+    if (breakAt === -1 || breakAt < TELEGRAM_MAX_MESSAGE_LENGTH / 2) {
+      breakAt = remaining.lastIndexOf(" ", TELEGRAM_MAX_MESSAGE_LENGTH);
+    }
+    if (breakAt === -1) {
+      breakAt = TELEGRAM_MAX_MESSAGE_LENGTH;
+    }
+    chunks.push(remaining.slice(0, breakAt));
+    remaining = remaining.slice(breakAt).trimStart();
+  }
+  return chunks;
+}
+export {
+  TelegramChannel,
+  chunkMessage,
+  escapeMdV2
+};

package/dist/whatsapp-36XWDSJ5.js

@@ -0,0 +1,92 @@
+import {
+  logger
+} from "./chunk-E7BP6DMO.js";
+
+// src/channels/whatsapp.ts
+var WhatsAppChannel = class {
+  constructor(authDir, allowedJids = [], onInbound) {
+    this.authDir = authDir;
+    this.allowedJids = allowedJids;
+    this.onInbound = onInbound ?? null;
+  }
+  name = "whatsapp";
+  sock = null;
+  connected = false;
+  onInbound = null;
+  async connect() {
+    const baileys = await import("@whiskeysockets/baileys");
+    const makeWASocket = baileys.default;
+    const { useMultiFileAuthState } = baileys;
+    const { state, saveCreds } = await useMultiFileAuthState(this.authDir);
+    this.sock = makeWASocket({
+      auth: state,
+      printQRInTerminal: true
+    });
+    this.sock.ev.on("creds.update", saveCreds);
+    this.sock.ev.on("connection.update", (update) => {
+      if (update.connection === "open") {
+        this.connected = true;
+        logger.info("WhatsApp connected");
+      } else if (update.connection === "close") {
+        this.connected = false;
+        logger.warn("WhatsApp disconnected");
+      }
+    });
+    this.sock.ev.on("messages.upsert", ({ messages }) => {
+      for (const msg of messages) {
+        if (msg.key.fromMe || !msg.message) continue;
+        const jid = msg.key.remoteJid;
+        if (!jid) continue;
+        if (this.allowedJids.length > 0 && !this.allowedJids.includes(jid)) continue;
+        const text = msg.message.conversation || msg.message.extendedTextMessage?.text || "";
+        if (!text) continue;
+        const newMsg = {
+          text,
+          sender: msg.key.participant || jid
+        };
+        this.onInbound?.(jid, newMsg);
+      }
+    });
+  }
+  async disconnect() {
+    if (this.sock) {
+      this.sock.end();
+      this.sock = null;
+      this.connected = false;
+    }
+  }
+  async sendMessage(jid, text) {
+    if (!this.sock) throw new Error("WhatsApp not connected");
+    await this.sock.sendMessage(jid, { text });
+  }
+  async sendConfirmation(jid, workflow) {
+    const steps = workflow.steps.map((s, i) => `${i + 1}. ${s.description}`).join("\n");
+    const trigger = workflow.trigger.type === "manual" ? "manual" : workflow.trigger.type === "cron" ? `cron (${workflow.trigger.expression})` : `poll (${workflow.trigger.interval_seconds}s)`;
+    const text = [
+      `Workflow: ${workflow.name}`,
+      `Trigger: ${trigger}`,
+      "",
+      "Steps:",
+      steps,
+      "",
+      "Reply: 1=Confirm, 2=Modify, 3=Cancel"
+    ].join("\n");
+    await this.sendMessage(jid, text);
+  }
+  isConnected() {
+    return this.connected;
+  }
+  ownsJid(jid) {
+    return jid.endsWith("@s.whatsapp.net") || jid.endsWith("@g.us");
+  }
+  async setTyping(jid, isTyping) {
+    if (!this.sock) return;
+    try {
+      await this.sock.sendPresenceUpdate(isTyping ? "composing" : "paused", jid);
+    } catch {
+    }
+  }
+};
+export {
+  WhatsAppChannel
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueclaw",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Orchestrate agent workflows with natural language. Natural language in, executable DAG out.",
   "type": "module",
   "bin": {
@@ -17,14 +17,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:integration": "vitest run --config vitest.integration.config.ts",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "pnpm build"
-  },
   "keywords": [
     "ai",
     "agent",
@@ -48,5 +40,51 @@
   "engines": {
     "node": ">=22.0.0"
   },
-  "packageManager": "pnpm@9.15.4"
-}
+  "simple-git-hooks": {
+    "commit-msg": "pnpm commitlint --edit $1"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@inkjs/ui": "^2.0.0",
+    "@whiskeysockets/baileys": "7.0.0-rc.9",
+    "better-sqlite3": "^12.6.2",
+    "commander": "^14.0.3",
+    "cron-parser": "^5.5.0",
+    "dotenv": "^17.3.1",
+    "grammy": "^1.40.0",
+    "ink": "5",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "nanoid": "^5.1.6",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "react": "18",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "@commitlint/cli": "^20.4.2",
+    "@commitlint/config-conventional": "^20.4.2",
+    "@eslint/js": "^10.0.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.3.0",
+    "@types/react": "^19.2.14",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.2",
+    "simple-git-hooks": "^2.13.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --target node22 --dts --clean",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/"
+  }
+}