volute 0.3.1 → 0.5.0

package/dist/connectors/slack.js

@@ -0,0 +1,179 @@
+#!/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;
+var serverName;
+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" || message.channel_type === "mpim";
+  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;
+  let numMembers;
+  if (message.channel_type !== "im") {
+    try {
+      const info = await app.client.conversations.info({
+        channel: message.channel
+      });
+      channelName = info.channel?.name;
+      numMembers = info.channel?.num_members;
+    } catch (err) {
+      console.warn(`Failed to get channel info: ${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 participantCount = message.channel_type === "im" ? 2 : numMembers;
+  const payload = {
+    content,
+    channel: channelKey,
+    sender: senderName,
+    platform: "Slack",
+    ...isDM ? { isDM: true } : {},
+    ...channelName ? { channelName } : {},
+    ...serverName ? { serverName } : {},
+    ...participantCount ? { participantCount } : {}
+  };
+  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;
+  serverName = auth.team;
+  console.log(
+    `Connected to Slack as bot user ${botUserId}${serverName ? ` in ${serverName}` : ""}`
+  );
+  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);
+});

package/dist/connectors/telegram.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+import {
+  fireAndForget,
+  handleAgentMessage,
+  loadEnv,
+  loadFollowedChannels,
+  splitMessage
+} from "../chunk-MXUCNIBG.js";
+import "../chunk-K3NQKI34.js";
+
+// src/connectors/telegram.ts
+import { Input, Telegraf } from "telegraf";
+import { message } from "telegraf/filters";
+var TELEGRAM_MAX_LENGTH = 4096;
+var TYPING_INTERVAL_MS = 5e3;
+var env = loadEnv();
+var botToken = process.env.TELEGRAM_BOT_TOKEN;
+if (!botToken) {
+  console.error("Missing required env var: TELEGRAM_BOT_TOKEN");
+  process.exit(1);
+}
+var followedChatIds = loadFollowedChannels(env, "telegram");
+var followedChatIdSet = new Set(followedChatIds.map(String));
+var bot = new Telegraf(botToken);
+bot.on(message("text"), async (ctx) => {
+  if (ctx.message.from.is_bot) return;
+  const isDM = ctx.chat.type === "private";
+  const botUsername = ctx.botInfo.username;
+  const isMentioned = !isDM && ctx.message.entities?.some(
+    (e) => e.type === "mention" && ctx.message.text.substring(e.offset, e.offset + e.length) === `@${botUsername}`
+  );
+  const isFollowedChat = !isDM && followedChatIdSet.has(String(ctx.chat.id));
+  if (!isDM && !isMentioned && !isFollowedChat) return;
+  let text = ctx.message.text;
+  if (isMentioned && botUsername) {
+    text = text.replace(new RegExp(`@${botUsername}`, "g"), "").trim();
+  }
+  const content = [];
+  if (text) content.push({ type: "text", text });
+  if (content.length === 0) return;
+  const senderName = ctx.message.from.first_name + (ctx.message.from.last_name ? ` ${ctx.message.from.last_name}` : "");
+  const chatTitle = "title" in ctx.chat ? ctx.chat.title : void 0;
+  let participantCount = isDM ? 2 : void 0;
+  if (!isDM) {
+    try {
+      participantCount = await ctx.telegram.getChatMembersCount(ctx.chat.id);
+    } catch (err) {
+      console.warn(`Failed to get member count for chat ${ctx.chat.id}: ${err}`);
+    }
+  }
+  const payload = {
+    content,
+    channel: `telegram:${ctx.chat.id}`,
+    sender: senderName,
+    platform: "Telegram",
+    ...isDM ? { isDM: true } : {},
+    ...chatTitle ? { channelName: chatTitle } : {},
+    ...participantCount ? { participantCount } : {}
+  };
+  if (isFollowedChat && !isMentioned) {
+    await fireAndForget(env, payload);
+    return;
+  }
+  await handleTelegramMessage(
+    ctx.chat.id,
+    payload,
+    (text2) => ctx.reply(text2),
+    (source) => ctx.replyWithPhoto(source)
+  );
+});
+bot.on(message("photo"), async (ctx) => {
+  if (ctx.message.from.is_bot) return;
+  const isDM = ctx.chat.type === "private";
+  const isFollowedChat = !isDM && followedChatIdSet.has(String(ctx.chat.id));
+  if (!isDM && !isFollowedChat) return;
+  const content = [];
+  const caption = ctx.message.caption;
+  if (caption) content.push({ type: "text", text: caption });
+  const photos = ctx.message.photo;
+  const largest = photos[photos.length - 1];
+  try {
+    const fileUrl = await ctx.telegram.getFileLink(largest.file_id);
+    const res = await fetch(fileUrl.href);
+    if (!res.ok) {
+      console.error(`Failed to download photo: HTTP ${res.status}`);
+    } else {
+      const buffer = Buffer.from(await res.arrayBuffer());
+      content.push({
+        type: "image",
+        media_type: "image/jpeg",
+        data: buffer.toString("base64")
+      });
+    }
+  } catch (err) {
+    console.error(`Failed to download photo: ${err}`);
+  }
+  if (content.length === 0) return;
+  const senderName = ctx.message.from.first_name + (ctx.message.from.last_name ? ` ${ctx.message.from.last_name}` : "");
+  const chatTitle = "title" in ctx.chat ? ctx.chat.title : void 0;
+  let participantCount = isDM ? 2 : void 0;
+  if (!isDM) {
+    try {
+      participantCount = await ctx.telegram.getChatMembersCount(ctx.chat.id);
+    } catch (err) {
+      console.warn(`Failed to get member count for chat ${ctx.chat.id}: ${err}`);
+    }
+  }
+  const payload = {
+    content,
+    channel: `telegram:${ctx.chat.id}`,
+    sender: senderName,
+    platform: "Telegram",
+    ...isDM ? { isDM: true } : {},
+    ...chatTitle ? { channelName: chatTitle } : {},
+    ...participantCount ? { participantCount } : {}
+  };
+  if (isFollowedChat) {
+    await fireAndForget(env, payload);
+    return;
+  }
+  await handleTelegramMessage(
+    ctx.chat.id,
+    payload,
+    (text) => ctx.reply(text),
+    (source) => ctx.replyWithPhoto(source)
+  );
+});
+async function handleTelegramMessage(chatId, payload, reply, replyWithPhoto) {
+  const typingInterval = setInterval(() => {
+    bot.telegram.sendChatAction(chatId, "typing").catch(() => {
+    });
+  }, TYPING_INTERVAL_MS);
+  bot.telegram.sendChatAction(chatId, "typing").catch(() => {
+  });
+  try {
+    await handleAgentMessage(env, payload, {
+      onFlush: async (text, images) => {
+        for (const img of images) {
+          try {
+            await replyWithPhoto(Input.fromBuffer(Buffer.from(img.data, "base64")));
+          } catch (err) {
+            console.error(`Failed to send image: ${err}`);
+          }
+        }
+        if (!text) return;
+        const chunks = splitMessage(text, TELEGRAM_MAX_LENGTH);
+        for (const chunk of chunks) {
+          try {
+            await reply(chunk);
+          } catch (err) {
+            console.error(`Failed to send message: ${err}`);
+          }
+        }
+      },
+      onError: async (msg) => {
+        await reply(msg).catch(() => {
+        });
+      }
+    });
+  } finally {
+    clearInterval(typingInterval);
+  }
+}
+bot.launch().then(() => {
+  console.log(`Connected to Telegram as @${bot.botInfo?.username}`);
+  console.log(`Bridging to agent: ${env.agentName} via ${env.baseUrl}/message`);
+  if (followedChatIds.length > 0) {
+    console.log(`Following chats: ${followedChatIds.join(", ")}`);
+  }
+}).catch((err) => {
+  console.error("Failed to start Telegram connector:", err);
+  process.exit(1);
+});
+process.once("SIGINT", () => bot.stop("SIGINT"));
+process.once("SIGTERM", () => bot.stop("SIGTERM"));

package/dist/conversation-ERXEQZTY.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import {
+  readStdin
+} from "./chunk-ZYGKG6VC.js";
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  summarizeTool
+} from "./chunk-B3R6L2GW.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  daemonFetch
+} from "./chunk-7L4AN5D4.js";
+import "./chunk-UX25Z2ND.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/conversation.ts
+import { userInfo } from "os";
+async function run(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "create":
+      await createConversation(args.slice(1));
+      break;
+    case "list":
+      await listConversations(args.slice(1));
+      break;
+    case "send":
+      await sendToConversation(args.slice(1));
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printUsage();
+      break;
+    default:
+      printUsage();
+      process.exit(1);
+  }
+}
+function printUsage() {
+  console.log(`Usage:
+  volute conversation create --participants user1,agent1 [--title "..."] [--agent <name>]
+  volute conversation list [--agent <name>]
+  volute conversation send <id> "<message>" [--agent <name>]
+  echo "message" | volute conversation send <id> [--agent <name>]`);
+}
+async function createConversation(args) {
+  const { flags } = parseArgs(args, {
+    agent: { type: "string" },
+    participants: { type: "string" },
+    title: { type: "string" }
+  });
+  const agentName = resolveAgentName(flags);
+  if (!flags.participants) {
+    console.error("--participants is required (comma-separated usernames)");
+    process.exit(1);
+  }
+  const participantNames = flags.participants.split(",").map((s) => s.trim());
+  const res = await daemonFetch(`/api/agents/${encodeURIComponent(agentName)}/conversations`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ participantNames, title: flags.title })
+  });
+  if (!res.ok) {
+    const data = await res.json();
+    console.error(data.error ?? `Failed to create conversation: ${res.status}`);
+    process.exit(1);
+  }
+  const conv = await res.json();
+  console.log(`Created conversation: ${conv.id}`);
+  if (conv.title) console.log(`Title: ${conv.title}`);
+}
+async function listConversations(args) {
+  const { flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const agentName = resolveAgentName(flags);
+  const res = await daemonFetch(`/api/agents/${encodeURIComponent(agentName)}/conversations`);
+  if (!res.ok) {
+    const data = await res.json();
+    console.error(data.error ?? `Failed to list conversations: ${res.status}`);
+    process.exit(1);
+  }
+  const convs = await res.json();
+  if (convs.length === 0) {
+    console.log("No conversations.");
+    return;
+  }
+  for (const conv of convs) {
+    const title = conv.title || "(untitled)";
+    console.log(`${conv.id}  ${title}  ${conv.updated_at}`);
+  }
+}
+async function sendToConversation(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const conversationId = positional[0];
+  const message = positional[1] ?? await readStdin();
+  if (!conversationId || !message) {
+    console.error('Usage: volute conversation send <id> "<message>" [--agent <name>]');
+    console.error('       echo "message" | volute conversation send <id> [--agent <name>]');
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  const res = await daemonFetch(`/api/agents/${encodeURIComponent(agentName)}/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      message,
+      conversationId,
+      sender: process.env.VOLUTE_AGENT || userInfo().username
+    })
+  });
+  if (!res.ok) {
+    const data = await res.json();
+    console.error(data.error ?? `Failed to send message: ${res.status}`);
+    process.exit(1);
+  }
+  if (!res.body) {
+    console.error("No response body");
+    process.exit(1);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  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.startsWith("data:")) continue;
+      const data = line.slice(5).trim();
+      if (!data) continue;
+      let event;
+      try {
+        event = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (event.type === "text") {
+        process.stdout.write(event.content);
+      } else if (event.type === "tool_use") {
+        process.stderr.write(`${summarizeTool(event.name, event.input)}
+`);
+      }
+      if (event.type === "done") {
+        process.stdout.write("\n");
+        return;
+      }
+    }
+  }
+  process.stdout.write("\n");
+}
+export {
+  run
+};

package/dist/create-RVCZN6HE.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import {
+  applyInitFiles,
+  composeTemplate,
+  copyTemplateToDir,
+  findTemplatesRoot,
+  listFiles
+} from "./chunk-XUA3JUFK.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  chownAgentDir,
+  createAgentUser,
+  ensureVoluteGroup
+} from "./chunk-UAVD2AHX.js";
+import {
+  exec,
+  execInherit
+} from "./chunk-5SKQ6J7T.js";
+import {
+  addAgent,
+  agentDir,
+  ensureVoluteHome,
+  nextPort
+} from "./chunk-UX25Z2ND.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/create.ts
+import { existsSync, rmSync } from "fs";
+import { resolve } from "path";
+var TEMPLATE_BRANCH = "volute/template";
+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 agent 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);
+    const port = nextPort();
+    addAgent(name, port);
+    console.log("Installing dependencies...");
+    await execInherit("npm", ["install"], { cwd: dest });
+    try {
+      await exec("git", ["init"], { cwd: dest });
+      await initTemplateBranch(dest, composedDir, manifest);
+    } catch (err) {
+      rmSync(resolve(dest, ".git"), { recursive: true, force: true });
+      console.warn(
+        "\nWarning: git setup failed \u2014 variants and upgrades won't be available.",
+        "\nTo fix: ensure git is installed with user.name/user.email configured."
+      );
+      console.warn("Details:", err.message ?? err);
+    }
+    ensureVoluteGroup();
+    createAgentUser(name);
+    chownAgentDir(dest, name);
+    console.log(`
+Created agent: ${name} (port ${port})`);
+    console.log(`
+  volute agent start ${name}`);
+  } finally {
+    rmSync(composedDir, { recursive: true, force: true });
+  }
+}
+async function initTemplateBranch(projectRoot, composedDir, manifest) {
+  const templateFiles = listFiles(composedDir).filter((f) => !f.startsWith(".init/") && !f.startsWith(".init\\")).map((f) => manifest.rename[f] ?? f);
+  await exec("git", ["checkout", "--orphan", TEMPLATE_BRANCH], { cwd: projectRoot });
+  await exec("git", ["add", "--", ...templateFiles], { cwd: projectRoot });
+  await exec("git", ["commit", "-m", "template update"], { cwd: projectRoot });
+  await exec("git", ["checkout", "-b", "main"], { cwd: projectRoot });
+  await exec("git", ["add", "-A"], { cwd: projectRoot });
+  await exec("git", ["commit", "-m", "initial commit"], { cwd: projectRoot });
+}
+export {
+  run
+};

package/dist/{daemon-client-XR24PUJF.js → daemon-client-ZY6UUN2M.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   daemonFetch
-} from "./chunk-YGFIWIOF.js";
-import "./chunk-3C2XR4IY.js";
+} from "./chunk-7L4AN5D4.js";
+import "./chunk-UX25Z2ND.js";
 import "./chunk-K3NQKI34.js";
 export {
   daemonFetch