volute 0.33.0 → 0.35.0

package/dist/split-AWVOYOPZ.js

@@ -0,0 +1,64 @@
+#!/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/split.ts
+var cmd = command({
+  name: "volute mind split",
+  description: "Create an experimental variant",
+  args: [{ name: "name", required: true, description: "Name for the variant" }],
+  flags: {
+    from: { type: "string", description: "Parent mind to split from" },
+    soul: { type: "string", description: "Custom SOUL.md content" },
+    port: { type: "number", description: "Port for variant server" },
+    "no-start": { type: "boolean", description: "Don't start the variant" },
+    json: { type: "boolean", description: "Output JSON result" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName({ mind: flags.from });
+    const variantName = args.name;
+    const { soul, port, json } = flags;
+    const noStart = flags["no-start"];
+    if (!json) console.log("Creating variant via daemon...");
+    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"].variants.$url({ param: { name: mindName } })),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          name: variantName,
+          ...soul && { soul },
+          ...port && { port },
+          ...noStart && { noStart }
+        })
+      }
+    );
+    const data = await res.json();
+    if (!res.ok) {
+      console.error(data.error ?? "Failed to create variant");
+      process.exit(1);
+    }
+    if (json) {
+      console.log(JSON.stringify(data.variant, null, 2));
+    } else {
+      console.log(`
+Variant created: ${variantName}`);
+      console.log(`  Branch: ${data.variant?.branch}`);
+      console.log(`  Path:   ${data.variant?.path}`);
+      console.log(`  Port:   ${data.variant?.port}`);
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/{sprout-WKLZXUIQ.js → sprout-HE4TITMK.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import "./chunk-K3NQKI34.js";
+import "./chunk-7KJOFUNN.js";
 
-// src/commands/sprout.ts
+// packages/cli/src/commands/sprout.ts
 async function run(args) {
   console.error("Note: `volute mind sprout` is now `volute seed sprout`");
-  await import("./seed-sprout-GQEIIQRT.js").then((m) => m.run(args));
+  await import("./seed-sprout-JYXGXOP3.js").then((m) => m.run(args));
 }
 export {
   run

package/dist/start-3UXOPXQG.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import {
+  command
+} 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/start.ts
+var cmd = command({
+  name: "volute mind start",
+  description: "Start a mind",
+  args: [{ name: "name", required: true, description: "Mind to start" }],
+  flags: {},
+  async run({ args }) {
+    const name = args.name;
+    const client = getClient();
+    const res = await daemonFetch(
+      urlOf(client.api.minds[":name"].start.$url({ param: { name } })),
+      { method: "POST" }
+    );
+    const data = await res.json();
+    if (!res.ok) {
+      console.error(data.error || "Failed to start mind");
+      process.exit(1);
+    }
+    console.log(`${name} started on port ${data.port}`);
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/status-ZK34WYIM.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import {
+  LAUNCHD_PLIST_LABEL,
+  LAUNCHD_PLIST_PATH,
+  SYSTEM_LAUNCHD_PLIST_PATH,
+  SYSTEM_SERVICE_PATH,
+  USER_SYSTEMD_UNIT,
+  getDaemonUrl,
+  getServiceMode,
+  modeLabel,
+  readDaemonConfig
+} from "./chunk-2TGZJFAT.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  checkForUpdate
+} from "./chunk-OTC67N2Z.js";
+import "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+
+// src/commands/status.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var cmd = command({
+  name: "volute status",
+  description: "Show daemon status, version, and running minds",
+  flags: {},
+  run: async () => {
+    const mode = getServiceMode();
+    console.log(`Mode: ${modeLabel(mode)}`);
+    const { hostname, port, internalPort, token } = readDaemonConfig();
+    const apiPort = internalPort ?? port;
+    const baseUrl = getDaemonUrl("127.0.0.1", apiPort);
+    let running = false;
+    let version;
+    try {
+      const res = await fetch(`${baseUrl}/api/health`);
+      if (res.ok) {
+        const body = await res.json();
+        if (body.ok) {
+          running = true;
+          version = body.version;
+        }
+      }
+    } catch {
+    }
+    if (!running) {
+      console.log("Status: not running");
+      return;
+    }
+    console.log(`Status: running on ${hostname}:${port}`);
+    if (version) console.log(`Version: ${version}`);
+    const update = await checkForUpdate();
+    if (update.updateAvailable) {
+      console.log(`Update available: ${update.current} \u2192 ${update.latest}`);
+    }
+    if (mode !== "manual") {
+      const serviceInfo = await getServiceInfo();
+      if (serviceInfo) {
+        console.log(`
+Service:
+${serviceInfo}`);
+      }
+    }
+    const headers = {};
+    if (token) headers.Authorization = `Bearer ${token}`;
+    headers.Origin = baseUrl;
+    try {
+      const res = await fetch(`${baseUrl}/api/minds`, { headers });
+      if (res.ok) {
+        const minds = await res.json();
+        if (minds.length > 0) {
+          console.log(`
+Minds (${minds.length}):`);
+          for (const mind of minds) {
+            const status = mind.status ?? (mind.running ? "running" : "stopped");
+            const label = mind.stage === "seed" ? " (seed)" : "";
+            console.log(`  ${mind.name}: ${status}${label}`);
+          }
+        } else {
+          console.log("\nNo minds configured.");
+        }
+      }
+    } catch {
+    }
+  }
+});
+var run = cmd.execute;
+async function getServiceInfo() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const plistPath = existsSync(SYSTEM_LAUNCHD_PLIST_PATH) ? SYSTEM_LAUNCHD_PLIST_PATH : existsSync(LAUNCHD_PLIST_PATH) ? LAUNCHD_PLIST_PATH : null;
+    if (!plistPath) return null;
+    try {
+      const { stdout } = await execFileAsync("launchctl", ["list", LAUNCHD_PLIST_LABEL]);
+      return stdout.trim();
+    } catch {
+      return "Service installed but not currently loaded.";
+    }
+  }
+  if (platform === "linux") {
+    const unitPath = existsSync(SYSTEM_SERVICE_PATH) ? "system" : existsSync(USER_SYSTEMD_UNIT) ? "user" : null;
+    if (!unitPath) return null;
+    const args = unitPath === "system" ? ["status", "volute", "--no-pager"] : ["--user", "status", "volute", "--no-pager"];
+    try {
+      const { stdout } = await execFileAsync("systemctl", args);
+      return stdout.trim();
+    } catch (err) {
+      const e = err;
+      if (e.stdout) return e.stdout.trim();
+      return "Service installed but status unknown.";
+    }
+  }
+  return null;
+}
+export {
+  run
+};

package/dist/stop-3XYIBGFM.js

@@ -0,0 +1,41 @@
+#!/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 {
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/stop.ts
+var cmd = command({
+  name: "volute mind stop",
+  description: "Stop a mind",
+  args: [{ name: "name", description: "Mind to stop (or use VOLUTE_MIND)" }],
+  flags: {},
+  async run({ args }) {
+    const name = resolveMindName({ mind: args.name });
+    const client = getClient();
+    const res = await daemonFetch(urlOf(client.api.minds[":name"].stop.$url({ param: { name } })), {
+      method: "POST"
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      console.error(data.error || "Failed to stop mind");
+      process.exit(1);
+    }
+    console.log(`${name} stopped.`);
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/system-chat-IDPHYHY4.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import {
+  ensureSystemDM,
+  generateSystemReply,
+  resetSystemDMCache,
+  sendSystemMessage,
+  sendSystemMessageDirect
+} 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 {
+  ensureSystemDM,
+  generateSystemReply,
+  resetSystemDMCache,
+  sendSystemMessage,
+  sendSystemMessageDirect
+};

package/dist/systems-O43WGQY6.js

@@ -0,0 +1,52 @@
+#!/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/systems.ts
+async function showStatus() {
+  const res = await daemonFetch("/api/system/info");
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+    console.error(`Failed to get system info: ${body.error}`);
+    process.exit(1);
+  }
+  const { system } = await res.json();
+  if (!system) {
+    console.log("Not connected to volute.systems");
+    console.log('Run "volute systems register" or "volute systems login" to connect.');
+    return;
+  }
+  console.log(`System: ${system}`);
+}
+var cmd = subcommands({
+  name: "volute systems",
+  description: "Manage volute.systems account",
+  commands: {
+    status: {
+      description: "Show volute.systems account info",
+      run: async () => showStatus()
+    },
+    register: {
+      description: "Register a system on volute.systems",
+      run: (args) => import("./register-SB7NXCOE.js").then((m) => m.run(args))
+    },
+    login: {
+      description: "Log in with an existing API key",
+      run: (args) => import("./login-GOTAYLXP.js").then((m) => m.run(args))
+    },
+    logout: {
+      description: "Remove stored credentials",
+      run: (args) => import("./logout-6KIA74EV.js").then((m) => m.run(args))
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/{tailscale-XHQBZROW.js → tailscale-ZIZ2HWJ5.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   logger_default
-} from "./chunk-YUIHSKR6.js";
+} from "./chunk-BKF4WQCY.js";
 import {
   voluteHome
-} from "./chunk-LRCG2JLP.js";
-import "./chunk-RPZZSXV3.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
 
-// src/lib/tailscale.ts
+// packages/daemon/src/lib/tailscale.ts
 import { execFile } from "child_process";
 import { existsSync, mkdirSync, readFileSync } from "fs";
 import { resolve } from "path";

package/dist/template-hash-A7FNHTB7.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  computeTemplateHash
+} from "./chunk-F7ZNLYKZ.js";
+import "./chunk-AOB6GVRM.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  computeTemplateHash
+};

package/dist/up-77ICEDEW.js

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

package/dist/update-ANE5ZM7F.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import {
+  getServiceMode,
+  modeLabel,
+  pollHealth,
+  readDaemonConfig,
+  restartService
+} from "./chunk-2TGZJFAT.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  checkForUpdate
+} from "./chunk-OTC67N2Z.js";
+import {
+  exec,
+  execInherit,
+  resolveVoluteBin
+} from "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import {
+  voluteSystemDir
+} from "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+
+// src/commands/update.ts
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { resolve } from "path";
+var cmd = command({
+  name: "volute update",
+  description: "Check for and install updates",
+  flags: {},
+  run: async () => {
+    const result = await checkForUpdate(true);
+    if (result.checkFailed) {
+      console.error("Could not reach npm registry. Check your network connection and try again.");
+      process.exit(1);
+    }
+    console.log(`Current version: ${result.current}`);
+    console.log(`Latest version:  ${result.latest}`);
+    if (!result.updateAvailable) {
+      console.log("\nAlready up to date.");
+      return;
+    }
+    console.log(`
+Updating volute ${result.current} \u2192 ${result.latest}...`);
+    const mode = getServiceMode();
+    if (mode === "system") {
+      let npmPath = "/usr/bin/npm";
+      if (!existsSync(npmPath)) {
+        try {
+          npmPath = (await exec("which", ["npm"])).trim();
+        } catch {
+          console.error("Could not find npm. Install npm and try again.");
+          process.exit(1);
+        }
+      }
+      try {
+        await execInherit("sudo", [npmPath, "install", "-g", "volute@latest"]);
+      } catch (err) {
+        console.error(`
+Update failed: ${err.message}`);
+        process.exit(1);
+      }
+      console.log("Restarting service...");
+      try {
+        await restartService(mode);
+      } catch (err) {
+        console.error(`Failed to restart: ${err instanceof Error ? err.message : err}`);
+        console.error("Try: sudo systemctl restart volute");
+        process.exit(1);
+      }
+      {
+        const config = readDaemonConfig();
+        if (await pollHealth("127.0.0.1", config.internalPort ?? config.port)) {
+          console.log(`
+Updated to volute v${result.latest}`);
+        } else {
+          console.error("Service restarted but daemon did not become healthy.");
+          process.exit(1);
+        }
+      }
+      return;
+    }
+    if (mode === "user-systemd" || mode === "user-launchd") {
+      try {
+        await execInherit("npm", ["install", "-g", "volute@latest"]);
+      } catch (err) {
+        console.error(`
+Update failed: ${err.message}`);
+        process.exit(1);
+      }
+      console.log(`Restarting service (${modeLabel(mode)})...`);
+      try {
+        await restartService(mode);
+      } catch (err) {
+        console.error(`Failed to restart: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+      {
+        const config = readDaemonConfig();
+        if (await pollHealth("127.0.0.1", config.internalPort ?? config.port)) {
+          console.log(`
+Updated to volute v${result.latest}`);
+        } else {
+          console.error("Service restarted but daemon did not become healthy.");
+          process.exit(1);
+        }
+      }
+      return;
+    }
+    const systemDir = voluteSystemDir();
+    const pidPath = resolve(systemDir, "daemon.pid");
+    const configPath = resolve(systemDir, "daemon.json");
+    let daemonWasRunning = false;
+    let daemonPort = 1618;
+    let daemonHost = "127.0.0.1";
+    if (existsSync(pidPath)) {
+      const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      try {
+        process.kill(pid, 0);
+        daemonWasRunning = true;
+      } catch {
+        try {
+          unlinkSync(pidPath);
+        } catch {
+        }
+      }
+    }
+    if (daemonWasRunning && existsSync(configPath)) {
+      try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        daemonPort = config.port ?? 1618;
+        daemonHost = config.hostname || "127.0.0.1";
+      } catch {
+        console.error("Warning: could not read daemon config, using default port/host");
+      }
+    }
+    if (daemonWasRunning) {
+      console.log("Stopping daemon...");
+      const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {
+        }
+      }
+      const maxWait = 1e4;
+      const start = Date.now();
+      while (Date.now() - start < maxWait) {
+        if (!existsSync(pidPath)) break;
+        await new Promise((r) => setTimeout(r, 200));
+      }
+      if (existsSync(pidPath)) {
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }
+      }
+      if (existsSync(pidPath)) {
+        try {
+          const stalePid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+          process.kill(stalePid, 0);
+          console.error("Warning: daemon process may still be running. Aborting update.");
+          process.exit(1);
+        } catch {
+          try {
+            unlinkSync(pidPath);
+          } catch {
+          }
+        }
+      }
+      console.log("Daemon stopped.");
+    }
+    try {
+      await execInherit("npm", ["install", "-g", "volute@latest"]);
+    } catch (err) {
+      console.error(`
+Update failed: ${err.message}`);
+      if (daemonWasRunning) {
+        console.log("Restarting daemon with current version...");
+        try {
+          await execInherit(resolveVoluteBin(), [
+            "up",
+            "--port",
+            String(daemonPort),
+            "--host",
+            daemonHost
+          ]);
+        } catch {
+          console.error("Failed to restart daemon. Run `volute up` manually.");
+        }
+      }
+      process.exit(1);
+    }
+    if (daemonWasRunning) {
+      console.log("Restarting daemon...");
+      try {
+        await execInherit(resolveVoluteBin(), [
+          "up",
+          "--port",
+          String(daemonPort),
+          "--host",
+          daemonHost
+        ]);
+      } catch {
+        console.error("Failed to restart daemon. Run `volute up` manually.");
+      }
+    }
+    console.log(`
+Updated to volute v${result.latest}`);
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/{update-check-ZD6OOIYQ.js → update-check-UV55CBEP.js}

@@ -5,10 +5,10 @@ import {
   fetchLatestVersion,
   getCurrentVersion,
   isNewer
-} from "./chunk-M7UL5S3Q.js";
-import "./chunk-LRCG2JLP.js";
-import "./chunk-RPZZSXV3.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-OTC67N2Z.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
 export {
   checkForUpdate,
   checkForUpdateCached,