volute 0.33.0 → 0.35.0

package/dist/chunk-QHG4OMZL.js

@@ -0,0 +1,145 @@
+#!/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')),
+      author TEXT
+    );
+    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);
+  `);
+  try {
+    db.exec("ALTER TABLE published_pages ADD COLUMN author TEXT");
+  } catch (err) {
+    if (!(err instanceof Error) || !err.message.includes("duplicate column")) {
+      throw err;
+    }
+  }
+}
+function getPublishedPages(db, mind) {
+  return db.prepare(
+    "SELECT file, published_at, updated_at, author 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, author FROM published_pages WHERE mind = ? ORDER BY updated_at DESC LIMIT ?"
+    ).all(opts.mind, limit);
+  }
+  return db.prepare(
+    "SELECT mind, file, updated_at, author FROM published_pages ORDER BY updated_at DESC LIMIT ?"
+  ).all(limit);
+}
+function getAllSites(db) {
+  const rows = db.prepare(
+    "SELECT mind, file, updated_at, author FROM published_pages WHERE mind != '_system' 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, author: row.author });
+  }
+  return Array.from(siteMap.entries()).map(([mind, files]) => ({ mind, files }));
+}
+function getSystemPages(db) {
+  const rows = db.prepare(
+    "SELECT mind, file, updated_at, author FROM published_pages WHERE mind = '_system' ORDER BY file"
+  ).all();
+  if (rows.length === 0) return null;
+  return {
+    mind: "_system",
+    files: rows.map((r) => ({ file: r.file, updated_at: r.updated_at, author: r.author }))
+  };
+}
+function syncSystemPages(db, htmlFiles, author) {
+  const existing = new Set(
+    db.prepare("SELECT file FROM published_pages WHERE mind = '_system'").all().map((r) => r.file)
+  );
+  const newSet = new Set(htmlFiles);
+  db.exec("BEGIN");
+  try {
+    for (const file of htmlFiles) {
+      if (existing.has(file)) {
+        if (author) {
+          db.prepare(
+            "UPDATE published_pages SET updated_at = datetime('now'), author = ? WHERE mind = '_system' AND file = ?"
+          ).run(author, file);
+        } else {
+          db.prepare(
+            "UPDATE published_pages SET updated_at = datetime('now') WHERE mind = '_system' AND file = ?"
+          ).run(file);
+        }
+      } else {
+        db.prepare("INSERT INTO published_pages (mind, file, author) VALUES ('_system', ?, ?)").run(
+          file,
+          author ?? null
+        );
+      }
+    }
+    for (const file of existing) {
+      if (!newSet.has(file)) {
+        db.prepare("DELETE FROM published_pages WHERE mind = '_system' AND file = ?").run(file);
+      }
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+function syncPublishedPages(db, mind, pageFiles) {
+  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(pageFiles);
+  const added = [];
+  const updated = [];
+  const removed = [];
+  db.exec("BEGIN");
+  try {
+    for (const file of pageFiles) {
+      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,
+  getSystemPages,
+  syncSystemPages,
+  syncPublishedPages
+};

package/dist/{chunk-SKLSMHXO.js → chunk-QWTR6AWZ.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   logger_default
-} from "./chunk-YUIHSKR6.js";
+} from "./chunk-BKF4WQCY.js";
 import {
   mindDir
-} from "./chunk-LRCG2JLP.js";
+} from "./chunk-BDYXIWA5.js";
 
-// src/lib/delivery/delivery-router.ts
+// packages/daemon/src/lib/delivery/delivery-router.ts
 import { readFileSync, statSync } from "fs";
 import { resolve } from "path";
 function extractTextContent(content) {

package/dist/chunk-TXSA4Q3V.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import {
+  parseArgs
+} from "./chunk-O7IGP7ZW.js";
+
+// packages/cli/src/lib/command.ts
+function command(def) {
+  function printHelp() {
+    const argParts = (def.args ?? []).map((a) => a.required ? `<${a.name}>` : `[${a.name}]`);
+    const hasFlags = Object.keys(def.flags).length > 0;
+    const flagPart = hasFlags ? " [options]" : "";
+    const argStr = argParts.length > 0 ? ` ${argParts.join(" ")}` : "";
+    console.log(`${def.description}
+`);
+    console.log(`Usage: ${def.name}${argStr}${flagPart}
+`);
+    if (def.args && def.args.length > 0) {
+      console.log("Arguments:");
+      const nameWidth = Math.max(...def.args.map((a) => a.name.length + 2));
+      for (const a of def.args) {
+        const label = a.required ? `<${a.name}>` : `[${a.name}]`;
+        console.log(`  ${label.padEnd(nameWidth + 2)}  ${a.description}`);
+      }
+      console.log("");
+    }
+    if (hasFlags) {
+      console.log("Options:");
+      const entries = Object.entries(def.flags);
+      const nameWidth = Math.max(
+        ...entries.map(([k, v]) => {
+          const valueHint = v.type === "boolean" ? "" : ` <${v.type === "string" ? "value" : "n"}>`;
+          return `--${k}${valueHint}`.length;
+        })
+      );
+      for (const [key, val] of entries) {
+        const valueHint = val.type === "boolean" ? "" : ` <${val.type === "string" ? "value" : "n"}>`;
+        const flag = `--${key}${valueHint}`;
+        console.log(`  ${flag.padEnd(nameWidth + 2)}  ${val.description}`);
+      }
+      console.log("");
+    }
+    if (def.examples && def.examples.length > 0) {
+      console.log("Examples:");
+      for (const ex of def.examples) {
+        console.log(`  ${ex}`);
+      }
+      console.log("");
+    }
+  }
+  async function execute(argv) {
+    const parseFlags = {};
+    for (const [key, val] of Object.entries(def.flags)) {
+      parseFlags[key] = { type: val.type };
+    }
+    const { positional, flags, help } = parseArgs(argv, parseFlags);
+    if (help) {
+      printHelp();
+      process.exit(0);
+    }
+    const namedArgs = {};
+    const argDefs = def.args ?? [];
+    for (let i = 0; i < argDefs.length; i++) {
+      namedArgs[argDefs[i].name] = positional[i];
+    }
+    for (const argDef of argDefs) {
+      if (argDef.required && !namedArgs[argDef.name]) {
+        console.error(`Missing required argument: <${argDef.name}>`);
+        printHelp();
+        process.exit(1);
+      }
+    }
+    const rest = positional.slice(argDefs.length);
+    await def.run({ args: namedArgs, flags, rest });
+  }
+  return { execute, printHelp };
+}
+function subcommands(def) {
+  function printHelp() {
+    console.log(`${def.description}
+`);
+    console.log(`Usage: ${def.name} <command> [options]
+`);
+    console.log("Commands:");
+    const entries = Object.entries(def.commands);
+    const nameWidth = Math.max(...entries.map(([k]) => k.length));
+    for (const [name, sub] of entries) {
+      console.log(`  ${name.padEnd(nameWidth + 2)}  ${sub.description}`);
+    }
+    if (def.footer) {
+      console.log(`
+${def.footer}`);
+    }
+    console.log("");
+  }
+  async function execute(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "--help" || sub === "-h") {
+      printHelp();
+      if (!sub) process.exit(1);
+      process.exit(0);
+    }
+    const entry = def.commands[sub];
+    if (!entry) {
+      console.error(`Unknown command: ${def.name} ${sub}`);
+      printHelp();
+      process.exit(1);
+    }
+    await entry.run(argv.slice(1));
+  }
+  return { execute, printHelp };
+}
+
+export {
+  command,
+  subcommands
+};

package/dist/{chunk-VH33ZWMW.js → chunk-VHJRZM2S.js}

@@ -2,9 +2,9 @@
 import {
   getBaseName,
   validateMindName
-} from "./chunk-LRCG2JLP.js";
+} from "./chunk-BDYXIWA5.js";
 
-// src/lib/isolation.ts
+// packages/daemon/src/lib/isolation.ts
 import { execFileSync } from "child_process";
 function isIsolationEnabled() {
   return process.env.VOLUTE_ISOLATION === "user";

package/dist/{chunk-SSI47XP2.js → chunk-VHWGEJ4V.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// src/lib/prompt.ts
+// packages/cli/src/lib/prompt.ts
 function rawPrompt(prompt, echo) {
   process.stderr.write(prompt);
   return new Promise((resolve) => {

package/dist/chunk-VY3RB2V7.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import {
+  getServiceMode,
+  modeLabel,
+  pollHealth,
+  startService
+} from "./chunk-2TGZJFAT.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import {
+  readGlobalConfig
+} from "./chunk-BMZQYACC.js";
+import {
+  voluteHome,
+  voluteSystemDir
+} from "./chunk-BDYXIWA5.js";
+
+// src/commands/up.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, openSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+var cmd = command({
+  name: "volute up",
+  description: "Start the daemon",
+  flags: {
+    port: { type: "number", description: "Port to listen on (default 1618)" },
+    host: { type: "string", description: "Host to bind to (default 127.0.0.1)" },
+    foreground: { type: "boolean", description: "Run in the foreground" },
+    "no-sandbox": { type: "boolean", description: "Disable sandbox mode" },
+    tailscale: { type: "boolean", description: "Enable Tailscale TLS" }
+  },
+  run: async ({ flags }) => {
+    const mode = getServiceMode();
+    if (!flags.foreground && mode !== "manual") {
+      console.log(`Starting volute (${modeLabel(mode)})...`);
+      try {
+        await startService(mode);
+      } catch (err) {
+        console.error(`Failed to start service: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+      const config2 = readGlobalConfig();
+      const h = flags.host ?? config2.hostname ?? "127.0.0.1";
+      const p = flags.port ?? config2.port ?? 1618;
+      if (await pollHealth(h, p)) {
+        console.log(`Volute daemon running on ${h}:${p}`);
+      } else {
+        console.error("Service started but daemon did not become healthy within 30s.");
+        process.exit(1);
+      }
+      return;
+    }
+    const config = readGlobalConfig();
+    const port = flags.port ?? config.port ?? 1618;
+    const hostname = flags.host ?? config.hostname ?? "127.0.0.1";
+    const home = voluteHome();
+    const systemDir = voluteSystemDir();
+    const pidPath = resolve(systemDir, "daemon.pid");
+    if (existsSync(pidPath)) {
+      try {
+        const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+        process.kill(pid, 0);
+        console.error(`Daemon already running (pid ${pid}). Use 'volute down' first.`);
+        process.exit(1);
+      } catch (err) {
+        if (err.code !== "ESRCH") {
+          console.error(`Warning: could not check PID file: ${err.message}`);
+        }
+      }
+    }
+    const pollHost = hostname === "0.0.0.0" || hostname === "::" ? "localhost" : hostname;
+    let tailscaleHostname;
+    if (flags.tailscale) {
+      try {
+        const { execFile } = await import("child_process");
+        const { promisify } = await import("util");
+        const execFileAsync = promisify(execFile);
+        const { stdout } = await execFileAsync("tailscale", ["status", "--json"]);
+        const status = JSON.parse(stdout);
+        tailscaleHostname = status.Self?.DNSName?.replace(/\.$/, "");
+      } catch (err) {
+        console.error(`Tailscale setup failed: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+    }
+    try {
+      const res = await fetch(`http://${pollHost}:${port}/api/health`);
+      if (res.ok) {
+        const body = await res.json().catch(() => null);
+        if (body && body.ok) {
+          console.error(
+            `Port ${port} is already in use by a Volute daemon. Use 'volute down' first, or kill the process on that port.`
+          );
+          process.exit(1);
+        }
+      }
+    } catch {
+    }
+    if (flags["no-sandbox"]) {
+      process.env.VOLUTE_SANDBOX = "0";
+    }
+    if (flags.foreground) {
+      const { startDaemon } = await import("./daemon.js");
+      await startDaemon({ port, hostname, foreground: true, tailscale: flags.tailscale });
+      return;
+    }
+    const daemonModule = resolve(dirname(new URL(import.meta.url).pathname), "daemon.js");
+    if (!existsSync(daemonModule)) {
+      console.error("Could not find daemon module. Run `npm run build` first.");
+      process.exit(1);
+    }
+    mkdirSync(home, { recursive: true });
+    mkdirSync(systemDir, { recursive: true });
+    const logFile = resolve(systemDir, "daemon.log");
+    const logFd = openSync(logFile, "a");
+    const daemonArgs = [daemonModule, "--port", String(port), "--host", hostname];
+    if (flags.tailscale) daemonArgs.push("--tailscale");
+    if (flags["no-sandbox"]) daemonArgs.push("--no-sandbox");
+    const child = spawn(process.execPath, daemonArgs, {
+      stdio: ["ignore", "ignore", logFd],
+      detached: true
+    });
+    child.unref();
+    const pollPort = flags.tailscale ? port + 1 : port;
+    const url = `http://localhost:${pollPort}/api/health`;
+    const maxWait = 3e4;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+      try {
+        const res = await fetch(url);
+        if (res.ok) {
+          const displayHost = tailscaleHostname ?? hostname;
+          const displayProto = flags.tailscale ? "https" : "http";
+          console.log(
+            `Volute daemon running on ${displayProto}://${displayHost}:${port} (pid ${child.pid})`
+          );
+          console.log(`Logs: ${logFile}`);
+          return;
+        }
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    if (child.pid) {
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        try {
+          process.kill(child.pid, "SIGTERM");
+        } catch {
+        }
+      }
+    }
+    console.error("Daemon started but did not become healthy within 30s.");
+    console.error(`Check logs: ${logFile}`);
+    process.exit(1);
+  }
+});
+var run = cmd.execute;
+
+export {
+  run
+};