volute 0.18.0 → 0.19.0

package/dist/chunk-4KPUF5JD.js

@@ -0,0 +1,214 @@
+#!/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, 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"))) return;
+  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-QJIIHU32.js → chunk-7NO7EV5Z.js}

@@ -5,10 +5,10 @@ import {
   pollHealthDown,
   readDaemonConfig,
   stopService
-} from "./chunk-6BDNWYKG.js";
+} from "./chunk-32VR2EOH.js";
 import {
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/commands/down.ts
 import { existsSync, readFileSync, unlinkSync } from "fs";

package/dist/chunk-AW7P4EVV.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import {
+  mindDir,
+  stateDir
+} from "./chunk-EBGCNDMM.js";
+
+// src/lib/archive.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join, relative, resolve } from "path";
+import AdmZip from "adm-zip";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".variants", ".git"]);
+function walkDir(dir, base, skipSessions) {
+  const results = [];
+  const baseDir = base ?? dir;
+  for (const entry of readdirSync(dir)) {
+    const fullPath = resolve(dir, entry);
+    const relPath = relative(baseDir, fullPath);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      if (EXCLUDED_DIRS.has(entry)) continue;
+      if (skipSessions && relPath === join(".mind", "sessions")) continue;
+      results.push(...walkDir(fullPath, baseDir, skipSessions));
+    } else {
+      results.push(relPath);
+    }
+  }
+  return results;
+}
+function createExportArchive(options) {
+  const {
+    name,
+    template,
+    includeEnv = false,
+    includeIdentity = false,
+    includeConnectors = false,
+    includeHistory = false,
+    includeSessions = false
+  } = options;
+  const dir = mindDir(name);
+  const state = stateDir(name);
+  const zip = new AdmZip();
+  const files = walkDir(dir, void 0, includeSessions);
+  for (const relPath of files) {
+    if (!includeIdentity && relPath.startsWith(join(".mind", "identity"))) continue;
+    if (!includeConnectors && relPath.startsWith(join(".mind", "connectors"))) continue;
+    const fullPath = resolve(dir, relPath);
+    zip.addFile(`mind/${relPath}`, readFileSync(fullPath));
+  }
+  if (existsSync(state)) {
+    const channelsPath = resolve(state, "channels.json");
+    if (existsSync(channelsPath)) {
+      zip.addFile("state/channels.json", readFileSync(channelsPath));
+    }
+  }
+  if (includeEnv && existsSync(state)) {
+    const envPath = resolve(state, "env.json");
+    if (existsSync(envPath)) {
+      zip.addFile("state/env.json", readFileSync(envPath));
+    }
+  }
+  if (includeSessions) {
+    const sessionsDir = resolve(dir, ".mind/sessions");
+    if (existsSync(sessionsDir)) {
+      for (const file of readdirSync(sessionsDir)) {
+        if (!file.endsWith(".json") && !file.endsWith(".jsonl")) continue;
+        const fullPath = resolve(sessionsDir, file);
+        zip.addFile(`sessions/${file}`, readFileSync(fullPath));
+      }
+    }
+  }
+  let voluteVersion = "unknown";
+  try {
+    const pkgPath = resolve(import.meta.dirname, "../../package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    voluteVersion = pkg.version;
+  } catch {
+  }
+  const manifest = {
+    version: 1,
+    name,
+    template,
+    voluteVersion,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    includes: {
+      env: includeEnv,
+      identity: includeIdentity,
+      connectors: includeConnectors,
+      history: includeHistory,
+      sessions: includeSessions
+    }
+  };
+  zip.addFile("manifest.json", Buffer.from(`${JSON.stringify(manifest, null, 2)}
+`));
+  return zip;
+}
+function addHistoryToArchive(zip, rows) {
+  if (rows.length === 0) return;
+  const lines = `${rows.map((r) => JSON.stringify(r)).join("\n")}
+`;
+  zip.addFile("history.jsonl", Buffer.from(lines));
+}
+function readManifest(archivePath) {
+  const zip = new AdmZip(archivePath);
+  const entry = zip.getEntry("manifest.json");
+  if (!entry) {
+    throw new Error("Invalid archive: missing manifest.json");
+  }
+  const manifest = JSON.parse(entry.getData().toString("utf-8"));
+  if (manifest.version !== 1) {
+    throw new Error(`Unsupported archive version: ${manifest.version}`);
+  }
+  return manifest;
+}
+function extractArchive(archivePath, destDir) {
+  const zip = new AdmZip(archivePath);
+  const manifestEntry = zip.getEntry("manifest.json");
+  if (!manifestEntry) {
+    throw new Error("Invalid archive: missing manifest.json");
+  }
+  const manifest = JSON.parse(manifestEntry.getData().toString("utf-8"));
+  if (manifest.version !== 1) {
+    throw new Error(`Unsupported archive version: ${manifest.version}`);
+  }
+  const normalizedDestDir = resolve(destDir);
+  const extractedMindDir = resolve(normalizedDestDir, "mind");
+  const extractedStateDir = resolve(normalizedDestDir, "state");
+  mkdirSync(extractedMindDir, { recursive: true });
+  mkdirSync(extractedStateDir, { recursive: true });
+  for (const entry of zip.getEntries()) {
+    if (entry.isDirectory) continue;
+    const name = entry.entryName;
+    if (name === "manifest.json") continue;
+    const destPath = resolve(normalizedDestDir, name);
+    if (!destPath.startsWith(`${normalizedDestDir}/`)) {
+      throw new Error(`Archive contains path traversal entry: ${name}`);
+    }
+    mkdirSync(resolve(destPath, ".."), { recursive: true });
+    writeFileSync(destPath, entry.getData());
+  }
+  const channelsJson = resolve(extractedStateDir, "channels.json");
+  const envJson = resolve(extractedStateDir, "env.json");
+  const historyJsonl = resolve(normalizedDestDir, "history.jsonl");
+  const sessionsDir = resolve(normalizedDestDir, "sessions");
+  return {
+    manifest,
+    mindDir: extractedMindDir,
+    channelsJson: existsSync(channelsJson) ? channelsJson : null,
+    envJson: existsSync(envJson) ? envJson : null,
+    historyJsonl: existsSync(historyJsonl) ? historyJsonl : null,
+    sessionsDir: existsSync(sessionsDir) ? sessionsDir : null
+  };
+}
+
+export {
+  createExportArchive,
+  addHistoryToArchive,
+  readManifest,
+  extractArchive
+};

package/dist/{chunk-2Y77MCFG.js → chunk-DYZGP3EW.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   wrapForIsolation
-} from "./chunk-ZCEYUUID.js";
+} from "./chunk-OGXOMR65.js";
 
 // src/lib/exec.ts
 import { execFile as execFileCb, execFileSync, spawn } from "child_process";
@@ -24,7 +24,7 @@ function exec(cmd, args, options) {
   });
 }
 function gitExec(args, options) {
-  const fullArgs = process.env.VOLUTE_ISOLATION === "user" ? ["-c", `safe.directory=${options.cwd}`, ...args] : args;
+  const fullArgs = process.env.VOLUTE_ISOLATION === "user" ? ["-c", "safe.directory=*", ...args] : args;
   return exec("git", fullArgs, options);
 }
 function resolveVoluteBin() {

package/dist/{chunk-M77QBTEH.js → chunk-EBGCNDMM.js}

@@ -9,6 +9,24 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "
 import { homedir } from "os";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
+var registryCache = null;
+function initRegistryCache() {
+  registryCache = readRegistryFromDisk();
+}
+function readRegistryFromDisk() {
+  const registryPath = resolve(voluteHome(), "minds.json");
+  if (!existsSync(registryPath)) return [];
+  try {
+    const entries = JSON.parse(readFileSync(registryPath, "utf-8"));
+    return entries.map((e) => ({
+      ...e,
+      running: e.running ?? false,
+      stage: e.stage ?? "sprouted"
+    }));
+  } catch {
+    return [];
+  }
+}
 function voluteHome() {
   if (process.env.VOLUTE_HOME) return process.env.VOLUTE_HOME;
   const dir = dirname(fileURLToPath(import.meta.url));
@@ -24,20 +42,11 @@ function ensureVoluteHome() {
   mkdirSync(mindsBase, { recursive: true });
 }
 function readRegistry() {
-  const registryPath = resolve(voluteHome(), "minds.json");
-  if (!existsSync(registryPath)) return [];
-  try {
-    const entries = JSON.parse(readFileSync(registryPath, "utf-8"));
-    return entries.map((e) => ({
-      ...e,
-      running: e.running ?? false,
-      stage: e.stage ?? "sprouted"
-    }));
-  } catch {
-    return [];
-  }
+  if (registryCache) return registryCache;
+  return readRegistryFromDisk();
 }
 function writeRegistry(entries) {
+  if (registryCache) registryCache = entries;
   ensureVoluteHome();
   const registryPath = resolve(voluteHome(), "minds.json");
   const tmpPath = `${registryPath}.tmp`;
@@ -55,12 +64,12 @@ function validateMindName(name) {
   }
   return null;
 }
-function addMind(name, port, stage) {
+function addMind(name, port, stage, template) {
   const err = validateMindName(name);
   if (err) throw new Error(err);
   const entries = readRegistry();
   const filtered = entries.filter((e) => e.name !== name);
-  filtered.push({ name, port, created: (/* @__PURE__ */ new Date()).toISOString(), running: false, stage });
+  filtered.push({ name, port, created: (/* @__PURE__ */ new Date()).toISOString(), running: false, stage, template });
   writeRegistry(filtered);
 }
 function removeMind(name) {
@@ -242,6 +251,7 @@ export {
   removeAllVariants,
   checkHealth,
   validateBranchName,
+  initRegistryCache,
   voluteHome,
   ensureVoluteHome,
   readRegistry,

package/dist/{chunk-GSPWIM5E.js → chunk-EMQSAY3B.js}

@@ -3,14 +3,25 @@ import {
   mindEnvPath,
   readEnv,
   writeEnv
-} from "./chunk-OYSZNX5I.js";
+} from "./chunk-VDWCHYTS.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 
 // src/commands/import.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { homedir } from "os";
+import {
+  closeSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  readSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir, tmpdir } from "os";
 import { basename, resolve as resolve2 } from "path";
 
 // src/lib/volute-config.ts
@@ -42,8 +53,13 @@ async function run(args) {
     session: { type: "string" },
     template: { type: "string" }
   });
-  const wsDir = resolveWorkspace(positional[0]);
-  const { daemonFetch } = await import("./daemon-client-ODKDUYDE.js");
+  const inputPath = positional[0];
+  if (inputPath && (inputPath.endsWith(".volute") || isZipFile(inputPath))) {
+    await importArchive(resolve2(inputPath), flags.name);
+    return;
+  }
+  const wsDir = resolveWorkspace(inputPath);
+  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.import.$url()), {
@@ -66,6 +82,61 @@ ${data.message ?? `Imported mind: ${data.name} (port ${data.port})`}`);
   console.log(`
   volute mind start ${data.name}`);
 }
+function isZipFile(path) {
+  const resolved = resolve2(path);
+  if (!existsSync2(resolved)) return false;
+  const fd = openSync(resolved, "r");
+  try {
+    const buf = Buffer.alloc(4);
+    const bytesRead = readSync(fd, buf, 0, 4, 0);
+    return bytesRead === 4 && buf[0] === 80 && buf[1] === 75 && buf[2] === 3 && buf[3] === 4;
+  } finally {
+    closeSync(fd);
+  }
+}
+async function importArchive(archivePath, nameOverride) {
+  if (!existsSync2(archivePath)) {
+    console.error(`File not found: ${archivePath}`);
+    process.exit(1);
+  }
+  const { extractArchive } = await import("./archive-ZCFOSTKB.js");
+  const tempDir = resolve2(tmpdir(), `volute-import-${Date.now()}`);
+  mkdirSync2(tempDir, { recursive: true });
+  let extracted;
+  try {
+    extracted = extractArchive(archivePath, tempDir);
+  } catch (err) {
+    rmSync(tempDir, { recursive: true, force: true });
+    console.error(`Failed to extract archive: ${err.message}`);
+    process.exit(1);
+  }
+  try {
+    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.import.$url()), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        archivePath: tempDir,
+        name: nameOverride,
+        manifest: extracted.manifest
+      })
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      console.error(data.error ?? "Failed to import mind");
+      process.exit(1);
+    }
+    console.log(`
+${data.message ?? `Imported mind: ${data.name} (port ${data.port})`}`);
+    console.log(`
+  volute mind start ${data.name}`);
+  } catch (err) {
+    rmSync(tempDir, { recursive: true, force: true });
+    throw err;
+  }
+}
 function resolveWorkspace(explicitPath) {
   if (explicitPath) {
     const wsDir = resolve2(explicitPath);
@@ -127,7 +198,7 @@ function sessionMatchesWorkspace(sessionPath, workspaceDir) {
 }
 function importPiSession(sessionFile, mindDirPath) {
   const homeDir = resolve2(mindDirPath, "home");
-  const piSessionDir = resolve2(mindDirPath, ".volute/pi-sessions/main");
+  const piSessionDir = resolve2(mindDirPath, ".mind/pi-sessions/main");
   mkdirSync2(piSessionDir, { recursive: true });
   const content = readFileSync2(sessionFile, "utf-8");
   const lines = content.trim().split("\n");

package/dist/{chunk-37X7ECMF.js → chunk-FCDU5BFX.js}

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