volute 0.19.0 → 0.21.0

package/dist/chunk-A4S7H6G6.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  activity,
+  getDb
+} from "./chunk-SGPEZ32F.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+
+// src/lib/events/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-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-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-HGCDWKSP.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import {
+  publish
+} from "./chunk-A4S7H6G6.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+
+// src/lib/events/mind-activity-tracker.ts
+var IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
+var minds = /* @__PURE__ */ new Map();
+function getState(mind) {
+  let state = minds.get(mind);
+  if (!state) {
+    state = { active: false, idleTimer: null };
+    minds.set(mind, state);
+  }
+  return state;
+}
+var IGNORED_EVENTS = /* @__PURE__ */ new Set(["done", "usage", "log"]);
+function onMindEvent(mind, type, channel) {
+  const state = getState(mind);
+  if (type === "done") {
+    state.active = false;
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+    }
+    state.idleTimer = setTimeout(() => {
+      state.idleTimer = null;
+      if (!state.active) {
+        publish({
+          type: "mind_idle",
+          mind,
+          summary: `${mind} is idle`
+        }).catch((err) => {
+          logger_default.error("[mind-activity] failed to publish mind_idle", logger_default.errorData(err));
+        });
+      }
+    }, IDLE_TIMEOUT_MS);
+  } else if (!IGNORED_EVENTS.has(type)) {
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+      state.idleTimer = null;
+    }
+    if (!state.active) {
+      state.active = true;
+      state.channel = channel;
+      publish({
+        type: "mind_active",
+        mind,
+        summary: `${mind} is active`,
+        metadata: channel ? { channel } : void 0
+      }).catch((err) => {
+        logger_default.error("[mind-activity] failed to publish mind_active", logger_default.errorData(err));
+      });
+    }
+  }
+}
+function markIdle(mind) {
+  const state = minds.get(mind);
+  if (!state) return;
+  if (state.idleTimer) {
+    clearTimeout(state.idleTimer);
+    state.idleTimer = null;
+  }
+  if (state.active) {
+    state.active = false;
+    publish({
+      type: "mind_idle",
+      mind,
+      summary: `${mind} is idle`
+    }).catch((err) => {
+      logger_default.error("[mind-activity] failed to publish mind_idle", logger_default.errorData(err));
+    });
+  }
+  minds.delete(mind);
+}
+function getActiveMinds() {
+  const result = [];
+  for (const [mind, state] of minds) {
+    if (state.active) result.push(mind);
+  }
+  return result;
+}
+function stopAll() {
+  for (const [, state] of minds) {
+    if (state.idleTimer) clearTimeout(state.idleTimer);
+  }
+  minds.clear();
+}
+
+export {
+  onMindEvent,
+  markIdle,
+  getActiveMinds,
+  stopAll
+};

package/dist/{chunk-DYZGP3EW.js → chunk-IPJXU366.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";

package/dist/{chunk-VE4D3GOP.js → chunk-J5A3DF2U.js}

@@ -4,13 +4,13 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-32VR2EOH.js";
+} from "./chunk-QUJUKM4U.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-WC6ZHVRL.js → chunk-KFI7TQJ6.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-EBGCNDMM.js";
+} from "./chunk-B2CPS4QU.js";
 
 // src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";
@@ -11,7 +11,7 @@ function readDaemonConfig() {
   if (!existsSync(configPath)) {
     if (existsSync("/etc/systemd/system/volute.service") && !process.env.VOLUTE_HOME) {
       console.error("Volute is running as a system service but VOLUTE_HOME is not set.");
-      console.error("Re-run setup to update the CLI wrapper: sudo volute setup");
+      console.error("Re-run setup to update the CLI wrapper: sudo volute service install --system");
       console.error("Then start a new shell or run: source /etc/profile.d/volute.sh");
     } else {
       console.error("Volute is not running. Start with: volute up");