volute 0.13.2 → 0.14.0

package/dist/{channel-JZJJRRWT.js → channel-SLURLIRV.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
-  resolveAgentName
-} from "./chunk-AZEL2IEK.js";
+  resolveMindName
+} from "./chunk-NAOW2CLO.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-VQIJUR43.js";
-import "./chunk-LGSW7T7K.js";
+} from "./chunk-OJQ47SCA.js";
+import "./chunk-M77QBTEH.js";
 import {
   getClient,
   urlOf
@@ -46,27 +46,27 @@ async function run(args) {
 }
 function printUsage() {
   console.log(`Usage:
-  volute channel read <channel-uri> [--limit N] [--agent <name>]
-  volute channel list [<platform>] [--agent <name>]
-  volute channel users <platform> [--agent <name>]
-  volute channel create <platform> --participants user1,user2 [--name "..."] [--agent <name>]
-  volute channel typing <channel-uri> [--agent <name>]`);
+  volute channel read <channel-uri> [--limit N] [--mind <name>]
+  volute channel list [<platform>] [--mind <name>]
+  volute channel users <platform> [--mind <name>]
+  volute channel create <platform> --participants user1,user2 [--name "..."] [--mind <name>]
+  volute channel typing <channel-uri> [--mind <name>]`);
 }
 async function readChannel(args) {
   const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" },
+    mind: { type: "string" },
     limit: { type: "number" }
   });
   const uri = positional[0];
   if (!uri) {
-    console.error("Usage: volute channel read <channel-uri> [--limit N] [--agent <name>]");
+    console.error("Usage: volute channel read <channel-uri> [--limit N] [--mind <name>]");
     process.exit(1);
   }
-  const agentName = resolveAgentName(flags);
+  const mindName = resolveMindName(flags);
   const { platform } = parseUri(uri);
   const limit = flags.limit ?? 20;
   const client = getClient();
-  const url = client.api.agents[":name"].channels.read.$url({ param: { name: agentName } });
+  const url = client.api.minds[":name"].channels.read.$url({ param: { name: mindName } });
   url.searchParams.set("platform", platform);
   url.searchParams.set("uri", uri);
   url.searchParams.set("limit", String(limit));
@@ -81,12 +81,12 @@ async function readChannel(args) {
 }
 async function listChannels(args) {
   const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" }
+    mind: { type: "string" }
   });
   const platform = positional[0];
-  const agentName = resolveAgentName(flags);
+  const mindName = resolveMindName(flags);
   const client = getClient();
-  const url = client.api.agents[":name"].channels.list.$url({ param: { name: agentName } });
+  const url = client.api.minds[":name"].channels.list.$url({ param: { name: mindName } });
   if (platform) url.searchParams.set("platform", platform);
   const res = await daemonFetch(urlOf(url));
   if (!res.ok) {
@@ -111,16 +111,16 @@ async function listChannels(args) {
 }
 async function listUsers(args) {
   const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" }
+    mind: { type: "string" }
   });
   const platform = positional[0];
   if (!platform) {
-    console.error("Usage: volute channel users <platform> [--agent <name>]");
+    console.error("Usage: volute channel users <platform> [--mind <name>]");
     process.exit(1);
   }
-  const agentName = resolveAgentName(flags);
+  const mindName = resolveMindName(flags);
   const client = getClient();
-  const url = client.api.agents[":name"].channels.users.$url({ param: { name: agentName } });
+  const url = client.api.minds[":name"].channels.users.$url({ param: { name: mindName } });
   url.searchParams.set("platform", platform);
   const res = await daemonFetch(urlOf(url));
   if (!res.ok) {
@@ -135,22 +135,22 @@ async function listUsers(args) {
 }
 async function createChannel(args) {
   const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" },
+    mind: { type: "string" },
     participants: { type: "string" },
     name: { type: "string" }
   });
   const platform = positional[0];
   if (!platform || !flags.participants) {
     console.error(
-      'Usage: volute channel create <platform> --participants user1,user2 [--name "..."] [--agent <name>]'
+      'Usage: volute channel create <platform> --participants user1,user2 [--name "..."] [--mind <name>]'
     );
     process.exit(1);
   }
-  const agentName = resolveAgentName(flags);
+  const mindName = resolveMindName(flags);
   const participants = flags.participants.split(",").map((s) => s.trim());
   const client = getClient();
   const res = await daemonFetch(
-    urlOf(client.api.agents[":name"].channels.create.$url({ param: { name: agentName } })),
+    urlOf(client.api.minds[":name"].channels.create.$url({ param: { name: mindName } })),
     {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -167,17 +167,17 @@ async function createChannel(args) {
 }
 async function typingChannel(args) {
   const { positional, flags } = parseArgs(args, {
-    agent: { type: "string" }
+    mind: { type: "string" }
   });
   const uri = positional[0];
   if (!uri) {
-    console.error("Usage: volute channel typing <channel-uri> [--agent <name>]");
+    console.error("Usage: volute channel typing <channel-uri> [--mind <name>]");
     process.exit(1);
   }
-  const agentName = resolveAgentName(flags);
+  const mindName = resolveMindName(flags);
   try {
     const client = getClient();
-    const url = client.api.agents[":name"].typing.$url({ param: { name: agentName } });
+    const url = client.api.minds[":name"].typing.$url({ param: { name: mindName } });
     url.searchParams.set("channel", uri);
     const res = await daemonFetch(urlOf(url));
     if (!res.ok) {

package/dist/{chunk-KRJ6KCBI.js → chunk-2Y77MCFG.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   wrapForIsolation
-} from "./chunk-NXT67PPK.js";
+} from "./chunk-ZCEYUUID.js";
 
 // src/lib/exec.ts
 import { execFile as execFileCb, execFileSync, spawn } from "child_process";
 function exec(cmd, args, options) {
-  const [wrappedCmd, wrappedArgs] = options?.agentName ? wrapForIsolation(cmd, args, options.agentName) : [cmd, args];
+  const [wrappedCmd, wrappedArgs] = options?.mindName ? wrapForIsolation(cmd, args, options.mindName) : [cmd, args];
   return new Promise((resolve, reject) => {
     execFileCb(
       wrappedCmd,
@@ -35,7 +35,7 @@ function resolveVoluteBin() {
   }
 }
 function execInherit(cmd, args, options) {
-  const [wrappedCmd, wrappedArgs] = options?.agentName ? wrapForIsolation(cmd, args, options.agentName) : [cmd, args];
+  const [wrappedCmd, wrappedArgs] = options?.mindName ? wrapForIsolation(cmd, args, options.mindName) : [cmd, args];
   return new Promise((resolve, reject) => {
     const child = spawn(wrappedCmd, wrappedArgs, {
       cwd: options?.cwd,

package/dist/{chunk-AA5TDLXB.js → chunk-3FC42ZBM.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   stateDir
-} from "./chunk-LGSW7T7K.js";
+} from "./chunk-M77QBTEH.js";
 
 // src/lib/slugify.ts
 function slugify(text) {
@@ -10,7 +10,7 @@ function slugify(text) {
 function buildVoluteSlug(opts) {
   const isDM = opts.participants.length === 2;
   if (isDM) {
-    const other = opts.participants.find((p) => p.username !== opts.agentUsername);
+    const other = opts.participants.find((p) => p.username !== opts.mindUsername);
     const otherSlug = other ? slugify(other.username) : "";
     return otherSlug ? `volute:@${otherSlug}` : `volute:${opts.conversationId}`;
   }
@@ -21,28 +21,28 @@ function buildVoluteSlug(opts) {
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join, resolve } from "path";
 function loadEnv() {
-  const agentPort = process.env.VOLUTE_AGENT_PORT;
-  const agentName = process.env.VOLUTE_AGENT_NAME;
-  if (!agentPort || !agentName) {
-    console.error("Missing required env vars: VOLUTE_AGENT_PORT, VOLUTE_AGENT_NAME");
+  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 agentDir = process.env.VOLUTE_AGENT_DIR;
+  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/agents/${encodeURIComponent(agentName)}` : `http://127.0.0.1:${agentPort}`;
-  return { agentPort, agentName, agentDir, baseUrl, daemonUrl, daemonToken };
+  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.agentDir) return [];
-  const configPath = resolve(env.agentDir, "home/.config/volute.json");
+  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 agent config: ${err}`);
+    console.warn(`Failed to load mind config: ${err}`);
     return [];
   }
 }
@@ -87,7 +87,7 @@ function reportTyping(env, channel, sender, active) {
     console.warn(`[typing] failed to report for ${sender} on ${channel}: ${err}`);
   });
 }
-async function sendToAgent(env, payload) {
+async function sendToMind(env, payload) {
   const url = `${env.baseUrl}/message`;
   try {
     const res = await fetch(url, {
@@ -97,14 +97,14 @@ async function sendToAgent(env, payload) {
     });
     if (!res.ok) {
       const body = await res.text().catch(() => "");
-      console.error(`Agent returned ${res.status}: ${body}`);
-      return { ok: false, error: `Agent returned ${res.status}` };
+      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 ? "Agent is not running" : "Failed to reach agent" };
+    return { ok: false, error: isConnRefused ? "Mind is not running" : "Failed to reach mind" };
   }
 }
 function buildChannelSlug(platform, meta) {
@@ -128,8 +128,8 @@ function buildChannelSlug(platform, meta) {
   }
   return `${platform}:unknown`;
 }
-function readChannelMap(agentName) {
-  const filePath = join(stateDir(agentName), "channels.json");
+function readChannelMap(mindName) {
+  const filePath = join(stateDir(mindName), "channels.json");
   if (!existsSync(filePath)) return {};
   try {
     return JSON.parse(readFileSync(filePath, "utf-8"));
@@ -138,16 +138,16 @@ function readChannelMap(agentName) {
     return {};
   }
 }
-function writeChannelEntry(agentName, slug, entry) {
-  const dir = stateDir(agentName);
+function writeChannelEntry(mindName, slug, entry) {
+  const dir = stateDir(mindName);
   mkdirSync(dir, { recursive: true });
   const filePath = join(dir, "channels.json");
-  const map = readChannelMap(agentName);
+  const map = readChannelMap(mindName);
   map[slug] = entry;
   writeFileSync(filePath, JSON.stringify(map, null, 2) + "\n");
 }
-function resolveChannelId(agentName, slug) {
-  const map = readChannelMap(agentName);
+function resolveChannelId(mindName, slug) {
+  const map = readChannelMap(mindName);
   if (map[slug]) {
     return map[slug].platformId;
   }
@@ -163,7 +163,7 @@ export {
   splitMessage,
   onShutdown,
   reportTyping,
-  sendToAgent,
+  sendToMind,
   buildChannelSlug,
   writeChannelEntry,
   resolveChannelId

package/dist/{chunk-YYUSXARD.js → chunk-6BDNWYKG.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   execInherit
-} from "./chunk-KRJ6KCBI.js";
+} from "./chunk-2Y77MCFG.js";
 import {
   voluteHome
-} from "./chunk-LGSW7T7K.js";
+} from "./chunk-M77QBTEH.js";
 
 // src/lib/service-mode.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-KN4WBLH2.js → chunk-GR3OG4QK.js}

@@ -4,13 +4,13 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-YYUSXARD.js";
+} from "./chunk-6BDNWYKG.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   voluteHome
-} from "./chunk-LGSW7T7K.js";
+} from "./chunk-M77QBTEH.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";

package/dist/{chunk-FE5O5RSL.js → chunk-GSPWIM5E.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
-  agentEnvPath,
+  mindEnvPath,
   readEnv,
   writeEnv
-} from "./chunk-O4BN3ZIY.js";
+} from "./chunk-OYSZNX5I.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
@@ -24,12 +24,12 @@ function readJson(path) {
     return null;
   }
 }
-function readVoluteConfig(agentDir) {
-  const path = resolve(agentDir, "home/.config/volute.json");
+function readVoluteConfig(mindDir) {
+  const path = resolve(mindDir, "home/.config/volute.json");
   return readJson(path);
 }
-function writeVoluteConfig(agentDir, config) {
-  const path = resolve(agentDir, "home/.config/volute.json");
+function writeVoluteConfig(mindDir, config) {
+  const path = resolve(mindDir, "home/.config/volute.json");
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(config, null, 2)}
 `);
@@ -43,10 +43,10 @@ async function run(args) {
     template: { type: "string" }
   });
   const wsDir = resolveWorkspace(positional[0]);
-  const { daemonFetch } = await import("./daemon-client-DEF7IFEJ.js");
+  const { daemonFetch } = await import("./daemon-client-ODKDUYDE.js");
   const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
   const client = getClient();
-  const res = await daemonFetch(urlOf(client.api.agents.import.$url()), {
+  const res = await daemonFetch(urlOf(client.api.minds.import.$url()), {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
@@ -58,13 +58,13 @@ async function run(args) {
   });
   const data = await res.json();
   if (!res.ok) {
-    console.error(data.error ?? "Failed to import agent");
+    console.error(data.error ?? "Failed to import mind");
     process.exit(1);
   }
   console.log(`
-${data.message ?? `Imported agent: ${data.name} (port ${data.port})`}`);
+${data.message ?? `Imported mind: ${data.name} (port ${data.port})`}`);
   console.log(`
-  volute agent start ${data.name}`);
+  volute mind start ${data.name}`);
 }
 function resolveWorkspace(explicitPath) {
   if (explicitPath) {
@@ -86,17 +86,17 @@ function resolveWorkspace(explicitPath) {
     return openclawWs;
   }
   console.error(
-    "Usage: volute agent import [<workspace-path>] [--name <name>] [--session <path>] [--template <name>]\n\nNo OpenClaw workspace found. Provide a path, run from a workspace, or ensure ~/.openclaw/workspace exists."
+    "Usage: volute mind import [<workspace-path>] [--name <name>] [--session <path>] [--template <name>]\n\nNo OpenClaw workspace found. Provide a path, run from a workspace, or ensure ~/.openclaw/workspace exists."
   );
   process.exit(1);
 }
 function findOpenClawSession(workspaceDir) {
-  const agentsDir = resolve2(homedir(), ".openclaw/agents");
-  if (!existsSync2(agentsDir)) return void 0;
+  const ocAgentsDir = resolve2(homedir(), ".openclaw/agents");
+  if (!existsSync2(ocAgentsDir)) return void 0;
   const matches = [];
   try {
-    for (const agent of readdirSync(agentsDir)) {
-      const sessionsDir = resolve2(agentsDir, agent, "sessions");
+    for (const entry of readdirSync(ocAgentsDir)) {
+      const sessionsDir = resolve2(ocAgentsDir, entry, "sessions");
       if (!existsSync2(sessionsDir)) continue;
       for (const file of readdirSync(sessionsDir)) {
         if (!file.endsWith(".jsonl")) continue;
@@ -125,9 +125,9 @@ function sessionMatchesWorkspace(sessionPath, workspaceDir) {
     return false;
   }
 }
-function importPiSession(sessionFile, agentDirPath) {
-  const homeDir = resolve2(agentDirPath, "home");
-  const piSessionDir = resolve2(agentDirPath, ".volute/pi-sessions/main");
+function importPiSession(sessionFile, mindDirPath) {
+  const homeDir = resolve2(mindDirPath, "home");
+  const piSessionDir = resolve2(mindDirPath, ".volute/pi-sessions/main");
   mkdirSync2(piSessionDir, { recursive: true });
   const content = readFileSync2(sessionFile, "utf-8");
   const lines = content.trim().split("\n");
@@ -145,7 +145,7 @@ function importPiSession(sessionFile, agentDirPath) {
 `);
   console.log(`Imported session (${lines.length} entries)`);
 }
-function importOpenClawConnectors(agentName, agentDirPath) {
+function importOpenClawConnectors(name, mindDirPath) {
   const configPath = resolve2(homedir(), ".openclaw/openclaw.json");
   if (!existsSync2(configPath)) return;
   let config;
@@ -157,7 +157,7 @@ function importOpenClawConnectors(agentName, agentDirPath) {
   }
   const discord = config.channels?.discord;
   if (!discord?.enabled || !discord.token) return;
-  const envPath = agentEnvPath(agentName);
+  const envPath = mindEnvPath(name);
   const env = readEnv(envPath);
   env.DISCORD_TOKEN = discord.token;
   writeEnv(envPath, env);
@@ -165,19 +165,19 @@ function importOpenClawConnectors(agentName, agentDirPath) {
   if (discord.guilds) {
     for (const guild of Object.values(discord.guilds)) {
       if (!guild.channels) continue;
-      for (const [name, ch] of Object.entries(guild.channels)) {
-        if (ch.allow) channelNames.add(name);
+      for (const [name2, ch] of Object.entries(guild.channels)) {
+        if (ch.allow) channelNames.add(name2);
       }
     }
   }
-  const voluteConfig = readVoluteConfig(agentDirPath) ?? {};
+  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(agentDirPath, voluteConfig);
+  writeVoluteConfig(mindDirPath, voluteConfig);
   console.log("Imported Discord connector config");
   if (channelNames.size > 0) {
     console.log(`Imported followed channels: ${[...channelNames].join(", ")}`);