volute 0.34.0 → 0.35.0

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-ZEUK7GKZ.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-N7BLAHNE.js";
-import "./chunk-4JSR7YO7.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-EJRTKE36.js → template-hash-A7FNHTB7.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   computeTemplateHash
-} from "./chunk-PVY5W6QN.js";
-import "./chunk-G53F3JA4.js";
+} 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-X3YG4WVP.js → update-check-UV55CBEP.js}

@@ -5,9 +5,9 @@ import {
   fetchLatestVersion,
   getCurrentVersion,
   isNewer
-} from "./chunk-2IOP6PHB.js";
-import "./chunk-N7BLAHNE.js";
-import "./chunk-4JSR7YO7.js";
+} from "./chunk-OTC67N2Z.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
 import "./chunk-7KJOFUNN.js";
 export {
   checkForUpdate,

package/dist/upgrade-ZMDGC7M2.js

@@ -0,0 +1,74 @@
+#!/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/upgrade.ts
+var cmd = command({
+  name: "volute mind upgrade",
+  description: "Upgrade mind to latest template",
+  args: [{ name: "name", required: true, description: "Mind to upgrade" }],
+  flags: {
+    template: { type: "string", description: "Template to upgrade to" },
+    diff: { type: "boolean", description: "Show changes without applying" },
+    continue: { type: "boolean", description: "Continue a paused upgrade" },
+    abort: { type: "boolean", description: "Abort a paused upgrade" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = 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 res = await daemonFetch(
+      urlOf(client.api.minds[":name"].upgrade.$url({ param: { name: mindName } })),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          template: flags.template,
+          continue: flags.continue,
+          abort: flags.abort,
+          diff: flags.diff
+        })
+      }
+    );
+    const data = await res.json();
+    if (!res.ok && !data.conflicts) {
+      console.error(data.error ?? "Failed to upgrade mind");
+      process.exit(1);
+    }
+    if (flags.diff) {
+      console.log(data.diff ?? "(no changes)");
+      return;
+    }
+    if (flags.abort) {
+      console.log(`Upgrade aborted for ${mindName}.`);
+      return;
+    }
+    if (data.conflicts) {
+      console.log("\nMerge conflicts detected. Resolve them in:");
+      console.log(`  ${data.worktreeDir}`);
+      console.log(`
+Then run:`);
+      console.log(`  volute mind upgrade ${mindName} --continue`);
+      console.log(`
+Or abort:`);
+      console.log(`  volute mind upgrade ${mindName} --abort`);
+      return;
+    }
+    if (data.warning) {
+      console.log(`Upgrade complete for ${mindName} (with warning: ${data.warning})`);
+    } else {
+      console.log(`Upgrade complete for ${mindName}.`);
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/variant-QWL2WSRI.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import {
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/variant.ts
+var cmd = subcommands({
+  name: "volute variant",
+  description: "(deprecated) Use 'volute mind split/join' instead",
+  commands: {
+    create: {
+      description: "(deprecated) Use 'volute mind split'",
+      run: async () => {
+        console.error(
+          "'volute variant create' has been replaced. Use 'volute mind split' to create variants."
+        );
+        console.error(
+          "Usage: volute mind split <name> [--from <mind>] [--soul '...'] [--no-start]"
+        );
+        process.exit(1);
+      }
+    },
+    merge: {
+      description: "(deprecated) Use 'volute mind join'",
+      run: async () => {
+        console.error(
+          "'volute variant merge' has been replaced. Use 'volute mind join' to merge variants."
+        );
+        console.error(
+          "Usage: volute mind join <name> [--summary '...' --memory '...' --justification '...']"
+        );
+        process.exit(1);
+      }
+    },
+    list: {
+      description: "(deprecated) Use 'volute mind list'",
+      run: async () => {
+        console.error("'volute variant list' is no longer available.");
+        console.error(
+          "Use 'volute mind list' to see variants, or 'volute mind delete <variant-name>' to delete."
+        );
+        process.exit(1);
+      }
+    },
+    delete: {
+      description: "(deprecated) Use 'volute mind delete'",
+      run: async () => {
+        console.error("'volute variant delete' is no longer available.");
+        console.error(
+          "Use 'volute mind list' to see variants, or 'volute mind delete <variant-name>' to delete."
+        );
+        process.exit(1);
+      }
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};