volute 0.18.0 → 0.20.0

package/dist/chunk-TIWH32HP.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  gitExec
+} from "./chunk-DYZGP3EW.js";
+import {
+  isIsolationEnabled,
+  mindUserName
+} from "./chunk-OGXOMR65.js";
+import {
+  voluteHome
+} from "./chunk-EBGCNDMM.js";
+
+// src/lib/shared.ts
+import { execFileSync } from "child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function readWorktreeGitDir(worktreePath) {
+  const dotGit = resolve(worktreePath, ".git");
+  if (!existsSync(dotGit)) return null;
+  try {
+    const content = readFileSync(dotGit, "utf-8").trim();
+    const match = content.match(/^gitdir:\s*(.+)$/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function sharedDir() {
+  return resolve(voluteHome(), "shared");
+}
+async function ensureSharedRepo() {
+  const dir = sharedDir();
+  mkdirSync(dir, { recursive: true });
+  if (existsSync(resolve(dir, ".git"))) {
+    try {
+      await gitExec(["rev-parse", "HEAD"], { cwd: dir });
+      return;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("unknown revision") || msg.includes("bad default revision")) {
+        logger_default.warn("shared repo has no commits, re-initializing");
+        rmSync(resolve(dir, ".git"), { recursive: true, force: true });
+      } else {
+        throw err;
+      }
+    }
+  }
+  const initArgs = isIsolationEnabled() ? ["init", "--shared=group"] : ["init"];
+  await gitExec(initArgs, { cwd: dir });
+  await gitExec(["checkout", "-b", "main"], { cwd: dir });
+  const pagesDir = resolve(dir, "pages");
+  mkdirSync(pagesDir, { recursive: true });
+  writeFileSync(resolve(pagesDir, ".gitkeep"), "");
+  await gitExec(["add", "-A"], { cwd: dir });
+  await gitExec(["commit", "-m", "init shared repo"], { cwd: dir });
+  if (isIsolationEnabled()) {
+    try {
+      execFileSync("chgrp", ["-R", "volute", dir], { stdio: "ignore" });
+    } catch (err) {
+      logger_default.warn("failed to chgrp shared repo to volute group", logger_default.errorData(err));
+    }
+    chmodSync(dir, 1533);
+  }
+}
+async function addSharedWorktree(mindName, mindDir) {
+  const dir = sharedDir();
+  if (!existsSync(resolve(dir, ".git"))) return;
+  const worktreePath = resolve(mindDir, "home", "shared");
+  if (existsSync(worktreePath)) return;
+  let branchExists = false;
+  try {
+    await gitExec(["rev-parse", "--verify", mindName], { cwd: dir });
+    branchExists = true;
+  } catch {
+  }
+  if (branchExists) {
+    await gitExec(["worktree", "add", worktreePath, mindName], { cwd: dir });
+  } else {
+    await gitExec(["worktree", "add", "-b", mindName, worktreePath], { cwd: dir });
+  }
+  if (isIsolationEnabled()) {
+    const worktreeGitDir = readWorktreeGitDir(worktreePath);
+    if (worktreeGitDir) {
+      try {
+        const user = mindUserName(mindName);
+        execFileSync("chown", ["-R", `${user}:volute`, worktreeGitDir], { stdio: "ignore" });
+      } catch (err) {
+        logger_default.warn(`failed to chown worktree git dir for ${mindName}`, logger_default.errorData(err));
+      }
+    }
+  }
+}
+async function removeSharedWorktree(mindName, mindDir) {
+  const dir = sharedDir();
+  if (!existsSync(resolve(dir, ".git"))) return;
+  const worktreePath = resolve(mindDir, "home", "shared");
+  if (existsSync(worktreePath)) {
+    try {
+      await gitExec(["worktree", "remove", "--force", worktreePath], { cwd: dir });
+    } catch (err) {
+      logger_default.debug(`worktree remove failed for ${mindName}`, logger_default.errorData(err));
+    }
+  }
+  try {
+    await gitExec(["worktree", "prune"], { cwd: dir });
+  } catch (err) {
+    logger_default.debug(`worktree prune failed for ${mindName}`, logger_default.errorData(err));
+  }
+  try {
+    await gitExec(["branch", "-D", mindName], { cwd: dir });
+  } catch {
+  }
+}
+var sharedLock = Promise.resolve();
+function rechownWorktree(worktreePath, mindName) {
+  if (!isIsolationEnabled()) return;
+  try {
+    const user = mindUserName(mindName);
+    execFileSync("chown", ["-R", `${user}:volute`, worktreePath], { stdio: "ignore" });
+  } catch (err) {
+    logger_default.warn(`failed to rechown worktree for ${mindName}`, logger_default.errorData(err));
+  }
+}
+async function withSharedLock(fn) {
+  const prev = sharedLock;
+  let resolve_;
+  sharedLock = new Promise((r) => {
+    resolve_ = r;
+  });
+  await prev;
+  try {
+    return await fn();
+  } finally {
+    resolve_();
+  }
+}
+async function sharedMerge(mindName, mindDir, message) {
+  return withSharedLock(async () => {
+    const dir = sharedDir();
+    const worktreePath = resolve(mindDir, "home", "shared");
+    const status = (await gitExec(["status", "--porcelain"], { cwd: worktreePath })).trim();
+    if (status) {
+      await gitExec(["add", "-A"], { cwd: worktreePath });
+      await gitExec(
+        ["commit", "--author", `${mindName} <${mindName}@volute>`, "-m", `wip: ${mindName}`],
+        { cwd: worktreePath }
+      );
+    }
+    const diff = (await gitExec(["diff", `main...${mindName}`, "--stat"], { cwd: dir })).trim();
+    if (!diff) {
+      return { ok: true, message: "Nothing to merge" };
+    }
+    try {
+      await gitExec(["merge", "--squash", mindName], { cwd: dir });
+    } catch {
+      try {
+        await gitExec(["reset", "--hard", "HEAD"], { cwd: dir });
+      } catch (resetErr) {
+        logger_default.error("reset after squash conflict failed in shared repo", logger_default.errorData(resetErr));
+      }
+      return { ok: false, conflicts: true, message: "Merge conflicts detected" };
+    }
+    await gitExec(["commit", "--author", `${mindName} <${mindName}@volute>`, "-m", message], {
+      cwd: dir
+    });
+    try {
+      await gitExec(["reset", "--hard", "main"], { cwd: worktreePath });
+    } catch {
+      return {
+        ok: true,
+        message: "Merged to main, but branch reset failed \u2014 run 'volute shared pull' to sync"
+      };
+    }
+    rechownWorktree(worktreePath, mindName);
+    return { ok: true };
+  });
+}
+async function sharedPull(mindName, mindDir) {
+  return withSharedLock(async () => {
+    const worktreePath = resolve(mindDir, "home", "shared");
+    const status = (await gitExec(["status", "--porcelain"], { cwd: worktreePath })).trim();
+    if (status) {
+      await gitExec(["add", "-A"], { cwd: worktreePath });
+      await gitExec(
+        ["commit", "--author", `${mindName} <${mindName}@volute>`, "-m", `wip: ${mindName}`],
+        { cwd: worktreePath }
+      );
+    }
+    try {
+      await gitExec(["rebase", "main"], { cwd: worktreePath });
+      rechownWorktree(worktreePath, mindName);
+      return { ok: true };
+    } catch {
+      try {
+        await gitExec(["rebase", "--abort"], { cwd: worktreePath });
+      } catch {
+        return {
+          ok: false,
+          message: "Rebase failed and abort failed \u2014 shared worktree may need manual repair"
+        };
+      }
+      return { ok: false, message: "Rebase failed \u2014 conflicts with main" };
+    }
+  });
+}
+async function sharedLog(limit = 20) {
+  const dir = sharedDir();
+  return gitExec(["log", "--oneline", "-n", String(limit), "main"], { cwd: dir });
+}
+async function sharedStatus(mindName) {
+  const dir = sharedDir();
+  return gitExec(["diff", `main...${mindName}`, "--stat"], { cwd: dir });
+}
+
+export {
+  sharedDir,
+  ensureSharedRepo,
+  addSharedWorktree,
+  removeSharedWorktree,
+  sharedMerge,
+  sharedPull,
+  sharedLog,
+  sharedStatus
+};

package/dist/{chunk-FW5API7X.js → chunk-UJ6GHNR7.js}

@@ -5,10 +5,10 @@ import {
   slugify,
   splitMessage,
   writeChannelEntry
-} from "./chunk-GK4E7LM7.js";
+} from "./chunk-RHEGSQFJ.js";
 import {
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";

package/dist/chunk-UU7A7KLB.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  getDb
+} from "./chunk-5XNT2472.js";
+import {
+  activity
+} from "./chunk-NSE7VJQA.js";
+
+// src/lib/activity-events.ts
+var subscribers = /* @__PURE__ */ new Set();
+function subscribe(callback) {
+  subscribers.add(callback);
+  return () => {
+    subscribers.delete(callback);
+  };
+}
+async function publish(event) {
+  const created_at = event.created_at ?? (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  let id = 0;
+  try {
+    const db = await getDb();
+    const result = await db.insert(activity).values({
+      type: event.type,
+      mind: event.mind,
+      summary: event.summary,
+      metadata: event.metadata ? JSON.stringify(event.metadata) : null,
+      created_at
+    });
+    id = Number(result.lastInsertRowid);
+  } catch (err) {
+    logger_default.error("[activity-events] failed to persist activity", logger_default.errorData(err));
+  }
+  const full = { ...event, id, created_at };
+  notify(full);
+}
+function broadcast(event) {
+  const created_at = event.created_at ?? (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  notify({ ...event, id: 0, created_at });
+}
+function notify(event) {
+  for (const cb of subscribers) {
+    try {
+      cb(event);
+    } catch (err) {
+      logger_default.error("[activity-events] subscriber threw:", logger_default.errorData(err));
+      subscribers.delete(cb);
+    }
+  }
+}
+
+export {
+  subscribe,
+  publish,
+  broadcast
+};

package/dist/{chunk-OYSZNX5I.js → chunk-VDWCHYTS.js}

@@ -2,7 +2,7 @@
 import {
   stateDir,
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/lib/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-OJQ47SCA.js → chunk-WC6ZHVRL.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";

package/dist/chunk-YUIHSKR6.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+// src/lib/log-buffer.ts
+var LogBuffer = class {
+  entries = [];
+  maxSize = 1e3;
+  subscribers = /* @__PURE__ */ new Set();
+  append(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.maxSize) {
+      this.entries.shift();
+    }
+    for (const sub of this.subscribers) {
+      sub(entry);
+    }
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => this.subscribers.delete(fn);
+  }
+};
+var logBuffer = new LogBuffer();
+
+// src/lib/logger.ts
+var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var minLevel = LEVELS[process.env.VOLUTE_LOG_LEVEL || "info"] ?? LEVELS.info;
+var output = (line) => process.stderr.write(`${line}
+`);
+function write(level, cat, msg, data) {
+  if (LEVELS[level] < minLevel) return;
+  const entry = {
+    level,
+    cat,
+    msg,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    ...data ? { data } : {}
+  };
+  output(JSON.stringify(entry));
+  logBuffer.append(entry);
+}
+function child(cat) {
+  return {
+    debug: (msg, data) => write("debug", cat, msg, data),
+    info: (msg, data) => write("info", cat, msg, data),
+    warn: (msg, data) => write("warn", cat, msg, data),
+    error: (msg, data) => write("error", cat, msg, data)
+  };
+}
+function errorData(err) {
+  if (err instanceof Error) return { error: err.stack ?? err.message };
+  return { error: String(err) };
+}
+var log = {
+  ...child("system"),
+  child,
+  errorData,
+  setLevel(level) {
+    minLevel = LEVELS[level];
+  },
+  setOutput(fn) {
+    output = fn;
+  }
+};
+var logger_default = log;
+
+export {
+  logBuffer,
+  logger_default
+};

package/dist/cli.js

@@ -9,76 +9,82 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-OKLFO7UY.js");
+  const { default: pkg } = await import("./package-4NHAVUUI.js");
   console.log(pkg.version);
   process.exit(0);
 }
 switch (command) {
   case "mind":
-    await import("./mind-OJN6RBZW.js").then((m) => m.run(args));
+    await import("./mind-Z7CKD6DG.js").then((m) => m.run(args));
     break;
   case "send":
-    await import("./send-BNDTLUPM.js").then((m) => m.run(args));
+    await import("./send-KVIZIGCE.js").then((m) => m.run(args));
     break;
   case "history":
-    await import("./history-YUEKTJ2N.js").then((m) => m.run(args));
+    await import("./history-WNK3DFUM.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-X5QFG6KK.js").then((m) => m.run(args));
+    await import("./variant-63ZWO2W7.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-3ELFMI2R.js").then((m) => m.run(args));
+    await import("./connector-JBVNZ7VK.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-SLURLIRV.js").then((m) => m.run(args));
+    await import("./channel-PUQKGSQM.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-AGYLDMNS.js").then((m) => m.run(args));
+    await import("./schedule-FFZG23IW.js").then((m) => m.run(args));
     break;
   case "skill":
-    await import("./skill-2Y42P4JY.js").then((m) => m.run(args));
+    await import("./skill-BCVNI6TV.js").then((m) => m.run(args));
+    break;
+  case "shared":
+    await import("./shared-KO35ZM44.js").then((m) => m.run(args));
+    break;
+  case "file":
+    await import("./file-C57SK5DK.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-6IDWGBUH.js").then((m) => m.run(args));
+    await import("./env-A3LMO777.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-7B3BWF2U.js").then((m) => m.run(args));
+    await import("./up-FS7CKM6V.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-A56B5JLK.js").then((m) => m.run(args));
+    await import("./down-ZY35KMHR.js").then((m) => m.run(args));
     break;
   case "restart":
-    await import("./daemon-restart-2HVTHZAT.js").then((m) => m.run(args));
+    await import("./daemon-restart-KPSWNYTH.js").then((m) => m.run(args));
     break;
   case "setup":
-    await import("./setup-DJKIZKGW.js").then((m) => m.run(args));
+    await import("./setup-52YRV7VP.js").then((m) => m.run(args));
     break;
   case "service":
-    await import("./service-U7MZ2H7F.js").then((m) => m.run(args));
+    await import("./service-LUR7WDO7.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-YAGN5ODG.js").then((m) => m.run(args));
+    await import("./update-FJIHDJKM.js").then((m) => m.run(args));
     break;
   case "status":
-    await import("./status-VSFZYX7S.js").then((m) => m.run(args));
+    await import("./status-4ESFLGH4.js").then((m) => m.run(args));
     break;
   case "seed":
-    await import("./seed-AP4Q7RZ7.js").then((m) => m.run(args));
+    await import("./seed-J43YDKXG.js").then((m) => m.run(args));
     break;
   case "sprout":
-    await import("./sprout-TJ3BHVOG.js").then((m) => m.run(args));
+    await import("./sprout-QN7Y4VVO.js").then((m) => m.run(args));
     break;
   case "pages":
-    await import("./pages-6IV4VQTU.js").then((m) => m.run(args));
+    await import("./pages-4DGQT7ZA.js").then((m) => m.run(args));
     break;
   case "register":
-    await import("./register-LDE6LRXY.js").then((m) => m.run(args));
+    await import("./register-VSPCMHKX.js").then((m) => m.run(args));
     break;
   case "login":
-    await import("./login-ORQDXLBM.js").then((m) => m.run(args));
+    await import("./login-HNH3EUQV.js").then((m) => m.run(args));
     break;
   case "logout":
-    await import("./logout-XC5AUO5I.js").then((m) => m.run());
+    await import("./logout-I5CB5UZS.js").then((m) => m.run());
     break;
   case "--help":
   case "-h":
@@ -126,6 +132,18 @@ Commands:
   volute skill remove <name>             Remove a shared skill
   volute skill uninstall <name> --mind   Uninstall a skill from a mind
 
+  volute file send <path> <mind>           Send a file to another mind
+  volute file list                         List pending incoming files
+  volute file accept <id>                  Accept a pending file
+  volute file reject <id>                  Reject a pending file
+  volute file trust <sender>               Trust a sender (auto-deliver)
+  volute file untrust <sender>             Remove sender trust
+
+  volute shared merge "<msg>"              Merge shared changes to main
+  volute shared pull                       Pull latest shared changes
+  volute shared log                        Show shared repo history
+  volute shared status                     Show pending changes diff
+
   volute env <set|get|list|remove>        Manage environment variables
 
   volute up [--port N]                    Start the daemon (default: 4200)
@@ -155,7 +173,7 @@ Options:
   --version, -v                           Show version number
   --help, -h                              Show this help message
 
-Mind-scoped commands (send, history, variant, connector, schedule, channel, skill, pages)
+Mind-scoped commands (send, history, variant, connector, schedule, channel, file, skill, shared, pages)
 use --mind <name> or VOLUTE_MIND env var to identify the mind.`);
     break;
   default:
@@ -164,7 +182,7 @@ Run 'volute --help' for usage.`);
     process.exit(1);
 }
 if (command !== "update") {
-  import("./update-check-APLTH4IN.js").then((m) => m.checkForUpdate()).then((result) => {
+  import("./update-check-MWE5AH4U.js").then((m) => m.checkForUpdate()).then((result) => {
     if (result.updateAvailable) {
       console.error(`
   Update available: ${result.current} \u2192 ${result.latest}`);

package/dist/{connector-3ELFMI2R.js → connector-JBVNZ7VK.js}

@@ -2,6 +2,10 @@
 import {
   promptLine
 } from "./chunk-RVKR2R7F.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
 import {
   resolveMindName
 } from "./chunk-NAOW2CLO.js";
@@ -10,12 +14,8 @@ import {
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-OJQ47SCA.js";
-import "./chunk-M77QBTEH.js";
-import {
-  getClient,
-  urlOf
-} from "./chunk-4RQBJWQX.js";
+} from "./chunk-WC6ZHVRL.js";
+import "./chunk-EBGCNDMM.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/connector.ts

package/dist/connectors/discord.js

@@ -7,8 +7,8 @@ import {
   sendToMind,
   slugify,
   writeChannelEntry
-} from "../chunk-GK4E7LM7.js";
-import "../chunk-M77QBTEH.js";
+} from "../chunk-RHEGSQFJ.js";
+import "../chunk-EBGCNDMM.js";
 import "../chunk-K3NQKI34.js";
 
 // src/connectors/discord.ts

package/dist/connectors/slack.js

@@ -6,8 +6,8 @@ import {
   onShutdown,
   sendToMind,
   writeChannelEntry
-} from "../chunk-GK4E7LM7.js";
-import "../chunk-M77QBTEH.js";
+} from "../chunk-RHEGSQFJ.js";
+import "../chunk-EBGCNDMM.js";
 import "../chunk-K3NQKI34.js";
 
 // src/connectors/slack.ts

package/dist/connectors/telegram.js

@@ -5,8 +5,8 @@ import {
   loadFollowedChannels,
   sendToMind,
   writeChannelEntry
-} from "../chunk-GK4E7LM7.js";
-import "../chunk-M77QBTEH.js";
+} from "../chunk-RHEGSQFJ.js";
+import "../chunk-EBGCNDMM.js";
 import "../chunk-K3NQKI34.js";
 
 // src/connectors/telegram.ts

package/dist/{create-ZWHCRT5F.js → create-HP4OVVHF.js}

@@ -7,21 +7,23 @@ import "./chunk-K3NQKI34.js";
 // src/commands/create.ts
 async function run(args) {
   const { positional, flags } = parseArgs(args, {
-    template: { type: "string" }
+    template: { type: "string" },
+    skills: { type: "string" }
   });
   const name = positional[0];
   const template = flags.template ?? "claude";
   if (!name) {
-    console.error("Usage: volute mind create <name> [--template <name>]");
+    console.error("Usage: volute mind create <name> [--template <name>] [--skills <list|none>]");
     process.exit(1);
   }
-  const { daemonFetch } = await import("./daemon-client-ODKDUYDE.js");
+  const skills = flags.skills === "none" ? [] : flags.skills ? flags.skills.split(",") : void 0;
+  const { daemonFetch } = await import("./daemon-client-ITWUCNFO.js");
   const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
   const client = getClient();
   const res = await daemonFetch(urlOf(client.api.minds.$url()), {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ name, template })
+    body: JSON.stringify({ name, template, skills })
   });
   const data = await res.json();
   if (!res.ok) {

package/dist/{daemon-client-ODKDUYDE.js → daemon-client-ITWUCNFO.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   daemonFetch
-} from "./chunk-OJQ47SCA.js";
-import "./chunk-M77QBTEH.js";
+} from "./chunk-WC6ZHVRL.js";
+import "./chunk-EBGCNDMM.js";
 import "./chunk-K3NQKI34.js";
 export {
   daemonFetch

package/dist/{daemon-restart-2HVTHZAT.js → daemon-restart-KPSWNYTH.js}

@@ -1,21 +1,21 @@
 #!/usr/bin/env node
 import {
   run
-} from "./chunk-6DVBMLVN.js";
+} from "./chunk-7UFKREVW.js";
 import {
   stopDaemon
-} from "./chunk-QJIIHU32.js";
+} from "./chunk-7NO7EV5Z.js";
 import {
   getServiceMode,
   modeLabel,
   pollHealth,
   readDaemonConfig,
   restartService
-} from "./chunk-6BDNWYKG.js";
-import "./chunk-2Y77MCFG.js";
-import "./chunk-ZCEYUUID.js";
+} from "./chunk-32VR2EOH.js";
 import "./chunk-D424ZQGI.js";
-import "./chunk-M77QBTEH.js";
+import "./chunk-DYZGP3EW.js";
+import "./chunk-OGXOMR65.js";
+import "./chunk-EBGCNDMM.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/daemon-restart.ts