volute 0.36.0 → 0.37.1

package/dist/chunk-LIIX2MOM.js

@@ -0,0 +1,853 @@
+#!/usr/bin/env node
+import {
+  findBridgeForChannel,
+  getBridgeConfig
+} from "./chunk-LQ6Z4FXN.js";
+import {
+  publish,
+  recordOutbound
+} from "./chunk-RUIVWCYY.js";
+import {
+  readEnv,
+  sharedEnvPath
+} from "./chunk-PMMHVSCR.js";
+import {
+  readVoluteConfig
+} from "./chunk-CU6OFXMM.js";
+import {
+  getOrCreateMindUser,
+  getUserByUsername
+} from "./chunk-UIM5NHPP.js";
+import {
+  addMessage,
+  findDMConversation,
+  getChannelByName,
+  getChannelName,
+  getConversation,
+  getParticipants
+} from "./chunk-5DPRTREW.js";
+import {
+  logger_default
+} from "./chunk-T2TP6ZC6.js";
+import {
+  buildVoluteSlug
+} from "./chunk-LGNUFVMR.js";
+import {
+  mindDir,
+  voluteSystemDir
+} from "./chunk-2NHRJ3YO.js";
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
+
+// packages/platforms/src/drivers/discord.ts
+var discord_exports = {};
+__export(discord_exports, {
+  createConversation: () => createConversation,
+  listConversations: () => listConversations,
+  listUsers: () => listUsers,
+  read: () => read,
+  send: () => send
+});
+
+// packages/platforms/src/slugify.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+// packages/platforms/src/split-message.ts
+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;
+}
+
+// packages/platforms/src/drivers/discord.ts
+var DISCORD_MAX_LENGTH = 2e3;
+var API_BASE = "https://discord.com/api/v10";
+function requireToken(env) {
+  const token = env.DISCORD_TOKEN;
+  if (!token) throw new Error("DISCORD_TOKEN not set");
+  return token;
+}
+async function discordGet(token, path) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    headers: { Authorization: `Bot ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function read(env, channelSlug, limit) {
+  const token = requireToken(env);
+  const channelId = resolvePlatformId(channelSlug);
+  const res = await fetch(`${API_BASE}/channels/${channelId}/messages?limit=${limit}`, {
+    headers: { Authorization: `Bot ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  const messages = await res.json();
+  return messages.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
+}
+async function send(env, channelSlug, message, images) {
+  const token = requireToken(env);
+  const channelId = resolvePlatformId(channelSlug);
+  if (images?.length) {
+    for (let i = 0; i < images.length; i++) {
+      const img = images[i];
+      const ext = img.media_type.split("/")[1] || "png";
+      const form = new FormData();
+      const content = i === 0 ? message.slice(0, DISCORD_MAX_LENGTH) : "";
+      form.append("payload_json", JSON.stringify({ content }));
+      form.append(
+        "files[0]",
+        new Blob([Buffer.from(img.data, "base64")], { type: img.media_type }),
+        `image.${ext}`
+      );
+      const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
+        method: "POST",
+        headers: { Authorization: `Bot ${token}` },
+        body: form
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        const partial = i > 0 ? ` (${i}/${images.length} images were already sent)` : "";
+        throw new Error(`Discord API error: ${res.status} ${body || res.statusText}${partial}`);
+      }
+    }
+    return;
+  }
+  const chunks = splitMessage(message, DISCORD_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bot ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ content: chunks[i] })
+    });
+    if (!res.ok) {
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`Discord API error: ${res.status} ${res.statusText}${partial}`);
+    }
+  }
+}
+async function listConversations(env) {
+  const token = requireToken(env);
+  const results = [];
+  const guilds = await discordGet(token, "/users/@me/guilds");
+  for (const guild of guilds) {
+    const channels = await discordGet(token, `/guilds/${guild.id}/channels`);
+    for (const ch of channels) {
+      if (ch.type !== 0) continue;
+      results.push({
+        id: `discord:${slugify(guild.name)}/${slugify(ch.name)}`,
+        platformId: ch.id,
+        name: `#${ch.name}`,
+        type: "channel"
+      });
+    }
+  }
+  const dms = await discordGet(token, "/users/@me/channels");
+  for (const dm of dms) {
+    const recipients = dm.recipients?.map((r) => r.username) ?? [];
+    const slug = recipients.length === 0 ? `discord:${dm.id}` : recipients.length === 1 ? `discord:@${slugify(recipients[0])}` : `discord:@${recipients.map(slugify).sort().join(",")}`;
+    results.push({
+      id: slug,
+      platformId: dm.id,
+      name: recipients.join(", ") || "DM",
+      type: dm.type === 1 ? "dm" : "channel"
+    });
+  }
+  return results;
+}
+async function listUsers(env) {
+  const token = requireToken(env);
+  const seen = /* @__PURE__ */ new Map();
+  const guilds = await discordGet(token, "/users/@me/guilds");
+  for (const guild of guilds) {
+    const members = await discordGet(token, `/guilds/${guild.id}/members?limit=1000`);
+    for (const m of members) {
+      if (!seen.has(m.user.id)) {
+        seen.set(m.user.id, {
+          id: m.user.id,
+          username: m.user.username,
+          type: m.user.bot ? "bot" : "human"
+        });
+      }
+    }
+  }
+  return [...seen.values()];
+}
+async function createConversation(env, participants, _name) {
+  const token = requireToken(env);
+  if (participants.length !== 1) {
+    throw new Error(
+      "Discord group creation not supported via bot \u2014 use threads in an existing channel"
+    );
+  }
+  const allUsers = await listUsers(env);
+  const target = allUsers.find((u) => u.username.toLowerCase() === participants[0].toLowerCase());
+  if (!target) {
+    throw new Error(`User not found: ${participants[0]}`);
+  }
+  const res = await fetch(`${API_BASE}/users/@me/channels`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ recipient_id: target.id })
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  const dmChannel = await res.json();
+  return `discord:${dmChannel.id}`;
+}
+
+// packages/platforms/src/drivers/slack.ts
+var slack_exports = {};
+__export(slack_exports, {
+  createConversation: () => createConversation2,
+  listConversations: () => listConversations2,
+  listUsers: () => listUsers2,
+  read: () => read2,
+  send: () => send2
+});
+var SLACK_MAX_LENGTH = 4e3;
+var API_BASE2 = "https://slack.com/api";
+function requireToken2(env) {
+  const token = env.SLACK_BOT_TOKEN;
+  if (!token) throw new Error("SLACK_BOT_TOKEN not set");
+  return token;
+}
+async function slackApi(token, method, body) {
+  const res = await fetch(`${API_BASE2}/${method}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new Error(`Slack API HTTP error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error}`);
+  }
+  return data;
+}
+async function read2(env, channelSlug, limit) {
+  const token = requireToken2(env);
+  const channelId = resolvePlatformId(channelSlug);
+  const data = await slackApi(token, "conversations.history", {
+    channel: channelId,
+    limit
+  });
+  return data.messages.reverse().map((m) => `${m.user ?? m.bot_id ?? "unknown"}: ${m.text}`).join("\n");
+}
+async function send2(env, channelSlug, message, images) {
+  const token = requireToken2(env);
+  const channelId = resolvePlatformId(channelSlug);
+  if (images?.length) {
+    for (const img of images) {
+      const ext = img.media_type.split("/")[1] || "png";
+      const filename = `image.${ext}`;
+      const binary = Buffer.from(img.data, "base64");
+      const uploadData = await slackApi(token, "files.getUploadURLExternal", {
+        filename,
+        length: binary.length
+      });
+      const uploadRes = await fetch(uploadData.upload_url, {
+        method: "POST",
+        body: binary
+      });
+      if (!uploadRes.ok) {
+        throw new Error(`Slack file upload failed: ${uploadRes.status} ${uploadRes.statusText}`);
+      }
+      await slackApi(token, "files.completeUploadExternal", {
+        files: [{ id: uploadData.file_id }],
+        channel_id: channelId
+      });
+    }
+    if (message) {
+      const chunks2 = splitMessage(message, SLACK_MAX_LENGTH);
+      for (const chunk of chunks2) {
+        await slackApi(token, "chat.postMessage", {
+          channel: channelId,
+          text: chunk
+        });
+      }
+    }
+    return;
+  }
+  const chunks = splitMessage(message, SLACK_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    try {
+      await slackApi(token, "chat.postMessage", {
+        channel: channelId,
+        text: chunks[i]
+      });
+    } catch (err) {
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`${err instanceof Error ? err.message : err}${partial}`);
+    }
+  }
+}
+async function listConversations2(env) {
+  const token = requireToken2(env);
+  const authData = await slackApi(token, "auth.test", {});
+  const teamName = authData.team ?? "workspace";
+  const data = await slackApi(token, "conversations.list", {
+    types: "public_channel,private_channel,mpim,im",
+    limit: 1e3
+  });
+  const userMap = /* @__PURE__ */ new Map();
+  const imChannels = data.channels.filter((ch) => ch.is_im && ch.user);
+  if (imChannels.length > 0) {
+    const users = await listUsers2(env);
+    for (const u of users) {
+      userMap.set(u.id, u.username);
+    }
+  }
+  return data.channels.map((ch) => {
+    let type = "channel";
+    if (ch.is_im) type = "dm";
+    let slug;
+    let name;
+    if (ch.is_im && ch.user) {
+      const username = userMap.get(ch.user) ?? ch.user;
+      slug = `slack:@${slugify(username)}`;
+      name = username;
+    } else if (ch.name) {
+      slug = `slack:${slugify(teamName)}/${slugify(ch.name)}`;
+      name = ch.name;
+    } else {
+      slug = `slack:${ch.id}`;
+      name = ch.id;
+    }
+    return {
+      id: slug,
+      platformId: ch.id,
+      name,
+      type,
+      participantCount: ch.num_members
+    };
+  });
+}
+async function listUsers2(env) {
+  const token = requireToken2(env);
+  const data = await slackApi(token, "users.list", {});
+  return data.members.filter((m) => !m.deleted).map((m) => ({
+    id: m.id,
+    username: m.name,
+    type: m.is_bot ? "bot" : "human"
+  }));
+}
+async function createConversation2(env, participants, name) {
+  const token = requireToken2(env);
+  const allUsers = await listUsers2(env);
+  const ids = [];
+  for (const p of participants) {
+    const user = allUsers.find((u) => u.username.toLowerCase() === p.toLowerCase());
+    if (!user) throw new Error(`User not found: ${p}`);
+    ids.push(user.id);
+  }
+  if (name) {
+    const createData = await slackApi(token, "conversations.create", {
+      name,
+      is_private: true
+    });
+    const channelId = createData.channel.id;
+    for (const userId of ids) {
+      await slackApi(token, "conversations.invite", {
+        channel: channelId,
+        users: userId
+      });
+    }
+    const authData = await slackApi(token, "auth.test", {});
+    const teamName = authData.team ?? "workspace";
+    const slug = `slack:${slugify(teamName)}/${slugify(name)}`;
+    return slug;
+  }
+  const openData = await slackApi(token, "conversations.open", { users: ids.join(",") });
+  return `slack:${openData.channel.id}`;
+}
+
+// packages/platforms/src/drivers/telegram.ts
+var telegram_exports = {};
+__export(telegram_exports, {
+  createConversation: () => createConversation3,
+  listConversations: () => listConversations3,
+  listUsers: () => listUsers3,
+  read: () => read3,
+  send: () => send3
+});
+var TELEGRAM_MAX_LENGTH = 4096;
+var API_BASE3 = "https://api.telegram.org";
+function requireToken3(env) {
+  const token = env.TELEGRAM_BOT_TOKEN;
+  if (!token) throw new Error("TELEGRAM_BOT_TOKEN not set");
+  return token;
+}
+async function read3(_env, _channelSlug, _limit) {
+  throw new Error(
+    "Telegram Bot API does not support reading chat history. Use volute chat send instead."
+  );
+}
+async function send3(env, channelSlug, message, images) {
+  const token = requireToken3(env);
+  const chatId = resolvePlatformId(channelSlug);
+  if (images?.length) {
+    const CAPTION_MAX = 1024;
+    for (let i = 0; i < images.length; i++) {
+      const img = images[i];
+      const ext = img.media_type.split("/")[1] || "png";
+      const form = new FormData();
+      form.append("chat_id", chatId);
+      form.append(
+        "photo",
+        new Blob([Buffer.from(img.data, "base64")], { type: img.media_type }),
+        `image.${ext}`
+      );
+      if (i === 0 && message) {
+        form.append("caption", message.slice(0, CAPTION_MAX));
+      }
+      const res = await fetch(`${API_BASE3}/bot${token}/sendPhoto`, {
+        method: "POST",
+        body: form
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        const partial = i > 0 ? ` (${i}/${images.length} images were already sent)` : "";
+        throw new Error(`Telegram API error: ${res.status} ${body}${partial}`);
+      }
+    }
+    if (message && message.length > CAPTION_MAX) {
+      const remaining = message.slice(CAPTION_MAX);
+      const chunks2 = splitMessage(remaining, TELEGRAM_MAX_LENGTH);
+      for (const chunk of chunks2) {
+        const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ chat_id: chatId, text: chunk })
+        });
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          throw new Error(`Telegram API error: ${res.status} ${body}`);
+        }
+      }
+    }
+    return;
+  }
+  const chunks = splitMessage(message, TELEGRAM_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text: chunks[i] })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`Telegram API error: ${res.status} ${body}${partial}`);
+    }
+  }
+}
+async function listConversations3() {
+  throw new Error(
+    "Telegram Bot API does not support listing conversations. Users must message the bot first."
+  );
+}
+async function listUsers3() {
+  throw new Error(
+    "Telegram Bot API does not support listing users. Users must message the bot first."
+  );
+}
+async function createConversation3() {
+  throw new Error(
+    "Telegram Bot API does not support creating conversations. Users must message the bot first."
+  );
+}
+
+// packages/platforms/src/index.ts
+var PLATFORMS = {
+  discord: {
+    name: "discord",
+    displayName: "Discord",
+    driver: discord_exports
+  },
+  slack: {
+    name: "slack",
+    displayName: "Slack",
+    driver: slack_exports
+  },
+  telegram: {
+    name: "telegram",
+    displayName: "Telegram",
+    driver: telegram_exports
+  },
+  volute: { name: "volute", displayName: "Volute" },
+  mail: { name: "mail", displayName: "Email" },
+  system: { name: "system", displayName: "System" }
+};
+function registerPlatform(name, platform) {
+  PLATFORMS[name] = platform;
+}
+function getPlatformDriver(platform) {
+  return PLATFORMS[platform]?.driver ?? null;
+}
+function resolvePlatformId(slug) {
+  const colonIdx = slug.indexOf(":");
+  return colonIdx !== -1 ? slug.slice(colonIdx + 1) : slug;
+}
+
+// packages/daemon/src/lib/platforms/volute.ts
+var volute_exports = {};
+__export(volute_exports, {
+  createConversation: () => createConversation4,
+  listConversations: () => listConversations4,
+  listUsers: () => listUsers4,
+  read: () => read4,
+  send: () => send4
+});
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+function readSessionFile(mindDir2) {
+  try {
+    const p = resolve(mindDir2, ".mind", "current-session");
+    if (existsSync(p)) return readFileSync(p, "utf-8").trim() || void 0;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.error(`[volute] failed to read session file: ${code ?? err}`);
+    }
+  }
+  return void 0;
+}
+function getDaemonConfig() {
+  const configPath = resolve(voluteSystemDir(), "daemon.json");
+  if (!existsSync(configPath)) {
+    throw new Error("Volute daemon is not running");
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (err) {
+    throw new Error(`Failed to parse ${configPath}: ${err}`);
+  }
+  if (typeof config.port !== "number") {
+    throw new Error(`Invalid or missing port in ${configPath}`);
+  }
+  const url = new URL("http://localhost");
+  url.hostname = config.hostname || "localhost";
+  url.port = String(config.port);
+  return { url: url.origin, token: config.token };
+}
+async function read4(env, channelSlug, limit) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) throw new Error("VOLUTE_MIND not set");
+  const conversationId = resolvePlatformId(channelSlug);
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(
+    `${url}/api/minds/${encodeURIComponent(mindName)}/conversations/${encodeURIComponent(conversationId)}/messages`,
+    { headers }
+  );
+  if (!res.ok) {
+    throw new Error(`Failed to read conversation: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  if (!Array.isArray(data.items)) {
+    throw new Error("Unexpected response format when reading conversation messages");
+  }
+  return data.items.slice(-limit).map((m) => {
+    const text = Array.isArray(m.content) ? m.content.filter((b) => b.type === "text").map((b) => b.text).join("") : m.content;
+    return `${m.sender_name ?? m.role}: ${text}`;
+  }).join("\n");
+}
+async function send4(env, channelSlug, message, images) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) throw new Error("VOLUTE_MIND not set");
+  const conversationId = resolvePlatformId(channelSlug);
+  const { url, token } = getDaemonConfig();
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: url
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const voluteSession = env.VOLUTE_SESSION || (env.VOLUTE_MIND_DIR ? readSessionFile(env.VOLUTE_MIND_DIR) : void 0);
+  if (voluteSession) headers["X-Volute-Session"] = voluteSession;
+  const res = await fetch(`${url}/api/v1/chat`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      message,
+      conversationId,
+      sender: env.VOLUTE_SENDER ?? mindName,
+      images,
+      targetMind: mindName
+    })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error ?? `Failed to send: ${res.status}`);
+  }
+}
+async function listConversations4(env) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) throw new Error("VOLUTE_MIND not set");
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/minds/${encodeURIComponent(mindName)}/conversations`, {
+    headers
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to list conversations: ${res.status} ${res.statusText}`);
+  }
+  const convs = await res.json();
+  const results = [];
+  for (const conv of convs) {
+    const participants = conv.participants ?? [];
+    const slug = buildVoluteSlug({
+      participants,
+      mindUsername: mindName,
+      conversationId: conv.id,
+      convType: conv.type,
+      convName: conv.channel_name
+    });
+    const convType = conv.type === "channel" ? "channel" : "dm";
+    const other = participants.find((p) => p.username !== mindName);
+    const displayName = conv.type === "channel" && conv.channel_name ? `#${conv.channel_name}` : other ? `@${other.username}` : "(untitled)";
+    results.push({
+      id: slug,
+      platformId: conv.id,
+      name: displayName,
+      type: convType,
+      participantCount: participants.length
+    });
+  }
+  return results;
+}
+async function listUsers4(_env) {
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/auth/users`, { headers });
+  if (!res.ok) {
+    throw new Error(`Failed to list users: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  return data.map((u) => ({
+    id: String(u.id),
+    username: u.username,
+    type: u.user_type
+  }));
+}
+async function createConversation4(env, participants, name) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) throw new Error("VOLUTE_MIND not set");
+  const { url, token } = getDaemonConfig();
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: url
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/minds/${encodeURIComponent(mindName)}/conversations`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ participantNames: participants })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error ?? `Failed to create conversation: ${res.status}`);
+  }
+  const conv = await res.json();
+  return conv.id;
+}
+
+// packages/daemon/src/lib/platforms.ts
+registerPlatform("volute", {
+  name: "volute",
+  displayName: "Volute",
+  builtIn: true,
+  driver: volute_exports
+});
+
+// packages/daemon/src/lib/bridges/bridge-outbound.ts
+function extractContent(contentBlocks) {
+  const text = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+  const images = contentBlocks.filter((b) => b.type === "image").map((b) => ({ media_type: b.media_type, data: b.data }));
+  return { text, images };
+}
+async function routeOutboundBridge(conversationId, senderName, contentBlocks) {
+  try {
+    const conv = await getConversation(conversationId);
+    if (!conv) return;
+    if (conv.type === "channel") {
+      const channelName = await getChannelName(conversationId);
+      if (channelName) {
+        await routeChannelOutbound(channelName, senderName, contentBlocks);
+      } else {
+        logger_default.warn(
+          `channel conversation ${conversationId} has no channel name \u2014 skipping bridge outbound`
+        );
+      }
+    } else if (conv.type === "dm") {
+      await routeDMOutbound(conversationId, senderName, contentBlocks);
+    }
+  } catch (err) {
+    logger_default.error(`bridge outbound failed for conversation ${conversationId}`, logger_default.errorData(err));
+  }
+}
+async function routeChannelOutbound(channelName, senderName, contentBlocks) {
+  const bridgeInfo = findBridgeForChannel(channelName);
+  if (!bridgeInfo) return;
+  const driver = getPlatformDriver(bridgeInfo.platform);
+  if (!driver) {
+    logger_default.warn(`no channel driver for bridge platform: ${bridgeInfo.platform}`);
+    return;
+  }
+  const { text, images } = extractContent(contentBlocks);
+  if (!text) return;
+  const env = readEnv(sharedEnvPath());
+  env.VOLUTE_SENDER = senderName;
+  await driver.send(env, bridgeInfo.externalChannel, text, images.length > 0 ? images : void 0);
+  logger_default.debug(`bridge outbound: sent to ${bridgeInfo.platform}:${bridgeInfo.externalChannel}`);
+}
+async function routeDMOutbound(conversationId, senderName, contentBlocks) {
+  const participants = await getParticipants(conversationId);
+  const puppets = participants.filter((p) => p.userType === "puppet");
+  if (puppets.length === 0) return;
+  const { text, images } = extractContent(contentBlocks);
+  if (!text) return;
+  for (const puppet of puppets) {
+    const colonIdx = puppet.username.indexOf(":");
+    if (colonIdx === -1) {
+      logger_default.warn(
+        `puppet user ${puppet.username} has malformed username (expected platform:id format)`
+      );
+      continue;
+    }
+    const platform = puppet.username.slice(0, colonIdx);
+    const externalUserId = puppet.username.slice(colonIdx + 1);
+    const bridgeConfig = getBridgeConfig(platform);
+    if (!bridgeConfig?.enabled) continue;
+    const driver = getPlatformDriver(platform);
+    if (!driver?.createConversation) {
+      logger_default.warn(`no channel driver with DM support for bridge platform: ${platform}`);
+      continue;
+    }
+    try {
+      const env = readEnv(sharedEnvPath());
+      env.VOLUTE_SENDER = senderName;
+      env.VOLUTE_MIND = senderName;
+      env.VOLUTE_MIND_DIR = mindDir(senderName);
+      const slug = await driver.createConversation(env, [externalUserId]);
+      await driver.send(env, slug, text, images.length > 0 ? images : void 0);
+      logger_default.debug(`bridge outbound DM: sent to ${platform}:${externalUserId}`);
+    } catch (err) {
+      logger_default.error(`bridge outbound DM failed for puppet ${puppet.username}`, logger_default.errorData(err));
+    }
+  }
+}
+
+// packages/daemon/src/lib/delivery/echo-text.ts
+var dlog = logger_default.child("echo-text");
+var echoTextCache = /* @__PURE__ */ new Map();
+var channelConvCache = /* @__PURE__ */ new Map();
+function clearEchoTextCache(mind) {
+  if (mind) {
+    echoTextCache.delete(mind);
+    for (const key of channelConvCache.keys()) {
+      if (key.startsWith(`${mind}:`)) channelConvCache.delete(key);
+    }
+  } else {
+    echoTextCache.clear();
+    channelConvCache.clear();
+  }
+}
+function isEchoEnabled(mind) {
+  const cached = echoTextCache.get(mind);
+  if (cached !== void 0) return cached;
+  const config = readVoluteConfig(mindDir(mind));
+  const enabled = config?.echoText === true;
+  echoTextCache.set(mind, enabled);
+  return enabled;
+}
+async function resolveConversationId(mind, channel) {
+  const cacheKey = `${mind}:${channel}`;
+  const cached = channelConvCache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  let conversationId = null;
+  if (channel.startsWith("#")) {
+    const conv = await getChannelByName(channel.slice(1));
+    if (conv) conversationId = conv.id;
+  } else if (channel.startsWith("@")) {
+    const otherUsername = channel.slice(1);
+    const [mindUser, otherUser] = await Promise.all([
+      getOrCreateMindUser(mind),
+      getUserByUsername(otherUsername)
+    ]);
+    if (otherUser) {
+      conversationId = await findDMConversation([mindUser.id, otherUser.id]);
+    }
+  }
+  if (conversationId) {
+    channelConvCache.set(cacheKey, conversationId);
+  }
+  return conversationId;
+}
+async function echoTextToChannel(mind, channel, text, turnId, textEventId) {
+  if (!isEchoEnabled(mind)) return void 0;
+  if (!text.trim()) return void 0;
+  const conversationId = await resolveConversationId(mind, channel);
+  if (!conversationId) {
+    dlog.debug(`echo-text: could not resolve channel "${channel}" to conversation`);
+    return void 0;
+  }
+  const contentBlocks = [{ type: "text", text }];
+  const message = await addMessage(conversationId, "user", mind, contentBlocks, {
+    turnId,
+    sourceEventId: textEventId
+  });
+  routeOutboundBridge(conversationId, mind, contentBlocks).catch((err) => {
+    dlog.warn(`echo-text: bridge routing failed for ${mind} on ${channel}`, logger_default.errorData(err));
+  });
+  const outboundId = await recordOutbound(mind, channel, text, {
+    messageId: message != null ? String(message.id) : void 0,
+    turnId
+  });
+  if (outboundId != null) {
+    publish(mind, {
+      mind,
+      type: "outbound",
+      channel,
+      content: text,
+      turnId
+    });
+  }
+  return outboundId;
+}
+
+export {
+  PLATFORMS,
+  getPlatformDriver,
+  routeOutboundBridge,
+  clearEchoTextCache,
+  echoTextToChannel
+};