volute 0.20.0 → 0.22.0

package/dist/{archive-ZCFOSTKB.js → archive-4ZQYK5MN.js}

@@ -3,13 +3,15 @@ import {
   addHistoryToArchive,
   createExportArchive,
   extractArchive,
+  isHomeOnlyArchive,
   readManifest
-} from "./chunk-AW7P4EVV.js";
-import "./chunk-EBGCNDMM.js";
+} from "./chunk-KTJGZ7M7.js";
+import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 export {
   addHistoryToArchive,
   createExportArchive,
   extractArchive,
+  isHomeOnlyArchive,
   readManifest
 };

package/dist/auth-HM2RSPY7.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import "./chunk-K3NQKI34.js";
+
+// src/commands/auth.ts
+async function run(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "register":
+      await import("./register-U2UO6TC4.js").then((m) => m.run(args.slice(1)));
+      break;
+    case "login":
+      await import("./login-UO6AOVEA.js").then((m) => m.run(args.slice(1)));
+      break;
+    case "logout":
+      await import("./logout-UKD5LA37.js").then((m) => m.run());
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printUsage();
+      break;
+    default:
+      printUsage();
+      console.error(`
+Unknown subcommand: ${subcommand}`);
+      process.exit(1);
+  }
+}
+function printUsage() {
+  console.log(`Usage:
+  volute auth register [--name <name>]   Register a system on volute.systems
+  volute auth login [--key <key>]        Log in with an existing API key
+  volute auth logout                     Remove stored credentials`);
+}
+export {
+  run
+};

package/dist/{channel-PUQKGSQM.js → channel-BOOMFULW.js}

@@ -11,8 +11,8 @@ import {
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-WC6ZHVRL.js";
-import "./chunk-EBGCNDMM.js";
+} from "./chunk-KFI7TQJ6.js";
+import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/channel.ts

package/dist/{chunk-UU7A7KLB.js → chunk-A4S7H6G6.js}

@@ -1,15 +1,13 @@
 #!/usr/bin/env node
 import {
-  logger_default
-} from "./chunk-YUIHSKR6.js";
-import {
+  activity,
   getDb
-} from "./chunk-5XNT2472.js";
+} from "./chunk-SGPEZ32F.js";
 import {
-  activity
-} from "./chunk-NSE7VJQA.js";
+  logger_default
+} from "./chunk-YUIHSKR6.js";
 
-// src/lib/activity-events.ts
+// src/lib/events/activity-events.ts
 var subscribers = /* @__PURE__ */ new Set();
 function subscribe(callback) {
   subscribers.add(callback);

package/dist/chunk-AKPFNL7L.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+// src/lib/template-hash.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/lib/template.ts
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { dirname, join, relative, resolve } from "path";
+function findTemplatesRoot() {
+  let dir = dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve(dir, "templates");
+    if (existsSync(resolve(candidate, "_base"))) return candidate;
+    dir = dirname(dir);
+  }
+  console.error(
+    "Templates directory not found. Searched up from:",
+    dirname(new URL(import.meta.url).pathname)
+  );
+  process.exit(1);
+}
+function composeTemplate(templatesRoot, templateName) {
+  const baseDir = resolve(templatesRoot, "_base");
+  const templateDir = resolve(templatesRoot, templateName);
+  if (!existsSync(baseDir)) {
+    console.error("Base template not found:", baseDir);
+    process.exit(1);
+  }
+  if (!existsSync(templateDir)) {
+    console.error(`Template not found: ${templateName}`);
+    process.exit(1);
+  }
+  const composedDir = resolve(tmpdir(), `volute-template-${Date.now()}`);
+  mkdirSync(composedDir, { recursive: true });
+  cpSync(baseDir, composedDir, { recursive: true });
+  for (const file of listFiles(templateDir)) {
+    const src = resolve(templateDir, file);
+    const dest = resolve(composedDir, file);
+    mkdirSync(dirname(dest), { recursive: true });
+    cpSync(src, dest);
+  }
+  const manifestPath = resolve(composedDir, "volute-template.json");
+  if (!existsSync(manifestPath)) {
+    rmSync(composedDir, { recursive: true, force: true });
+    console.error(`Template manifest not found: ${templateName}/volute-template.json`);
+    process.exit(1);
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  rmSync(manifestPath);
+  return { composedDir, manifest };
+}
+function copyTemplateToDir(composedDir, destDir, mindName, manifest) {
+  cpSync(composedDir, destDir, { recursive: true });
+  for (const [from, to] of Object.entries(manifest.rename)) {
+    const fromPath = resolve(destDir, from);
+    if (existsSync(fromPath)) {
+      renameSync(fromPath, resolve(destDir, to));
+    }
+  }
+  for (const file of manifest.substitute) {
+    const path = resolve(destDir, file);
+    if (existsSync(path)) {
+      const content = readFileSync(path, "utf-8");
+      writeFileSync(path, content.replaceAll("{{name}}", mindName));
+    }
+  }
+}
+function applyInitFiles(destDir) {
+  const initDir = resolve(destDir, ".init");
+  if (!existsSync(initDir)) return;
+  const homeDir = resolve(destDir, "home");
+  for (const file of listFiles(initDir)) {
+    const src = resolve(initDir, file);
+    const dest = resolve(homeDir, file);
+    const parent = dirname(dest);
+    if (!existsSync(parent)) {
+      mkdirSync(parent, { recursive: true });
+    }
+    cpSync(src, dest);
+  }
+  rmSync(initDir, { recursive: true, force: true });
+}
+function listFiles(dir) {
+  const results = [];
+  function walk(current) {
+    for (const entry of readdirSync(current)) {
+      const full = join(current, entry);
+      if (statSync(full).isDirectory()) {
+        if (entry === ".git") continue;
+        walk(full);
+      } else {
+        results.push(relative(dir, full));
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+// src/lib/template-hash.ts
+var hashCache = /* @__PURE__ */ new Map();
+function computeTemplateHash(templateName) {
+  const cached = hashCache.get(templateName);
+  if (cached) return cached;
+  const templatesRoot = findTemplatesRoot();
+  const baseDir = resolve2(templatesRoot, "_base");
+  const templateDir = resolve2(templatesRoot, templateName);
+  if (!existsSync2(baseDir)) throw new Error(`Base template not found: ${baseDir}`);
+  if (!existsSync2(templateDir)) throw new Error(`Template not found: ${templateName}`);
+  const { composedDir } = composeTemplate(templatesRoot, templateName);
+  try {
+    const files = listFiles(composedDir).filter((f) => !f.startsWith(".init/") && !f.startsWith(".init\\")).sort();
+    const hash = createHash("sha256");
+    for (const file of files) {
+      const content = readFileSync2(resolve2(composedDir, file));
+      hash.update(file);
+      hash.update("\0");
+      hash.update(content);
+    }
+    const result = hash.digest("hex");
+    hashCache.set(templateName, result);
+    return result;
+  } finally {
+    rmSync2(composedDir, { recursive: true, force: true });
+  }
+}
+
+export {
+  findTemplatesRoot,
+  composeTemplate,
+  copyTemplateToDir,
+  applyInitFiles,
+  listFiles,
+  computeTemplateHash
+};

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

@@ -1,23 +1,122 @@
 #!/usr/bin/env node
 
-// src/lib/variants.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-
 // src/lib/registry.ts
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { dirname, resolve } from "path";
+import { dirname, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
+
+// src/lib/variants.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function variantsPath() {
+  return resolve(voluteHome(), "variants.json");
+}
+function readAllVariants() {
+  const path = variantsPath();
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeAllVariants(all) {
+  mkdirSync(voluteHome(), { recursive: true });
+  writeFileSync(variantsPath(), `${JSON.stringify(all, null, 2)}
+`);
+}
+function readVariants(mindName) {
+  return readAllVariants()[mindName] ?? [];
+}
+function writeVariants(mindName, variants) {
+  const all = readAllVariants();
+  if (variants.length === 0) {
+    delete all[mindName];
+  } else {
+    all[mindName] = variants;
+  }
+  writeAllVariants(all);
+}
+function addVariant(mindName, variant) {
+  const variants = readVariants(mindName);
+  const filtered = variants.filter((v) => v.name !== variant.name);
+  filtered.push(variant);
+  writeVariants(mindName, filtered);
+}
+function removeVariant(mindName, name) {
+  const variants = readVariants(mindName);
+  writeVariants(
+    mindName,
+    variants.filter((v) => v.name !== name)
+  );
+}
+function findVariant(mindName, name) {
+  return readVariants(mindName).find((v) => v.name === name);
+}
+function setVariantRunning(mindName, variantName, running) {
+  const all = readAllVariants();
+  const variants = all[mindName] ?? [];
+  const variant = variants.find((v) => v.name === variantName);
+  if (variant) {
+    variant.running = running;
+    all[mindName] = variants;
+    writeAllVariants(all);
+  }
+}
+function getAllRunningVariants() {
+  const all = readAllVariants();
+  const result = [];
+  for (const [mindName, variants] of Object.entries(all)) {
+    for (const variant of variants) {
+      if (variant.running) {
+        result.push({ mindName, variant });
+      }
+    }
+  }
+  return result;
+}
+function removeAllVariants(mindName) {
+  const all = readAllVariants();
+  delete all[mindName];
+  writeAllVariants(all);
+}
+async function checkHealth(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return { ok: false };
+    const data = await res.json();
+    return { ok: true, name: data.name };
+  } catch {
+    return { ok: false };
+  }
+}
+var SAFE_BRANCH_RE = /^[a-zA-Z0-9._\-/]+$/;
+function validateBranchName(branch) {
+  if (!SAFE_BRANCH_RE.test(branch)) {
+    return `Invalid branch name: ${branch}. Only alphanumeric, '.', '_', '-', '/' allowed.`;
+  }
+  if (branch.includes("..")) {
+    return `Invalid branch name: ${branch}. '..' not allowed.`;
+  }
+  return null;
+}
+
+// src/lib/registry.ts
 var registryCache = null;
 function initRegistryCache() {
   registryCache = readRegistryFromDisk();
 }
+function getRegistryCache() {
+  return registryCache;
+}
 function readRegistryFromDisk() {
-  const registryPath = resolve(voluteHome(), "minds.json");
-  if (!existsSync(registryPath)) return [];
+  const registryPath = resolve2(voluteHome(), "minds.json");
+  if (!existsSync2(registryPath)) return [];
   try {
-    const entries = JSON.parse(readFileSync(registryPath, "utf-8"));
+    const entries = JSON.parse(readFileSync2(registryPath, "utf-8"));
     return entries.map((e) => ({
       ...e,
       running: e.running ?? false,
@@ -35,11 +134,11 @@ function voluteHome() {
       'VOLUTE_HOME must be set when running from source. For tests, run via "npm test" or add "--import ./test/setup.ts".'
     );
   }
-  return resolve(homedir(), ".volute");
+  return resolve2(homedir(), ".volute");
 }
 function ensureVoluteHome() {
-  const mindsBase = process.env.VOLUTE_MINDS_DIR ?? resolve(voluteHome(), "minds");
-  mkdirSync(mindsBase, { recursive: true });
+  const mindsBase = process.env.VOLUTE_MINDS_DIR ?? resolve2(voluteHome(), "minds");
+  mkdirSync2(mindsBase, { recursive: true });
 }
 function readRegistry() {
   if (registryCache) return registryCache;
@@ -48,9 +147,9 @@ function readRegistry() {
 function writeRegistry(entries) {
   if (registryCache) registryCache = entries;
   ensureVoluteHome();
-  const registryPath = resolve(voluteHome(), "minds.json");
+  const registryPath = resolve2(voluteHome(), "minds.json");
   const tmpPath = `${registryPath}.tmp`;
-  writeFileSync(tmpPath, `${JSON.stringify(entries, null, 2)}
+  writeFileSync2(tmpPath, `${JSON.stringify(entries, null, 2)}
 `);
   renameSync(tmpPath, registryPath);
 }
@@ -92,17 +191,25 @@ function setMindStage(name, stage) {
     writeRegistry(entries);
   }
 }
+function setMindTemplateHash(name, hash) {
+  const entries = readRegistry();
+  const entry = entries.find((e) => e.name === name);
+  if (entry) {
+    entry.templateHash = hash;
+    writeRegistry(entries);
+  }
+}
 function findMind(name) {
   return readRegistry().find((e) => e.name === name);
 }
 function mindDir(name) {
   if (process.env.VOLUTE_MINDS_DIR) {
-    return resolve(process.env.VOLUTE_MINDS_DIR, name);
+    return resolve2(process.env.VOLUTE_MINDS_DIR, name);
   }
-  return resolve(voluteHome(), "minds", name);
+  return resolve2(voluteHome(), "minds", name);
 }
 function stateDir(name) {
-  return resolve(voluteHome(), "state", name);
+  return resolve2(voluteHome(), "state", name);
 }
 function nextPort() {
   const entries = readRegistry();
@@ -131,7 +238,7 @@ function resolveMind(name) {
     throw new Error(`Unknown mind: ${baseName}`);
   }
   const dir = mindDir(baseName);
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     throw new Error(`Mind directory missing: ${dir}`);
   }
   if (variantName) {
@@ -144,102 +251,6 @@ function resolveMind(name) {
   return { entry, dir };
 }
 
-// src/lib/variants.ts
-function variantsPath() {
-  return resolve2(voluteHome(), "variants.json");
-}
-function readAllVariants() {
-  const path = variantsPath();
-  if (!existsSync2(path)) return {};
-  try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function writeAllVariants(all) {
-  mkdirSync2(voluteHome(), { recursive: true });
-  writeFileSync2(variantsPath(), `${JSON.stringify(all, null, 2)}
-`);
-}
-function readVariants(mindName) {
-  return readAllVariants()[mindName] ?? [];
-}
-function writeVariants(mindName, variants) {
-  const all = readAllVariants();
-  if (variants.length === 0) {
-    delete all[mindName];
-  } else {
-    all[mindName] = variants;
-  }
-  writeAllVariants(all);
-}
-function addVariant(mindName, variant) {
-  const variants = readVariants(mindName);
-  const filtered = variants.filter((v) => v.name !== variant.name);
-  filtered.push(variant);
-  writeVariants(mindName, filtered);
-}
-function removeVariant(mindName, name) {
-  const variants = readVariants(mindName);
-  writeVariants(
-    mindName,
-    variants.filter((v) => v.name !== name)
-  );
-}
-function findVariant(mindName, name) {
-  return readVariants(mindName).find((v) => v.name === name);
-}
-function setVariantRunning(mindName, variantName, running) {
-  const all = readAllVariants();
-  const variants = all[mindName] ?? [];
-  const variant = variants.find((v) => v.name === variantName);
-  if (variant) {
-    variant.running = running;
-    all[mindName] = variants;
-    writeAllVariants(all);
-  }
-}
-function getAllRunningVariants() {
-  const all = readAllVariants();
-  const result = [];
-  for (const [mindName, variants] of Object.entries(all)) {
-    for (const variant of variants) {
-      if (variant.running) {
-        result.push({ mindName, variant });
-      }
-    }
-  }
-  return result;
-}
-function removeAllVariants(mindName) {
-  const all = readAllVariants();
-  delete all[mindName];
-  writeAllVariants(all);
-}
-async function checkHealth(port) {
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/health`, {
-      signal: AbortSignal.timeout(2e3)
-    });
-    if (!res.ok) return { ok: false };
-    const data = await res.json();
-    return { ok: true, name: data.name };
-  } catch {
-    return { ok: false };
-  }
-}
-var SAFE_BRANCH_RE = /^[a-zA-Z0-9._\-/]+$/;
-function validateBranchName(branch) {
-  if (!SAFE_BRANCH_RE.test(branch)) {
-    return `Invalid branch name: ${branch}. Only alphanumeric, '.', '_', '-', '/' allowed.`;
-  }
-  if (branch.includes("..")) {
-    return `Invalid branch name: ${branch}. '..' not allowed.`;
-  }
-  return null;
-}
-
 export {
   readVariants,
   writeVariants,
@@ -252,14 +263,17 @@ export {
   checkHealth,
   validateBranchName,
   initRegistryCache,
+  getRegistryCache,
   voluteHome,
   ensureVoluteHome,
   readRegistry,
+  writeRegistry,
   validateMindName,
   addMind,
   removeMind,
   setMindRunning,
   setMindStage,
+  setMindTemplateHash,
   findMind,
   mindDir,
   stateDir,

package/dist/chunk-G5KRTU2F.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {
+  subscribe
+} from "./chunk-A4S7H6G6.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+
+// src/lib/webhook.ts
+var slog = logger_default.child("webhook");
+function getWebhookUrl() {
+  return process.env.VOLUTE_WEBHOOK_URL;
+}
+function getAuthHeaders() {
+  const headers = { "Content-Type": "application/json" };
+  const secret = process.env.VOLUTE_WEBHOOK_SECRET;
+  if (secret) headers.Authorization = `Bearer ${secret}`;
+  return headers;
+}
+function fireWebhook(event) {
+  try {
+    const url = getWebhookUrl();
+    if (!url) return;
+    const payload = { ...event, timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
+    fetch(url, {
+      method: "POST",
+      headers: getAuthHeaders(),
+      body: JSON.stringify(payload)
+    }).then((res) => {
+      if (!res.ok) {
+        slog.warn(`webhook ${event.event} returned HTTP ${res.status}`);
+      }
+    }).catch((err) => {
+      slog.warn(`webhook delivery failed for ${event.event}`, logger_default.errorData(err));
+    });
+  } catch (err) {
+    slog.error(`webhook ${event.event} failed to serialize`, logger_default.errorData(err));
+  }
+}
+function initWebhook() {
+  const url = getWebhookUrl();
+  if (!url) return () => {
+  };
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      slog.error(`VOLUTE_WEBHOOK_URL has unsupported protocol: ${parsed.protocol}`);
+      return () => {
+      };
+    }
+  } catch {
+    slog.error(`VOLUTE_WEBHOOK_URL is not a valid URL`);
+    return () => {
+    };
+  }
+  slog.info("webhook enabled");
+  return subscribe((event) => {
+    try {
+      fireWebhook({
+        event: event.type,
+        mind: event.mind,
+        data: { summary: event.summary, ...event.metadata },
+        timestamp: event.created_at
+      });
+    } catch (err) {
+      slog.error(`failed to fire webhook for ${event.type}`, logger_default.errorData(err));
+    }
+  });
+}
+
+export {
+  getWebhookUrl,
+  getAuthHeaders,
+  fireWebhook,
+  initWebhook
+};

package/dist/{chunk-FCDU5BFX.js → chunk-HFCBO2GL.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-EBGCNDMM.js";
+} from "./chunk-B2CPS4QU.js";
 
 // src/lib/systems-config.ts
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
@@ -18,7 +18,7 @@ function readSystemsConfig() {
   try {
     data = JSON.parse(raw);
   } catch {
-    console.error(`Warning: ${path} contains invalid JSON. Run "volute logout" and re-login.`);
+    console.error(`Warning: ${path} contains invalid JSON. Run "volute auth logout" and re-login.`);
     return null;
   }
   if (!data.apiKey || !data.system) return null;

package/dist/{chunk-GZ7DW4YL.js → chunk-HGCDWKSP.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   publish
-} from "./chunk-UU7A7KLB.js";
+} from "./chunk-A4S7H6G6.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
 
-// src/lib/mind-activity-tracker.ts
+// src/lib/events/mind-activity-tracker.ts
 var IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
 var minds = /* @__PURE__ */ new Map();
 function getState(mind) {

package/dist/{chunk-7UFKREVW.js → chunk-JNFRY2WU.js}

@@ -4,13 +4,13 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-32VR2EOH.js";
+} from "./chunk-VT5QODNE.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   voluteHome
-} from "./chunk-EBGCNDMM.js";
+} from "./chunk-B2CPS4QU.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";

package/dist/{chunk-DYZGP3EW.js → chunk-JTDFJWI2.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   wrapForIsolation
-} from "./chunk-OGXOMR65.js";
+} from "./chunk-NWPT4ASZ.js";
 
 // src/lib/exec.ts
 import { execFile as execFileCb, execFileSync, spawn } from "child_process";
@@ -15,6 +15,7 @@ function exec(cmd, args, options) {
       (err, stdout, stderr) => {
         if (err) {
           err.stderr = stderr;
+          err.stdout = stdout;
           reject(err);
         } else {
           resolve(stdout);