volute 0.30.1 → 0.32.0

package/dist/{chunk-W5OOPLNP.js → chunk-JJ7W6WSB.js}

@@ -4,17 +4,17 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-FXHXHI2A.js";
+} from "./chunk-LSGWR54X.js";
 import {
   readGlobalConfig
-} from "./chunk-7D47T4RB.js";
+} from "./chunk-TSXLLQZW.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   voluteHome,
   voluteSystemDir
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-LRCG2JLP.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";

package/dist/{chunk-G3GBKZGG.js → chunk-LGB6JBHI.js}

@@ -2,7 +2,7 @@
 import {
   getBaseName,
   validateMindName
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-LRCG2JLP.js";
 
 // src/lib/isolation.ts
 import { execFileSync } from "child_process";
@@ -166,6 +166,54 @@ function chownMindDir(dir, name) {
   }
 }
 
+// src/lib/exec.ts
+import { execFile as execFileCb, execFileSync as execFileSync2, spawn } from "child_process";
+async function exec(cmd, args, options) {
+  const [wrappedCmd, wrappedArgs] = options?.mindName ? await wrapForIsolation(cmd, args, options.mindName) : [cmd, args];
+  return new Promise((resolve, reject) => {
+    execFileCb(
+      wrappedCmd,
+      wrappedArgs,
+      { cwd: options?.cwd, env: options?.env },
+      (err, stdout, stderr) => {
+        if (err) {
+          err.stderr = stderr;
+          err.stdout = stdout;
+          reject(err);
+        } else {
+          resolve(stdout);
+        }
+      }
+    );
+  });
+}
+function gitExec(args, options) {
+  const fullArgs = process.env.VOLUTE_ISOLATION === "user" ? ["-c", "safe.directory=*", ...args] : args;
+  return exec("git", fullArgs, options);
+}
+function resolveVoluteBin() {
+  try {
+    return execFileSync2("which", ["volute"], { encoding: "utf-8" }).trim();
+  } catch {
+    throw new Error("Could not find volute binary on PATH");
+  }
+}
+async function execInherit(cmd, args, options) {
+  const [wrappedCmd, wrappedArgs] = options?.mindName ? await wrapForIsolation(cmd, args, options.mindName) : [cmd, args];
+  return new Promise((resolve, reject) => {
+    const child = spawn(wrappedCmd, wrappedArgs, {
+      cwd: options?.cwd,
+      env: options?.env,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+
 export {
   isIsolationEnabled,
   mindUserName,
@@ -173,5 +221,9 @@ export {
   createMindUser,
   deleteMindUser,
   wrapForIsolation,
-  chownMindDir
+  chownMindDir,
+  exec,
+  gitExec,
+  resolveVoluteBin,
+  execInherit
 };

package/dist/chunk-LRCG2JLP.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import {
+  minds,
+  schema_exports
+} from "./chunk-RPZZSXV3.js";
+
+// src/lib/db.ts
+import { chmodSync, existsSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { drizzle } from "drizzle-orm/libsql";
+import { migrate } from "drizzle-orm/libsql/migrator";
+
+// src/lib/registry.ts
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { and, eq, isNull } from "drizzle-orm";
+function voluteHome() {
+  if (process.env.VOLUTE_HOME) return process.env.VOLUTE_HOME;
+  const dir = dirname(fileURLToPath(import.meta.url));
+  if (dir.endsWith("/src/lib")) {
+    throw new Error(
+      '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");
+}
+function voluteUserHome() {
+  if (process.env.VOLUTE_USER_HOME) return process.env.VOLUTE_USER_HOME;
+  return resolve(homedir(), ".volute");
+}
+function voluteSystemDir() {
+  return resolve(voluteHome(), "system");
+}
+function ensureSystemDir() {
+  mkdirSync(voluteSystemDir(), { recursive: true });
+}
+function ensureVoluteHome() {
+  const mindsBase = process.env.VOLUTE_MINDS_DIR ?? resolve(voluteHome(), "minds");
+  mkdirSync(mindsBase, { recursive: true });
+  ensureSystemDir();
+}
+function rowToEntry(row) {
+  return {
+    name: row.name,
+    port: row.port,
+    created: row.created_at,
+    running: row.running === 1,
+    stage: row.stage ?? (row.parent ? void 0 : "sprouted"),
+    template: row.template ?? void 0,
+    templateHash: row.template_hash ?? void 0,
+    parent: row.parent ?? void 0,
+    dir: row.dir ?? void 0,
+    branch: row.branch ?? void 0,
+    mindType: row.mind_type ?? "mind",
+    createdBy: row.created_by ?? void 0
+  };
+}
+async function readRegistry() {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds).where(and(isNull(minds.parent), eq(minds.mind_type, "mind")));
+  return rows.map(rowToEntry);
+}
+async function readAllMinds() {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds);
+  return rows.map(rowToEntry);
+}
+var MIND_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var MIND_NAME_MAX = 64;
+var RESERVED_NAMES = /* @__PURE__ */ new Set(["volute", "system"]);
+function validateMindName(name) {
+  if (!name) return "Mind name is required";
+  if (name.length > MIND_NAME_MAX) return `Mind name must be at most ${MIND_NAME_MAX} characters`;
+  if (!MIND_NAME_RE.test(name)) {
+    return "Mind name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
+  }
+  if (RESERVED_NAMES.has(name.toLowerCase())) {
+    return `"${name}" is a reserved name`;
+  }
+  return null;
+}
+async function addMind(name, port, stage, template, createdBy) {
+  const err = validateMindName(name);
+  if (err) throw new Error(err);
+  const db2 = await getDb();
+  await db2.insert(minds).values({
+    name,
+    port,
+    stage: stage ?? null,
+    template: template ?? null,
+    created_by: createdBy ?? null
+  }).onConflictDoUpdate({
+    target: minds.name,
+    set: {
+      port,
+      stage: stage ?? null,
+      template: template ?? null,
+      created_by: createdBy ?? null
+    }
+  });
+}
+async function addSpirit(name, port, template, dir) {
+  const db2 = await getDb();
+  await db2.insert(minds).values({
+    name,
+    port,
+    template,
+    dir,
+    mind_type: "spirit",
+    stage: "sprouted"
+  }).onConflictDoUpdate({
+    target: minds.name,
+    set: { port, template, dir, mind_type: "spirit" }
+  });
+}
+async function readSpirits() {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds).where(eq(minds.mind_type, "spirit"));
+  return rows.map(rowToEntry);
+}
+async function addVariant(name, parent, port, dir, branch) {
+  const err = validateMindName(name);
+  if (err) throw new Error(err);
+  const db2 = await getDb();
+  await db2.insert(minds).values({ name, port, parent, dir, branch }).onConflictDoUpdate({
+    target: minds.name,
+    set: { port, parent, dir, branch }
+  });
+}
+async function removeMind(name) {
+  const db2 = await getDb();
+  await db2.delete(minds).where(eq(minds.name, name));
+}
+async function setMindRunning(name, running) {
+  const db2 = await getDb();
+  await db2.update(minds).set({ running: running ? 1 : 0 }).where(eq(minds.name, name));
+}
+async function setMindStage(name, stage) {
+  const db2 = await getDb();
+  await db2.update(minds).set({ stage }).where(eq(minds.name, name));
+}
+async function setMindTemplateHash(name, hash) {
+  const db2 = await getDb();
+  await db2.update(minds).set({ template_hash: hash }).where(eq(minds.name, name));
+}
+async function findMind(name) {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds).where(eq(minds.name, name));
+  if (rows.length === 0) return void 0;
+  return rowToEntry(rows[0]);
+}
+async function findVariants(parent) {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds).where(eq(minds.parent, parent));
+  return rows.map(rowToEntry);
+}
+async function getBaseName(name) {
+  const entry = await findMind(name);
+  return entry?.parent ?? name;
+}
+function mindDir(name) {
+  if (process.env.VOLUTE_MINDS_DIR) {
+    return resolve(process.env.VOLUTE_MINDS_DIR, name);
+  }
+  return resolve(voluteHome(), "minds", name);
+}
+async function resolveMindDir(name) {
+  const entry = await findMind(name);
+  return entry?.dir ?? mindDir(name);
+}
+function stateDir(name) {
+  return resolve(voluteSystemDir(), "state", name);
+}
+async function nextPort() {
+  const db2 = await getDb();
+  const rows = await db2.select({ port: minds.port }).from(minds);
+  const usedPorts = new Set(rows.map((r) => r.port));
+  const basePort = parseInt(process.env.VOLUTE_BASE_PORT || "4100", 10);
+  let port = basePort;
+  while (usedPorts.has(port)) port++;
+  if (port > 65535) throw new Error("No available ports \u2014 all ports 4100-65535 are allocated");
+  return port;
+}
+function daemonLoopback() {
+  const host = process.env.VOLUTE_DAEMON_HOSTNAME || "127.0.0.1";
+  if (host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  return host;
+}
+
+// src/lib/db.ts
+var __dirname = dirname2(fileURLToPath2(import.meta.url));
+var migrationsFolder = existsSync(resolve2(__dirname, "../drizzle")) ? resolve2(__dirname, "../drizzle") : resolve2(__dirname, "../../drizzle");
+var db = null;
+var dbPromise = null;
+async function getDb() {
+  if (db) return db;
+  if (dbPromise) return dbPromise;
+  dbPromise = (async () => {
+    try {
+      const dbPath = process.env.VOLUTE_DB_PATH || resolve2(voluteSystemDir(), "volute.db");
+      const instance = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
+      await migrate(instance, { migrationsFolder });
+      try {
+        chmodSync(dbPath, 384);
+      } catch (err) {
+        console.error(
+          `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
+          err
+        );
+      }
+      db = instance;
+      return instance;
+    } catch (err) {
+      dbPromise = null;
+      throw err;
+    }
+  })();
+  return dbPromise;
+}
+
+export {
+  getDb,
+  voluteHome,
+  voluteUserHome,
+  voluteSystemDir,
+  ensureSystemDir,
+  ensureVoluteHome,
+  readRegistry,
+  readAllMinds,
+  validateMindName,
+  addMind,
+  addSpirit,
+  readSpirits,
+  addVariant,
+  removeMind,
+  setMindRunning,
+  setMindStage,
+  setMindTemplateHash,
+  findMind,
+  findVariants,
+  getBaseName,
+  mindDir,
+  resolveMindDir,
+  stateDir,
+  nextPort,
+  daemonLoopback
+};

package/dist/{chunk-FXHXHI2A.js → chunk-LSGWR54X.js}

@@ -2,11 +2,10 @@
 import {
   exec,
   execInherit
-} from "./chunk-CVH6Y2YG.js";
+} from "./chunk-LGB6JBHI.js";
 import {
-  voluteHome,
   voluteSystemDir
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-LRCG2JLP.js";
 
 // src/lib/service-mode.ts
 import { execFileSync } from "child_process";
@@ -170,9 +169,7 @@ async function restartService(mode) {
   }
 }
 function readDaemonConfig() {
-  const newPath = resolve(voluteSystemDir(), "daemon.json");
-  const legacyPath = resolve(voluteHome(), "daemon.json");
-  const configPath = existsSync(newPath) ? newPath : legacyPath;
+  const configPath = resolve(voluteSystemDir(), "daemon.json");
   if (!existsSync(configPath)) return { hostname: "127.0.0.1", port: 1618 };
   try {
     const config = JSON.parse(readFileSync(configPath, "utf-8"));

package/dist/{chunk-S5LR3XYJ.js → chunk-M7UL5S3Q.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteSystemDir
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-LRCG2JLP.js";
 
 // src/lib/update-check.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/chunk-PB65JZK2.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+// packages/extensions/pages/src/db.ts
+function initDb(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS published_pages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mind TEXT NOT NULL,
+      file TEXT NOT NULL,
+      published_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_pp_mind_file ON published_pages(mind, file);
+    CREATE INDEX IF NOT EXISTS idx_pp_updated_at ON published_pages(updated_at);
+  `);
+}
+function getPublishedPages(db, mind) {
+  return db.prepare(
+    "SELECT file, published_at, updated_at FROM published_pages WHERE mind = ? ORDER BY file"
+  ).all(mind);
+}
+function getRecentPages(db, opts) {
+  const limit = opts?.limit ?? 10;
+  if (opts?.mind) {
+    return db.prepare(
+      "SELECT mind, file, updated_at FROM published_pages WHERE mind = ? ORDER BY updated_at DESC LIMIT ?"
+    ).all(opts.mind, limit);
+  }
+  return db.prepare("SELECT mind, file, updated_at FROM published_pages ORDER BY updated_at DESC LIMIT ?").all(limit);
+}
+function getAllSites(db) {
+  const rows = db.prepare("SELECT mind, file, updated_at FROM published_pages ORDER BY mind, file").all();
+  const siteMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let files = siteMap.get(row.mind);
+    if (!files) {
+      files = [];
+      siteMap.set(row.mind, files);
+    }
+    files.push({ file: row.file, updated_at: row.updated_at });
+  }
+  return Array.from(siteMap.entries()).map(([mind, files]) => ({ mind, files }));
+}
+function syncPublishedPages(db, mind, htmlFiles) {
+  const existing = new Map(
+    db.prepare("SELECT file, updated_at FROM published_pages WHERE mind = ?").all(mind).map((r) => [r.file, r.updated_at])
+  );
+  const newSet = new Set(htmlFiles);
+  const added = [];
+  const updated = [];
+  const removed = [];
+  db.exec("BEGIN");
+  try {
+    for (const file of htmlFiles) {
+      if (existing.has(file)) {
+        db.prepare(
+          "UPDATE published_pages SET updated_at = datetime('now') WHERE mind = ? AND file = ?"
+        ).run(mind, file);
+        updated.push(file);
+      } else {
+        db.prepare("INSERT INTO published_pages (mind, file) VALUES (?, ?)").run(mind, file);
+        added.push(file);
+      }
+    }
+    for (const [file] of existing) {
+      if (!newSet.has(file)) {
+        db.prepare("DELETE FROM published_pages WHERE mind = ? AND file = ?").run(mind, file);
+        removed.push(file);
+      }
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+  return { added, removed, updated };
+}
+
+export {
+  initDb,
+  getPublishedPages,
+  getRecentPages,
+  getAllSites,
+  syncPublishedPages
+};

package/dist/chunk-PVY5W6QN.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import {
+  composeTemplate,
+  findTemplatesRoot,
+  listFiles
+} from "./chunk-G53F3JA4.js";
+
+// src/lib/template-hash.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, rmSync } from "fs";
+import { resolve } from "path";
+var hashCache = /* @__PURE__ */ new Map();
+function computeTemplateHash(templateName) {
+  const cached = hashCache.get(templateName);
+  if (cached) return cached;
+  const templatesRoot = findTemplatesRoot();
+  const baseDir = resolve(templatesRoot, "_base");
+  const templateDir = resolve(templatesRoot, templateName);
+  if (!existsSync(baseDir)) throw new Error(`Base template not found: ${baseDir}`);
+  if (!existsSync(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 = readFileSync(resolve(composedDir, file));
+      hash.update(file);
+      hash.update("\0");
+      hash.update(content);
+    }
+    const result = hash.digest("hex");
+    hashCache.set(templateName, result);
+    return result;
+  } finally {
+    rmSync(composedDir, { recursive: true, force: true });
+  }
+}
+
+export {
+  computeTemplateHash
+};