volute 0.33.0 → 0.35.0

package/dist/db-BDMH4SZ2.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import {
+  getAllSites,
+  getPublishedPages,
+  getRecentPages,
+  getSystemPages,
+  initDb,
+  syncPublishedPages,
+  syncSystemPages
+} from "./chunk-QHG4OMZL.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  getAllSites,
+  getPublishedPages,
+  getRecentPages,
+  getSystemPages,
+  initDb,
+  syncPublishedPages,
+  syncSystemPages
+};

package/dist/db-BVBJ57TU.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  getDb
+} from "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  getDb
+};

package/dist/delete-L5PAVDGQ.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import {
+  resolveMindName
+} from "./chunk-BTY4WNFE.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/delete.ts
+var cmd = command({
+  name: "volute mind delete",
+  description: "Delete a mind from the registry",
+  args: [{ name: "name", description: "Mind to delete (or use VOLUTE_MIND)" }],
+  flags: {
+    force: { type: "boolean", description: "Also delete the mind's directory" }
+  },
+  async run({ args, flags }) {
+    const name = resolveMindName({ mind: args.name });
+    const { daemonFetch } = await import("./daemon-client-RVIKXGFQ.js");
+    const { getClient, urlOf } = await import("./api-client-3A77HMH7.js");
+    const client = getClient();
+    const url = urlOf(client.api.minds[":name"].$url({ param: { name } })) + (flags.force ? "?force=true" : "");
+    const res = await daemonFetch(url, { method: "DELETE" });
+    const data = await res.json();
+    if (!res.ok) {
+      console.error(data.error ?? "Failed to delete mind");
+      process.exit(1);
+    }
+    console.log(`Removed ${name}.`);
+    if (flags.force) {
+      console.log("Deleted mind directory.");
+    } else {
+      console.log("Use --force to also delete the mind directory.");
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/delivery-manager-H5ZVBMCQ.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import {
+  DeliveryManager,
+  getDeliveryManager,
+  initDeliveryManager
+} from "./chunk-WJPROOU5.js";
+import "./chunk-5XJYUFZH.js";
+import "./chunk-AOB6GVRM.js";
+import "./chunk-IJHIXLVN.js";
+import "./chunk-QWTR6AWZ.js";
+import "./chunk-N446KRP7.js";
+import "./chunk-QHG4OMZL.js";
+import "./chunk-XRQSAMX2.js";
+import "./chunk-WZRZFFCL.js";
+import "./chunk-CORXD635.js";
+import "./chunk-ZSR72JB3.js";
+import "./chunk-PWQ2ITYG.js";
+import "./chunk-A2ZLHBHG.js";
+import "./chunk-FT5KETXZ.js";
+import "./chunk-BKF4WQCY.js";
+import "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BMZQYACC.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  DeliveryManager,
+  getDeliveryManager,
+  initDeliveryManager
+};

package/dist/{delivery-router-FL45JL7N.js → delivery-router-HEJSJAHQ.js}

@@ -6,11 +6,11 @@ import {
   registerMindDir,
   resolveDeliveryMode,
   resolveRoute
-} from "./chunk-SKLSMHXO.js";
-import "./chunk-YUIHSKR6.js";
-import "./chunk-LRCG2JLP.js";
-import "./chunk-RPZZSXV3.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-QWTR6AWZ.js";
+import "./chunk-BKF4WQCY.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
 export {
   clearConfigCache,
   extractTextContent,

package/dist/down-74VXM45A.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  run,
+  stopDaemon
+} from "./chunk-J6CJQDWI.js";
+import "./chunk-2TGZJFAT.js";
+import "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  run,
+  stopDaemon
+};

package/dist/env-E4XHO2BI.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+import {
+  isCompact
+} from "./chunk-5T5YMX6S.js";
+import {
+  promptLine
+} from "./chunk-VHWGEJ4V.js";
+import {
+  command,
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  daemonFetch
+} from "./chunk-ZX7EAV5J.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/env.ts
+function maskValue(value) {
+  if (value.length <= 6) return "***";
+  return `${value.slice(0, 3)}...${value.slice(-3)}`;
+}
+var envSetCmd = command({
+  name: "volute env set",
+  description: "Set an environment variable",
+  args: [
+    { name: "key", required: true, description: "Variable name" },
+    { name: "value", description: "Variable value (prompts if omitted)" }
+  ],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const client = getClient();
+    const key = args.key;
+    const value = args.value ?? await promptLine(`Enter value for ${key}: `);
+    let res;
+    if (flags.mind) {
+      res = await daemonFetch(
+        urlOf(
+          client.api.minds[":name"].env[":key"].$url({
+            param: { name: flags.mind, key }
+          })
+        ),
+        {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ value })
+        }
+      );
+    } else {
+      res = await daemonFetch(urlOf(client.api.env[":key"].$url({ param: { key } })), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ value })
+      });
+    }
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(body.error ?? `Failed to set ${key}`);
+      process.exit(1);
+    }
+    const scope = flags.mind ? `mind:${flags.mind}` : "shared";
+    console.log(`Set ${key} [${scope}]`);
+  }
+});
+var envGetCmd = command({
+  name: "volute env get",
+  description: "Get an environment variable value",
+  args: [{ name: "key", required: true, description: "Variable name" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const client = getClient();
+    const key = args.key;
+    if (flags.mind) {
+      const res = await daemonFetch(
+        urlOf(
+          client.api.minds[":name"].env[":key"].$url({
+            param: { name: flags.mind, key }
+          })
+        )
+      );
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        console.error(body.error ?? `${key} not set`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      console.log(data.value);
+    } else {
+      const res = await daemonFetch(urlOf(client.api.env.$url()));
+      if (!res.ok) {
+        console.error(`Failed to read shared env`);
+        process.exit(1);
+      }
+      const env = await res.json();
+      if (key in env) {
+        console.log(env[key]);
+      } else {
+        console.error(`${key} not set`);
+        process.exit(1);
+      }
+    }
+  }
+});
+var envListCmd = command({
+  name: "volute env list",
+  description: "List environment variables",
+  args: [],
+  flags: {
+    mind: { type: "string", description: "Mind name" },
+    reveal: { type: "boolean", description: "Show values unmasked" }
+  },
+  run: async ({ flags }) => {
+    const client = getClient();
+    const compact = isCompact();
+    if (flags.mind) {
+      const res = await daemonFetch(
+        urlOf(client.api.minds[":name"].env.$url({ param: { name: flags.mind } }))
+      );
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        console.error(body.error ?? "Failed to list env");
+        process.exit(1);
+      }
+      const data = await res.json();
+      const allKeys = /* @__PURE__ */ new Set([...Object.keys(data.shared), ...Object.keys(data.mind)]);
+      if (allKeys.size === 0) {
+        console.log("No environment variables set.");
+        return;
+      }
+      for (const key of [...allKeys].sort()) {
+        const scope = key in data.mind ? "mind" : "shared";
+        const raw = key in data.mind ? data.mind[key] : data.shared[key];
+        const value = flags.reveal ? raw : maskValue(raw);
+        console.log(compact ? `${key}=${value}` : `${key}=${value} [${scope}]`);
+      }
+    } else {
+      const res = await daemonFetch(urlOf(client.api.env.$url()));
+      if (!res.ok) {
+        console.error("Failed to list shared env");
+        process.exit(1);
+      }
+      const env = await res.json();
+      const keys = Object.keys(env);
+      if (keys.length === 0) {
+        console.log("No shared environment variables set.");
+        return;
+      }
+      for (const key of keys.sort()) {
+        const value = flags.reveal ? env[key] : maskValue(env[key]);
+        console.log(compact ? `${key}=${value}` : `${key}=${value} [shared]`);
+      }
+    }
+  }
+});
+var envRemoveCmd = command({
+  name: "volute env remove",
+  description: "Remove an environment variable",
+  args: [{ name: "key", required: true, description: "Variable name" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const client = getClient();
+    const key = args.key;
+    let res;
+    if (flags.mind) {
+      res = await daemonFetch(
+        urlOf(
+          client.api.minds[":name"].env[":key"].$url({
+            param: { name: flags.mind, key }
+          })
+        ),
+        { method: "DELETE" }
+      );
+    } else {
+      res = await daemonFetch(urlOf(client.api.env[":key"].$url({ param: { key } })), {
+        method: "DELETE"
+      });
+    }
+    if (!res.ok) {
+      const scope2 = flags.mind ? `mind:${flags.mind}` : "shared";
+      console.error(`${key} not set in ${scope2} scope`);
+      process.exit(1);
+    }
+    const scope = flags.mind ? `mind:${flags.mind}` : "shared";
+    console.log(`Removed ${key} [${scope}]`);
+  }
+});
+var cmd = subcommands({
+  name: "volute env",
+  description: "Manage environment variables",
+  commands: {
+    set: {
+      description: "Set an environment variable",
+      run: envSetCmd.execute
+    },
+    get: {
+      description: "Get an environment variable",
+      run: envGetCmd.execute
+    },
+    list: {
+      description: "List environment variables",
+      run: envListCmd.execute
+    },
+    remove: {
+      description: "Remove an environment variable",
+      run: envRemoveCmd.execute
+    }
+  },
+  footer: "Use --mind <name> or VOLUTE_MIND for mind-scoped variables."
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/exec-PY7THYH4.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  exec,
+  execInherit,
+  gitExec,
+  resolveVoluteBin
+} from "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  exec,
+  execInherit,
+  gitExec,
+  resolveVoluteBin
+};

package/dist/export-OAS6QVBN.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  addHistoryToArchive,
+  createExportArchive
+} from "./chunk-N5LMGYXX.js";
+import {
+  findMind,
+  mindDir
+} from "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/export.ts
+import { existsSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var cmd = command({
+  name: "volute mind export",
+  description: "Export a mind to an archive",
+  args: [{ name: "name", required: true, description: "Mind to export" }],
+  flags: {
+    "include-env": { type: "boolean", description: "Include environment variables" },
+    "include-identity": { type: "boolean", description: "Include identity keys" },
+    "include-connectors": { type: "boolean", description: "Include connector configs" },
+    "include-history": { type: "boolean", description: "Include message history" },
+    "include-sessions": { type: "boolean", description: "Include session data" },
+    "include-src": { type: "boolean", description: "Include source code" },
+    all: { type: "boolean", description: "Include everything" },
+    output: { type: "string", description: "Output file path" }
+  },
+  run: async ({ args, flags }) => {
+    const name = args.name;
+    const entry = await findMind(name);
+    if (!entry) {
+      console.error(`Unknown mind: ${name}`);
+      process.exit(1);
+    }
+    const dir = mindDir(name);
+    if (!existsSync(dir)) {
+      console.error(`Mind directory missing: ${dir}`);
+      process.exit(1);
+    }
+    const includeAll = flags.all;
+    const includeEnv = includeAll || flags["include-env"];
+    const includeIdentity = includeAll || flags["include-identity"];
+    const includeConnectors = includeAll || flags["include-connectors"];
+    const includeHistory = includeAll || flags["include-history"];
+    const includeSessions = includeAll || flags["include-sessions"];
+    const includeSrc = includeAll || flags["include-src"];
+    const zip = createExportArchive({
+      name,
+      template: entry.template ?? "claude",
+      stage: entry.stage,
+      includeSrc,
+      includeEnv,
+      includeIdentity,
+      includeConnectors,
+      includeHistory,
+      includeSessions
+    });
+    if (includeHistory) {
+      try {
+        const { daemonFetch } = await import("./daemon-client-RVIKXGFQ.js");
+        const { getClient, urlOf } = await import("./api-client-3A77HMH7.js");
+        const client = getClient();
+        const res = await daemonFetch(
+          urlOf(client.api.minds[":name"].history.export.$url({ param: { name } }))
+        );
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw new Error(`Failed to fetch history: HTTP ${res.status}${text ? ` - ${text}` : ""}`);
+        }
+        const rows = await res.json();
+        addHistoryToArchive(zip, rows);
+      } catch (err) {
+        console.error(`Error: could not export history: ${err.message}`);
+        process.exit(1);
+      }
+    }
+    const outputPath = resolve(flags.output ?? `${name}.volute`);
+    const buf = zip.toBuffer();
+    try {
+      writeFileSync(outputPath, buf);
+    } catch (err) {
+      console.error(`Failed to write archive to ${outputPath}: ${err.message}`);
+      process.exit(1);
+    }
+    const sizeMB = (buf.length / 1024 / 1024).toFixed(2);
+    console.log(`
+Exported ${name} \u2192 ${outputPath} (${sizeMB} MB)`);
+    const included = [];
+    const excluded = [];
+    for (const [key, val] of [
+      ["src", includeSrc],
+      ["env", includeEnv],
+      ["identity", includeIdentity],
+      ["connectors", includeConnectors],
+      ["history", includeHistory],
+      ["sessions", includeSessions]
+    ]) {
+      (val ? included : excluded).push(key);
+    }
+    if (included.length > 0) console.log(`  Included: ${included.join(", ")}`);
+    if (excluded.length > 0) console.log(`  Excluded: ${excluded.join(", ")}`);
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/extension-D74CNM7G.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import {
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  daemonFetch
+} from "./chunk-ZX7EAV5J.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/extension.ts
+async function listExtensions() {
+  const res = await daemonFetch("/api/extensions/all");
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    console.error(`Error: ${body.error}`);
+    process.exit(1);
+  }
+  const extensions = await res.json();
+  if (extensions.length === 0) {
+    console.log("No extensions found.");
+    return;
+  }
+  console.log("Extensions:\n");
+  for (const ext of extensions) {
+    const status = ext.enabled ? "enabled" : "disabled";
+    console.log(`  ${ext.id} \u2014 ${ext.name} v${ext.version} (${ext.source}, ${status})`);
+    if (ext.description) console.log(`    ${ext.description}`);
+  }
+}
+async function installExtension(args) {
+  const pkg = args[0];
+  if (!pkg) {
+    console.error("Usage: volute extension install <package>");
+    process.exit(1);
+  }
+  console.log(`Installing "${pkg}"...`);
+  const res = await daemonFetch("/api/extensions/install", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ package: pkg })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    console.error(`Failed to install "${pkg}": ${body.error}`);
+    process.exit(1);
+  }
+  console.log(`Installed "${pkg}".`);
+  console.log("Restart the daemon (`volute restart`) to load the extension.");
+}
+async function uninstallExtension(args) {
+  const pkg = args[0];
+  if (!pkg) {
+    console.error("Usage: volute extension uninstall <package>");
+    process.exit(1);
+  }
+  const res = await daemonFetch(`/api/extensions/uninstall/${encodeURIComponent(pkg)}`, {
+    method: "DELETE"
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    console.error(`Failed to uninstall "${pkg}": ${body.error}`);
+    process.exit(1);
+  }
+  console.log(`Removed "${pkg}".`);
+  console.log("Restart the daemon (`volute restart`) to unload the extension.");
+}
+var cmd = subcommands({
+  name: "volute extension",
+  description: "Manage extensions",
+  commands: {
+    list: {
+      description: "List installed extensions",
+      run: async () => listExtensions()
+    },
+    install: {
+      description: "Install a third-party extension",
+      run: installExtension
+    },
+    uninstall: {
+      description: "Uninstall a third-party extension",
+      run: uninstallExtension
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/extensions-XDDFY72A.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import {
+  getAllDiscoveredExtensions,
+  getExtensionStandardSkills,
+  getLoadedExtensions,
+  installNpmExtension,
+  loadAllExtensions,
+  notifyExtensionsDaemonStart,
+  notifyExtensionsDaemonStop,
+  notifyExtensionsMindStart,
+  notifyExtensionsMindStop,
+  parseCommandArgs,
+  setExtensionEnabled,
+  uninstallNpmExtension
+} from "./chunk-WJPROOU5.js";
+import "./chunk-5XJYUFZH.js";
+import "./chunk-AOB6GVRM.js";
+import "./chunk-IJHIXLVN.js";
+import "./chunk-QWTR6AWZ.js";
+import "./chunk-N446KRP7.js";
+import "./chunk-QHG4OMZL.js";
+import "./chunk-XRQSAMX2.js";
+import "./chunk-WZRZFFCL.js";
+import "./chunk-CORXD635.js";
+import "./chunk-ZSR72JB3.js";
+import "./chunk-PWQ2ITYG.js";
+import "./chunk-A2ZLHBHG.js";
+import "./chunk-FT5KETXZ.js";
+import "./chunk-BKF4WQCY.js";
+import "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BMZQYACC.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  getAllDiscoveredExtensions,
+  getExtensionStandardSkills,
+  getLoadedExtensions,
+  installNpmExtension,
+  loadAllExtensions,
+  notifyExtensionsDaemonStart,
+  notifyExtensionsDaemonStop,
+  notifyExtensionsMindStart,
+  notifyExtensionsMindStop,
+  parseCommandArgs,
+  setExtensionEnabled,
+  uninstallNpmExtension
+};

package/dist/files-CWTK6V3H.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import {
+  resolveMindName
+} from "./chunk-BTY4WNFE.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  daemonFetch
+} from "./chunk-ZX7EAV5J.js";
+import {
+  formatFileSize
+} from "./chunk-BV65KRHM.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/chat/files.ts
+var cmd = command({
+  name: "volute chat files",
+  description: "List pending incoming files",
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  async run({ flags }) {
+    const mind = resolveMindName(flags);
+    const res = await daemonFetch(`/api/minds/${encodeURIComponent(mind)}/files/pending`);
+    if (!res.ok) {
+      const data = await res.json();
+      console.error(data.error ?? `Failed to list pending files: ${res.status}`);
+      process.exit(1);
+    }
+    const pending = await res.json();
+    if (pending.length === 0) {
+      console.log("No pending files.");
+      return;
+    }
+    const idW = Math.max(2, ...pending.map((p) => p.id.length));
+    const senderW = Math.max(6, ...pending.map((p) => p.sender.length));
+    const fileW = Math.max(4, ...pending.map((p) => p.filename.length));
+    console.log(`${"ID".padEnd(idW)}  ${"SENDER".padEnd(senderW)}  ${"FILE".padEnd(fileW)}  SIZE`);
+    for (const p of pending) {
+      console.log(
+        `${p.id.padEnd(idW)}  ${p.sender.padEnd(senderW)}  ${p.filename.padEnd(fileW)}  ${formatFileSize(p.size)}`
+      );
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};