volute 0.25.0 → 0.27.0

package/dist/{seed-6FEKB3YC.js → seed-SSUCYYDF.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-I42FK2BF.js");
   const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
   const client = getClient();
   const createRes = await daemonFetch(urlOf(client.api.minds.$url()), {
@@ -64,7 +64,7 @@ async function run(args) {
 Seeded mind: ${name} (port ${createData.port})`);
   console.log(`
 Talk to your new mind:`);
-  console.log(`  volute send @${name} "hello"`);
+  console.log(`  volute chat send @${name} "hello"`);
 }
 export {
   run

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

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
 import {
-  getClient,
-  urlOf
-} from "./chunk-4RQBJWQX.js";
+  readStdin
+} from "./chunk-ZYGKG6VC.js";
 import {
   resolveMindName
 } from "./chunk-NAOW2CLO.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-TRQEV3CD.js";
+} from "./chunk-JGFVMROS.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
 import {
-  findMind
-} from "./chunk-B2CPS4QU.js";
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-H7OZRFJB.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/send.ts
@@ -51,24 +52,15 @@ function parseTarget(target) {
   };
 }
 
-// src/lib/read-stdin.ts
-import { isatty } from "tty";
-async function readStdin() {
-  if (isatty(0)) return void 0;
-  const chunks = [];
+// src/commands/send.ts
+async function isMind(name) {
   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 res = await daemonFetch(`/api/minds/${encodeURIComponent(name)}`);
+    return res.ok;
+  } catch {
+    return false;
   }
-  const text = Buffer.concat(chunks).toString().replace(/\r?\n$/, "");
-  return text || void 0;
 }
-
-// src/commands/send.ts
 var IMAGE_MEDIA_TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -170,28 +162,28 @@ async function run(args) {
   const images = flags.image ? [loadImage(flags.image)] : void 0;
   if (!target || !message && !images) {
     console.error(
-      'Usage: volute send <target> "<message>" [--mind <name>] [--image <path>] [--wait]'
+      'Usage: volute chat send <target> "<message>" [--mind <name>] [--image <path>] [--wait]'
     );
-    console.error('       echo "message" | volute send <target> [--mind <name>]');
+    console.error('       echo "message" | volute chat send <target> [--mind <name>]');
     console.error("");
     console.error("Examples:");
-    console.error('  volute send @other-mind "hello"');
-    console.error('  volute send animal-chat "hello everyone"');
-    console.error('  volute send discord:server/channel "hello"');
-    console.error('  volute send @mind "check this out" --image photo.png');
-    console.error("  volute send @mind --image photo.png");
-    console.error('  volute send @mind "hello" --wait');
+    console.error('  volute chat send @other-mind "hello"');
+    console.error('  volute chat send animal-chat "hello everyone"');
+    console.error('  volute chat send discord:server/channel "hello"');
+    console.error('  volute chat send @mind "check this out" --image photo.png');
+    console.error("  volute chat send @mind --image photo.png");
+    console.error('  volute chat send @mind "hello" --wait');
     process.exit(1);
   }
   if (target === "system" || target === "@system") {
     console.error(
       `Can't send to system \u2014 system messages are automated.
-To reply to a person, use their username from the message prefix (e.g. volute send @username "msg").`
+To reply to a person, use their username from the message prefix (e.g. volute chat send @username "msg").`
     );
     process.exit(1);
   }
   let parsed = parseTarget(target);
-  if (!parsed.isDM && parsed.platform === "volute" && findMind(parsed.identifier)) {
+  if (!parsed.isDM && parsed.platform === "volute" && await isMind(parsed.identifier)) {
     parsed = {
       platform: "volute",
       identifier: `@${parsed.identifier}`,
@@ -206,8 +198,8 @@ To reply to a person, use their username from the message prefix (e.g. volute se
     const targetName = parsed.identifier.slice(1);
     const mindSelf = process.env.VOLUTE_MIND;
     const sender = flags.sender || mindSelf || userInfo().username;
-    waitMindName = findMind(targetName) ? targetName : void 0;
-    const targetIsMind = !!findMind(targetName);
+    const targetIsMind = await isMind(targetName);
+    waitMindName = targetIsMind ? targetName : void 0;
     const contextMind = mindSelf && !targetIsMind ? mindSelf : targetName;
     const participants = mindSelf && !targetIsMind ? [targetName] : [sender];
     const createRes = await daemonFetch(

package/dist/service-6LIN3F3K.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-LAC664WU.js";
+import "./chunk-AW7PFDVN.js";
+import "./chunk-RKQEHRBB.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-H7OZRFJB.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-JG4QAEBV.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+import {
+  promptLine
+} from "./chunk-SSI47XP2.js";
+import {
+  LAUNCHD_PLIST_LABEL,
+  LAUNCHD_PLIST_PATH,
+  SYSTEM_LAUNCHD_PLIST_PATH,
+  SYSTEM_SERVICE_PATH,
+  USER_SYSTEMD_UNIT
+} from "./chunk-LAC664WU.js";
+import {
+  resolveVoluteBin
+} from "./chunk-AW7PFDVN.js";
+import {
+  ensureVoluteGroup
+} from "./chunk-RKQEHRBB.js";
+import {
+  readGlobalConfig,
+  writeGlobalConfig
+} from "./chunk-IKRVFPWU.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-H7OZRFJB.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/system/daemon.log" : resolve(homedir(), ".volute", "system", "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
+};

package/dist/setup-JHL5ZEST.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  configPath,
+  isSetupComplete,
+  migrateSetupConfig,
+  readGlobalConfig,
+  writeGlobalConfig
+} from "./chunk-IKRVFPWU.js";
+import "./chunk-H7OZRFJB.js";
+import "./chunk-K3NQKI34.js";
+export {
+  configPath,
+  isSetupComplete,
+  migrateSetupConfig,
+  readGlobalConfig,
+  writeGlobalConfig
+};

package/dist/{shared-LWMNTTZN.js → shared-ML5I4Q2A.js}

@@ -6,16 +6,16 @@ async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
     case "merge":
-      await import("./merge-KSFJKX6T.js").then((m) => m.run(args.slice(1)));
+      await import("./merge-LNSMSAOF.js").then((m) => m.run(args.slice(1)));
       break;
     case "pull":
-      await import("./pull-D32SPFVU.js").then((m) => m.run(args.slice(1)));
+      await import("./pull-XCHJTM5M.js").then((m) => m.run(args.slice(1)));
       break;
     case "log":
-      await import("./log-6SGSSR3D.js").then((m) => m.run(args.slice(1)));
+      await import("./log-ABYNVYJ3.js").then((m) => m.run(args.slice(1)));
       break;
     case "status":
-      await import("./status-LYS4NUOZ.js").then((m) => m.run(args.slice(1)));
+      await import("./status-7GA4SM4Y.js").then((m) => m.run(args.slice(1)));
       break;
     case "--help":
     case "-h":

package/dist/{skill-T3EMR6IR.js → skill-AUAQTSP5.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
+import {
+  resolveMindName
+} from "./chunk-NAOW2CLO.js";
+import {
+  daemonFetch
+} from "./chunk-JGFVMROS.js";
 import {
   getClient,
   urlOf
 } from "./chunk-4RQBJWQX.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-H7OZRFJB.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/skill.ts