volute 0.1.0

package/dist/chunk-GSPKUPKU.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+// src/lib/template.ts
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { dirname, join, relative, resolve } from "path";
+function findTemplatesRoot() {
+  let dir = dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve(dir, "templates");
+    if (existsSync(resolve(candidate, "_base"))) return candidate;
+    dir = dirname(dir);
+  }
+  console.error(
+    "Templates directory not found. Searched up from:",
+    dirname(new URL(import.meta.url).pathname)
+  );
+  process.exit(1);
+}
+function composeTemplate(templatesRoot, templateName) {
+  const baseDir = resolve(templatesRoot, "_base");
+  const templateDir = resolve(templatesRoot, templateName);
+  if (!existsSync(baseDir)) {
+    console.error("Base template not found:", baseDir);
+    process.exit(1);
+  }
+  if (!existsSync(templateDir)) {
+    console.error(`Template not found: ${templateName}`);
+    process.exit(1);
+  }
+  const composedDir = resolve(tmpdir(), `volute-template-${Date.now()}`);
+  mkdirSync(composedDir, { recursive: true });
+  cpSync(baseDir, composedDir, { recursive: true });
+  for (const file of listFiles(templateDir)) {
+    const src = resolve(templateDir, file);
+    const dest = resolve(composedDir, file);
+    mkdirSync(dirname(dest), { recursive: true });
+    cpSync(src, dest);
+  }
+  const manifestPath = resolve(composedDir, "volute-template.json");
+  if (!existsSync(manifestPath)) {
+    rmSync(composedDir, { recursive: true, force: true });
+    console.error(`Template manifest not found: ${templateName}/volute-template.json`);
+    process.exit(1);
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  const skillsSrc = resolve(composedDir, "_skills");
+  if (existsSync(skillsSrc)) {
+    const skillsDest = resolve(composedDir, manifest.skillsDir);
+    mkdirSync(skillsDest, { recursive: true });
+    cpSync(skillsSrc, skillsDest, { recursive: true });
+    rmSync(skillsSrc, { recursive: true, force: true });
+  }
+  rmSync(manifestPath);
+  return { composedDir, manifest };
+}
+function copyTemplateToDir(composedDir, destDir, agentName, manifest) {
+  cpSync(composedDir, destDir, { recursive: true });
+  for (const [from, to] of Object.entries(manifest.rename)) {
+    const fromPath = resolve(destDir, from);
+    if (existsSync(fromPath)) {
+      renameSync(fromPath, resolve(destDir, to));
+    }
+  }
+  for (const file of manifest.substitute) {
+    const path = resolve(destDir, file);
+    if (existsSync(path)) {
+      const content = readFileSync(path, "utf-8");
+      writeFileSync(path, content.replaceAll("{{name}}", agentName));
+    }
+  }
+}
+function applyInitFiles(destDir) {
+  const initDir = resolve(destDir, ".init");
+  if (!existsSync(initDir)) return;
+  const homeDir = resolve(destDir, "home");
+  for (const file of listFiles(initDir)) {
+    const src = resolve(initDir, file);
+    const dest = resolve(homeDir, file);
+    const parent = dirname(dest);
+    if (!existsSync(parent)) {
+      mkdirSync(parent, { recursive: true });
+    }
+    cpSync(src, dest);
+  }
+  rmSync(initDir, { recursive: true, force: true });
+}
+function listFiles(dir) {
+  const results = [];
+  function walk(current) {
+    for (const entry of readdirSync(current)) {
+      const full = join(current, entry);
+      if (statSync(full).isDirectory()) {
+        if (entry === ".git") continue;
+        walk(full);
+      } else {
+        results.push(relative(dir, full));
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+export {
+  findTemplatesRoot,
+  composeTemplate,
+  copyTemplateToDir,
+  applyInitFiles
+};

package/dist/chunk-H5XQARAP.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import {
+  VOLUTE_HOME
+} from "./chunk-5YW4B7CG.js";
+
+// src/lib/daemon-client.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+function readDaemonConfig() {
+  const configPath = resolve(VOLUTE_HOME, "daemon.json");
+  if (!existsSync(configPath)) {
+    console.error("Volute is not running. Start with: volute up");
+    process.exit(1);
+  }
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    console.error("Volute is not running. Start with: volute up");
+    process.exit(1);
+  }
+}
+function getDaemonUrl() {
+  const config = readDaemonConfig();
+  return `http://localhost:${config.port}`;
+}
+async function daemonFetch(path, options) {
+  const config = readDaemonConfig();
+  const url = `http://localhost:${config.port}`;
+  const headers = new Headers(options?.headers);
+  if (config.token) {
+    headers.set("Authorization", `Bearer ${config.token}`);
+  }
+  headers.set("Origin", url);
+  try {
+    return await fetch(`${url}${path}`, { ...options, headers });
+  } catch (err) {
+    if (err instanceof TypeError && err.cause?.code === "ECONNREFUSED") {
+      console.error("Volute is not running. Start with: volute up");
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
+export {
+  getDaemonUrl,
+  daemonFetch
+};

package/dist/chunk-KSMIWOCN.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+// src/lib/log-buffer.ts
+var LogBuffer = class {
+  entries = [];
+  maxSize = 1e3;
+  subscribers = /* @__PURE__ */ new Set();
+  append(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.maxSize) {
+      this.entries.shift();
+    }
+    for (const sub of this.subscribers) {
+      sub(entry);
+    }
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => this.subscribers.delete(fn);
+  }
+};
+var logBuffer = new LogBuffer();
+
+// src/lib/logger.ts
+function write(level, msg, data) {
+  const entry = {
+    level,
+    msg,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    ...data ? { data } : {}
+  };
+  const line = JSON.stringify(entry);
+  process.stderr.write(`${line}
+`);
+  logBuffer.append(entry);
+}
+var log = {
+  info: (msg, data) => write("info", msg, data),
+  warn: (msg, data) => write("warn", msg, data),
+  error: (msg, data) => write("error", msg, data)
+};
+var logger_default = log;
+
+// src/lib/ndjson.ts
+async function* readNdjson(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          yield JSON.parse(line);
+        } catch {
+          logger_default.warn("ndjson: skipping invalid line", { line: line.slice(0, 100) });
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        yield JSON.parse(buffer);
+      } catch {
+        logger_default.warn("ndjson: skipping invalid line", { line: buffer.slice(0, 100) });
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export {
+  logBuffer,
+  logger_default,
+  readNdjson
+};

package/dist/chunk-N4QN44LC.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+// src/lib/spawn-server.ts
+import { spawn } from "child_process";
+import { resolve } from "path";
+function tsxBin(cwd) {
+  return resolve(cwd, "node_modules", ".bin", "tsx");
+}
+function spawnServer(cwd, port, options) {
+  if (options?.detached) {
+    return spawnDetached(cwd, port);
+  }
+  return spawnAttached(cwd, port);
+}
+function spawnAttached(cwd, port) {
+  const child = spawn(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return new Promise((resolve2) => {
+    const timeout = setTimeout(() => resolve2(null), 3e4);
+    function checkOutput(data) {
+      const match = data.toString().match(/listening on :(\d+)/);
+      if (match) {
+        clearTimeout(timeout);
+        resolve2({ child, actualPort: parseInt(match[1], 10) });
+      }
+    }
+    child.stdout?.on("data", checkOutput);
+    child.stderr?.on("data", checkOutput);
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve2(null);
+    });
+    child.on("exit", () => {
+      clearTimeout(timeout);
+      resolve2(null);
+    });
+  });
+}
+function spawnDetached(cwd, port) {
+  const child = spawn(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
+  });
+  return new Promise((resolve2) => {
+    const timeout = setTimeout(() => resolve2(null), 3e4);
+    function checkOutput(data) {
+      const match = data.toString().match(/listening on :(\d+)/);
+      if (match) {
+        clearTimeout(timeout);
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        child.unref();
+        resolve2({ child, actualPort: parseInt(match[1], 10) });
+      }
+    }
+    child.stdout?.on("data", checkOutput);
+    child.stderr?.on("data", checkOutput);
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve2(null);
+    });
+    child.on("exit", () => {
+      clearTimeout(timeout);
+      resolve2(null);
+    });
+  });
+}
+
+export {
+  spawnServer
+};

package/dist/chunk-XZN4WPNC.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// src/lib/exec.ts
+import { execFile as execFileCb, spawn } from "child_process";
+function exec(cmd, args, options) {
+  return new Promise((resolve, reject) => {
+    execFileCb(cmd, args, { cwd: options?.cwd }, (err, stdout, stderr) => {
+      if (err) {
+        err.stderr = stderr;
+        reject(err);
+      } else {
+        resolve(stdout);
+      }
+    });
+  });
+}
+function execInherit(cmd, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd: options?.cwd,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+
+export {
+  exec,
+  execInherit
+};

package/dist/cli.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+var command = process.argv[2];
+var args = process.argv.slice(3);
+switch (command) {
+  case "create":
+    await import("./create-3K6O2SDC.js").then((m) => m.run(args));
+    break;
+  case "start":
+    await import("./start-LKMWS6ZE.js").then((m) => m.run(args));
+    break;
+  case "stop":
+    await import("./stop-YTOAGYE4.js").then((m) => m.run(args));
+    break;
+  case "logs":
+    await import("./logs-BUHRIQ2L.js").then((m) => m.run(args));
+    break;
+  case "status":
+    await import("./status-CIEKUI3V.js").then((m) => m.run(args));
+    break;
+  case "fork":
+    await import("./fork-BB3DZ426.js").then((m) => m.run(args));
+    break;
+  case "variants":
+    await import("./variants-HPY4DEWU.js").then((m) => m.run(args));
+    break;
+  case "send":
+    await import("./send-WQSVSRDD.js").then((m) => m.run(args));
+    break;
+  case "merge":
+    await import("./merge-446QTE7Q.js").then((m) => m.run(args));
+    break;
+  case "import":
+    await import("./import-W2AMTEV5.js").then((m) => m.run(args));
+    break;
+  case "delete":
+    await import("./delete-JNGY7ZFH.js").then((m) => m.run(args));
+    break;
+  case "env":
+    await import("./env-7SLRN3MG.js").then((m) => m.run(args));
+    break;
+  case "connect":
+    await import("./connect-LW6G23AV.js").then((m) => m.run(args));
+    break;
+  case "disconnect":
+    await import("./disconnect-ACVTKTRE.js").then((m) => m.run(args));
+    break;
+  case "channel":
+    await import("./channel-Q642YUZE.js").then((m) => m.run(args));
+    break;
+  case "upgrade":
+    await import("./upgrade-JACA6YMO.js").then((m) => m.run(args));
+    break;
+  case "up":
+    await import("./up-AJJ4GCXY.js").then((m) => m.run(args));
+    break;
+  case "down":
+    await import("./down-FYCUYC5H.js").then((m) => m.run(args));
+    break;
+  case "schedule":
+    await import("./schedule-KKSOVUDF.js").then((m) => m.run(args));
+    break;
+  default:
+    console.log(`volute \u2014 create and manage AI agents
+
+Commands:
+  volute create <name>               Create a new agent
+  volute start <name>                Start an agent (daemonized)
+  volute stop <name>                 Stop an agent
+  volute status [<name>]             Check agent status (or list all)
+  volute logs <name>                 Tail agent logs
+  volute send <name> "<msg>"         Send a message to an agent
+  volute fork <name> <variant>       Create a variant (worktree + server)
+  volute variants <name>             List variants for an agent
+  volute merge <name> <variant>      Merge a variant back
+  volute import <path>               Import an OpenClaw workspace
+  volute env <set|get|list|remove>   Manage environment variables
+  volute connect <type> <name>        Enable a connector for an agent
+  volute disconnect <type> <name>    Disable a connector for an agent
+  volute channel read <uri>          Read recent messages from a channel
+  volute channel send <uri> "<msg>"  Send a message to a channel
+  volute schedule list <agent>       List schedules for an agent
+  volute schedule add <agent> ...    Add a cron schedule
+  volute schedule remove <agent> ... Remove a schedule
+  volute up [--port N]               Start the daemon (default: 4200)
+  volute down                        Stop the daemon
+  volute upgrade <name>              Upgrade agent to latest template
+  volute delete <name> [--force]     Delete an agent (--force removes files)`);
+    if (command) {
+      console.error(`
+Unknown command: ${command}`);
+      process.exit(1);
+    }
+}

package/dist/connect-LW6G23AV.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import {
+  loadMergedEnv
+} from "./chunk-A5ZJEMHT.js";
+import {
+  daemonFetch
+} from "./chunk-H5XQARAP.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  resolveAgent
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/connect.ts
+async function run(args) {
+  const { positional } = parseArgs(args, {});
+  const type = positional[0];
+  const name = positional[1];
+  if (!type || !name) {
+    console.error("Usage: volute connect <type> <agent>");
+    process.exit(1);
+  }
+  const { dir } = resolveAgent(name);
+  if (type === "discord") {
+    const env = loadMergedEnv(dir);
+    if (!env.DISCORD_TOKEN) {
+      console.error("DISCORD_TOKEN not set. Run: volute env set DISCORD_TOKEN <token>");
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown connector type: ${type}`);
+    process.exit(1);
+  }
+  const res = await daemonFetch(
+    `/api/agents/${encodeURIComponent(name)}/connectors/${encodeURIComponent(type)}`,
+    { method: "POST" }
+  );
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    console.error(`Failed to start ${type} connector: ${body.error}`);
+    process.exit(1);
+  }
+  console.log(`${type} connector for ${name} started.`);
+}
+export {
+  run
+};