volute 0.26.0 → 0.27.0

package/dist/connectors/discord-bridge.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import {
+  loadBridgeEnv,
+  onShutdown,
+  sendToBridge
+} from "../chunk-KTLFDYPT.js";
+import {
+  slugify
+} from "../chunk-T6HKBWXZ.js";
+import "../chunk-K3NQKI34.js";
+
+// src/connectors/discord-bridge.ts
+import { Client, Events, GatewayIntentBits, Partials } from "discord.js";
+var env = loadBridgeEnv();
+var token = process.env.DISCORD_TOKEN;
+if (!token) {
+  console.error("Missing required env var: DISCORD_TOKEN");
+  process.exit(1);
+}
+var TYPING_INTERVAL_MS = 8e3;
+var client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+    GatewayIntentBits.DirectMessages,
+    GatewayIntentBits.GuildMessageTyping,
+    GatewayIntentBits.DirectMessageTyping
+  ],
+  partials: [Partials.Channel]
+});
+onShutdown(() => {
+  client.destroy();
+});
+client.once(Events.ClientReady, (c) => {
+  console.log(`Discord bridge connected as ${c.user.tag}`);
+});
+client.on(Events.MessageCreate, async (message) => {
+  if (message.author.bot) return;
+  const isDM = !message.guild;
+  const content = [];
+  let text = message.content;
+  if (!isDM && message.mentions.has(client.user)) {
+    text = text.replace(new RegExp(`<@!?${client.user.id}>`, "g"), "").trim();
+  }
+  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}`);
+      content.push({ type: "text", text: "[Image attachment could not be loaded]" });
+    }
+  }
+  if (content.length === 0) return;
+  const displayName = message.author.displayName || message.author.username;
+  const platformUserId = message.author.username;
+  const channelName = !isDM && "name" in message.channel ? message.channel.name : void 0;
+  const externalChannel = isDM ? `@${slugify(message.author.username)}` : channelName && message.guild ? `${slugify(message.guild.name)}/${slugify(channelName)}` : message.channelId;
+  if (isDM) {
+    const channel = message.channel;
+    if ("sendTyping" in channel) {
+      const typingInterval = setInterval(() => {
+        channel.sendTyping().catch(() => {
+        });
+      }, TYPING_INTERVAL_MS);
+      channel.sendTyping().catch(() => {
+      });
+      try {
+        const result = await sendToBridge(env, {
+          content,
+          platformUserId,
+          displayName,
+          externalChannel,
+          isDM: true
+        });
+        if (!result.ok) {
+          message.reply(result.error ?? "Failed to process message").catch((err) => {
+            console.error(`Failed to send error reply: ${err}`);
+          });
+        }
+      } finally {
+        clearInterval(typingInterval);
+      }
+    }
+  } else {
+    const isMentioned = message.mentions.has(client.user);
+    if (isMentioned) {
+      const channel = message.channel;
+      if ("sendTyping" in channel) {
+        const typingInterval = setInterval(() => {
+          channel.sendTyping().catch(() => {
+          });
+        }, TYPING_INTERVAL_MS);
+        channel.sendTyping().catch(() => {
+        });
+        try {
+          const result = await sendToBridge(env, {
+            content,
+            platformUserId,
+            displayName,
+            externalChannel,
+            isDM: false
+          });
+          if (!result.ok) {
+            message.reply(result.error ?? "Failed to process message").catch((err) => {
+              console.error(`Failed to send error reply: ${err}`);
+            });
+          }
+        } finally {
+          clearInterval(typingInterval);
+        }
+      }
+    } else {
+      const result = await sendToBridge(env, {
+        content,
+        platformUserId,
+        displayName,
+        externalChannel,
+        isDM: false
+      });
+      if (!result.ok) {
+        message.reply(result.error ?? "Failed to process message").catch((err) => {
+          console.error(`Failed to send error reply: ${err}`);
+        });
+      }
+    }
+  }
+});
+async function loginWithRetry() {
+  try {
+    await client.login(token);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const match = msg.match(/resets at (.+)/);
+    if (match) {
+      const resetAt = new Date(match[1]);
+      const waitMs = resetAt.getTime() - Date.now();
+      if (waitMs > 0) {
+        console.error(`Session limit hit, waiting until ${resetAt.toISOString()}...`);
+        await new Promise((r) => setTimeout(r, waitMs + 5e3));
+        return loginWithRetry();
+      }
+    }
+    throw err;
+  }
+}
+loginWithRetry().catch((err) => {
+  console.error("Failed to connect to Discord:", err);
+  process.exit(1);
+});

package/dist/connectors/slack-bridge.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import {
+  loadBridgeEnv,
+  onShutdown,
+  sendToBridge
+} from "../chunk-KTLFDYPT.js";
+import {
+  slugify
+} from "../chunk-T6HKBWXZ.js";
+import "../chunk-K3NQKI34.js";
+
+// src/connectors/slack-bridge.ts
+import { App } from "@slack/bolt";
+var env = loadBridgeEnv();
+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 app = new App({
+  token: botToken,
+  socketMode: true,
+  appToken
+});
+var botUserId;
+var serverName;
+app.message(async ({ message }) => {
+  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";
+  let text = message.text ?? "";
+  if (!isDM && botUserId && text.includes(`<@${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.warn(`Failed to download Slack file: HTTP ${res.status}`);
+          content.push({ type: "text", text: "[Image attachment could not be loaded]" });
+          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}`);
+        content.push({ type: "text", text: "[Image attachment could not be loaded]" });
+      }
+    }
+  }
+  if (content.length === 0) return;
+  let displayName = message.user;
+  let senderUsername = message.user;
+  try {
+    const userInfo = await app.client.users.info({
+      user: message.user
+    });
+    displayName = userInfo.user?.profile?.display_name || userInfo.user?.profile?.real_name || message.user;
+    senderUsername = userInfo.user?.name ?? message.user;
+  } catch (err) {
+    console.warn(`Failed to get user info: ${err}`);
+  }
+  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 info: ${err}`);
+    }
+  }
+  const externalChannel = isDM ? `@${slugify(senderUsername)}` : channelName && serverName ? `${slugify(serverName)}/${slugify(channelName)}` : message.channel;
+  const result = await sendToBridge(env, {
+    content,
+    platformUserId: senderUsername,
+    displayName,
+    externalChannel,
+    isDM
+  });
+  if (!result.ok) {
+    app.client.chat.postMessage({
+      channel: message.channel,
+      text: result.error ?? "Failed to process message"
+    }).catch((err) => {
+      console.warn(`[slack-bridge] failed to send error reply: ${err}`);
+    });
+  }
+});
+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(`Slack bridge connected as ${botUserId}${serverName ? ` in ${serverName}` : ""}`);
+}
+onShutdown(async () => {
+  await app.stop();
+});
+start().catch((err) => {
+  console.error("Failed to start Slack bridge:", err);
+  process.exit(1);
+});

package/dist/connectors/telegram-bridge.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import {
+  loadBridgeEnv,
+  onShutdown,
+  sendToBridge
+} from "../chunk-KTLFDYPT.js";
+import {
+  slugify
+} from "../chunk-T6HKBWXZ.js";
+import "../chunk-K3NQKI34.js";
+
+// src/connectors/telegram-bridge.ts
+import { Telegraf } from "telegraf";
+import { message } from "telegraf/filters";
+var env = loadBridgeEnv();
+var botToken = process.env.TELEGRAM_BOT_TOKEN;
+if (!botToken) {
+  console.error("Missing required env var: TELEGRAM_BOT_TOKEN");
+  process.exit(1);
+}
+var TYPING_INTERVAL_MS = 5e3;
+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;
+  let text = ctx.message.text;
+  if (!isDM && botUsername) {
+    const isMentioned = ctx.message.entities?.some(
+      (e) => e.type === "mention" && ctx.message.text.substring(e.offset, e.offset + e.length) === `@${botUsername}`
+    );
+    if (isMentioned) {
+      text = text.replace(new RegExp(`@${botUsername}`, "g"), "").trim();
+    }
+  }
+  const content = [];
+  if (text) content.push({ type: "text", text });
+  if (content.length === 0) return;
+  const displayName = ctx.message.from.first_name + (ctx.message.from.last_name ? ` ${ctx.message.from.last_name}` : "");
+  const platformUserId = ctx.message.from.username ?? String(ctx.message.from.id);
+  const chatTitle = "title" in ctx.chat ? ctx.chat.title : void 0;
+  const externalChannel = isDM ? `@${slugify(platformUserId)}` : chatTitle ? slugify(chatTitle) : String(ctx.chat.id);
+  if (isDM) {
+    const typingInterval = setInterval(() => {
+      bot.telegram.sendChatAction(ctx.chat.id, "typing").catch(() => {
+      });
+    }, TYPING_INTERVAL_MS);
+    bot.telegram.sendChatAction(ctx.chat.id, "typing").catch(() => {
+    });
+    try {
+      const result = await sendToBridge(env, {
+        content,
+        platformUserId,
+        displayName,
+        externalChannel,
+        isDM: true
+      });
+      if (!result.ok) {
+        ctx.reply(result.error ?? "Failed to process message").catch((err) => {
+          console.error(`Failed to send error reply: ${err}`);
+        });
+      }
+    } finally {
+      clearInterval(typingInterval);
+    }
+  } else {
+    const result = await sendToBridge(env, {
+      content,
+      platformUserId,
+      displayName,
+      externalChannel,
+      isDM: false
+    });
+    if (!result.ok) {
+      ctx.reply(result.error ?? "Failed to process message").catch((err) => {
+        console.error(`Failed to send error reply: ${err}`);
+      });
+    }
+  }
+});
+bot.on(message("photo"), async (ctx) => {
+  if (ctx.message.from.is_bot) return;
+  const isDM = ctx.chat.type === "private";
+  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) {
+      const buffer = Buffer.from(await res.arrayBuffer());
+      content.push({
+        type: "image",
+        media_type: "image/jpeg",
+        data: buffer.toString("base64")
+      });
+    } else {
+      console.warn(`Failed to download Telegram photo: HTTP ${res.status}`);
+      content.push({ type: "text", text: "[Image attachment could not be loaded]" });
+    }
+  } catch (err) {
+    console.error(`Failed to download photo: ${err}`);
+    content.push({ type: "text", text: "[Image attachment could not be loaded]" });
+  }
+  if (content.length === 0) return;
+  const displayName = ctx.message.from.first_name + (ctx.message.from.last_name ? ` ${ctx.message.from.last_name}` : "");
+  const platformUserId = ctx.message.from.username ?? String(ctx.message.from.id);
+  const chatTitle = "title" in ctx.chat ? ctx.chat.title : void 0;
+  const externalChannel = isDM ? `@${slugify(platformUserId)}` : chatTitle ? slugify(chatTitle) : String(ctx.chat.id);
+  const result = await sendToBridge(env, {
+    content,
+    platformUserId,
+    displayName,
+    externalChannel,
+    isDM
+  });
+  if (!result.ok) {
+    ctx.reply(result.error ?? "Failed to process message").catch((err) => {
+      console.error(`Failed to send error reply: ${err}`);
+    });
+  }
+});
+bot.launch().then(() => {
+  console.log(`Telegram bridge connected as @${bot.botInfo?.username}`);
+}).catch((err) => {
+  console.error("Failed to start Telegram bridge:", err);
+  process.exit(1);
+});
+onShutdown(() => {
+  bot.stop("SIGTERM");
+});

package/dist/conversations-M2K4253F.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import {
+  addMessage,
+  addParticipant,
+  createChannel,
+  createConversation,
+  deleteConversation,
+  deleteConversationForUser,
+  findDMConversation,
+  getChannelByName,
+  getConversation,
+  getMessages,
+  getMessagesPaginated,
+  getOrCreateConversation,
+  getParticipants,
+  getUnreadCounts,
+  isParticipant,
+  isParticipantOrOwner,
+  joinChannel,
+  leaveChannel,
+  listChannels,
+  listConversationsForUser,
+  listConversationsWithParticipants,
+  markConversationRead,
+  removeParticipant
+} from "./chunk-IAYBDWVG.js";
+import "./chunk-VIVMW2H2.js";
+import "./chunk-YUIHSKR6.js";
+import "./chunk-H7OZRFJB.js";
+import "./chunk-K3NQKI34.js";
+export {
+  addMessage,
+  addParticipant,
+  createChannel,
+  createConversation,
+  deleteConversation,
+  deleteConversationForUser,
+  findDMConversation,
+  getChannelByName,
+  getConversation,
+  getMessages,
+  getMessagesPaginated,
+  getOrCreateConversation,
+  getParticipants,
+  getUnreadCounts,
+  isParticipant,
+  isParticipantOrOwner,
+  joinChannel,
+  leaveChannel,
+  listChannels,
+  listConversationsForUser,
+  listConversationsWithParticipants,
+  markConversationRead,
+  removeParticipant
+};

package/dist/create-D7J73A6H.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import {
+  resolveMindName
+} from "./chunk-NAOW2CLO.js";
+import {
+  daemonFetch
+} from "./chunk-JGFVMROS.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-H7OZRFJB.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/chat/create.ts
+async function run(args) {
+  const { flags } = parseArgs(args, {
+    mind: { type: "string" },
+    participants: { type: "string" },
+    name: { type: "string" }
+  });
+  if (!flags.participants) {
+    console.error('Usage: volute chat create --participants u1,u2 [--name "..."] [--mind <name>]');
+    process.exit(1);
+  }
+  const mindName = resolveMindName(flags);
+  const participants = flags.participants.split(",").map((p) => p.trim());
+  const res = await daemonFetch(`/api/minds/${encodeURIComponent(mindName)}/conversations`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      participantNames: participants,
+      title: flags.name
+    })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    console.error(data.error ?? `Failed to create conversation: ${res.status}`);
+    process.exit(1);
+  }
+  const conv = await res.json();
+  console.log(`Created conversation: ${conv.id}`);
+}
+export {
+  run
+};

package/dist/{create-4YBRTTJS.js → create-QWV73WXD.js}

@@ -17,7 +17,7 @@ async function run(args) {
     process.exit(1);
   }
   const skills = flags.skills === "none" ? [] : flags.skills ? flags.skills.split(",") : void 0;
-  const { daemonFetch } = await import("./daemon-client-Z7FAJ6JW.js");
+  const { daemonFetch } = await import("./daemon-client-I42FK2BF.js");
   const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
   const client = getClient();
   const res = await daemonFetch(urlOf(client.api.minds.$url()), {

package/dist/{daemon-client-Z7FAJ6JW.js → daemon-client-I42FK2BF.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   daemonFetch
-} from "./chunk-WGOGUMPO.js";
-import "./chunk-B2CPS4QU.js";
+} from "./chunk-JGFVMROS.js";
+import "./chunk-H7OZRFJB.js";
 import "./chunk-K3NQKI34.js";
 export {
   daemonFetch

package/dist/{daemon-restart-BJZ3O4U4.js → daemon-restart-M2QTYMEG.js}

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 import {
   run
-} from "./chunk-LX22GRG7.js";
+} from "./chunk-GIE6CSN5.js";
 import {
   stopDaemon
-} from "./chunk-OZFKBXD6.js";
+} from "./chunk-EHYDTZTF.js";
 import {
   getServiceMode,
   modeLabel,
   pollHealth,
   readDaemonConfig,
   restartService
-} from "./chunk-V63B7DX3.js";
-import "./chunk-YJA7P64S.js";
-import "./chunk-XOXLRRR2.js";
+} from "./chunk-LAC664WU.js";
+import "./chunk-AW7PFDVN.js";
+import "./chunk-RKQEHRBB.js";
+import "./chunk-IKRVFPWU.js";
 import "./chunk-D424ZQGI.js";
-import "./chunk-TZKJLDQN.js";
-import "./chunk-B2CPS4QU.js";
+import "./chunk-H7OZRFJB.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/daemon-restart.ts