volute 0.9.0 → 0.10.0

package/dist/{agent-MB3OTRRK.js → agent-ECRX44DB.js}

@@ -6,7 +6,7 @@ async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
     case "create":
-      await import("./create-HGJHLABX.js").then((m) => m.run(args.slice(1)));
+      await import("./create-VBZZNJOG.js").then((m) => m.run(args.slice(1)));
       break;
     case "start":
       await import("./start-6YRS6FF6.js").then((m) => m.run(args.slice(1)));
@@ -18,7 +18,7 @@ async function run(args) {
       await import("./restart-CCYM3MEC.js").then((m) => m.run(args.slice(1)));
       break;
     case "delete":
-      await import("./delete-WKQKE3FT.js").then((m) => m.run(args.slice(1)));
+      await import("./delete-BOTVU4YO.js").then((m) => m.run(args.slice(1)));
       break;
     case "list":
       await import("./status-SIMKH3ZE.js").then((m) => m.run(args.slice(1)));
@@ -34,14 +34,14 @@ async function run(args) {
     case "logs": {
       const rest = args.slice(1);
       const logsArgs = transformAgentFlag(rest);
-      await import("./logs-V54B6QSG.js").then((m) => m.run(logsArgs));
+      await import("./logs-APWVWGNX.js").then((m) => m.run(logsArgs));
       break;
     }
     case "upgrade":
-      await import("./upgrade-BRNMSQBX.js").then((m) => m.run(args.slice(1)));
+      await import("./upgrade-RSE4CZNE.js").then((m) => m.run(args.slice(1)));
       break;
     case "import":
-      await import("./import-CNEDF3TD.js").then((m) => m.run(args.slice(1)));
+      await import("./import-2BZUWT23.js").then((m) => m.run(args.slice(1)));
       break;
     case "--help":
     case "-h":

package/dist/{agent-manager-CMMH5KQQ.js → agent-manager-MRHHKAB6.js}

@@ -3,9 +3,9 @@ import {
   AgentManager,
   getAgentManager,
   initAgentManager
-} from "./chunk-W6TMWYU3.js";
-import "./chunk-QF22MYDJ.js";
+} from "./chunk-WV4W7BAT.js";
 import "./chunk-IQXBMFZG.js";
+import "./chunk-QF22MYDJ.js";
 import "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/{chunk-YNNK4QN2.js → chunk-FYQGANL6.js}

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-STOEJOJO.js";
 import {
   voluteHome
 } from "./chunk-DP2DX4WV.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
 
 // src/commands/down.ts
 import { execFileSync } from "child_process";
@@ -112,8 +119,39 @@ async function run(_args) {
   const result = await stopDaemon();
   if (result.stopped) return;
   if (result.reason === "systemd") {
-    console.error("Volute is managed by a systemd service.");
-    console.error("Use: sudo systemctl stop volute");
+    const client = getClient();
+    await daemonFetch(urlOf(client.api.system.stop.$url()), { method: "POST" });
+    const home = voluteHome();
+    const configPath = resolve(home, "daemon.json");
+    let hostname = "localhost";
+    let port = 4200;
+    if (existsSync(configPath)) {
+      try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        hostname = config.hostname || "localhost";
+        port = config.port ?? 4200;
+      } catch {
+      }
+    }
+    if (hostname === "0.0.0.0") hostname = "127.0.0.1";
+    if (hostname === "::") hostname = "[::1]";
+    const url = new URL("http://localhost");
+    url.hostname = hostname;
+    url.port = String(port);
+    const healthUrl = `${url.origin}/api/health`;
+    const maxWait = 1e4;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+      await new Promise((r) => setTimeout(r, 500));
+      try {
+        await fetch(healthUrl);
+      } catch {
+        console.log("Daemon stopped.");
+        return;
+      }
+    }
+    console.error("Daemon may not have stopped. Check with: volute service status");
+    process.exit(1);
   } else if (result.reason === "orphan") {
     console.error(`Daemon appears to be running on port ${result.port} but PID file is missing.`);
     console.error(`Kill the process manually: lsof -ti :${result.port} | xargs kill`);

package/dist/chunk-R3VB7NF5.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import {
+  agentEnvPath,
+  readEnv,
+  writeEnv
+} from "./chunk-QF22MYDJ.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+
+// src/commands/import.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { basename, resolve as resolve2 } from "path";
+
+// src/lib/volute-config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+function readJson(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readVoluteConfig(agentDir) {
+  const path = resolve(agentDir, "home/.config/volute.json");
+  return readJson(path);
+}
+function writeVoluteConfig(agentDir, config) {
+  const path = resolve(agentDir, "home/.config/volute.json");
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+}
+
+// src/commands/import.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    name: { type: "string" },
+    session: { type: "string" },
+    template: { type: "string" }
+  });
+  const wsDir = resolveWorkspace(positional[0]);
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(urlOf(client.api.agents.import.$url()), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      workspacePath: wsDir,
+      name: flags.name,
+      template: flags.template,
+      sessionPath: flags.session
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to import agent");
+    process.exit(1);
+  }
+  console.log(`
+${data.message ?? `Imported agent: ${data.name} (port ${data.port})`}`);
+  console.log(`
+  volute agent start ${data.name}`);
+}
+function resolveWorkspace(explicitPath) {
+  if (explicitPath) {
+    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 (existsSync2(resolve2(cwd, "SOUL.md")) && existsSync2(resolve2(cwd, "IDENTITY.md"))) {
+    console.log(`Using workspace: ${cwd}`);
+    return cwd;
+  }
+  const openclawWs = resolve2(homedir(), ".openclaw/workspace");
+  if (existsSync2(resolve2(openclawWs, "SOUL.md")) && existsSync2(resolve2(openclawWs, "IDENTITY.md"))) {
+    console.log(`Using workspace: ${openclawWs}`);
+    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."
+  );
+  process.exit(1);
+}
+function findOpenClawSession(workspaceDir) {
+  const agentsDir = resolve2(homedir(), ".openclaw/agents");
+  if (!existsSync2(agentsDir)) return void 0;
+  const matches = [];
+  try {
+    for (const agent of readdirSync(agentsDir)) {
+      const sessionsDir = resolve2(agentsDir, agent, "sessions");
+      if (!existsSync2(sessionsDir)) continue;
+      for (const file of readdirSync(sessionsDir)) {
+        if (!file.endsWith(".jsonl")) continue;
+        const fullPath = resolve2(sessionsDir, file);
+        if (sessionMatchesWorkspace(fullPath, workspaceDir)) {
+          matches.push({ path: fullPath, mtime: statSync(fullPath).mtimeMs });
+        }
+      }
+    }
+  } catch (err) {
+    console.warn("Warning: error scanning OpenClaw sessions:", err);
+    return void 0;
+  }
+  if (matches.length === 0) return void 0;
+  matches.sort((a, b) => b.mtime - a.mtime);
+  console.log(`Found session: ${matches[0].path}`);
+  return matches[0].path;
+}
+function sessionMatchesWorkspace(sessionPath, workspaceDir) {
+  try {
+    const fd = readFileSync2(sessionPath, "utf-8");
+    const firstLine = fd.slice(0, fd.indexOf("\n"));
+    const header = JSON.parse(firstLine);
+    return header.type === "session" && resolve2(header.cwd) === resolve2(workspaceDir);
+  } catch {
+    return false;
+  }
+}
+function importPiSession(sessionFile, agentDirPath) {
+  const homeDir = resolve2(agentDirPath, "home");
+  const piSessionDir = resolve2(agentDirPath, ".volute/pi-sessions/main");
+  mkdirSync2(piSessionDir, { recursive: true });
+  const content = readFileSync2(sessionFile, "utf-8");
+  const lines = content.trim().split("\n");
+  try {
+    const header = JSON.parse(lines[0]);
+    if (header.type === "session") {
+      header.cwd = homeDir;
+      lines[0] = JSON.stringify(header);
+    }
+  } catch {
+  }
+  const filename = basename(sessionFile);
+  const destPath = resolve2(piSessionDir, filename);
+  writeFileSync2(destPath, `${lines.join("\n")}
+`);
+  console.log(`Imported session (${lines.length} entries)`);
+}
+function importOpenClawConnectors(agentName, agentDirPath) {
+  const configPath = resolve2(homedir(), ".openclaw/openclaw.json");
+  if (!existsSync2(configPath)) return;
+  let config;
+  try {
+    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 = agentEnvPath(agentName);
+  const env = readEnv(envPath);
+  env.DISCORD_TOKEN = discord.token;
+  writeEnv(envPath, env);
+  const channelNames = /* @__PURE__ */ new Set();
+  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);
+      }
+    }
+  }
+  const voluteConfig = readVoluteConfig(agentDirPath) ?? {};
+  const connectors = new Set(voluteConfig.connectors ?? []);
+  connectors.add("discord");
+  voluteConfig.connectors = [...connectors];
+  if (channelNames.size > 0) {
+    voluteConfig.discord = { channels: [...channelNames] };
+  }
+  writeVoluteConfig(agentDirPath, voluteConfig);
+  console.log("Imported Discord connector config");
+  if (channelNames.size > 0) {
+    console.log(`Imported followed channels: ${[...channelNames].join(", ")}`);
+  }
+}
+function parseNameFromIdentity(identity) {
+  const match = identity.match(/\*\*Name:\*\*\s*(.+)/);
+  if (match) {
+    const raw = match[1].trim();
+    if (!raw || raw.startsWith("*") || raw.startsWith("(")) return void 0;
+    return raw.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9.-]/g, "");
+  }
+  return void 0;
+}
+
+export {
+  readVoluteConfig,
+  writeVoluteConfig,
+  run,
+  findOpenClawSession,
+  sessionMatchesWorkspace,
+  importPiSession,
+  importOpenClawConnectors,
+  parseNameFromIdentity
+};

package/dist/cli.js

@@ -9,49 +9,49 @@ 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-WPX6LCYE.js");
+  const { default: pkg } = await import("./package-ERGXEDAF.js");
   console.log(pkg.version);
   process.exit(0);
 }
 switch (command) {
   case "agent":
-    await import("./agent-MB3OTRRK.js").then((m) => m.run(args));
+    await import("./agent-ECRX44DB.js").then((m) => m.run(args));
     break;
   case "send":
-    await import("./send-TFZ62XPZ.js").then((m) => m.run(args));
+    await import("./send-X6OQGSD6.js").then((m) => m.run(args));
     break;
   case "history":
-    await import("./history-SH25BAA5.js").then((m) => m.run(args));
+    await import("./history-NI5QP27M.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-AQRAN6FR.js").then((m) => m.run(args));
+    await import("./variant-7IZF6OWO.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-PK7D5GTN.js").then((m) => m.run(args));
+    await import("./connector-L2HBLZBW.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-G5D4VBXY.js").then((m) => m.run(args));
+    await import("./channel-2WHBRDTD.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-XGBUF7NU.js").then((m) => m.run(args));
+    await import("./schedule-E4MFGYSA.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-HZMZSWWD.js").then((m) => m.run(args));
+    await import("./env-CGORIKVF.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-J7AHQHIM.js").then((m) => m.run(args));
+    await import("./up-MNNPCMFF.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-4DGRZRJU.js").then((m) => m.run(args));
+    await import("./down-4LIQG3CE.js").then((m) => m.run(args));
     break;
   case "restart":
-    await import("./daemon-restart-EKDXXHKH.js").then((m) => m.run(args));
+    await import("./daemon-restart-QCLR6ZZV.js").then((m) => m.run(args));
     break;
   case "setup":
-    await import("./setup-7SPMWF2O.js").then((m) => m.run(args));
+    await import("./setup-ABMZK6LS.js").then((m) => m.run(args));
     break;
   case "service":
-    await import("./service-56CY4S6Z.js").then((m) => m.run(args));
+    await import("./service-OW35VZ5G.js").then((m) => m.run(args));
     break;
   case "update":
     await import("./update-3TGXUTO2.js").then((m) => m.run(args));

package/dist/create-VBZZNJOG.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/create.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    template: { type: "string" }
+  });
+  const name = positional[0];
+  const template = flags.template ?? "agent-sdk";
+  if (!name) {
+    console.error("Usage: volute agent create <name> [--template <name>]");
+    process.exit(1);
+  }
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(urlOf(client.api.agents.$url()), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name, template })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to create agent");
+    process.exit(1);
+  }
+  console.log(`
+${data.message ?? `Created agent: ${data.name} (port ${data.port})`}`);
+  console.log(`
+  volute agent start ${data.name ?? name}`);
+}
+export {
+  run
+};

package/dist/daemon-restart-QCLR6ZZV.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import {
+  run
+} from "./chunk-4NAGJV3I.js";
+import {
+  stopDaemon
+} from "./chunk-FYQGANL6.js";
+import "./chunk-D424ZQGI.js";
+import {
+  daemonFetch
+} from "./chunk-STOEJOJO.js";
+import {
+  voluteHome
+} from "./chunk-DP2DX4WV.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/daemon-restart.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+async function run2(args) {
+  const result = await stopDaemon();
+  if (!result.stopped && result.reason === "systemd") {
+    const client = getClient();
+    await daemonFetch(urlOf(client.api.system.restart.$url()), { method: "POST" });
+    const config = JSON.parse(readFileSync(resolve(voluteHome(), "daemon.json"), "utf-8"));
+    let hostname = config.hostname || "localhost";
+    if (hostname === "0.0.0.0") hostname = "127.0.0.1";
+    if (hostname === "::") hostname = "[::1]";
+    const url = new URL("http://localhost");
+    url.hostname = hostname;
+    url.port = String(config.port ?? 4200);
+    const healthUrl = `${url.origin}/api/health`;
+    const maxWait = 15e3;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+      try {
+        const res = await fetch(healthUrl);
+        if (res.ok) {
+          console.log("Daemon restarted.");
+          return;
+        }
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    console.error("Daemon did not restart within 15s. Check logs.");
+    process.exit(1);
+  }
+  if (!result.stopped && result.reason === "kill-failed") {
+    console.error("Cannot restart: failed to stop the running daemon.");
+    process.exit(1);
+  }
+  await run(args);
+}
+export {
+  run2 as run
+};