volute 0.3.0 → 0.4.0

package/dist/connector-DKDJTLYZ.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import {
+  resolveAgentName
+} from "./chunk-VRVVQIYY.js";
+import {
+  agentEnvPath,
+  readEnv,
+  writeEnv
+} from "./chunk-DNOXHLE5.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  daemonFetch
+} from "./chunk-YGFIWIOF.js";
+import {
+  agentDir
+} from "./chunk-3C2XR4IY.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;
+    default:
+      printUsage();
+      process.exit(subcommand ? 1 : 0);
+  }
+}
+function printUsage() {
+  console.error(`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://localhost:${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} (port ${agentPort})`);
+  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,80 @@ 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 payload = {
+    content,
+    channel: channelKey,
+    sender: senderName,
+    platform: "Discord",
+    ...isDM ? { isDM: true } : {},
+    ...channelName ? { channelName } : {},
+    ...message.guild?.name ? { guildName: message.guild.name } : {}
+  };
+  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,148 +183,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) {
-      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) {
-    const errMsg = err instanceof TypeError && err.cause?.code === "ECONNREFUSED" ? "Agent is not running" : `Error: ${err}`;
-    await message.reply(errMsg).catch(() => {
-    });
-  } finally {
-    clearInterval(typingInterval);
-  }
-}

package/dist/connectors/slack.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import {
+  fireAndForget,
+  handleAgentMessage,
+  loadEnv,
+  loadFollowedChannels,
+  onShutdown,
+  splitMessage
+} from "../chunk-MXUCNIBG.js";
+import "../chunk-K3NQKI34.js";
+
+// src/connectors/slack.ts
+import { App } from "@slack/bolt";
+var SLACK_MAX_LENGTH = 4e3;
+var env = loadEnv();
+var botToken = process.env.SLACK_BOT_TOKEN;
+var appToken = process.env.SLACK_APP_TOKEN;
+if (!botToken || !appToken) {
+  console.error("Missing required env vars: SLACK_BOT_TOKEN, SLACK_APP_TOKEN");
+  process.exit(1);
+}
+var followedChannelNames = loadFollowedChannels(env, "slack");
+var followedChannelIds = /* @__PURE__ */ new Set();
+var app = new App({
+  token: botToken,
+  socketMode: true,
+  appToken
+});
+var botUserId;
+app.message(async ({ message, say }) => {
+  if (message.subtype) return;
+  if (!("user" in message) || !("text" in message)) return;
+  if ("bot_id" in message && message.bot_id) return;
+  const isDM = message.channel_type === "im";
+  const isMentioned = !isDM && botUserId && message.text?.includes(`<@${botUserId}>`);
+  const isFollowedChannel = !isDM && followedChannelIds.has(message.channel);
+  if (!isDM && !isMentioned && !isFollowedChannel) return;
+  let text = message.text ?? "";
+  if (isMentioned && botUserId) {
+    text = text.replace(new RegExp(`<@${botUserId}>`, "g"), "").trim();
+  }
+  const content = [];
+  if (text) content.push({ type: "text", text });
+  if ("files" in message && message.files) {
+    for (const file of message.files) {
+      if (!file.mimetype?.startsWith("image/") || !file.url_private) continue;
+      try {
+        const res = await fetch(file.url_private, {
+          headers: { Authorization: `Bearer ${botToken}` }
+        });
+        if (!res.ok) {
+          console.error(`Failed to download attachment: HTTP ${res.status}`);
+          continue;
+        }
+        const buffer = Buffer.from(await res.arrayBuffer());
+        content.push({
+          type: "image",
+          media_type: file.mimetype,
+          data: buffer.toString("base64")
+        });
+      } catch (err) {
+        console.error(`Failed to download attachment: ${err}`);
+      }
+    }
+  }
+  if (content.length === 0) return;
+  let channelName;
+  if (!isDM) {
+    try {
+      const info = await app.client.conversations.info({
+        channel: message.channel
+      });
+      channelName = info.channel?.name;
+    } catch (err) {
+      console.warn(`Failed to get channel name: ${err}`);
+    }
+  }
+  let senderName = message.user;
+  try {
+    const userInfo = await app.client.users.info({
+      user: message.user
+    });
+    senderName = userInfo.user?.profile?.display_name || userInfo.user?.profile?.real_name || message.user;
+  } catch (err) {
+    console.warn(`Failed to get user info: ${err}`);
+  }
+  const channelKey = `slack:${message.channel}`;
+  const payload = {
+    content,
+    channel: channelKey,
+    sender: senderName,
+    platform: "Slack",
+    ...isDM ? { isDM: true } : {},
+    ...channelName ? { channelName } : {}
+  };
+  if (isFollowedChannel && !isMentioned) {
+    await fireAndForget(env, payload);
+    return;
+  }
+  await handleAgentMessage(env, payload, {
+    onFlush: async (text2, images) => {
+      for (const img of images) {
+        const ext = img.media_type.split("/")[1] || "png";
+        try {
+          await app.client.filesUploadV2({
+            channel_id: message.channel,
+            file: Buffer.from(img.data, "base64"),
+            filename: `image.${ext}`
+          });
+        } catch (err) {
+          console.error(`Failed to upload image: ${err}`);
+        }
+      }
+      if (!text2) return;
+      const chunks = splitMessage(text2, SLACK_MAX_LENGTH);
+      for (const chunk of chunks) {
+        try {
+          await say(chunk);
+        } catch (err) {
+          console.error(`Failed to send message: ${err}`);
+        }
+      }
+    },
+    onError: async (msg) => {
+      await say(msg).catch(() => {
+      });
+    }
+  });
+});
+async function start() {
+  await app.start();
+  const auth = await app.client.auth.test();
+  if (!auth.user_id) {
+    throw new Error("auth.test succeeded but returned no user_id");
+  }
+  botUserId = auth.user_id;
+  console.log(`Connected to Slack as bot user ${botUserId}`);
+  console.log(`Bridging to agent: ${env.agentName} via ${env.baseUrl}/message`);
+  if (followedChannelNames.length > 0) {
+    try {
+      let cursor;
+      do {
+        const result = await app.client.conversations.list({
+          types: "public_channel,private_channel",
+          limit: 200,
+          ...cursor ? { cursor } : {}
+        });
+        for (const ch of result.channels ?? []) {
+          if (followedChannelNames.includes(ch.name)) {
+            followedChannelIds.add(ch.id);
+            console.log(`Following #${ch.name} (${ch.id})`);
+          }
+        }
+        cursor = result.response_metadata?.next_cursor || void 0;
+      } while (cursor);
+    } catch (err) {
+      console.error(`Failed to resolve channel names: ${err}`);
+    }
+    if (followedChannelIds.size === 0 && followedChannelNames.length > 0) {
+      console.warn(`No channels found matching: ${followedChannelNames.join(", ")}`);
+    }
+  }
+}
+onShutdown(async () => {
+  await app.stop();
+});
+start().catch((err) => {
+  console.error("Failed to start Slack connector:", err);
+  process.exit(1);
+});