volute 0.25.0 → 0.27.0

package/dist/{chunk-SHSWYG2J.js → chunk-PHSAT7YL.js}

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 import {
-  loadMergedEnv
-} from "./chunk-PHU4DEAJ.js";
+  isSandboxEnabled,
+  wrapForSandbox
+} from "./chunk-USUXRNVD.js";
 import {
-  getDb,
-  mindHistory,
-  systemPrompts
-} from "./chunk-33XAVCS4.js";
+  loadMergedEnv
+} from "./chunk-2WPW7OT6.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
@@ -14,16 +13,17 @@ import {
   chownMindDir,
   isIsolationEnabled,
   wrapForIsolation
-} from "./chunk-NWPT4ASZ.js";
+} from "./chunk-RKQEHRBB.js";
 import {
   findMind,
-  findVariant,
+  getDb,
   mindDir,
+  mindHistory,
   setMindRunning,
-  setVariantRunning,
   stateDir,
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  systemPrompts,
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/daemon/mind-manager.ts
 import { execFile, spawn } from "child_process";
@@ -82,8 +82,7 @@ var PROMPT_KEYS = [
   "reply_instructions",
   "channel_invite",
   "pre_sleep",
-  "wake_summary",
-  "wake_trigger_summary"
+  "wake_summary"
 ];
 var PROMPT_DEFAULTS = {
   seed_soul: {
@@ -141,7 +140,7 @@ Have a conversation with the human. Explore what kind of mind you want to be. Wh
     category: "mind"
   },
   reply_instructions: {
-    content: 'To reply to this message, use: volute send ${channel} "your message"',
+    content: 'To reply to this message, use: volute chat send ${channel} "your message"',
     description: "First-message reply hint injected via hook",
     variables: ["channel"],
     category: "mind"
@@ -157,7 +156,7 @@ Further messages will be saved to \${filePath}
 
 To accept, add to .config/routes.json:
   Rule: { "channel": "\${channel}", "session": "\${suggestedSession}" }
-\${batchRecommendation}To respond, use: volute send \${channel} "your message"
+\${batchRecommendation}To respond, use: volute chat send \${channel} "your message"
 To reject, delete \${filePath}`,
     description: "New channel notification template",
     variables: [
@@ -179,15 +178,9 @@ To reject, delete \${filePath}`,
     category: "system"
   },
   wake_summary: {
-    content: "Good morning \u2014 it's ${currentDate}. You slept from ${sleepTime} to now (${duration}).\n\n${queuedSummary}",
+    content: "Good morning \u2014 it's ${currentDate}. You slept from ${sleepTime} to now (${duration}).\n\n${sleepActivity}",
     description: "Wake-up summary after scheduled sleep",
-    variables: ["currentDate", "sleepTime", "duration", "queuedSummary"],
-    category: "system"
-  },
-  wake_trigger_summary: {
-    content: "You were woken during sleep by a message on ${triggerChannel}. It's ${currentDate} \u2014 you've been asleep since ${sleepTime} (${duration}).\n\nYou have this full turn to respond and handle anything else. You'll return to sleep when you go idle.\n\n${queuedSummary}",
-    description: "Wake-up summary when woken by a trigger message",
-    variables: ["currentDate", "triggerChannel", "sleepTime", "duration", "queuedSummary"],
+    variables: ["currentDate", "sleepTime", "duration", "sleepActivity"],
     category: "system"
   }
 };
@@ -295,6 +288,28 @@ var RotatingLog = class extends Writable {
   }
 };
 
+// src/lib/daemon/mind-tokens.ts
+import { randomUUID } from "crypto";
+var tokenToMind = /* @__PURE__ */ new Map();
+var mindToToken = /* @__PURE__ */ new Map();
+function generateMindToken(mindName) {
+  revokeMindToken(mindName);
+  const token = randomUUID();
+  tokenToMind.set(token, mindName);
+  mindToToken.set(mindName, token);
+  return token;
+}
+function revokeMindToken(mindName) {
+  const token = mindToToken.get(mindName);
+  if (token) {
+    tokenToMind.delete(token);
+    mindToToken.delete(mindName);
+  }
+}
+function resolveMindToken(token) {
+  return tokenToMind.get(token) ?? null;
+}
+
 // src/lib/daemon/restart-tracker.ts
 var DEFAULT_MAX_ATTEMPTS = 5;
 var DEFAULT_BASE_DELAY = 3e3;
@@ -352,25 +367,23 @@ var MindManager = class {
   shuttingDown = false;
   restartTracker = new RestartTracker();
   pendingContext = /* @__PURE__ */ new Map();
-  resolveTarget(name) {
-    const [baseName, variantName] = name.split("@", 2);
-    const entry = findMind(baseName);
-    if (!entry) throw new Error(`Unknown mind: ${baseName}`);
-    if (variantName) {
-      const variant = findVariant(baseName, variantName);
-      if (!variant) throw new Error(`Unknown variant: ${variantName} (mind: ${baseName})`);
-      return { dir: variant.path, port: variant.port, isVariant: true, baseName, variantName };
+  async resolveTarget(name) {
+    const entry = await findMind(name);
+    if (!entry) throw new Error(`Unknown mind: ${name}`);
+    if (entry.parent) {
+      if (!entry.dir) throw new Error(`Variant ${name} has no directory`);
+      return { dir: entry.dir, port: entry.port, baseName: entry.parent };
     }
-    const dir = mindDir(baseName);
+    const dir = mindDir(name);
     if (!existsSync3(dir)) throw new Error(`Mind directory missing: ${dir}`);
-    return { dir, port: entry.port, isVariant: false, baseName };
+    return { dir, port: entry.port, baseName: name };
   }
   async startMind(name) {
     if (this.minds.has(name)) {
       throw new Error(`Mind ${name} is already running`);
     }
-    const target = this.resolveTarget(name);
-    const { dir, isVariant, baseName, variantName } = target;
+    const target = await this.resolveTarget(name);
+    const { dir, baseName } = target;
     const port = target.port;
     const pidFile = mindPidPath(name);
     try {
@@ -420,6 +433,7 @@ var MindManager = class {
       }
     }
     const logStream = new RotatingLog(resolve(logsDir, "mind.log"));
+    const mindToken = generateMindToken(name);
     const mindEnv = loadMergedEnv(name);
     const env = {
       ...process.env,
@@ -428,6 +442,7 @@ var MindManager = class {
       VOLUTE_STATE_DIR: stateDir(name),
       VOLUTE_MIND_DIR: dir,
       VOLUTE_MIND_PORT: String(port),
+      VOLUTE_DAEMON_TOKEN: mindToken,
       // Strip CLAUDECODE so the Agent SDK can spawn Claude Code subprocesses
       CLAUDECODE: void 0
     };
@@ -436,7 +451,16 @@ var MindManager = class {
     }
     const tsxBin = resolve(dir, "node_modules", ".bin", "tsx");
     const tsxArgs = ["src/server.ts", "--port", String(port)];
-    const [spawnCmd, spawnArgs] = wrapForIsolation(tsxBin, tsxArgs, name);
+    let spawnCmd;
+    let spawnArgs;
+    if (isIsolationEnabled()) {
+      [spawnCmd, spawnArgs] = await wrapForIsolation(tsxBin, tsxArgs, name);
+    } else if (isSandboxEnabled()) {
+      [spawnCmd, spawnArgs] = await wrapForSandbox(tsxBin, tsxArgs, dir, name);
+    } else {
+      spawnCmd = tsxBin;
+      spawnArgs = tsxArgs;
+    }
     const spawnOpts = {
       cwd: dir,
       stdio: ["ignore", "pipe", "pipe"],
@@ -486,11 +510,7 @@ var MindManager = class {
     }
     if (this.restartTracker.reset(name)) this.saveCrashAttempts();
     this.setupCrashRecovery(name, child);
-    if (isVariant) {
-      setVariantRunning(baseName, variantName, true);
-    } else {
-      setMindRunning(name, true);
-    }
+    await setMindRunning(name, true);
     mlog.info(`started mind ${name} on port ${port}`);
     await this.deliverPendingContext(name);
   }
@@ -548,28 +568,24 @@ var MindManager = class {
       if (this.shuttingDown || this.stopping.has(name)) return;
       mlog.error(`mind ${name} exited with code ${code}`);
       try {
-        const { getSleepManagerIfReady } = await import("./sleep-manager-RKTFZPD3.js");
-        if (getSleepManagerIfReady()?.isSleeping(name)) {
+        const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
+        const sleepState = getSleepManagerIfReady()?.getState(name);
+        if (sleepState?.sleeping) {
           mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
           return;
         }
       } catch (err) {
         mlog.warn(`failed to check sleep state for ${name}`, logger_default.errorData(err));
       }
-      import("./mind-activity-tracker-NMDDEV3K.js").then(({ markIdle }) => markIdle(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-4O37J7PD.js").then(
+      import("./mind-activity-tracker-EN6XNXPF.js").then(({ markIdle }) => markIdle(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
+      import("./activity-events-BBIEA2F4.js").then(
         ({ publish }) => publish({ type: "mind_stopped", mind: name, summary: `${name} crashed (exit ${code})` })
       ).catch((err) => mlog.warn(`failed to publish crash event for ${name}`, logger_default.errorData(err)));
       const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(name);
       this.saveCrashAttempts();
       if (!shouldRestart) {
         mlog.error(`${name} crashed ${attempt} times \u2014 giving up on restart`);
-        const [base, variant] = name.split("@", 2);
-        if (variant) {
-          setVariantRunning(base, variant, false);
-        } else {
-          setMindRunning(name, false);
-        }
+        await setMindRunning(name, false);
         return;
       }
       mlog.info(
@@ -605,15 +621,11 @@ var MindManager = class {
       }, 5e3);
     });
     this.stopping.delete(name);
+    revokeMindToken(name);
     if (this.restartTracker.reset(name)) this.saveCrashAttempts();
     rmSync2(mindPidPath(name), { force: true });
     if (!this.shuttingDown) {
-      const [baseName, variantName] = name.split("@", 2);
-      if (variantName) {
-        setVariantRunning(baseName, variantName, false);
-      } else {
-        setMindRunning(name, false);
-      }
+      await setMindRunning(name, false);
     }
     mlog.info(`stopped mind ${name}`);
   }
@@ -633,7 +645,7 @@ var MindManager = class {
     return [...this.minds.keys()];
   }
   get crashAttemptsPath() {
-    return resolve(voluteHome(), "crash-attempts.json");
+    return resolve(voluteSystemDir(), "crash-attempts.json");
   }
   loadCrashAttempts() {
     this.restartTracker.load(loadJsonMap(this.crashAttemptsPath));
@@ -696,6 +708,7 @@ export {
   loadJsonMap,
   saveJsonMap,
   clearJsonMap,
+  resolveMindToken,
   MindManager,
   initMindManager,
   getMindManager

package/dist/chunk-RKQEHRBB.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import {
+  getBaseName,
+  validateMindName
+} from "./chunk-H7OZRFJB.js";
+
+// src/lib/isolation.ts
+import { execFileSync } from "child_process";
+function isIsolationEnabled() {
+  return process.env.VOLUTE_ISOLATION === "user";
+}
+function mindUserName(mindName) {
+  const err = validateMindName(mindName);
+  if (err) throw new Error(`Invalid mind name for isolation: ${err}`);
+  const prefix = process.env.VOLUTE_USER_PREFIX ?? "mind-";
+  return `${prefix}${mindName}`;
+}
+function findNextMacId(type) {
+  const idField = type === "Users" ? "UniqueID" : "PrimaryGroupID";
+  let output;
+  try {
+    output = execFileSync("dscl", [".", "-list", `/${type}`, idField], { encoding: "utf-8" });
+  } catch (err) {
+    throw new Error(
+      `Failed to query ${type} via dscl: ${err instanceof Error ? err.message : err}`
+    );
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const line of output.split("\n")) {
+    const parts = line.trim().split(/\s+/);
+    const id = parseInt(parts[parts.length - 1], 10);
+    if (!Number.isNaN(id)) ids.add(id);
+  }
+  let next = 401;
+  while (ids.has(next)) next++;
+  return next;
+}
+function getVoluteGroupGid() {
+  if (process.platform === "darwin") {
+    const output2 = execFileSync("dscl", [".", "-read", "/Groups/volute", "PrimaryGroupID"], {
+      encoding: "utf-8"
+    });
+    const match = output2.match(/PrimaryGroupID:\s*(\d+)/);
+    if (!match) throw new Error("Could not read volute group GID");
+    return parseInt(match[1], 10);
+  }
+  const output = execFileSync("getent", ["group", "volute"], { encoding: "utf-8" });
+  const gid = parseInt(output.split(":")[2], 10);
+  if (Number.isNaN(gid)) throw new Error("Could not read volute group GID");
+  return gid;
+}
+function ensureVoluteGroup(opts) {
+  if (!opts?.force && !isIsolationEnabled()) return;
+  if (process.platform === "darwin") {
+    try {
+      execFileSync("dscl", [".", "-read", "/Groups/volute"], { stdio: "ignore" });
+      return;
+    } catch {
+    }
+    const gid = findNextMacId("Groups");
+    try {
+      execFileSync("dscl", [".", "-create", "/Groups/volute"]);
+      execFileSync("dscl", [".", "-create", "/Groups/volute", "PrimaryGroupID", String(gid)]);
+      execFileSync("dscl", [".", "-create", "/Groups/volute", "Password", "*"]);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to create volute group on macOS: ${msg}`);
+    }
+    return;
+  }
+  try {
+    execFileSync("getent", ["group", "volute"], { stdio: "ignore" });
+  } catch {
+    try {
+      execFileSync("groupadd", ["volute"], { stdio: ["ignore", "ignore", "pipe"] });
+    } catch (err) {
+      const stderr = err?.stderr?.toString().trim();
+      throw new Error(`Failed to create volute group${stderr ? `: ${stderr}` : ""}`);
+    }
+  }
+}
+function createMindUser(name, homeDir) {
+  if (!isIsolationEnabled()) return;
+  const user = mindUserName(name);
+  try {
+    execFileSync("id", [user], { stdio: "ignore" });
+    return;
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    const uid = findNextMacId("Users");
+    const gid = getVoluteGroupGid();
+    const home = homeDir ?? "/var/empty";
+    try {
+      execFileSync("dscl", [".", "-create", `/Users/${user}`]);
+      execFileSync("dscl", [".", "-create", `/Users/${user}`, "UniqueID", String(uid)]);
+      execFileSync("dscl", [".", "-create", `/Users/${user}`, "PrimaryGroupID", String(gid)]);
+      execFileSync("dscl", [".", "-create", `/Users/${user}`, "UserShell", "/usr/bin/false"]);
+      execFileSync("dscl", [".", "-create", `/Users/${user}`, "NFSHomeDirectory", home]);
+      execFileSync("dscl", [".", "-create", `/Users/${user}`, "RealName", `Volute Mind: ${name}`]);
+      execFileSync("dscl", [".", "-create", `/Users/${user}`, "IsHidden", "1"]);
+      execFileSync("dscl", [".", "-append", "/Groups/volute", "GroupMembership", user]);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to create user ${user} on macOS: ${msg}`);
+    }
+    return;
+  }
+  try {
+    const args = ["-r", "-M", "-G", "volute", "-s", "/usr/sbin/nologin"];
+    if (homeDir) args.push("-d", homeDir);
+    args.push(user);
+    execFileSync("useradd", args, {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+  } catch (err) {
+    const stderr = err?.stderr?.toString().trim();
+    throw new Error(`Failed to create user ${user}${stderr ? `: ${stderr}` : ""}`);
+  }
+}
+function deleteMindUser(name) {
+  if (!isIsolationEnabled()) return;
+  const user = mindUserName(name);
+  if (process.platform === "darwin") {
+    try {
+      execFileSync("dscl", [".", "-delete", `/Users/${user}`], { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      execFileSync("dscl", [".", "-delete", "/Groups/volute", "GroupMembership", user], {
+        stdio: "ignore"
+      });
+    } catch {
+    }
+    return;
+  }
+  try {
+    execFileSync("userdel", [user], { stdio: "ignore" });
+  } catch {
+  }
+}
+async function wrapForIsolation(cmd, args, mindName) {
+  if (!isIsolationEnabled()) return [cmd, args];
+  const baseName = await getBaseName(mindName);
+  const user = mindUserName(baseName);
+  if (process.platform === "darwin") {
+    return ["sudo", ["-u", user, "--", cmd, ...args]];
+  }
+  return ["runuser", ["-u", user, "--", cmd, ...args]];
+}
+function chownMindDir(dir, name) {
+  if (!isIsolationEnabled()) return;
+  const user = mindUserName(name);
+  const group = process.platform === "darwin" ? "volute" : user;
+  try {
+    execFileSync("chown", ["-R", `${user}:${group}`, dir], { stdio: ["ignore", "ignore", "pipe"] });
+  } catch (err) {
+    const stderr = err?.stderr?.toString().trim();
+    throw new Error(`Failed to chown ${dir} to ${user}:${group}${stderr ? `: ${stderr}` : ""}`);
+  }
+  try {
+    execFileSync("chmod", ["700", dir], { stdio: ["ignore", "ignore", "pipe"] });
+  } catch (err) {
+    const stderr = err?.stderr?.toString().trim();
+    throw new Error(`Failed to chmod ${dir}${stderr ? `: ${stderr}` : ""}`);
+  }
+}
+
+export {
+  isIsolationEnabled,
+  mindUserName,
+  ensureVoluteGroup,
+  createMindUser,
+  deleteMindUser,
+  wrapForIsolation,
+  chownMindDir
+};

package/dist/{chunk-RVKR2R7F.js → chunk-SSI47XP2.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/lib/prompt.ts
-function promptLine(prompt) {
+function rawPrompt(prompt, echo) {
   process.stderr.write(prompt);
   return new Promise((resolve) => {
     let value = "";
@@ -23,6 +23,7 @@ function promptLine(prompt) {
           value = value.slice(0, -1);
         } else {
           value += String.fromCharCode(byte);
+          if (echo) process.stderr.write(String.fromCharCode(byte));
         }
       }
     };
@@ -31,7 +32,14 @@ function promptLine(prompt) {
     process.stdin.on("data", onData);
   });
 }
+function promptLine(prompt) {
+  return rawPrompt(prompt, true);
+}
+function promptPassword(prompt) {
+  return rawPrompt(prompt, false);
+}
 
 export {
-  promptLine
+  promptLine,
+  promptPassword
 };

package/dist/chunk-T6HKBWXZ.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+// src/lib/slugify.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function buildVoluteSlug(opts) {
+  if (opts.convType === "channel" && opts.convName) {
+    return `volute:#${opts.convName}`;
+  }
+  const isDM = opts.participants.length === 2;
+  if (isDM) {
+    const other = opts.participants.find((p) => p.username !== opts.mindUsername);
+    const otherSlug = other ? slugify(other.username) : "";
+    return otherSlug ? `volute:@${otherSlug}` : `volute:${opts.conversationId}`;
+  }
+  return opts.convTitle ? `volute:${slugify(opts.convTitle)}` : `volute:${opts.conversationId}`;
+}
+
+export {
+  slugify,
+  buildVoluteSlug
+};

package/dist/chunk-USUXRNVD.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  readGlobalConfig
+} from "./chunk-IKRVFPWU.js";
+import {
+  getBaseName,
+  readRegistry,
+  voluteHome,
+  voluteSystemDir,
+  voluteUserHome
+} from "./chunk-H7OZRFJB.js";
+
+// src/lib/sandbox.ts
+import { resolve } from "path";
+var slog = logger_default.child("sandbox");
+var sandboxManager = null;
+function isSandboxEnabled() {
+  if (process.env.VOLUTE_SANDBOX === "0") return false;
+  return readGlobalConfig().setup?.isolation === "sandbox";
+}
+async function initSandbox() {
+  if (!isSandboxEnabled()) return;
+  try {
+    const { SandboxManager } = await import("@anthropic-ai/sandbox-runtime");
+    const config = {
+      network: {
+        allowedDomains: ["*"],
+        deniedDomains: [],
+        allowLocalBinding: true
+      },
+      filesystem: {
+        denyRead: [],
+        allowWrite: [],
+        denyWrite: []
+      }
+    };
+    await SandboxManager.initialize(config);
+    sandboxManager = SandboxManager;
+  } catch (err) {
+    slog.error(
+      "sandbox runtime not available \u2014 minds will run without sandbox isolation",
+      logger_default.errorData(err)
+    );
+  }
+}
+async function buildDenyRead(mindName, mindDir) {
+  const home = voluteHome();
+  const userHome = process.env.HOME || "";
+  const mindsDir = process.env.VOLUTE_MINDS_DIR || resolve(home, "minds");
+  const deny = [];
+  deny.push(voluteSystemDir());
+  const userVoluteHome = voluteUserHome();
+  if (userVoluteHome !== home) {
+    deny.push(userVoluteHome);
+  } else {
+    deny.push(resolve(home, "systems.json"));
+  }
+  try {
+    const entries = await readRegistry();
+    for (const entry of entries) {
+      if (entry.name === await getBaseName(mindName)) continue;
+      const otherDir = resolve(mindsDir, entry.name);
+      if (otherDir !== mindDir) {
+        deny.push(otherDir);
+      }
+    }
+  } catch (err) {
+    slog.warn("failed to read minds registry for deny-read list", logger_default.errorData(err));
+  }
+  if (userHome) {
+    deny.push(resolve(userHome, ".ssh"));
+    deny.push(resolve(userHome, ".aws"));
+    deny.push(resolve(userHome, ".gnupg"));
+    deny.push(resolve(userHome, ".config"));
+  }
+  return deny;
+}
+function shellEscape(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+async function wrapForSandbox(cmd, args, mindDir, mindName, allowWrite) {
+  if (!sandboxManager) return [cmd, args];
+  const denyRead = await buildDenyRead(mindName, mindDir);
+  const customConfig = {
+    filesystem: {
+      denyRead,
+      allowWrite: allowWrite ?? [mindDir],
+      denyWrite: []
+    }
+  };
+  try {
+    const shellCmd = [cmd, ...args].map(shellEscape).join(" ");
+    const wrapped = await sandboxManager.wrapWithSandbox(shellCmd, void 0, customConfig);
+    return ["bash", ["-c", wrapped]];
+  } catch (err) {
+    slog.error(
+      `failed to sandbox mind ${mindName} \u2014 running without isolation`,
+      logger_default.errorData(err)
+    );
+    return [cmd, args];
+  }
+}
+
+export {
+  isSandboxEnabled,
+  initSandbox,
+  buildDenyRead,
+  shellEscape,
+  wrapForSandbox
+};

package/dist/{chunk-BFK6SOEJ.js → chunk-VIVMW2H2.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import {
-  activity,
-  getDb
-} from "./chunk-33XAVCS4.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
+import {
+  activity,
+  getDb
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/events/activity-events.ts
 var subscribers = /* @__PURE__ */ new Set();

package/dist/{chunk-KTJGZ7M7.js → chunk-XBLSAVJF.js}

@@ -2,7 +2,7 @@
 import {
   mindDir,
   stateDir
-} from "./chunk-B2CPS4QU.js";
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/archive.ts
 import { execFileSync } from "child_process";

package/dist/chunk-ZYGKG6VC.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+// 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;
+}
+
+export {
+  readStdin
+};