volute 0.26.0 → 0.28.0

package/dist/{archive-4ZQYK5MN.js → archive-UA4BDFXQ.js}

@@ -5,8 +5,8 @@ import {
   extractArchive,
   isHomeOnlyArchive,
   readManifest
-} from "./chunk-KTJGZ7M7.js";
-import "./chunk-B2CPS4QU.js";
+} from "./chunk-XBLSAVJF.js";
+import "./chunk-H7OZRFJB.js";
 import "./chunk-K3NQKI34.js";
 export {
   addHistoryToArchive,

package/dist/bridge-FQHZL3MC.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-JGFVMROS.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-H7OZRFJB.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/chat/bridge.ts
+async function run(args) {
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+  switch (subcommand) {
+    case "add":
+      await bridgeAdd(subArgs);
+      break;
+    case "remove":
+      await bridgeRemove(subArgs);
+      break;
+    case "list":
+      await bridgeList();
+      break;
+    case "map":
+      await bridgeMap(subArgs);
+      break;
+    case "unmap":
+      await bridgeUnmap(subArgs);
+      break;
+    case "mappings":
+      await bridgeMappings(subArgs);
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      console.log(`volute chat bridge \u2014 manage platform bridges
+
+  add <platform>                 Set up a bridge (e.g. discord, slack, telegram)
+  remove <platform>              Remove a bridge
+  list                           Show bridges + status
+  map <platform>:<channel> <ch>  Map external \u2192 Volute channel
+  unmap <platform>:<channel>     Remove mapping
+  mappings [<platform>]          List mappings`);
+      break;
+    default:
+      console.error(
+        `Unknown bridge subcommand: ${subcommand}
+Run 'volute chat bridge --help' for usage.`
+      );
+      process.exit(1);
+  }
+}
+async function bridgeAdd(args) {
+  const { positional, flags } = parseArgs(args, {
+    "default-mind": { type: "string" }
+  });
+  const platform = positional[0];
+  if (!platform) {
+    console.error("Usage: volute chat bridge add <platform> --default-mind <name>");
+    process.exit(1);
+  }
+  const defaultMind = flags["default-mind"];
+  if (!defaultMind) {
+    console.error("--default-mind is required (mind to route DMs to)");
+    process.exit(1);
+  }
+  const res = await daemonFetch(`/api/bridges/${encodeURIComponent(platform)}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ defaultMind })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    if (data.error === "missing_env" && data.missing) {
+      console.error(`Missing required environment variables:`);
+      for (const v of data.missing) {
+        console.error(`  ${v.name} \u2014 ${v.description}`);
+      }
+      console.error(`
+Set them with: volute env set <VAR> <value>`);
+    } else {
+      console.error(data.error ?? `Failed to add bridge: ${res.status}`);
+    }
+    process.exit(1);
+  }
+  console.log(`Bridge ${platform} enabled.`);
+}
+async function bridgeRemove(args) {
+  const platform = args[0];
+  if (!platform) {
+    console.error("Usage: volute chat bridge remove <platform>");
+    process.exit(1);
+  }
+  const res = await daemonFetch(`/api/bridges/${encodeURIComponent(platform)}`, {
+    method: "DELETE"
+  });
+  if (!res.ok) {
+    console.error(`Failed to remove bridge: ${res.status}`);
+    process.exit(1);
+  }
+  console.log(`Bridge ${platform} removed.`);
+}
+async function bridgeList() {
+  const res = await daemonFetch("/api/bridges");
+  if (!res.ok) {
+    console.error(`Failed to list bridges: ${res.status}`);
+    process.exit(1);
+  }
+  const bridges = await res.json();
+  if (bridges.length === 0) {
+    console.log("No bridges configured. Use 'volute chat bridge add <platform>' to set one up.");
+    return;
+  }
+  for (const b of bridges) {
+    const status = b.running ? "running" : b.enabled ? "stopped" : "disabled";
+    console.log(`  ${b.displayName} (${b.platform})  ${status}  default: ${b.defaultMind}`);
+  }
+}
+async function bridgeMap(args) {
+  const target = args[0];
+  const voluteChannel = args[1];
+  if (!target || !voluteChannel) {
+    console.error("Usage: volute chat bridge map <platform>:<channel> <volute-channel>");
+    process.exit(1);
+  }
+  const colonIdx = target.indexOf(":");
+  if (colonIdx < 1) {
+    console.error("Target must be in format platform:channel (e.g. discord:my-server/general)");
+    process.exit(1);
+  }
+  const platform = target.slice(0, colonIdx);
+  const externalChannel = target.slice(colonIdx + 1);
+  const res = await daemonFetch(`/api/bridges/${encodeURIComponent(platform)}/mappings`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ externalChannel, voluteChannel })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    console.error(data.error ?? `Failed to set mapping: ${res.status}`);
+    process.exit(1);
+  }
+  console.log(`Mapped ${platform}:${externalChannel} \u2192 ${voluteChannel}`);
+}
+async function bridgeUnmap(args) {
+  const target = args[0];
+  if (!target) {
+    console.error("Usage: volute chat bridge unmap <platform>:<channel>");
+    process.exit(1);
+  }
+  const colonIdx = target.indexOf(":");
+  if (colonIdx < 1) {
+    console.error("Target must be in format platform:channel");
+    process.exit(1);
+  }
+  const platform = target.slice(0, colonIdx);
+  const externalChannel = target.slice(colonIdx + 1);
+  const res = await daemonFetch(
+    `/api/bridges/${encodeURIComponent(platform)}/mappings/${encodeURIComponent(externalChannel)}`,
+    { method: "DELETE" }
+  );
+  if (!res.ok) {
+    console.error(`Failed to remove mapping: ${res.status}`);
+    process.exit(1);
+  }
+  console.log(`Removed mapping for ${platform}:${externalChannel}`);
+}
+async function bridgeMappings(args) {
+  const platform = args[0];
+  if (platform) {
+    const res = await daemonFetch(`/api/bridges/${encodeURIComponent(platform)}/mappings`);
+    if (!res.ok) {
+      console.error(`Failed to get mappings: ${res.status}`);
+      process.exit(1);
+    }
+    const mappings = await res.json();
+    if (Object.keys(mappings).length === 0) {
+      console.log(`No mappings for ${platform}.`);
+      return;
+    }
+    for (const [external, volute] of Object.entries(mappings)) {
+      console.log(`  ${platform}:${external} \u2192 ${volute}`);
+    }
+  } else {
+    const res = await daemonFetch("/api/bridges");
+    if (!res.ok) {
+      console.error(`Failed to list bridges: ${res.status}`);
+      process.exit(1);
+    }
+    const bridges = await res.json();
+    let found = false;
+    for (const b of bridges) {
+      for (const [external, volute] of Object.entries(b.channelMappings)) {
+        console.log(`  ${b.platform}:${external} \u2192 ${volute}`);
+        found = true;
+      }
+    }
+    if (!found) {
+      console.log("No mappings configured.");
+    }
+  }
+}
+export {
+  run
+};

package/dist/chat-M4SX42JD.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import "./chunk-K3NQKI34.js";
+
+// src/commands/chat.ts
+async function run(args) {
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+  switch (subcommand) {
+    case "send":
+      await import("./send-TAOEZ4NH.js").then((m) => m.run(subArgs));
+      break;
+    case "list":
+      await import("./list-R73GENNL.js").then((m) => m.run(subArgs));
+      break;
+    case "read":
+      await import("./read-36UFXN3G.js").then((m) => m.run(subArgs));
+      break;
+    case "create":
+      await import("./create-D7J73A6H.js").then((m) => m.run(subArgs));
+      break;
+    case "bridge":
+      await import("./bridge-FQHZL3MC.js").then((m) => m.run(subArgs));
+      break;
+    case "files":
+      await import("./files-M546TKVN.js").then((m) => m.run(subArgs));
+      break;
+    case "accept":
+      await import("./accept-666DIZX2.js").then((m) => m.run(subArgs));
+      break;
+    case "reject":
+      await import("./reject-LXIZFJ4Q.js").then((m) => m.run(subArgs));
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      console.log(`volute chat \u2014 conversations, files, and bridges
+
+Messages:
+  send <target> "<msg>"          Send a message (--image, --file)
+  list                           List conversations
+  read <conversation> [--limit]  Read conversation messages
+  create --participants u1,u2    Create a conversation
+
+Files:
+  files [--mind <name>]              List pending incoming files
+  accept <id> [--mind] [--dest]      Accept a pending file
+  reject <id> [--mind]               Reject a pending file
+
+Bridges:
+  bridge add <platform>          Set up a bridge
+  bridge remove <platform>       Remove a bridge
+  bridge list                    Show bridges + status
+  bridge map <p>:<ch> <volute>   Map external \u2192 Volute channel
+  bridge unmap <p>:<ch>          Remove mapping
+  bridge mappings [<platform>]   List mappings
+
+Send targets: @mindname for DMs, channel-name for conversations.
+Mind-scoped commands use --mind <name> or VOLUTE_MIND env var.`);
+      break;
+    default:
+      console.error(`Unknown chat subcommand: ${subcommand}
+Run 'volute chat --help' for usage.`);
+      process.exit(1);
+  }
+}
+export {
+  run
+};

package/dist/{chunk-PHU4DEAJ.js → chunk-2WPW7OT6.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   stateDir,
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 function sharedEnvPath() {
-  return resolve(voluteHome(), "env.json");
+  return resolve(voluteSystemDir(), "env.json");
 }
 function mindEnvPath(mindName) {
   return resolve(stateDir(mindName), "env.json");

package/dist/{chunk-5Y3PBKW6.js → chunk-2YP2TVDT.js}

@@ -1,32 +1,105 @@
 #!/usr/bin/env node
 import {
-  readVoluteConfig,
-  writeVoluteConfig
-} from "./chunk-SIAG3QMM.js";
-import {
-  mindEnvPath,
   readEnv,
+  sharedEnvPath,
   writeEnv
-} from "./chunk-PHU4DEAJ.js";
+} from "./chunk-2WPW7OT6.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
+import {
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/commands/import.ts
 import {
   closeSync,
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
   openSync,
   readdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   readSync,
   rmSync,
   statSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
 import { homedir, tmpdir } from "os";
-import { basename, resolve } from "path";
+import { basename, resolve as resolve2 } from "path";
+
+// src/lib/bridges.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function bridgesPath() {
+  return resolve(voluteSystemDir(), "bridges.json");
+}
+function readBridgesConfig() {
+  const path = bridgesPath();
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    logger_default.error(
+      `bridges.json is corrupt or unreadable at ${path} \u2014 all bridges disabled`,
+      logger_default.errorData(err)
+    );
+    return {};
+  }
+}
+function writeBridgesConfig(config) {
+  writeFileSync(bridgesPath(), `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function getBridgeConfig(platform) {
+  const config = readBridgesConfig();
+  return config[platform] ?? null;
+}
+function setBridgeConfig(platform, bridge) {
+  const config = readBridgesConfig();
+  config[platform] = bridge;
+  writeBridgesConfig(config);
+}
+function removeBridgeConfig(platform) {
+  const config = readBridgesConfig();
+  delete config[platform];
+  writeBridgesConfig(config);
+}
+function setChannelMapping(platform, externalChannel, voluteChannel) {
+  const config = readBridgesConfig();
+  const bridge = config[platform];
+  if (!bridge) throw new Error(`Bridge not configured for ${platform}`);
+  bridge.channelMappings[externalChannel] = voluteChannel;
+  writeBridgesConfig(config);
+}
+function removeChannelMapping(platform, externalChannel) {
+  const config = readBridgesConfig();
+  const bridge = config[platform];
+  if (!bridge) return;
+  delete bridge.channelMappings[externalChannel];
+  writeBridgesConfig(config);
+}
+function resolveChannelMapping(platform, externalChannel) {
+  const bridge = getBridgeConfig(platform);
+  if (!bridge) return null;
+  return bridge.channelMappings[externalChannel] ?? null;
+}
+function findBridgeForChannel(voluteChannelName) {
+  const config = readBridgesConfig();
+  for (const [platform, bridge] of Object.entries(config)) {
+    if (!bridge.enabled) continue;
+    for (const [external, volute] of Object.entries(bridge.channelMappings)) {
+      if (volute === voluteChannelName) {
+        return { platform, externalChannel: external };
+      }
+    }
+  }
+  return null;
+}
+
+// src/commands/import.ts
 async function run(args) {
   const { positional, flags } = parseArgs(args, {
     name: { type: "string" },
@@ -35,11 +108,11 @@ async function run(args) {
   });
   const inputPath = positional[0];
   if (inputPath && (inputPath.endsWith(".volute") || isZipFile(inputPath))) {
-    await importArchive(resolve(inputPath), flags.name);
+    await importArchive(resolve2(inputPath), flags.name);
     return;
   }
   const wsDir = resolveWorkspace(inputPath);
-  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.import.$url()), {
@@ -63,8 +136,8 @@ ${data.message ?? `Imported mind: ${data.name} (port ${data.port})`}`);
   volute mind start ${data.name}`);
 }
 function isZipFile(path) {
-  const resolved = resolve(path);
-  if (!existsSync(resolved)) return false;
+  const resolved = resolve2(path);
+  if (!existsSync2(resolved)) return false;
   const fd = openSync(resolved, "r");
   try {
     const buf = Buffer.alloc(4);
@@ -75,12 +148,12 @@ function isZipFile(path) {
   }
 }
 async function importArchive(archivePath, nameOverride) {
-  if (!existsSync(archivePath)) {
+  if (!existsSync2(archivePath)) {
     console.error(`File not found: ${archivePath}`);
     process.exit(1);
   }
-  const { extractArchive } = await import("./archive-4ZQYK5MN.js");
-  const tempDir = resolve(tmpdir(), `volute-import-${Date.now()}`);
+  const { extractArchive } = await import("./archive-UA4BDFXQ.js");
+  const tempDir = resolve2(tmpdir(), `volute-import-${Date.now()}`);
   mkdirSync(tempDir, { recursive: true });
   let extracted;
   try {
@@ -91,7 +164,7 @@ async function importArchive(archivePath, nameOverride) {
     process.exit(1);
   }
   try {
-    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.import.$url()), {
@@ -119,20 +192,20 @@ ${data.message ?? `Imported mind: ${data.name} (port ${data.port})`}`);
 }
 function resolveWorkspace(explicitPath) {
   if (explicitPath) {
-    const wsDir = resolve(explicitPath);
-    if (!existsSync(resolve(wsDir, "SOUL.md")) || !existsSync(resolve(wsDir, "IDENTITY.md"))) {
+    const wsDir = resolve2(explicitPath);
+    if (!existsSync2(resolve2(wsDir, "SOUL.md")) || !existsSync2(resolve2(wsDir, "IDENTITY.md"))) {
       console.error("Not a valid OpenClaw workspace: missing SOUL.md or IDENTITY.md");
       process.exit(1);
     }
     return wsDir;
   }
   const cwd = process.cwd();
-  if (existsSync(resolve(cwd, "SOUL.md")) && existsSync(resolve(cwd, "IDENTITY.md"))) {
+  if (existsSync2(resolve2(cwd, "SOUL.md")) && existsSync2(resolve2(cwd, "IDENTITY.md"))) {
     console.log(`Using workspace: ${cwd}`);
     return cwd;
   }
-  const openclawWs = resolve(homedir(), ".openclaw/workspace");
-  if (existsSync(resolve(openclawWs, "SOUL.md")) && existsSync(resolve(openclawWs, "IDENTITY.md"))) {
+  const openclawWs = resolve2(homedir(), ".openclaw/workspace");
+  if (existsSync2(resolve2(openclawWs, "SOUL.md")) && existsSync2(resolve2(openclawWs, "IDENTITY.md"))) {
     console.log(`Using workspace: ${openclawWs}`);
     return openclawWs;
   }
@@ -142,16 +215,16 @@ function resolveWorkspace(explicitPath) {
   process.exit(1);
 }
 function findOpenClawSession(workspaceDir) {
-  const ocAgentsDir = resolve(homedir(), ".openclaw/agents");
-  if (!existsSync(ocAgentsDir)) return void 0;
+  const ocAgentsDir = resolve2(homedir(), ".openclaw/agents");
+  if (!existsSync2(ocAgentsDir)) return void 0;
   const matches = [];
   try {
     for (const entry of readdirSync(ocAgentsDir)) {
-      const sessionsDir = resolve(ocAgentsDir, entry, "sessions");
-      if (!existsSync(sessionsDir)) continue;
+      const sessionsDir = resolve2(ocAgentsDir, entry, "sessions");
+      if (!existsSync2(sessionsDir)) continue;
       for (const file of readdirSync(sessionsDir)) {
         if (!file.endsWith(".jsonl")) continue;
-        const fullPath = resolve(sessionsDir, file);
+        const fullPath = resolve2(sessionsDir, file);
         if (sessionMatchesWorkspace(fullPath, workspaceDir)) {
           matches.push({ path: fullPath, mtime: statSync(fullPath).mtimeMs });
         }
@@ -168,19 +241,19 @@ function findOpenClawSession(workspaceDir) {
 }
 function sessionMatchesWorkspace(sessionPath, workspaceDir) {
   try {
-    const fd = readFileSync(sessionPath, "utf-8");
+    const fd = readFileSync2(sessionPath, "utf-8");
     const firstLine = fd.slice(0, fd.indexOf("\n"));
     const header = JSON.parse(firstLine);
-    return header.type === "session" && resolve(header.cwd) === resolve(workspaceDir);
+    return header.type === "session" && resolve2(header.cwd) === resolve2(workspaceDir);
   } catch {
     return false;
   }
 }
 function importPiSession(sessionFile, mindDirPath) {
-  const homeDir = resolve(mindDirPath, "home");
-  const piSessionDir = resolve(mindDirPath, ".mind/pi-sessions/main");
+  const homeDir = resolve2(mindDirPath, "home");
+  const piSessionDir = resolve2(mindDirPath, ".mind/pi-sessions/main");
   mkdirSync(piSessionDir, { recursive: true });
-  const content = readFileSync(sessionFile, "utf-8");
+  const content = readFileSync2(sessionFile, "utf-8");
   const lines = content.trim().split("\n");
   try {
     const header = JSON.parse(lines[0]);
@@ -191,47 +264,48 @@ function importPiSession(sessionFile, mindDirPath) {
   } catch {
   }
   const filename = basename(sessionFile);
-  const destPath = resolve(piSessionDir, filename);
-  writeFileSync(destPath, `${lines.join("\n")}
+  const destPath = resolve2(piSessionDir, filename);
+  writeFileSync2(destPath, `${lines.join("\n")}
 `);
   console.log(`Imported session (${lines.length} entries)`);
 }
-function importOpenClawConnectors(name, mindDirPath) {
-  const configPath = resolve(homedir(), ".openclaw/openclaw.json");
-  if (!existsSync(configPath)) return;
+function importOpenClawConnectors(name, _mindDirPath) {
+  const configPath = resolve2(homedir(), ".openclaw/openclaw.json");
+  if (!existsSync2(configPath)) return;
   let config;
   try {
-    config = JSON.parse(readFileSync(configPath, "utf-8"));
+    config = JSON.parse(readFileSync2(configPath, "utf-8"));
   } catch (err) {
     console.warn("Warning: failed to parse openclaw.json:", err);
     return;
   }
   const discord = config.channels?.discord;
   if (!discord?.enabled || !discord.token) return;
-  const envPath = mindEnvPath(name);
+  const envPath = sharedEnvPath();
   const env = readEnv(envPath);
-  env.DISCORD_TOKEN = discord.token;
-  writeEnv(envPath, env);
-  const channelNames = /* @__PURE__ */ new Set();
+  if (!env.DISCORD_TOKEN) {
+    env.DISCORD_TOKEN = discord.token;
+    writeEnv(envPath, env);
+  }
+  const channelMappings = {};
   if (discord.guilds) {
     for (const guild of Object.values(discord.guilds)) {
       if (!guild.channels) continue;
-      for (const [name2, ch] of Object.entries(guild.channels)) {
-        if (ch.allow) channelNames.add(name2);
+      for (const [channelName, ch] of Object.entries(guild.channels)) {
+        if (ch.allow) {
+          channelMappings[channelName] = channelName;
+        }
       }
     }
   }
-  const voluteConfig = readVoluteConfig(mindDirPath) ?? {};
-  const connectors = new Set(voluteConfig.connectors ?? []);
-  connectors.add("discord");
-  voluteConfig.connectors = [...connectors];
-  if (channelNames.size > 0) {
-    voluteConfig.discord = { channels: [...channelNames] };
-  }
-  writeVoluteConfig(mindDirPath, voluteConfig);
-  console.log("Imported Discord connector config");
-  if (channelNames.size > 0) {
-    console.log(`Imported followed channels: ${[...channelNames].join(", ")}`);
+  setBridgeConfig("discord", {
+    enabled: true,
+    defaultMind: name,
+    channelMappings
+  });
+  console.log(`Imported Discord as system bridge (default mind: ${name})`);
+  if (Object.keys(channelMappings).length > 0) {
+    console.log(`Mapped channels: ${Object.keys(channelMappings).join(", ")}`);
   }
 }
 function parseNameFromIdentity(identity) {
@@ -245,6 +319,14 @@ function parseNameFromIdentity(identity) {
 }
 
 export {
+  readBridgesConfig,
+  getBridgeConfig,
+  setBridgeConfig,
+  removeBridgeConfig,
+  setChannelMapping,
+  removeChannelMapping,
+  resolveChannelMapping,
+  findBridgeForChannel,
   run,
   findOpenClawSession,
   sessionMatchesWorkspace,