volute 0.25.0 → 0.27.0

package/dist/cli.js

@@ -9,64 +9,79 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-3HF5MXU2.js");
+  const { default: pkg } = await import("./package-7WY6VKU3.js");
   console.log(pkg.version);
   process.exit(0);
 }
+var ungatedCommands = /* @__PURE__ */ new Set(["setup", "--help", "-h", "--version", "-v", "update", void 0]);
+if (!ungatedCommands.has(command)) {
+  const { isSetupComplete, migrateSetupConfig } = await import("./setup-JHL5ZEST.js");
+  migrateSetupConfig();
+  if (!isSetupComplete()) {
+    console.error("Volute is not set up. Run `volute setup` first.");
+    process.exit(1);
+  }
+}
 switch (command) {
-  case "mind":
-    await import("./mind-YVWAHL2A.js").then((m) => m.run(args));
+  case "setup":
+    await import("./setup-JG4QAEBV.js").then((m) => m.run(args));
     break;
-  case "send":
-    await import("./send-IISDYFCL.js").then((m) => m.run(args));
+  case "mind":
+    await import("./mind-DI33C74K.js").then((m) => m.run(args));
     break;
-  case "history":
-    await import("./history-46WZN5CN.js").then((m) => m.run(args));
+  case "chat":
+    await import("./chat-MHJ3L6JQ.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-UGREB4G5.js").then((m) => m.run(args));
-    break;
-  case "channel":
-    await import("./channel-HZOSHGNF.js").then((m) => m.run(args));
+    await import("./variant-7TGZHOU3.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-YEFDLVMJ.js").then((m) => m.run(args));
+    await import("./schedule-QTJMFATP.js").then((m) => m.run(args));
     break;
   case "skill":
-    await import("./skill-T3EMR6IR.js").then((m) => m.run(args));
+    await import("./skill-AUAQTSP5.js").then((m) => m.run(args));
     break;
   case "shared":
-    await import("./shared-LWMNTTZN.js").then((m) => m.run(args));
+    await import("./shared-ML5I4Q2A.js").then((m) => m.run(args));
     break;
   case "file":
-    await import("./file-KT3UIQM3.js").then((m) => m.run(args));
+    await import("./file-CR36YUPD.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-2FPOZK37.js").then((m) => m.run(args));
+    await import("./env-YJMUMFIY.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-CJ26KQLN.js").then((m) => m.run(args));
+    await import("./up-NKSMXBWR.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-674SX2IZ.js").then((m) => m.run(args));
+    await import("./down-LVBXEULC.js").then((m) => m.run(args));
     break;
   case "restart":
-    await import("./daemon-restart-FDNOZEAD.js").then((m) => m.run(args));
+    await import("./daemon-restart-M2QTYMEG.js").then((m) => m.run(args));
     break;
   case "service":
-    await import("./service-FASYWLTC.js").then((m) => m.run(args));
+    await import("./service-6LIN3F3K.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-7XCZMYBT.js").then((m) => m.run(args));
+    await import("./update-PTSH22AZ.js").then((m) => m.run(args));
     break;
   case "status":
-    await import("./status-SIRPLEZC.js").then((m) => m.run(args));
+    await import("./status-77YEPHMW.js").then((m) => m.run(args));
+    break;
+  case "notes":
+    await import("./notes-XCER3I7M.js").then((m) => m.run(args));
     break;
   case "pages":
-    await import("./pages-Y6DRWUOJ.js").then((m) => m.run(args));
+    await import("./pages-6EBS6CBR.js").then((m) => m.run(args));
     break;
   case "auth":
-    await import("./auth-HM2RSPY7.js").then((m) => m.run(args));
+    await import("./auth-D3OT2ARB.js").then((m) => m.run(args));
+    break;
+  case "login":
+    await import("./login-3QZNR2DF.js").then((m) => m.run(args));
+    break;
+  case "logout":
+    await import("./logout-T53VKCPU.js").then((m) => m.run(args));
     break;
   case "--help":
   case "-h":
@@ -74,8 +89,10 @@ switch (command) {
     console.log(`volute \u2014 create and manage AI minds
 
 Common:
-  send <target> "<msg>"            Send a message
-  history [--channel <ch>]         View activity history
+  chat send <target> "<msg>"       Send a message
+  chat history [--channel <ch>]    View activity history
+  chat list / read / create        Manage conversations
+  chat bridge                      Manage platform bridges
   status                           Show system status
 
 Mind:
@@ -84,25 +101,27 @@ Mind:
   mind start/stop/restart [name]   Control a mind
   mind list                        List all minds
   mind status [name]               Check a mind's status
-  mind connect/disconnect <type>   Manage connectors
   mind logs [name] [--follow]      Tail mind logs
   mind sprout                      Complete orientation
+  mind split/join                  Create and merge experimental splits
   mind upgrade/import/export       Lifecycle operations
 
 Configuration:
-  channel   Read, list, and manage channels
-  variant   Create and merge experimental variants
+  chat      Conversations, messages, and platform bridges
   schedule  Manage cron schedules
   skill     Browse and install skills
   env       Manage environment variables
   file      Mind-to-mind file sharing
   shared    Collaborative shared repository
+  notes     Read and write notes
   pages     Publish web pages
 
 System:
+  setup                            First-time setup
   up / down / restart              Daemon control
+  login / logout                   CLI authentication
   update                           Update volute
-  service install/uninstall        Auto-start service
+  service status                   Check service status
   auth register/login/logout       volute.systems account
 
 Options:
@@ -111,7 +130,7 @@ Options:
 
 Run 'volute <command> --help' for details.
 
-Mind-scoped commands (send, history, variant, schedule, channel, file, skill, shared, pages)
+Mind-scoped commands (chat, schedule, file, skill, shared, pages)
 use --mind <name> or VOLUTE_MIND env var to identify the mind.`);
     break;
   default:
@@ -120,7 +139,7 @@ Run 'volute --help' for usage.`);
     process.exit(1);
 }
 if (command !== "update") {
-  import("./update-check-F5Z3ALXX.js").then((m) => m.checkForUpdate()).then((result) => {
+  import("./update-check-64FWC4Y2.js").then((m) => m.checkForUpdate()).then((result) => {
     if (result.updateAvailable) {
       console.error(`
   Update available: ${result.current} \u2192 ${result.latest}`);

package/dist/{cloud-sync-PPBBJDY6.js → cloud-sync-T7M3ESC3.js}

@@ -1,22 +1,25 @@
 #!/usr/bin/env node
 import {
-  deliverMessage,
+  deliverMessage
+} from "./chunk-OQZH4PBB.js";
+import "./chunk-KDGS53OS.js";
+import "./chunk-K5NAC55T.js";
+import "./chunk-PHSAT7YL.js";
+import "./chunk-USUXRNVD.js";
+import {
   getAuthHeaders,
   getWebhookUrl
-} from "./chunk-PMX4EIJK.js";
-import "./chunk-HFCBO2GL.js";
-import "./chunk-E7GOKNOT.js";
-import "./chunk-BFK6SOEJ.js";
-import "./chunk-SHSWYG2J.js";
-import "./chunk-SIAG3QMM.js";
-import "./chunk-PHU4DEAJ.js";
-import "./chunk-33XAVCS4.js";
+} from "./chunk-IAYBDWVG.js";
+import "./chunk-VIVMW2H2.js";
+import "./chunk-2WPW7OT6.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
-import "./chunk-JTDFJWI2.js";
-import "./chunk-NWPT4ASZ.js";
-import "./chunk-B2CPS4QU.js";
+import "./chunk-AW7PFDVN.js";
+import "./chunk-RKQEHRBB.js";
+import "./chunk-IKRVFPWU.js";
+import "./chunk-T6HKBWXZ.js";
+import "./chunk-H7OZRFJB.js";
 import "./chunk-K3NQKI34.js";
 
 // src/lib/cloud-sync.ts

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
+};