volute 0.18.0 → 0.20.0

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-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";