volute 0.26.0 → 0.27.0

package/dist/chunk-WSLPZF72.js

@@ -1,173 +0,0 @@
-#!/usr/bin/env node
-import {
-  stateDir
-} from "./chunk-B2CPS4QU.js";
-
-// src/lib/slugify.ts
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function buildVoluteSlug(opts) {
-  if (opts.convType === "channel" && opts.convName) {
-    return `volute:#${opts.convName}`;
-  }
-  const isDM = opts.participants.length === 2;
-  if (isDM) {
-    const other = opts.participants.find((p) => p.username !== opts.mindUsername);
-    const otherSlug = other ? slugify(other.username) : "";
-    return otherSlug ? `volute:@${otherSlug}` : `volute:${opts.conversationId}`;
-  }
-  return opts.convTitle ? `volute:${slugify(opts.convTitle)}` : `volute:${opts.conversationId}`;
-}
-
-// src/connectors/sdk.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join, resolve } from "path";
-function loadEnv() {
-  const mindPort = process.env.VOLUTE_MIND_PORT;
-  const mindName = process.env.VOLUTE_MIND_NAME;
-  if (!mindPort || !mindName) {
-    console.error("Missing required env vars: VOLUTE_MIND_PORT, VOLUTE_MIND_NAME");
-    process.exit(1);
-  }
-  const mindDir = process.env.VOLUTE_MIND_DIR;
-  const daemonUrl = process.env.VOLUTE_DAEMON_URL;
-  const daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
-  const baseUrl = daemonUrl ? `${daemonUrl}/api/minds/${encodeURIComponent(mindName)}` : `http://127.0.0.1:${mindPort}`;
-  return { mindPort, mindName, mindDir, baseUrl, daemonUrl, daemonToken };
-}
-function loadFollowedChannels(env, platform) {
-  if (!env.mindDir) return [];
-  const configPath = resolve(env.mindDir, "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 mind 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;
-}
-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);
-}
-function reportTyping(env, channel, sender, active) {
-  fetch(`${env.baseUrl}/typing`, {
-    method: "POST",
-    headers: getHeaders(env),
-    body: JSON.stringify({ channel, sender, active })
-  }).catch((err) => {
-    console.warn(`[typing] failed to report for ${sender} on ${channel}: ${err}`);
-  });
-}
-async function sendToMind(env, payload) {
-  const url = `${env.baseUrl}/message`;
-  try {
-    const res = await fetch(url, {
-      method: "POST",
-      headers: getHeaders(env),
-      body: JSON.stringify(payload)
-    });
-    if (!res.ok) {
-      const body = await res.text().catch(() => "");
-      console.error(`Mind returned ${res.status}: ${body}`);
-      return { ok: false, error: `Mind returned ${res.status}` };
-    }
-    return { ok: true };
-  } catch (err) {
-    console.error(`Failed to forward message: ${err}`);
-    const isConnRefused = err instanceof TypeError && err.cause?.code === "ECONNREFUSED";
-    return { ok: false, error: isConnRefused ? "Mind is not running" : "Failed to reach mind" };
-  }
-}
-function buildChannelSlug(platform, meta) {
-  if (meta.isDM) {
-    if (meta.recipients && meta.recipients.length > 0) {
-      const sorted = meta.recipients.map(slugify).sort();
-      return `${platform}:@${sorted.join(",")}`;
-    }
-    if (meta.senderName) {
-      return `${platform}:@${slugify(meta.senderName)}`;
-    }
-  }
-  if (meta.channelName && meta.serverName) {
-    return `${platform}:${slugify(meta.serverName)}/${slugify(meta.channelName)}`;
-  }
-  if (meta.channelName) {
-    return `${platform}:${slugify(meta.channelName)}`;
-  }
-  if (meta.platformId) {
-    return `${platform}:${meta.platformId}`;
-  }
-  return `${platform}:unknown`;
-}
-function readChannelMap(mindName) {
-  const filePath = join(stateDir(mindName), "channels.json");
-  if (!existsSync(filePath)) return {};
-  try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
-  } catch (err) {
-    console.error(`[sdk] failed to parse ${filePath}:`, err);
-    return {};
-  }
-}
-function writeChannelEntry(mindName, slug, entry) {
-  const dir = stateDir(mindName);
-  mkdirSync(dir, { recursive: true });
-  const filePath = join(dir, "channels.json");
-  const map = readChannelMap(mindName);
-  map[slug] = entry;
-  writeFileSync(filePath, JSON.stringify(map, null, 2) + "\n");
-}
-function resolveChannelId(mindName, slug) {
-  const map = readChannelMap(mindName);
-  if (map[slug]) {
-    return map[slug].platformId;
-  }
-  const colonIndex = slug.indexOf(":");
-  return colonIndex >= 0 ? slug.slice(colonIndex + 1) : slug;
-}
-
-export {
-  slugify,
-  buildVoluteSlug,
-  loadEnv,
-  loadFollowedChannels,
-  splitMessage,
-  onShutdown,
-  reportTyping,
-  sendToMind,
-  buildChannelSlug,
-  writeChannelEntry,
-  resolveChannelId
-};

package/dist/connector-G722WXAU.js

@@ -1,147 +0,0 @@
-#!/usr/bin/env node
-import {
-  promptLine
-} from "./chunk-SSI47XP2.js";
-import {
-  daemonFetch
-} from "./chunk-WGOGUMPO.js";
-import {
-  getClient,
-  urlOf
-} from "./chunk-4RQBJWQX.js";
-import {
-  resolveMindName
-} from "./chunk-NAOW2CLO.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
-import "./chunk-B2CPS4QU.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;
-    case "--help":
-    case "-h":
-    case void 0:
-      printUsage();
-      break;
-    default:
-      printUsage();
-      process.exit(1);
-  }
-}
-function printUsage() {
-  console.log(`Usage:
-  volute mind connect <type> [--mind <name>]
-  volute mind disconnect <type> [--mind <name>]`);
-}
-async function connectConnector(args) {
-  const { positional, flags } = parseArgs(args, {
-    mind: { type: "string" }
-  });
-  const mindName = resolveMindName(flags);
-  const type = positional[0];
-  if (!type) {
-    console.error("Usage: volute mind connect <type> [--mind <name>]");
-    process.exit(1);
-  }
-  const client = getClient();
-  const connectorUrl = urlOf(
-    client.api.minds[":name"].connectors[":type"].$url({
-      param: { name: mindName, type }
-    })
-  );
-  let res = await daemonFetch(connectorUrl, { 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> --mind ${mindName}`);
-        process.exit(1);
-      }
-      console.error(`${connectorName} connector requires some environment variables.
-`);
-      for (const v of missing) {
-        const value = await promptLine(`${v.description}
-Enter value for ${v.name}: `);
-        if (!value) {
-          console.error(`No value provided for ${v.name}. Aborting.`);
-          process.exit(1);
-        }
-        const envRes = await daemonFetch(
-          urlOf(
-            client.api.minds[":name"].env[":key"].$url({
-              param: { name: mindName, key: v.name }
-            })
-          ),
-          {
-            method: "PUT",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ value })
-          }
-        );
-        if (!envRes.ok) {
-          const errBody = await envRes.json().catch(() => ({}));
-          console.error(`Failed to set ${v.name}: ${errBody.error ?? `HTTP ${envRes.status}`}`);
-          process.exit(1);
-        }
-      }
-      console.log("Environment variables saved.\n");
-      res = await daemonFetch(connectorUrl, { 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 ${mindName} started.`);
-}
-async function disconnectConnector(args) {
-  const { positional, flags } = parseArgs(args, {
-    mind: { type: "string" }
-  });
-  const mindName = resolveMindName(flags);
-  const type = positional[0];
-  if (!type) {
-    console.error("Usage: volute mind disconnect <type> [--mind <name>]");
-    process.exit(1);
-  }
-  const client = getClient();
-  const res = await daemonFetch(
-    urlOf(
-      client.api.minds[":name"].connectors[":type"].$url({
-        param: { name: mindName, 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 ${mindName} stopped.`);
-}
-export {
-  run
-};

package/dist/connectors/discord.js

@@ -1,177 +0,0 @@
-#!/usr/bin/env node
-import {
-  buildChannelSlug,
-  loadEnv,
-  loadFollowedChannels,
-  reportTyping,
-  sendToMind,
-  slugify,
-  writeChannelEntry
-} from "../chunk-WSLPZF72.js";
-import "../chunk-B2CPS4QU.js";
-import "../chunk-K3NQKI34.js";
-
-// src/connectors/discord.ts
-import { ChannelType, Client, Events, GatewayIntentBits, Partials } from "discord.js";
-var TYPING_INTERVAL_MS = 8e3;
-var env = loadEnv();
-var token = process.env.DISCORD_TOKEN;
-if (!token) {
-  console.error("Missing required env var: DISCORD_TOKEN");
-  process.exit(1);
-}
-var followedChannelNames = loadFollowedChannels(env, "discord");
-var followedChannelIds = /* @__PURE__ */ new Set();
-var client = new Client({
-  intents: [
-    GatewayIntentBits.Guilds,
-    GatewayIntentBits.GuildMessages,
-    GatewayIntentBits.MessageContent,
-    GatewayIntentBits.DirectMessages,
-    GatewayIntentBits.GuildMessageTyping,
-    GatewayIntentBits.DirectMessageTyping
-  ],
-  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 mind: ${env.mindName} 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);
-  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();
-  }
-  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;
-  const senderName = message.author.displayName || message.author.username;
-  const channelName = !isDM && "name" in message.channel ? message.channel.name : void 0;
-  const channelKey = isDM ? buildChannelSlug("discord", {
-    isDM: true,
-    recipients: [message.author.username]
-  }) : buildChannelSlug("discord", {
-    channelName: channelName ?? message.channelId,
-    serverName: message.guild?.name
-  });
-  try {
-    writeChannelEntry(env.mindName, channelKey, {
-      platformId: message.channelId,
-      platform: "discord",
-      name: channelName ? `#${channelName}` : void 0,
-      server: message.guild?.name,
-      type: isDM ? "dm" : "channel"
-    });
-  } catch (err) {
-    console.error(`[discord] failed to write channel entry for ${channelKey}:`, err);
-  }
-  const participantCount = isDM ? 2 : message.guild?.memberCount;
-  const payload = {
-    content,
-    channel: channelKey,
-    sender: senderName,
-    platform: "Discord",
-    ...isDM ? { isDM: true } : {},
-    ...channelName ? { channelName } : {},
-    ...message.guild?.name ? { serverName: message.guild.name } : {},
-    ...participantCount ? { participantCount } : {}
-  };
-  reportTyping(env, channelKey, senderName, false);
-  if (isFollowedChannel && !isMentioned) {
-    const result = await sendToMind(env, payload);
-    if (!result.ok)
-      message.reply(result.error ?? "Failed to process message").catch((err) => {
-        console.warn(`[discord] failed to send error reply: ${err}`);
-      });
-    return;
-  }
-  await handleDiscordMessage(message, payload);
-});
-client.on(Events.TypingStart, (typing) => {
-  if (typing.user.bot) return;
-  const sender = typing.user.displayName || typing.user.username || typing.user.id || "unknown";
-  const typingChannel = typing.guild ? `discord:${slugify(typing.guild.name)}/${slugify("name" in typing.channel ? String(typing.channel.name) : typing.channel.id)}` : `discord:@${slugify(typing.user.username ?? typing.user.id)}`;
-  reportTyping(env, typingChannel, sender, true);
-});
-async function handleDiscordMessage(message, payload) {
-  const channel = message.channel;
-  if (!("sendTyping" in channel)) return;
-  const typingInterval = setInterval(() => {
-    channel.sendTyping().catch((err) => {
-      console.warn(`[discord] sendTyping failed: ${err}`);
-    });
-  }, TYPING_INTERVAL_MS);
-  channel.sendTyping().catch((err) => {
-    console.warn(`[discord] sendTyping failed: ${err}`);
-  });
-  try {
-    const result = await sendToMind(env, payload);
-    if (!result.ok)
-      message.reply(result.error ?? "Failed to process message").catch((err) => {
-        console.warn(`[discord] failed to send error reply: ${err}`);
-      });
-  } finally {
-    clearInterval(typingInterval);
-  }
-}
-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.js

@@ -1,181 +0,0 @@
-#!/usr/bin/env node
-import {
-  buildChannelSlug,
-  loadEnv,
-  loadFollowedChannels,
-  onShutdown,
-  sendToMind,
-  writeChannelEntry
-} from "../chunk-WSLPZF72.js";
-import "../chunk-B2CPS4QU.js";
-import "../chunk-K3NQKI34.js";
-
-// src/connectors/slack.ts
-import { App } from "@slack/bolt";
-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 }) => {
-  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;
-  let senderUsername = 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;
-    senderUsername = userInfo.user?.name ?? message.user;
-  } catch (err) {
-    console.warn(`Failed to get user info: ${err}`);
-  }
-  const channelKey = isDM ? buildChannelSlug("slack", {
-    isDM: true,
-    senderName: senderUsername
-  }) : buildChannelSlug("slack", {
-    channelName: channelName ?? message.channel,
-    serverName
-  });
-  try {
-    writeChannelEntry(env.mindName, channelKey, {
-      platformId: message.channel,
-      platform: "slack",
-      name: channelName ? `#${channelName}` : void 0,
-      server: serverName,
-      type: isDM ? "dm" : "channel"
-    });
-  } catch (err) {
-    console.error(`[slack] failed to write channel entry for ${channelKey}:`, err);
-  }
-  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) {
-    const result2 = await sendToMind(env, payload);
-    if (!result2.ok)
-      app.client.chat.postMessage({
-        channel: message.channel,
-        text: result2.error ?? "Failed to process message"
-      }).catch((err) => {
-        console.warn(`[slack] failed to send error reply: ${err}`);
-      });
-    return;
-  }
-  const result = await sendToMind(env, payload);
-  if (!result.ok)
-    app.client.chat.postMessage({ channel: message.channel, text: result.error ?? "Failed to process message" }).catch((err) => {
-      console.warn(`[slack] 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(
-    `Connected to Slack as bot user ${botUserId}${serverName ? ` in ${serverName}` : ""}`
-  );
-  console.log(`Bridging to mind: ${env.mindName} 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);
-});