volute 0.3.1 → 0.5.0

package/dist/cli.js

@@ -1,105 +1,128 @@
 #!/usr/bin/env node
 
 // src/cli.ts
+import { homedir } from "os";
+import { resolve } from "path";
+if (!process.env.VOLUTE_HOME) {
+  process.env.VOLUTE_HOME = resolve(homedir(), ".volute");
+}
 var command = process.argv[2];
 var args = process.argv.slice(3);
+if (command === "--version" || command === "-v") {
+  const { default: pkg } = await import("./package-VQOE7JNH.js");
+  console.log(pkg.version);
+  process.exit(0);
+}
 switch (command) {
-  case "create":
-    await import("./create-BRG2DBWI.js").then((m) => m.run(args));
-    break;
-  case "start":
-    await import("./start-LDPMCMYT.js").then((m) => m.run(args));
-    break;
-  case "stop":
-    await import("./stop-5PZTZCLL.js").then((m) => m.run(args));
-    break;
-  case "logs":
-    await import("./logs-NXFFGUKY.js").then((m) => m.run(args));
+  case "agent":
+    await import("./agent-Z2B6EFEQ.js").then((m) => m.run(args));
     break;
-  case "status":
-    await import("./status-MVSQG54T.js").then((m) => m.run(args));
+  case "message":
+    await import("./message-ADHWFHSI.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-CVYM3EQG.js").then((m) => m.run(args));
-    break;
-  case "send":
-    await import("./send-UK3JBZIB.js").then((m) => m.run(args));
-    break;
-  case "import":
-    await import("./import-K4MP2GX7.js").then((m) => m.run(args));
-    break;
-  case "delete":
-    await import("./delete-GQ7JEK2S.js").then((m) => m.run(args));
-    break;
-  case "env":
-    await import("./env-JB27UAC3.js").then((m) => m.run(args));
+    await import("./variant-LAB67OC2.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-TVJULIRT.js").then((m) => m.run(args));
+    await import("./connector-LYEMXQEV.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-7FZ6D25H.js").then((m) => m.run(args));
+    await import("./channel-MK5OK2SI.js").then((m) => m.run(args));
+    break;
+  case "schedule":
+    await import("./schedule-NAG6F463.js").then((m) => m.run(args));
+    break;
+  case "conversation":
+    await import("./conversation-ERXEQZTY.js").then((m) => m.run(args));
     break;
-  case "upgrade":
-    await import("./upgrade-CDKECCGN.js").then((m) => m.run(args));
+  case "env":
+    await import("./env-4D4REPJF.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-UT3IMKCA.js").then((m) => m.run(args));
+    await import("./up-7ILD7GU7.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-3OB6UVAJ.js").then((m) => m.run(args));
-    break;
-  case "schedule":
-    await import("./schedule-4I5TYHFH.js").then((m) => m.run(args));
+    await import("./down-O7IFZLVJ.js").then((m) => m.run(args));
     break;
-  case "history":
-    await import("./history-3VRUBGGV.js").then((m) => m.run(args));
+  case "setup":
+    await import("./setup-RPRRGG2F.js").then((m) => m.run(args));
     break;
   case "service":
-    await import("./service-SA4TTMDU.js").then((m) => m.run(args));
+    await import("./service-HZNIDNJF.js").then((m) => m.run(args));
     break;
-  case "setup":
-    await import("./setup-SRS7AUAA.js").then((m) => m.run(args));
+  case "update":
+    await import("./update-LPSIAWQ2.js").then((m) => m.run(args));
     break;
-  default:
+  case "--help":
+  case "-h":
+  case void 0:
     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 [--agent <name>]          Tail agent logs
-  volute send <name> "<msg>"            Send a message to an agent
-  volute variant create <name>          Create a variant (worktree + server)
-  volute variant list                   List variants for an agent
-  volute variant merge <name>           Merge a variant back
-  volute variant delete <name>          Delete a variant
-  volute import <path>                  Import an OpenClaw workspace
-  volute env <set|get|list|remove>      Manage environment variables
-  volute connector connect <type>       Enable a connector for an agent
-  volute connector disconnect <type>    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                  List schedules for an agent
-  volute schedule add ...               Add a cron schedule
-  volute schedule remove ...            Remove a schedule
-  volute history                        View message history
-  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)
-  volute service install [--port N]     Install as system service (auto-start)
-  volute service uninstall              Remove system service
-  volute service status                 Check service status
-  volute setup [--port N] [--host H]   Install system service with user isolation
-  volute setup uninstall [--force]     Remove system service + isolation
+  volute agent create <name>              Create a new agent
+  volute agent start <name>               Start an agent (daemonized)
+  volute agent stop <name>                Stop an agent
+  volute agent delete <name> [--force]    Delete an agent (--force removes files)
+  volute agent list                       List all agents
+  volute agent status <name>              Check agent status
+  volute agent logs <name> [--follow]     Tail agent logs
+  volute agent upgrade <name>             Upgrade agent to latest template
+  volute agent import <path>              Import an OpenClaw workspace
+
+  volute message send <name> "<msg>"      Send a message to an agent
+  volute message history [--agent <name>] View message history
+
+  volute variant create <name>            Create a variant (worktree + server)
+  volute variant list                     List variants for an agent
+  volute variant merge <name>             Merge a variant back
+  volute variant delete <name>            Delete a variant
+
+  volute connector connect <type>         Enable a connector for an agent
+  volute connector disconnect <type>      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                    List schedules for an agent
+  volute schedule add ...                 Add a cron schedule
+  volute schedule remove ...              Remove a schedule
+
+  volute conversation create ...           Create a group conversation
+  volute conversation list                 List conversations
+  volute conversation send <id> "<msg>"    Send a message to a conversation
 
-Agent commands (variant, connector, schedule, logs, history, channel) use
---agent <name> or VOLUTE_AGENT env var to identify the agent.`);
-    if (command) {
+  volute env <set|get|list|remove>        Manage environment variables
+
+  volute up [--port N]                    Start the daemon (default: 4200)
+  volute down                             Stop the daemon
+
+  volute service install [--port N]       Install as system service (auto-start)
+  volute service uninstall                Remove system service
+  volute service status                   Check service status
+  volute setup [--port N] [--host H]      Install system service with user isolation
+  volute setup uninstall [--force]        Remove system service + isolation
+
+  volute update                           Update to latest version
+
+Options:
+  --version, -v                           Show version number
+  --help, -h                              Show this help message
+
+Agent-scoped commands (variant, connector, schedule, channel, conversation, message history)
+use --agent <name> or VOLUTE_AGENT env var to identify the agent.`);
+    break;
+  default:
+    console.error(`Unknown command: ${command}
+Run 'volute --help' for usage.`);
+    process.exit(1);
+}
+if (command !== "update") {
+  import("./update-check-Y33QDCFL.js").then((m) => m.checkForUpdate()).then((result) => {
+    if (result.updateAvailable) {
       console.error(`
-Unknown command: ${command}`);
-      process.exit(1);
+  Update available: ${result.current} \u2192 ${result.latest}`);
+      console.error("  Run `volute update` to update\n");
     }
+  }).catch(() => {
+  });
 }

package/dist/connector-LYEMXQEV.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  agentEnvPath,
+  readEnv,
+  writeEnv
+} from "./chunk-HE67X4T6.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  daemonFetch
+} from "./chunk-7L4AN5D4.js";
+import {
+  agentDir
+} from "./chunk-UX25Z2ND.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/connector.ts
+async function run(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "connect":
+      await connectConnector(args.slice(1));
+      break;
+    case "disconnect":
+      await disconnectConnector(args.slice(1));
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printUsage();
+      break;
+    default:
+      printUsage();
+      process.exit(1);
+  }
+}
+function printUsage() {
+  console.log(`Usage:
+  volute connector connect <type> [--agent <name>]
+  volute connector disconnect <type> [--agent <name>]`);
+}
+async function promptValue(key, description) {
+  process.stderr.write(`${description}
+Enter value for ${key}: `);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+  return new Promise((resolve) => {
+    let value = "";
+    const onData = (buf) => {
+      for (const byte of buf) {
+        if (byte === 3) {
+          process.stderr.write("\n");
+          process.exit(1);
+        }
+        if (byte === 13 || byte === 10) {
+          process.stderr.write("\n");
+          if (process.stdin.isTTY) process.stdin.setRawMode(false);
+          process.stdin.removeListener("data", onData);
+          process.stdin.pause();
+          resolve(value);
+          return;
+        }
+        if (byte === 127 || byte === 8) {
+          value = value.slice(0, -1);
+        } else {
+          value += String.fromCharCode(byte);
+        }
+      }
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+async function connectConnector(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const agentName = resolveAgentName(flags);
+  const type = positional[0];
+  if (!type) {
+    console.error("Usage: volute connector connect <type> [--agent <name>]");
+    process.exit(1);
+  }
+  const url = `/api/agents/${encodeURIComponent(agentName)}/connectors/${encodeURIComponent(type)}`;
+  let res = await daemonFetch(url, { method: "POST" });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    if (body.error === "missing_env" && "missing" in body) {
+      const { missing, connectorName } = body;
+      if (!process.stdin.isTTY) {
+        console.error(`Missing required environment variables for ${connectorName}:`);
+        for (const v of missing) {
+          console.error(`  ${v.name} \u2014 ${v.description}`);
+        }
+        console.error(`
+Set them with: volute env set <KEY> --agent ${agentName}`);
+        process.exit(1);
+      }
+      console.error(`${connectorName} connector requires some environment variables.
+`);
+      const dir = agentDir(agentName);
+      const envPath = agentEnvPath(dir);
+      const env = readEnv(envPath);
+      for (const v of missing) {
+        const value = await promptValue(v.name, v.description);
+        if (!value) {
+          console.error(`No value provided for ${v.name}. Aborting.`);
+          process.exit(1);
+        }
+        env[v.name] = value;
+      }
+      writeEnv(envPath, env);
+      console.log("Environment variables saved.\n");
+      res = await daemonFetch(url, { method: "POST" });
+      if (!res.ok) {
+        const retryBody = await res.json().catch(() => ({ error: "Unknown error" }));
+        console.error(
+          `Failed to start ${type} connector: ${retryBody.error}`
+        );
+        process.exit(1);
+      }
+    } else {
+      console.error(`Failed to start ${type} connector: ${body.error}`);
+      process.exit(1);
+    }
+  }
+  console.log(`${type} connector for ${agentName} started.`);
+}
+async function disconnectConnector(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const agentName = resolveAgentName(flags);
+  const type = positional[0];
+  if (!type) {
+    console.error("Usage: volute connector disconnect <type> [--agent <name>]");
+    process.exit(1);
+  }
+  const res = await daemonFetch(
+    `/api/agents/${encodeURIComponent(agentName)}/connectors/${encodeURIComponent(type)}`,
+    {
+      method: "DELETE"
+    }
+  );
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    console.error(`Failed to stop ${type} connector: ${body.error}`);
+    process.exit(1);
+  }
+  console.log(`${type} connector for ${agentName} stopped.`);
+}
+export {
+  run
+};

package/dist/connectors/discord.js

@@ -1,8 +1,17 @@
 #!/usr/bin/env node
+import {
+  fireAndForget,
+  handleAgentMessage,
+  loadEnv,
+  loadFollowedChannels,
+  splitMessage
+} from "../chunk-MXUCNIBG.js";
+import "../chunk-K3NQKI34.js";
 
 // src/connectors/discord.ts
 import {
   AttachmentBuilder,
+  ChannelType,
   Client,
   Events,
   GatewayIntentBits,
@@ -10,21 +19,14 @@ import {
 } from "discord.js";
 var DISCORD_MAX_LENGTH = 2e3;
 var TYPING_INTERVAL_MS = 8e3;
-var agentPort = process.env.VOLUTE_AGENT_PORT;
-var agentName = process.env.VOLUTE_AGENT_NAME;
+var env = loadEnv();
 var token = process.env.DISCORD_TOKEN;
-if (!agentPort || !agentName) {
-  console.error("Missing required env vars: VOLUTE_AGENT_PORT, VOLUTE_AGENT_NAME");
-  process.exit(1);
-}
 if (!token) {
   console.error("Missing required env var: DISCORD_TOKEN");
   process.exit(1);
 }
-var guildId = process.env.DISCORD_GUILD_ID;
-var daemonUrl = process.env.VOLUTE_DAEMON_URL;
-var daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
-var baseUrl = daemonUrl ? `${daemonUrl}/api/agents/${encodeURIComponent(agentName)}` : `http://127.0.0.1:${agentPort}`;
+var followedChannelNames = loadFollowedChannels(env, "discord");
+var followedChannelIds = /* @__PURE__ */ new Set();
 var client = new Client({
   intents: [
     GatewayIntentBits.Guilds,
@@ -42,13 +44,28 @@ process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 client.once(Events.ClientReady, (c) => {
   console.log(`Connected to Discord as ${c.user.tag}`);
-  console.log(`Bridging to agent: ${agentName} via ${baseUrl}/message`);
+  console.log(`Bridging to agent: ${env.agentName} via ${env.baseUrl}/message`);
+  if (followedChannelNames.length > 0) {
+    for (const guild of c.guilds.cache.values()) {
+      for (const ch of guild.channels.cache.values()) {
+        if (ch.type !== ChannelType.GuildText) continue;
+        if (followedChannelNames.includes(ch.name)) {
+          followedChannelIds.add(ch.id);
+          console.log(`Following #${ch.name} (${ch.id}) in ${guild.name}`);
+        }
+      }
+    }
+    if (followedChannelIds.size === 0) {
+      console.warn(`No channels found matching: ${followedChannelNames.join(", ")}`);
+    }
+  }
 });
 client.on(Events.MessageCreate, async (message) => {
   if (message.author.bot) return;
   const isDM = !message.guild;
   const isMentioned = !isDM && message.mentions.has(client.user);
-  if (!isDM && !isMentioned) return;
+  const isFollowedChannel = !isDM && followedChannelIds.has(message.channelId);
+  if (!isDM && !isMentioned && !isFollowedChannel) return;
   let text = message.content;
   if (isMentioned) {
     text = text.replace(new RegExp(`<@!?${client.user.id}>`, "g"), "").trim();
@@ -70,8 +87,82 @@ client.on(Events.MessageCreate, async (message) => {
     }
   }
   if (content.length === 0) return;
-  await handleAgentRequest(message, content);
+  const senderName = message.author.displayName || message.author.username;
+  const channelKey = `discord:${message.channelId}`;
+  const channelName = !isDM && "name" in message.channel ? message.channel.name : void 0;
+  const participantCount = isDM ? 2 : message.guild?.memberCount;
+  const payload = {
+    content,
+    channel: channelKey,
+    sender: senderName,
+    platform: "Discord",
+    ...isDM ? { isDM: true } : {},
+    ...channelName ? { channelName } : {},
+    ...message.guild?.name ? { serverName: message.guild.name } : {},
+    ...participantCount ? { participantCount } : {}
+  };
+  if (isFollowedChannel && !isMentioned) {
+    await fireAndForget(env, payload);
+    return;
+  }
+  await handleDiscordMessage(message, payload);
 });
+async function handleDiscordMessage(message, payload) {
+  const channel = message.channel;
+  if (!("sendTyping" in channel)) return;
+  const typingInterval = setInterval(() => {
+    channel.sendTyping().catch(() => {
+    });
+  }, TYPING_INTERVAL_MS);
+  channel.sendTyping().catch(() => {
+  });
+  let replied = false;
+  try {
+    await handleAgentMessage(env, payload, {
+      onFlush: async (text, images) => {
+        if (!text && images.length === 0) return;
+        const chunks = text ? splitMessage(text, DISCORD_MAX_LENGTH) : [];
+        const imageFiles = images.map((img, i) => {
+          const ext = img.media_type.split("/")[1] || "png";
+          return new AttachmentBuilder(Buffer.from(img.data, "base64"), {
+            name: `image-${i}.${ext}`
+          });
+        });
+        if (chunks.length === 0 && imageFiles.length > 0) {
+          const sendFn = replied ? channel.send.bind(channel) : message.reply.bind(message);
+          await sendFn({ content: "\u200B", files: imageFiles }).catch((err) => {
+            console.error(`Failed to send message: ${err}`);
+          });
+          replied = true;
+          return;
+        }
+        for (let i = 0; i < chunks.length; i++) {
+          const isLast = i === chunks.length - 1;
+          const opts = {
+            content: chunks[i]
+          };
+          if (isLast && imageFiles.length > 0) opts.files = imageFiles;
+          try {
+            if (!replied) {
+              await message.reply(opts);
+              replied = true;
+            } else {
+              await channel.send(opts);
+            }
+          } catch (err) {
+            console.error(`Failed to send message: ${err}`);
+          }
+        }
+      },
+      onError: async (msg) => {
+        await message.reply(msg).catch(() => {
+        });
+      }
+    });
+  } finally {
+    clearInterval(typingInterval);
+  }
+}
 async function loginWithRetry() {
   try {
     await client.login(token);
@@ -94,151 +185,3 @@ loginWithRetry().catch((err) => {
   console.error("Failed to connect to Discord:", err);
   process.exit(1);
 });
-function splitMessage(text) {
-  const chunks = [];
-  while (text.length > DISCORD_MAX_LENGTH) {
-    let splitAt = text.lastIndexOf("\n", DISCORD_MAX_LENGTH);
-    if (splitAt < DISCORD_MAX_LENGTH / 2) splitAt = DISCORD_MAX_LENGTH;
-    chunks.push(text.slice(0, splitAt));
-    text = text.slice(splitAt).replace(/^\n/, "");
-  }
-  if (text) chunks.push(text);
-  return chunks;
-}
-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 {
-        }
-      }
-    }
-    if (buffer.trim()) {
-      try {
-        yield JSON.parse(buffer);
-      } catch {
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function handleAgentRequest(message, content) {
-  const channel = message.channel;
-  if (!("sendTyping" in channel)) return;
-  const typingInterval = setInterval(() => {
-    channel.sendTyping().catch(() => {
-    });
-  }, TYPING_INTERVAL_MS);
-  channel.sendTyping().catch(() => {
-  });
-  let accumulated = "";
-  const pendingImages = [];
-  let replied = false;
-  async function flush() {
-    const text = accumulated.trim();
-    accumulated = "";
-    if (!text && pendingImages.length === 0) return;
-    const chunks = text ? splitMessage(text) : [];
-    const imageFiles = pendingImages.splice(0).map((img, i) => {
-      const ext = img.media_type.split("/")[1] || "png";
-      return new AttachmentBuilder(Buffer.from(img.data, "base64"), {
-        name: `image-${i}.${ext}`
-      });
-    });
-    if (chunks.length === 0 && imageFiles.length > 0) {
-      const sendFn = replied ? channel.send.bind(channel) : message.reply.bind(message);
-      await sendFn({ content: "\u200B", files: imageFiles }).catch((err) => {
-        console.error(`Failed to send message: ${err}`);
-      });
-      replied = true;
-      return;
-    }
-    for (let i = 0; i < chunks.length; i++) {
-      const isLast = i === chunks.length - 1;
-      const opts = {
-        content: chunks[i]
-      };
-      if (isLast && imageFiles.length > 0) opts.files = imageFiles;
-      try {
-        if (!replied) {
-          await message.reply(opts);
-          replied = true;
-        } else {
-          await channel.send(opts);
-        }
-      } catch (err) {
-        console.error(`Failed to send message: ${err}`);
-      }
-    }
-  }
-  const senderName = message.author.displayName || message.author.username;
-  const channelKey = `discord:${message.channelId}`;
-  const isDM = !message.guild;
-  const channelName = !isDM && "name" in message.channel ? message.channel.name : null;
-  try {
-    const headers = { "Content-Type": "application/json" };
-    if (daemonUrl && daemonToken) {
-      headers.Authorization = `Bearer ${daemonToken}`;
-      headers.Origin = daemonUrl;
-    }
-    const res = await fetch(`${baseUrl}/message`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        content,
-        channel: channelKey,
-        sender: senderName,
-        platform: "Discord",
-        ...isDM ? { isDM: true } : {},
-        ...channelName ? { channelName } : {},
-        ...message.guild?.name ? { guildName: message.guild.name } : {}
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text().catch(() => "");
-      console.error(`Agent returned ${res.status}: ${body}`);
-      await message.reply(`Error: agent returned ${res.status}`);
-      clearInterval(typingInterval);
-      return;
-    }
-    if (!res.body) {
-      await message.reply("Error: no response from agent");
-      clearInterval(typingInterval);
-      return;
-    }
-    for await (const event of readNdjson(res.body)) {
-      if (event.type === "text") {
-        accumulated += event.content;
-      } else if (event.type === "image") {
-        pendingImages.push({
-          data: event.data,
-          media_type: event.media_type
-        });
-      } else if (event.type === "tool_use") {
-        await flush();
-      } else if (event.type === "done") {
-        break;
-      }
-    }
-    await flush();
-  } catch (err) {
-    console.error(`Failed to reach agent at ${baseUrl}/message:`, err);
-    const errMsg = err instanceof TypeError && err.cause?.code === "ECONNREFUSED" ? "Agent is not running" : `Error: ${err}`;
-    await message.reply(errMsg).catch(() => {
-    });
-  } finally {
-    clearInterval(typingInterval);
-  }
-}