volute 0.1.0

package/dist/connectors/discord.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+// src/connectors/discord.ts
+import {
+  AttachmentBuilder,
+  Client,
+  Events,
+  GatewayIntentBits,
+  Partials
+} 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 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 baseUrl = `http://localhost:${agentPort}`;
+var client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+    GatewayIntentBits.DirectMessages
+  ],
+  partials: [Partials.Channel]
+});
+function shutdown() {
+  client.destroy();
+  process.exit(0);
+}
+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})`);
+});
+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;
+  let text = message.content;
+  if (isMentioned) {
+    text = text.replace(new RegExp(`<@!?${client.user.id}>`, "g"), "").trim();
+  }
+  const content = [];
+  if (text) content.push({ type: "text", text });
+  for (const attachment of message.attachments.values()) {
+    if (!attachment.contentType?.startsWith("image/")) continue;
+    try {
+      const res = await fetch(attachment.url);
+      const buffer = Buffer.from(await res.arrayBuffer());
+      content.push({
+        type: "image",
+        media_type: attachment.contentType,
+        data: buffer.toString("base64")
+      });
+    } catch (err) {
+      console.error(`Failed to download attachment: ${err}`);
+    }
+  }
+  if (content.length === 0) return;
+  await handleAgentRequest(message, content);
+});
+client.login(token);
+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 res = await fetch(`${baseUrl}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      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/create-3K6O2SDC.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import {
+  applyInitFiles,
+  composeTemplate,
+  copyTemplateToDir,
+  findTemplatesRoot
+} from "./chunk-GSPKUPKU.js";
+import {
+  exec,
+  execInherit
+} from "./chunk-XZN4WPNC.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  addAgent,
+  agentDir,
+  ensureVoluteHome,
+  nextPort
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/create.ts
+import { existsSync, rmSync } from "fs";
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    template: { type: "string" }
+  });
+  const name = positional[0];
+  const template = flags.template ?? "agent-sdk";
+  if (!name) {
+    console.error("Usage: volute create <name> [--template <name>]");
+    process.exit(1);
+  }
+  ensureVoluteHome();
+  const dest = agentDir(name);
+  if (existsSync(dest)) {
+    console.error(`Agent already exists: ${name}`);
+    process.exit(1);
+  }
+  const templatesRoot = findTemplatesRoot();
+  const { composedDir, manifest } = composeTemplate(templatesRoot, template);
+  try {
+    copyTemplateToDir(composedDir, dest, name, manifest);
+    applyInitFiles(dest);
+  } finally {
+    rmSync(composedDir, { recursive: true, force: true });
+  }
+  const port = nextPort();
+  addAgent(name, port);
+  console.log("Installing dependencies...");
+  await execInherit("npm", ["install"], { cwd: dest });
+  await exec("git", ["init"], { cwd: dest });
+  await exec("git", ["add", "-A"], { cwd: dest });
+  await exec("git", ["commit", "-m", "initial commit"], { cwd: dest });
+  console.log(`
+Created agent: ${name} (port ${port})`);
+  console.log(`
+  volute start ${name}`);
+}
+export {
+  run
+};

package/dist/daemon-client-ZTHW7ROS.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  daemonFetch,
+  getDaemonUrl
+} from "./chunk-H5XQARAP.js";
+import "./chunk-5YW4B7CG.js";
+export {
+  daemonFetch,
+  getDaemonUrl
+};