volute 0.3.0 → 0.4.0

package/README.md

@@ -121,7 +121,7 @@ Agents have access to the `volute` CLI from their working directory, so they can
 
 ## Connectors
 
-Connect agents to external services.
+Connect agents to external services. Connectors are generic — any connector type that has an implementation (built-in, shared, or agent-specific) can be enabled.
 
 ### Discord
 
@@ -130,21 +130,21 @@ Connect agents to external services.
 volute env set DISCORD_TOKEN <your-bot-token>
 
 # Connect
-volute connect discord atlas
+volute connector connect discord --agent atlas
 
 # Disconnect
-volute disconnect discord atlas
+volute connector disconnect discord --agent atlas
 ```
 
-The agent receives Discord messages and responds in-channel. Tool calls are filtered out — Discord users see clean text responses.
+The agent receives Discord messages and responds in-channel. Tool calls are filtered out — connector users see clean text responses.
 
 ### Channel commands
 
-Read from and write to channels directly:
+Read from and write to connector channels directly:
 
 ```sh
-volute channel read discord:123456789         # recent messages
-volute channel send discord:123456789 "hello" # send a message
+volute channel read discord:123456789 --agent atlas         # recent messages
+volute channel send discord:123456789 "hello" --agent atlas # send a message
 ```
 
 ## Schedules

package/dist/{agent-manager-2LU6KULR.js → agent-manager-AUCKMGPR.js}

@@ -3,10 +3,10 @@ import {
   AgentManager,
   getAgentManager,
   initAgentManager
-} from "./chunk-IPIPLGME.js";
-import "./chunk-YEIHRP2J.js";
-import "./chunk-DEUAVGSA.js";
-import "./chunk-RALYNMHR.js";
+} from "./chunk-I6OHXCMV.js";
+import "./chunk-DNOXHLE5.js";
+import "./chunk-SOZA2TLP.js";
+import "./chunk-3C2XR4IY.js";
 import "./chunk-K3NQKI34.js";
 export {
   AgentManager,

package/dist/{channel-H7N4SGR2.js → channel-DQ6UY7QB.js}

@@ -1,44 +1,21 @@
 #!/usr/bin/env node
-import {
-  loadMergedEnv
-} from "./chunk-YEIHRP2J.js";
 import {
   resolveAgentName
 } from "./chunk-VRVVQIYY.js";
+import {
+  getChannelDriver
+} from "./chunk-5OCWMTVS.js";
+import {
+  loadMergedEnv
+} from "./chunk-DNOXHLE5.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   resolveAgent
-} from "./chunk-RALYNMHR.js";
+} from "./chunk-3C2XR4IY.js";
 import "./chunk-K3NQKI34.js";
 
-// src/lib/channels/discord.ts
-var API_BASE = "https://discord.com/api/v10";
-async function read(token, channelId, limit) {
-  const res = await fetch(`${API_BASE}/channels/${channelId}/messages?limit=${limit}`, {
-    headers: { Authorization: `Bot ${token}` }
-  });
-  if (!res.ok) {
-    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
-  }
-  const messages = await res.json();
-  return messages.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
-}
-async function send(token, channelId, message) {
-  const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bot ${token}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ content: message })
-  });
-  if (!res.ok) {
-    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
-  }
-}
-
 // src/commands/channel.ts
 async function run(args) {
   const { positional, flags } = parseArgs(args, {
@@ -62,26 +39,26 @@ async function run(args) {
   }
   const platform = uri.slice(0, colonIdx);
   const channelId = uri.slice(colonIdx + 1);
+  const driver = getChannelDriver(platform);
+  if (!driver) {
+    console.error(`No channel driver for platform: ${platform}`);
+    process.exit(1);
+  }
   const { dir } = resolveAgent(agentName);
   const env = loadMergedEnv(dir);
-  if (platform === "discord") {
-    const token = env.DISCORD_TOKEN;
-    if (!token) {
-      console.error("DISCORD_TOKEN not set. Run: volute env set DISCORD_TOKEN <token>");
-      process.exit(1);
-    }
+  try {
     if (subcommand === "read") {
       const limit = flags.limit ?? 20;
-      const output = await read(token, channelId, limit);
+      const output = await driver.read(env, channelId, limit);
       console.log(output);
     } else if (subcommand === "send") {
-      await send(token, channelId, message);
+      await driver.send(env, channelId, message);
     } else {
       console.error(`Unknown subcommand: ${subcommand}`);
       process.exit(1);
     }
-  } else {
-    console.error(`Unsupported platform: ${platform}`);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
 }

package/dist/{chunk-RALYNMHR.js → chunk-3C2XR4IY.js}

@@ -81,7 +81,7 @@ function removeAllVariants(agentName) {
 }
 async function checkHealth(port) {
   try {
-    const res = await fetch(`http://localhost:${port}/health`, {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, {
       signal: AbortSignal.timeout(2e3)
     });
     if (!res.ok) return { ok: false };

package/dist/chunk-5OCWMTVS.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
+
+// src/lib/channels/discord.ts
+var discord_exports = {};
+__export(discord_exports, {
+  read: () => read,
+  send: () => send
+});
+var API_BASE = "https://discord.com/api/v10";
+function requireToken(env) {
+  const token = env.DISCORD_TOKEN;
+  if (!token) throw new Error("DISCORD_TOKEN not set");
+  return token;
+}
+async function read(env, channelId, limit) {
+  const token = requireToken(env);
+  const res = await fetch(`${API_BASE}/channels/${channelId}/messages?limit=${limit}`, {
+    headers: { Authorization: `Bot ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  const messages = await res.json();
+  return messages.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
+}
+async function send(env, channelId, message) {
+  const token = requireToken(env);
+  const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ content: message })
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+}
+
+// src/lib/channels/slack.ts
+var slack_exports = {};
+__export(slack_exports, {
+  read: () => read2,
+  send: () => send2
+});
+var API_BASE2 = "https://slack.com/api";
+function requireToken2(env) {
+  const token = env.SLACK_BOT_TOKEN;
+  if (!token) throw new Error("SLACK_BOT_TOKEN not set");
+  return token;
+}
+async function slackApi(token, method, body) {
+  const res = await fetch(`${API_BASE2}/${method}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new Error(`Slack API HTTP error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error}`);
+  }
+  return data;
+}
+async function read2(env, channelId, limit) {
+  const token = requireToken2(env);
+  const data = await slackApi(token, "conversations.history", {
+    channel: channelId,
+    limit
+  });
+  return data.messages.reverse().map((m) => `${m.user ?? m.bot_id ?? "unknown"}: ${m.text}`).join("\n");
+}
+async function send2(env, channelId, message) {
+  const token = requireToken2(env);
+  await slackApi(token, "chat.postMessage", {
+    channel: channelId,
+    text: message
+  });
+}
+
+// src/lib/channels/telegram.ts
+var telegram_exports = {};
+__export(telegram_exports, {
+  read: () => read3,
+  send: () => send3
+});
+var API_BASE3 = "https://api.telegram.org";
+function requireToken3(env) {
+  const token = env.TELEGRAM_BOT_TOKEN;
+  if (!token) throw new Error("TELEGRAM_BOT_TOKEN not set");
+  return token;
+}
+async function read3(_env, _channelId, _limit) {
+  throw new Error(
+    "Telegram Bot API does not support reading chat history. Use volute channel send instead."
+  );
+}
+async function send3(env, chatId, message) {
+  const token = requireToken3(env);
+  const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: chatId, text: message })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Telegram API error: ${res.status} ${body}`);
+  }
+}
+
+// src/lib/channels.ts
+var CHANNELS = {
+  web: { name: "web", displayName: "Web UI", showToolCalls: true },
+  discord: {
+    name: "discord",
+    displayName: "Discord",
+    showToolCalls: false,
+    driver: discord_exports
+  },
+  slack: {
+    name: "slack",
+    displayName: "Slack",
+    showToolCalls: false,
+    driver: slack_exports
+  },
+  telegram: {
+    name: "telegram",
+    displayName: "Telegram",
+    showToolCalls: false,
+    driver: telegram_exports
+  },
+  cli: { name: "cli", displayName: "CLI", showToolCalls: true },
+  agent: { name: "agent", displayName: "Agent", showToolCalls: true },
+  system: { name: "system", displayName: "System", showToolCalls: false }
+};
+function getChannelDriver(platform) {
+  return CHANNELS[platform]?.driver ?? null;
+}
+
+export {
+  CHANNELS,
+  getChannelDriver
+};

package/dist/{chunk-YEIHRP2J.js → chunk-DNOXHLE5.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-RALYNMHR.js";
+} from "./chunk-3C2XR4IY.js";
 
 // src/lib/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-IPIPLGME.js → chunk-I6OHXCMV.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-YEIHRP2J.js";
+} from "./chunk-DNOXHLE5.js";
 import {
   applyIsolation
-} from "./chunk-DEUAVGSA.js";
+} from "./chunk-SOZA2TLP.js";
 import {
   agentDir,
   findAgent,
@@ -13,7 +13,7 @@ import {
   setVariantRunning,
   validateBranchName,
   voluteHome
-} from "./chunk-RALYNMHR.js";
+} from "./chunk-3C2XR4IY.js";
 
 // src/lib/agent-manager.ts
 import { execFile, spawn } from "child_process";
@@ -89,7 +89,7 @@ var AgentManager = class {
     const { dir, isVariant, baseName, variantName } = target;
     const port = target.port;
     try {
-      const res = await fetch(`http://localhost:${port}/health`);
+      const res = await fetch(`http://127.0.0.1:${port}/health`);
       if (res.ok) {
         console.error(`[daemon] killing orphan process on port ${port}`);
         await killProcessOnPort(port);

package/dist/chunk-MXUCNIBG.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+// src/connectors/sdk.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+function loadEnv() {
+  const agentPort = process.env.VOLUTE_AGENT_PORT;
+  const agentName = process.env.VOLUTE_AGENT_NAME;
+  if (!agentPort || !agentName) {
+    console.error("Missing required env vars: VOLUTE_AGENT_PORT, VOLUTE_AGENT_NAME");
+    process.exit(1);
+  }
+  const agentDir = process.env.VOLUTE_AGENT_DIR;
+  const daemonUrl = process.env.VOLUTE_DAEMON_URL;
+  const daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
+  const baseUrl = daemonUrl ? `${daemonUrl}/api/agents/${encodeURIComponent(agentName)}` : `http://127.0.0.1:${agentPort}`;
+  return { agentPort, agentName, agentDir, baseUrl, daemonUrl, daemonToken };
+}
+function loadFollowedChannels(env, platform) {
+  if (!env.agentDir) return [];
+  const configPath = resolve(env.agentDir, "home/.config/volute.json");
+  if (!existsSync(configPath)) return [];
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    const platformConfig = config[platform];
+    return platformConfig?.channels ?? platformConfig?.chats ?? [];
+  } catch (err) {
+    console.warn(`Failed to load agent config: ${err}`);
+    return [];
+  }
+}
+function splitMessage(text, maxLength) {
+  const chunks = [];
+  while (text.length > maxLength) {
+    let splitAt = text.lastIndexOf("\n", maxLength);
+    if (splitAt < maxLength / 2) splitAt = maxLength;
+    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 {
+          console.warn(`ndjson: skipping invalid line: ${line.slice(0, 100)}`);
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        yield JSON.parse(buffer);
+      } catch {
+        console.warn(`ndjson: skipping invalid line: ${buffer.slice(0, 100)}`);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function getHeaders(env) {
+  const headers = { "Content-Type": "application/json" };
+  if (env.daemonUrl && env.daemonToken) {
+    headers.Authorization = `Bearer ${env.daemonToken}`;
+    headers.Origin = env.daemonUrl;
+  }
+  return headers;
+}
+function onShutdown(cleanup) {
+  const handler = () => {
+    Promise.resolve(cleanup()).then(
+      () => process.exit(0),
+      (err) => {
+        console.error(`Shutdown error: ${err}`);
+        process.exit(1);
+      }
+    );
+  };
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+}
+async function fireAndForget(env, payload) {
+  try {
+    const res = await fetch(`${env.baseUrl}/message`, {
+      method: "POST",
+      headers: getHeaders(env),
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      console.error(`fireAndForget: agent returned ${res.status}`);
+    }
+    if (res.body) {
+      const reader = res.body.getReader();
+      while (!(await reader.read()).done) {
+      }
+    }
+  } catch (err) {
+    console.error(`Failed to forward message: ${err}`);
+  }
+}
+async function handleAgentMessage(env, payload, handlers) {
+  try {
+    const res = await fetch(`${env.baseUrl}/message`, {
+      method: "POST",
+      headers: getHeaders(env),
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      console.error(`Agent returned ${res.status}: ${body}`);
+      await handlers.onError(`Error: agent returned ${res.status}`);
+      return;
+    }
+    if (!res.body) {
+      await handlers.onError("Error: no response from agent");
+      return;
+    }
+    let accumulated = "";
+    const pendingImages = [];
+    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") {
+        const text2 = accumulated.trim();
+        accumulated = "";
+        const images2 = pendingImages.splice(0);
+        if (text2 || images2.length > 0) {
+          await handlers.onFlush(text2, images2);
+        }
+      } else if (event.type === "done") {
+        break;
+      }
+    }
+    const text = accumulated.trim();
+    const images = pendingImages.splice(0);
+    if (text || images.length > 0) {
+      await handlers.onFlush(text, images);
+    }
+  } catch (err) {
+    console.error(`Failed to reach agent at ${env.baseUrl}/message:`, err);
+    const errMsg = err instanceof TypeError && err.cause?.code === "ECONNREFUSED" ? "Agent is not running" : `Error: ${err}`;
+    await handlers.onError(errMsg);
+  }
+}
+
+export {
+  loadEnv,
+  loadFollowedChannels,
+  splitMessage,
+  onShutdown,
+  fireAndForget,
+  handleAgentMessage
+};

package/dist/{chunk-DEUAVGSA.js → chunk-SOZA2TLP.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   validateAgentName
-} from "./chunk-RALYNMHR.js";
+} from "./chunk-3C2XR4IY.js";
 
 // src/lib/isolation.ts
 import { execFile, execFileSync } from "child_process";

package/dist/{chunk-VVD3XO3E.js → chunk-YGFIWIOF.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-RALYNMHR.js";
+} from "./chunk-3C2XR4IY.js";
 
 // src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-N4YNKR3Q.js → chunk-ZHCE4DPY.js}

@@ -1,5 +1,23 @@
 #!/usr/bin/env node
 
+// src/lib/format-tool.ts
+function summarizeTool(name, input) {
+  if (input && typeof input === "object") {
+    const args = input;
+    const val = args.path ?? args.command ?? args.query ?? args.url;
+    if (typeof val === "string") {
+      const brief = val.length > 60 ? `${val.slice(0, 57)}...` : val;
+      return `[${name} ${brief}]`;
+    }
+  }
+  return `[${name}]`;
+}
+function collectPart(event) {
+  if (event.type === "text") return event.content ?? "";
+  if (event.type === "tool_use") return summarizeTool(event.name ?? "", event.input);
+  return null;
+}
+
 // src/lib/log-buffer.ts
 var LogBuffer = class {
   entries = [];
@@ -84,6 +102,8 @@ async function* readNdjson(body) {
 }
 
 export {
+  summarizeTool,
+  collectPart,
   logBuffer,
   logger_default,
   readNdjson

package/dist/cli.js

@@ -3,65 +3,72 @@
 // src/cli.ts
 var command = process.argv[2];
 var args = process.argv.slice(3);
+if (command === "--version" || command === "-v") {
+  const { default: pkg } = await import("./package-Z2SFO2SV.js");
+  console.log(pkg.version);
+  process.exit(0);
+}
 switch (command) {
   case "create":
-    await import("./create-RSWWMGKT.js").then((m) => m.run(args));
+    await import("./create-ILVOG75A.js").then((m) => m.run(args));
     break;
   case "start":
-    await import("./start-2BSXX6BS.js").then((m) => m.run(args));
+    await import("./start-LDPMCMYT.js").then((m) => m.run(args));
     break;
   case "stop":
-    await import("./stop-DSKBIJ2D.js").then((m) => m.run(args));
+    await import("./stop-5PZTZCLL.js").then((m) => m.run(args));
     break;
   case "logs":
-    await import("./logs-NHWGHNBF.js").then((m) => m.run(args));
+    await import("./logs-NXFFGUKY.js").then((m) => m.run(args));
     break;
   case "status":
-    await import("./status-N23CV27T.js").then((m) => m.run(args));
+    await import("./status-MVSQG54T.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-JPLJTS2P.js").then((m) => m.run(args));
+    await import("./variant-T64BKARF.js").then((m) => m.run(args));
     break;
   case "send":
-    await import("./send-5LEJXPYV.js").then((m) => m.run(args));
+    await import("./send-3U6OTKG7.js").then((m) => m.run(args));
     break;
   case "import":
-    await import("./import-6HTSSDFW.js").then((m) => m.run(args));
+    await import("./import-4CI2ZUTJ.js").then((m) => m.run(args));
     break;
   case "delete":
-    await import("./delete-4ERL2QHH.js").then((m) => m.run(args));
+    await import("./delete-55MXCEY5.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-DBWDTIP6.js").then((m) => m.run(args));
+    await import("./env-JB27UAC3.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-6LWB5PRU.js").then((m) => m.run(args));
+    await import("./connector-DKDJTLYZ.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-H7N4SGR2.js").then((m) => m.run(args));
+    await import("./channel-DQ6UY7QB.js").then((m) => m.run(args));
     break;
   case "upgrade":
-    await import("./upgrade-BGFVRCVP.js").then((m) => m.run(args));
+    await import("./upgrade-6ZW2RD64.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-4UGID4DM.js").then((m) => m.run(args));
+    await import("./up-F7TMTLRE.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-HRC4MQCT.js").then((m) => m.run(args));
+    await import("./down-3OB6UVAJ.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-DKZ2E2CL.js").then((m) => m.run(args));
+    await import("./schedule-A35SH4HT.js").then((m) => m.run(args));
     break;
   case "history":
-    await import("./history-W7BD2H74.js").then((m) => m.run(args));
+    await import("./history-BKG74I43.js").then((m) => m.run(args));
     break;
   case "service":
     await import("./service-SA4TTMDU.js").then((m) => m.run(args));
     break;
   case "setup":
-    await import("./setup-ZMNTOJAV.js").then((m) => m.run(args));
+    await import("./setup-2FDVN7OF.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:
@@ -74,6 +81,7 @@ Commands:
   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
@@ -94,11 +102,15 @@ Commands:
   volute setup [--port N] [--host H]   Install system service with user isolation
   volute setup uninstall [--force]     Remove system service + isolation
 
+Options:
+  --version, -v                         Show version number
+  --help, -h                            Show this help message
+
 Agent commands (variant, connector, schedule, logs, history, channel) use
 --agent <name> or VOLUTE_AGENT env var to identify the agent.`);
-    if (command) {
-      console.error(`
-Unknown command: ${command}`);
-      process.exit(1);
-    }
+    break;
+  default:
+    console.error(`Unknown command: ${command}
+Run 'volute --help' for usage.`);
+    process.exit(1);
 }