volute 0.24.0 → 0.26.0

package/dist/{package-S5YF25XV.js → package-VZWLXPHV.js}

@@ -4,7 +4,7 @@ import "./chunk-K3NQKI34.js";
 // package.json
 var package_default = {
   name: "volute",
-  version: "0.24.0",
+  version: "0.26.0",
   description: "CLI for creating and managing self-modifying AI minds powered by the Claude Agent SDK",
   type: "module",
   license: "MIT",
@@ -60,6 +60,7 @@ var package_default = {
     "db:migrate": "drizzle-kit migrate"
   },
   dependencies: {
+    "@anthropic-ai/sandbox-runtime": "^0.0.39",
     "@hono/node-server": "^1.19.9",
     "@hono/zod-validator": "^0.7.6",
     "@libsql/client": "^0.17.0",
@@ -86,6 +87,7 @@ var package_default = {
     dompurify: "^3.3.1",
     "drizzle-kit": "^0.31.8",
     lefthook: "^2.1.0",
+    libsql: "^0.5.22",
     marked: "^17.0.1",
     svelte: "^5.53.0",
     tsup: "^8.0.0",

package/dist/{pages-TWR6U7DS.js → pages-DIIT5HMQ.js}

@@ -6,7 +6,7 @@ async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
     case "publish":
-      await import("./publish-BZNHKUUK.js").then((m) => m.run(args.slice(1)));
+      await import("./publish-HQV7YREB.js").then((m) => m.run(args.slice(1)));
       break;
     case "status":
       await import("./status-LV34BG6G.js").then((m) => m.run(args.slice(1)));

package/dist/{publish-BZNHKUUK.js → publish-HQV7YREB.js}

@@ -7,16 +7,16 @@ import {
 } from "./chunk-NAOW2CLO.js";
 import {
   sharedDir
-} from "./chunk-PHHKNGA3.js";
+} from "./chunk-3TV4GLFO.js";
 import {
   readSystemsConfig
 } from "./chunk-HFCBO2GL.js";
 import "./chunk-YUIHSKR6.js";
+import "./chunk-YJA7P64S.js";
+import "./chunk-XOXLRRR2.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
-import "./chunk-JTDFJWI2.js";
-import "./chunk-NWPT4ASZ.js";
 import {
   mindDir
 } from "./chunk-B2CPS4QU.js";
@@ -42,7 +42,7 @@ async function run(args) {
     pagesDir = resolve(sharedDir(), "pages");
   } else if (flags.mind || process.env.VOLUTE_MIND) {
     mindName = resolveMindName(flags);
-    pagesDir = resolve(mindDir(mindName), "home", "pages");
+    pagesDir = resolve(mindDir(mindName), "home", "public", "pages");
   } else {
     mindName = "system";
     pagesDir = resolve(sharedDir(), "pages");

package/dist/{pull-D32SPFVU.js → pull-2MB4SK3C.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-WGOGUMPO.js";
 import {
   resolveMindName
 } from "./chunk-NAOW2CLO.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
-import {
-  daemonFetch
-} from "./chunk-TRQEV3CD.js";
 import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 

package/dist/{register-U2UO6TC4.js → register-EFND67FQ.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-RWKVSSLY.js";
 import {
   promptLine
-} from "./chunk-RVKR2R7F.js";
+} from "./chunk-SSI47XP2.js";
 import {
   readSystemsConfig,
   writeSystemsConfig

package/dist/{restart-5BMNV7KU.js → restart-CCK7D6TV.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-WGOGUMPO.js";
 import {
   getClient,
   urlOf
@@ -6,9 +9,6 @@ import {
 import {
   resolveMindName
 } from "./chunk-NAOW2CLO.js";
-import {
-  daemonFetch
-} from "./chunk-TRQEV3CD.js";
 import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 

package/dist/sandbox-EHGFF52K.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  buildDenyRead,
+  initSandbox,
+  isSandboxEnabled,
+  shellEscape,
+  wrapForSandbox
+} from "./chunk-UTL75LP6.js";
+import "./chunk-YUIHSKR6.js";
+import "./chunk-TZKJLDQN.js";
+import "./chunk-B2CPS4QU.js";
+import "./chunk-K3NQKI34.js";
+export {
+  buildDenyRead,
+  initSandbox,
+  isSandboxEnabled,
+  shellEscape,
+  wrapForSandbox
+};

package/dist/{schedule-YEFDLVMJ.js → schedule-6F7ELB2M.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-WGOGUMPO.js";
 import {
   getClient,
   urlOf
@@ -9,9 +12,6 @@ import {
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
-import {
-  daemonFetch
-} from "./chunk-TRQEV3CD.js";
 import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 

package/dist/{seed-6FEKB3YC.js → seed-E5OQGWX3.js}

@@ -21,7 +21,7 @@ async function run(args) {
   }
   const template = flags.template ?? "claude";
   const skills = flags.skills === "none" ? [] : flags.skills ? flags.skills.split(",") : void 0;
-  const { daemonFetch } = await import("./daemon-client-JOVQZ52X.js");
+  const { daemonFetch } = await import("./daemon-client-Z7FAJ6JW.js");
   const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
   const client = getClient();
   const createRes = await daemonFetch(urlOf(client.api.minds.$url()), {

package/dist/{send-IISDYFCL.js → send-IH6XZKPC.js}

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+import {
+  readStdin
+} from "./chunk-ZYGKG6VC.js";
+import {
+  daemonFetch
+} from "./chunk-WGOGUMPO.js";
 import {
   getClient,
   urlOf
@@ -9,9 +15,6 @@ import {
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
-import {
-  daemonFetch
-} from "./chunk-TRQEV3CD.js";
 import {
   findMind
 } from "./chunk-B2CPS4QU.js";
@@ -51,23 +54,6 @@ function parseTarget(target) {
   };
 }
 
-// src/lib/read-stdin.ts
-import { isatty } from "tty";
-async function readStdin() {
-  if (isatty(0)) return void 0;
-  const chunks = [];
-  try {
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-  } catch (err) {
-    console.error(`Failed to read from stdin: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  }
-  const text = Buffer.concat(chunks).toString().replace(/\r?\n$/, "");
-  return text || void 0;
-}
-
 // src/commands/send.ts
 var IMAGE_MEDIA_TYPES = {
   ".png": "image/png",

package/dist/service-LLBV3R7M.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import {
+  LAUNCHD_PLIST_LABEL,
+  LAUNCHD_PLIST_PATH,
+  SYSTEM_LAUNCHD_PLIST_PATH,
+  SYSTEM_SERVICE_PATH,
+  USER_SYSTEMD_UNIT
+} from "./chunk-V63B7DX3.js";
+import "./chunk-YJA7P64S.js";
+import "./chunk-XOXLRRR2.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-B2CPS4QU.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/service.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function status() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    if (existsSync(SYSTEM_LAUNCHD_PLIST_PATH)) {
+      try {
+        const { stdout } = await execFileAsync("launchctl", ["list", LAUNCHD_PLIST_LABEL]);
+        console.log("System service (LaunchDaemon):");
+        console.log(stdout);
+      } catch {
+        console.log("System service installed but not currently loaded.");
+      }
+      return;
+    }
+    if (!existsSync(LAUNCHD_PLIST_PATH)) {
+      console.log("Service not installed.");
+      return;
+    }
+    try {
+      const { stdout } = await execFileAsync("launchctl", ["list", LAUNCHD_PLIST_LABEL]);
+      console.log(stdout);
+    } catch {
+      console.log("Service installed but not currently loaded.");
+    }
+  } else if (platform === "linux") {
+    if (existsSync(SYSTEM_SERVICE_PATH)) {
+      try {
+        const { stdout } = await execFileAsync("systemctl", ["status", "volute", "--no-pager"]);
+        console.log(stdout);
+      } catch (err) {
+        const e = err;
+        if (e.stdout) {
+          console.log(e.stdout);
+        } else {
+          console.error("System service installed but could not retrieve status.");
+          if (e.stderr) console.error(e.stderr);
+          else if (e.message) console.error(e.message);
+          console.error("Try running: systemctl status volute");
+        }
+      }
+      return;
+    }
+    if (!existsSync(USER_SYSTEMD_UNIT)) {
+      console.log("Service not installed.");
+      return;
+    }
+    try {
+      const { stdout } = await execFileAsync("systemctl", [
+        "--user",
+        "status",
+        "volute",
+        "--no-pager"
+      ]);
+      console.log(stdout);
+    } catch (err) {
+      const e = err;
+      if (e.stdout) console.log(e.stdout);
+      else console.log("Service installed but status unknown.");
+    }
+  } else {
+    console.error(`Unsupported platform: ${platform}`);
+    process.exit(1);
+  }
+}
+async function run(args) {
+  const { positional } = parseArgs(args, {});
+  const subcommand = positional[0];
+  switch (subcommand) {
+    case "install":
+      console.log("'volute service install' has been replaced by 'volute setup'.");
+      console.log("Run `volute setup` to configure your installation.");
+      break;
+    case "uninstall":
+      console.log("'volute service uninstall' has been replaced by 'volute setup'.");
+      console.log("To uninstall the service, remove the service file manually:");
+      if (process.platform === "darwin") {
+        console.log("  launchctl unload ~/Library/LaunchAgents/com.volute.daemon.plist");
+        console.log("  rm ~/Library/LaunchAgents/com.volute.daemon.plist");
+      } else {
+        console.log("  systemctl --user disable --now volute");
+        console.log("  rm ~/.config/systemd/user/volute.service");
+      }
+      break;
+    case "status":
+      await status();
+      break;
+    default:
+      console.log(`Usage:
+  volute service status    Check service status
+
+Note: 'volute service install' and 'volute service uninstall' have been
+replaced by 'volute setup'. Run 'volute setup' to configure your installation.`);
+      if (subcommand && subcommand !== "--help") {
+        console.error(`
+Unknown subcommand: ${subcommand}`);
+        process.exit(1);
+      }
+  }
+}
+export {
+  run
+};

package/dist/setup-F6TWFYGQ.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+import {
+  LAUNCHD_PLIST_LABEL,
+  LAUNCHD_PLIST_PATH,
+  SYSTEM_LAUNCHD_PLIST_PATH,
+  SYSTEM_SERVICE_PATH,
+  USER_SYSTEMD_UNIT
+} from "./chunk-V63B7DX3.js";
+import {
+  promptLine
+} from "./chunk-SSI47XP2.js";
+import {
+  resolveVoluteBin
+} from "./chunk-YJA7P64S.js";
+import {
+  ensureVoluteGroup
+} from "./chunk-XOXLRRR2.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  readGlobalConfig,
+  writeGlobalConfig
+} from "./chunk-TZKJLDQN.js";
+import "./chunk-B2CPS4QU.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/setup.ts
+import { execFile, execFileSync } from "child_process";
+import { mkdirSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var HOST_RE = /^[a-zA-Z0-9.:_-]+$/;
+function validateHost(host) {
+  if (!HOST_RE.test(host)) {
+    throw new Error(`Invalid host: ${host}`);
+  }
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function generatePlist(voluteBin, opts) {
+  const args = ["up", "--foreground"];
+  if (opts.port != null) args.push("--port", String(opts.port));
+  if (opts.host) args.push("--host", opts.host);
+  const logPath = opts.system ? "/var/lib/volute/daemon.log" : resolve(homedir(), ".volute", "daemon.log");
+  const envEntries = [];
+  if (opts.system) {
+    envEntries.push(
+      "  <key>EnvironmentVariables</key>",
+      "  <dict>",
+      "    <key>VOLUTE_HOME</key>",
+      "    <string>/var/lib/volute</string>",
+      "    <key>VOLUTE_MINDS_DIR</key>",
+      "    <string>/minds</string>",
+      "    <key>VOLUTE_ISOLATION</key>",
+      "    <string>user</string>",
+      "  </dict>"
+    );
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    ${[voluteBin, ...args].map((a) => `<string>${escapeXml(a)}</string>`).join("\n    ")}
+  </array>
+${envEntries.length > 0 ? envEntries.join("\n") + "\n" : ""}  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+</dict>
+</plist>`;
+}
+function generateUserUnit(voluteBin, port, host) {
+  const args = ["up", "--foreground"];
+  if (port != null) args.push("--port", String(port));
+  if (host) args.push("--host", host);
+  return `[Unit]
+Description=Volute Daemon
+After=network.target
+
+[Service]
+Type=exec
+ExecStart=${voluteBin} ${args.join(" ")}
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+}
+function buildServicePath(voluteBin) {
+  const binDir = dirname(voluteBin);
+  const standardPaths = [
+    "/usr/local/sbin",
+    "/usr/local/bin",
+    "/usr/sbin",
+    "/usr/bin",
+    "/sbin",
+    "/bin"
+  ];
+  const parts = standardPaths.includes(binDir) ? standardPaths : [binDir, ...standardPaths];
+  return parts.join(":");
+}
+function generateSystemUnit(voluteBin, port, host) {
+  const args = ["up", "--foreground"];
+  if (port != null) args.push("--port", String(port));
+  if (host) args.push("--host", host);
+  const home = homedir();
+  const binUnderHome = voluteBin.startsWith(`${home}/`);
+  const lines = [
+    "[Unit]",
+    "Description=Volute Mind Manager",
+    "After=network.target",
+    "",
+    "[Service]",
+    "Type=exec",
+    `ExecStart=${voluteBin} ${args.join(" ")}`,
+    `Environment=PATH=${buildServicePath(voluteBin)}`,
+    "Environment=VOLUTE_HOME=/var/lib/volute",
+    "Environment=VOLUTE_MINDS_DIR=/minds",
+    "Environment=VOLUTE_ISOLATION=user",
+    "Restart=on-failure",
+    "RestartSec=5",
+    "ProtectSystem=true",
+    "ReadWritePaths=/var/lib/volute /minds",
+    "PrivateTmp=yes"
+  ];
+  if (!binUnderHome) {
+    lines.push("ProtectHome=yes");
+  }
+  lines.push("RestrictSUIDSGID=yes", "", "[Install]", "WantedBy=multi-user.target", "");
+  return lines.join("\n");
+}
+var DATA_DIR = "/var/lib/volute";
+var MINDS_DIR = "/minds";
+var PROFILE_PATH = "/etc/profile.d/volute.sh";
+var WRAPPER_PATH = "/usr/local/bin/volute";
+async function installUserService(voluteBin, port, host) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      mkdirSync(resolve(homedir(), "Library", "LaunchAgents"), { recursive: true });
+      writeFileSync(LAUNCHD_PLIST_PATH, generatePlist(voluteBin, { port, host }));
+      console.log(`  Wrote ${LAUNCHD_PLIST_PATH}`);
+      await execFileAsync("launchctl", ["load", LAUNCHD_PLIST_PATH]);
+      console.log("  Service installed (launchd)");
+      return true;
+    } else if (platform === "linux") {
+      mkdirSync(resolve(homedir(), ".config", "systemd", "user"), { recursive: true });
+      writeFileSync(USER_SYSTEMD_UNIT, generateUserUnit(voluteBin, port, host));
+      console.log(`  Wrote ${USER_SYSTEMD_UNIT}`);
+      await execFileAsync("systemctl", ["--user", "enable", "--now", "volute"]);
+      console.log("  Service installed (systemd user)");
+      return true;
+    }
+  } catch (err) {
+    console.warn(
+      `  Warning: failed to install service: ${err instanceof Error ? err.message : err}`
+    );
+  }
+  return false;
+}
+function installSystemService(voluteBin, port, host) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    writeFileSync(
+      SYSTEM_LAUNCHD_PLIST_PATH,
+      generatePlist(voluteBin, { port, host: host ?? "0.0.0.0", system: true })
+    );
+    console.log(`  Wrote ${SYSTEM_LAUNCHD_PLIST_PATH}`);
+    try {
+      execFileSync("launchctl", ["load", SYSTEM_LAUNCHD_PLIST_PATH]);
+      console.log("  Service installed (LaunchDaemon)");
+      return true;
+    } catch (err) {
+      console.warn(
+        `  Warning: failed to load LaunchDaemon: ${err instanceof Error ? err.message : err}`
+      );
+      console.warn("  Try: sudo launchctl load /Library/LaunchDaemons/com.volute.daemon.plist");
+      return false;
+    }
+  } else if (platform === "linux") {
+    writeFileSync(SYSTEM_SERVICE_PATH, generateSystemUnit(voluteBin, port, host ?? "0.0.0.0"));
+    console.log(`  Wrote ${SYSTEM_SERVICE_PATH}`);
+    try {
+      execFileSync("systemctl", ["daemon-reload"]);
+      execFileSync("systemctl", ["enable", "--now", "volute"]);
+      console.log("  Service installed (systemd)");
+      return true;
+    } catch (err) {
+      console.warn(
+        `  Warning: failed to enable service: ${err instanceof Error ? err.message : err}`
+      );
+      console.warn("  Try: systemctl daemon-reload && systemctl enable --now volute");
+      return false;
+    }
+  }
+  return false;
+}
+function setupSystemDirectories() {
+  mkdirSync(DATA_DIR, { recursive: true });
+  console.log(`  Created ${DATA_DIR}`);
+  mkdirSync(MINDS_DIR, { recursive: true });
+  console.log(`  Created ${MINDS_DIR}`);
+  execFileSync("chmod", ["755", DATA_DIR]);
+  execFileSync("chmod", ["755", MINDS_DIR]);
+}
+function setupSystemGitIdentity() {
+  try {
+    execFileSync("git", ["config", "--system", "user.name"]);
+    console.log("  System git identity already configured");
+  } catch {
+    try {
+      execFileSync("git", ["config", "--system", "user.name", "Volute"]);
+      execFileSync("git", ["config", "--system", "user.email", "volute@localhost"]);
+      console.log("  Configured system git identity");
+    } catch (err) {
+      console.warn(
+        `  Warning: failed to set system git config: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+}
+function setupSystemWrapper(voluteBin) {
+  const binDir = dirname(voluteBin);
+  if (voluteBin !== WRAPPER_PATH && !voluteBin.startsWith("/usr/bin")) {
+    const wrapper = `#!/bin/sh
+export PATH="${binDir}:$PATH"
+export VOLUTE_HOME="${DATA_DIR}"
+export VOLUTE_MINDS_DIR="${MINDS_DIR}"
+exec "${voluteBin}" "$@"
+`;
+    writeFileSync(WRAPPER_PATH, wrapper, { mode: 493 });
+    console.log(`  Wrote ${WRAPPER_PATH}`);
+  }
+}
+function setupSystemEnvProfile() {
+  if (process.platform === "linux") {
+    writeFileSync(
+      PROFILE_PATH,
+      `export VOLUTE_HOME=${DATA_DIR}
+export VOLUTE_MINDS_DIR=${MINDS_DIR}
+`
+    );
+    console.log(`  Wrote ${PROFILE_PATH}`);
+  }
+}
+async function run(args) {
+  const { flags } = parseArgs(args, {
+    name: { type: "string" },
+    system: { type: "boolean" },
+    service: { type: "boolean" },
+    dir: { type: "string" },
+    port: { type: "number" },
+    host: { type: "string" }
+  });
+  const isInteractive = !flags.name && process.stdin.isTTY;
+  let systemName;
+  let setupType;
+  let wantService;
+  const port = flags.port;
+  const host = flags.host;
+  if (isInteractive) {
+    console.log("Welcome to Volute!\n");
+    systemName = await promptLine("System name: ");
+    if (!systemName.trim()) {
+      console.error("System name is required.");
+      process.exit(1);
+    }
+    systemName = systemName.trim();
+    console.log("\nInstall type:");
+    console.log("  1. Local (minds in ~/.volute/minds/, sandbox isolation)");
+    console.log("  2. System (minds in /minds, per-user isolation, requires sudo)");
+    const typeChoice = await promptLine("> ");
+    setupType = typeChoice.trim() === "2" ? "system" : "local";
+    if (setupType === "system" && process.getuid?.() !== 0) {
+      console.error("\nSystem install requires root. Re-run with sudo.");
+      process.exit(1);
+    }
+    const serviceDefault = setupType === "system" ? "Y/n" : "y/N";
+    const servicePrompt = `
+Install as a service (auto-start on boot)? [${serviceDefault}]: `;
+    const serviceAnswer = (await promptLine(servicePrompt)).trim().toLowerCase();
+    if (setupType === "system") {
+      wantService = serviceAnswer !== "n";
+    } else {
+      wantService = serviceAnswer === "y" || serviceAnswer === "yes";
+    }
+  } else {
+    if (!flags.name) {
+      console.error("Error: --name is required in non-interactive mode.");
+      console.error("Usage: volute setup --name <name> [--system] [--service] [--dir <path>]");
+      process.exit(1);
+    }
+    systemName = flags.name;
+    setupType = flags.system ? "system" : "local";
+    wantService = flags.service ?? setupType === "system";
+    if (setupType === "system" && process.getuid?.() !== 0) {
+      console.error("Error: system install requires root (use sudo).");
+      process.exit(1);
+    }
+  }
+  if (host) validateHost(host);
+  console.log("\nSetting up...");
+  let isolation;
+  let mindsDir;
+  let configHome;
+  if (setupType === "system") {
+    configHome = DATA_DIR;
+    mindsDir = MINDS_DIR;
+    isolation = "user";
+    process.env.VOLUTE_HOME = DATA_DIR;
+    process.env.VOLUTE_MINDS_DIR = MINDS_DIR;
+    setupSystemDirectories();
+    ensureVoluteGroup({ force: true });
+    console.log("  Ensured volute group exists");
+    setupSystemGitIdentity();
+    const voluteBin = resolveVoluteBin();
+    setupSystemWrapper(voluteBin);
+    setupSystemEnvProfile();
+    if (wantService) {
+      if (!installSystemService(voluteBin, port, host)) wantService = false;
+    }
+  } else {
+    configHome = flags.dir ? resolve(flags.dir) : resolve(homedir(), ".volute");
+    if (flags.dir) {
+      process.env.VOLUTE_HOME = configHome;
+    }
+    mindsDir = resolve(configHome, "minds");
+    isolation = "sandbox";
+    mkdirSync(configHome, { recursive: true });
+    console.log(`  Created ${configHome}`);
+    mkdirSync(mindsDir, { recursive: true });
+    console.log("  Sandbox enabled for mind isolation");
+    if (wantService) {
+      const voluteBin = resolveVoluteBin();
+      if (!await installUserService(voluteBin, port, host)) wantService = false;
+    }
+  }
+  const existingConfig = readGlobalConfig();
+  const setup = {
+    type: setupType,
+    mindsDir,
+    isolation,
+    service: wantService
+  };
+  const config = {
+    ...existingConfig,
+    name: systemName,
+    setup
+  };
+  if (port != null) config.port = port;
+  if (host) config.hostname = host;
+  writeGlobalConfig(config);
+  console.log(`
+Done! Use \`volute mind create <name>\` to create your first mind.`);
+}
+export {
+  run
+};