volute 0.43.1 → 0.45.1

package/dist/{chunk-EFL5UOY4.js → chunk-CYI534DJ.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   broadcast
-} from "./chunk-7G2EEYXX.js";
+} from "./chunk-ZMIMSIIT.js";
 import {
   getDb
-} from "./chunk-YAMO2U3N.js";
+} from "./chunk-H7IYFRAL.js";
 import {
   users
-} from "./chunk-L3IV23ZG.js";
+} from "./chunk-ZV7MFISX.js";
 
 // packages/daemon/src/lib/auth.ts
 import { compareSync, hashSync } from "bcryptjs";

package/dist/{chunk-57LBQ7JX.js → chunk-FHWUQZXE.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-T2TP6ZC6.js";
 import {
   voluteSystemDir
-} from "./chunk-YAMO2U3N.js";
+} from "./chunk-H7IYFRAL.js";
 
 // packages/daemon/src/lib/bridges/bridges.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-YAMO2U3N.js → chunk-H7IYFRAL.js}

@@ -2,7 +2,7 @@
 import {
   minds,
   schema_exports
-} from "./chunk-L3IV23ZG.js";
+} from "./chunk-ZV7MFISX.js";
 
 // packages/daemon/src/lib/db.ts
 import { chmodSync, existsSync } from "fs";

package/dist/{chunk-M3PGGSBH.js → chunk-HVU45COX.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   publish
-} from "./chunk-7G2EEYXX.js";
+} from "./chunk-ZMIMSIIT.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";

package/dist/{chunk-O3DXAR44.js → chunk-IEWZ7VD7.js}

@@ -8,10 +8,10 @@ import {
   pollHealthDown,
   readDaemonConfig,
   stopService
-} from "./chunk-ATEX3ZPG.js";
+} from "./chunk-Q2XBKQ2D.js";
 import {
   voluteSystemDir
-} from "./chunk-YAMO2U3N.js";
+} from "./chunk-H7IYFRAL.js";
 
 // src/commands/down.ts
 import { existsSync, readFileSync, unlinkSync } from "fs";

package/dist/{chunk-DE4EKQFH.js → chunk-IUXTYXFI.js}

@@ -7,14 +7,14 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-ATEX3ZPG.js";
+} from "./chunk-Q2XBKQ2D.js";
 import {
   readGlobalConfig
-} from "./chunk-ONM2AZFL.js";
+} from "./chunk-322KE457.js";
 import {
   voluteHome,
   voluteSystemDir
-} from "./chunk-YAMO2U3N.js";
+} from "./chunk-H7IYFRAL.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";

package/dist/{chunk-K4EHBHPE.js → chunk-JSRMEY52.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   subscribe
-} from "./chunk-7G2EEYXX.js";
+} from "./chunk-ZMIMSIIT.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
 import {
   getDb
-} from "./chunk-YAMO2U3N.js";
+} from "./chunk-H7IYFRAL.js";
 import {
   channels,
   conversationParticipants,
@@ -15,7 +15,7 @@ import {
   conversations,
   messages,
   users
-} from "./chunk-L3IV23ZG.js";
+} from "./chunk-ZV7MFISX.js";
 
 // packages/daemon/src/lib/events/conversations.ts
 import { randomUUID } from "crypto";
@@ -470,7 +470,7 @@ async function joinChannel(conversationId, userId) {
 async function leaveChannel(conversationId, userId) {
   await removeParticipant(conversationId, userId);
 }
-async function getUnreadCounts(userId, conversationIds) {
+async function getUnreadCounts(userId, conversationIds, username) {
   if (conversationIds.length === 0) return {};
   const db = await getDb();
   const rows = await db.select({
@@ -485,7 +485,9 @@ async function getUnreadCounts(userId, conversationIds) {
   ).where(
     and(
       inArray(messages.conversation_id, conversationIds),
-      sql`${messages.id} > COALESCE(${conversationReads.last_read_message_id}, 0)`
+      sql`${messages.id} > COALESCE(${conversationReads.last_read_message_id}, 0)`,
+      // A user's own messages are never "unread" for them
+      sql`(${messages.sender_name} IS NULL OR ${messages.sender_name} != ${username})`
     )
   ).groupBy(messages.conversation_id);
   const result = {};

package/dist/{chunk-QHG4OMZL.js → chunk-KDLYIECM.js}

@@ -14,11 +14,13 @@ function initDb(db) {
     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;
+  for (const column of ["author TEXT", "hash TEXT"]) {
+    try {
+      db.exec(`ALTER TABLE published_pages ADD COLUMN ${column}`);
+    } catch (err) {
+      if (!(err instanceof Error) || !err.message.includes("duplicate column")) {
+        throw err;
+      }
     }
   }
 }
@@ -63,32 +65,31 @@ function getSystemPages(db) {
     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)
+function syncSystemPages(db, pages, author) {
+  const existing = new Map(
+    db.prepare("SELECT file, hash FROM published_pages WHERE mind = '_system'").all().map((r) => [r.file, r.hash])
   );
-  const newSet = new Set(htmlFiles);
+  const newSet = new Set(pages.map((p) => p.file));
   db.exec("BEGIN");
   try {
-    for (const file of htmlFiles) {
-      if (existing.has(file)) {
+    for (const { file, hash } of pages) {
+      if (!existing.has(file)) {
+        db.prepare(
+          "INSERT INTO published_pages (mind, file, hash, author) VALUES ('_system', ?, ?, ?)"
+        ).run(file, hash, author ?? null);
+      } else if (existing.get(file) !== hash) {
         if (author) {
           db.prepare(
-            "UPDATE published_pages SET updated_at = datetime('now'), author = ? WHERE mind = '_system' AND file = ?"
-          ).run(author, file);
+            "UPDATE published_pages SET updated_at = datetime('now'), hash = ?, author = ? WHERE mind = '_system' AND file = ?"
+          ).run(hash, author, file);
         } else {
           db.prepare(
-            "UPDATE published_pages SET updated_at = datetime('now') WHERE mind = '_system' AND file = ?"
-          ).run(file);
+            "UPDATE published_pages SET updated_at = datetime('now'), hash = ? WHERE mind = '_system' AND file = ?"
+          ).run(hash, file);
         }
-      } else {
-        db.prepare("INSERT INTO published_pages (mind, file, author) VALUES ('_system', ?, ?)").run(
-          file,
-          author ?? null
-        );
       }
     }
-    for (const file of existing) {
+    for (const file of existing.keys()) {
       if (!newSet.has(file)) {
         db.prepare("DELETE FROM published_pages WHERE mind = '_system' AND file = ?").run(file);
       }
@@ -99,28 +100,32 @@ function syncSystemPages(db, htmlFiles, author) {
     throw err;
   }
 }
-function syncPublishedPages(db, mind, pageFiles) {
+function syncPublishedPages(db, mind, pages) {
   const existing = new Map(
-    db.prepare("SELECT file, updated_at FROM published_pages WHERE mind = ?").all(mind).map((r) => [r.file, r.updated_at])
+    db.prepare("SELECT file, hash FROM published_pages WHERE mind = ?").all(mind).map((r) => [r.file, r.hash])
   );
-  const newSet = new Set(pageFiles);
+  const newSet = new Set(pages.map((p) => p.file));
   const added = [];
   const updated = [];
   const removed = [];
   db.exec("BEGIN");
   try {
-    for (const file of pageFiles) {
-      if (existing.has(file)) {
+    for (const { file, hash } of pages) {
+      if (!existing.has(file)) {
+        db.prepare("INSERT INTO published_pages (mind, file, hash) VALUES (?, ?, ?)").run(
+          mind,
+          file,
+          hash
+        );
+        added.push(file);
+      } else if (existing.get(file) !== hash) {
         db.prepare(
-          "UPDATE published_pages SET updated_at = datetime('now') WHERE mind = ? AND file = ?"
-        ).run(mind, file);
+          "UPDATE published_pages SET updated_at = datetime('now'), hash = ? WHERE mind = ? AND file = ?"
+        ).run(hash, 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) {
+    for (const file of existing.keys()) {
       if (!newSet.has(file)) {
         db.prepare("DELETE FROM published_pages WHERE mind = ? AND file = ?").run(mind, file);
         removed.push(file);

package/dist/{chunk-EE7SZJON.js → chunk-KP3KWNG6.js}

@@ -3,10 +3,10 @@ import {
   LAUNCHD_PLIST_LABEL,
   LAUNCHD_PLIST_PATH,
   USER_SYSTEMD_UNIT
-} from "./chunk-ATEX3ZPG.js";
+} from "./chunk-Q2XBKQ2D.js";
 import {
   resolveVoluteBin
-} from "./chunk-PGPLCJPK.js";
+} from "./chunk-3ERIL673.js";
 
 // packages/daemon/src/lib/config/service-install.ts
 import { execFile } from "child_process";

package/dist/chunk-KVKP6VQ5.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+import {
+  exec
+} from "./chunk-3ERIL673.js";
+import {
+  readGlobalConfig
+} from "./chunk-322KE457.js";
+import {
+  logger_default
+} from "./chunk-T2TP6ZC6.js";
+import {
+  getDb,
+  readAllMinds,
+  voluteHome,
+  voluteSystemDir
+} from "./chunk-H7IYFRAL.js";
+
+// packages/daemon/src/lib/backup/restic.ts
+import { writeFileSync } from "fs";
+import { resolve } from "path";
+var RESTIC_INSTALL_HINT = "Install restic: `brew install restic` (macOS), `apt-get install restic` (Debian/Ubuntu), or see https://restic.net";
+async function resticVersion() {
+  try {
+    const out = await exec("restic", ["version"]);
+    return out.trim();
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      logger_default.child("backup").warn("restic exists but failed to run", logger_default.errorData(err));
+    }
+    return null;
+  }
+}
+function resticEnv(config) {
+  if (!config.repository) throw new Error("Backup repository is not configured");
+  if (!config.password) throw new Error("Backup password is not configured");
+  return {
+    ...process.env,
+    ...config.env,
+    RESTIC_REPOSITORY: config.repository,
+    RESTIC_PASSWORD: config.password
+  };
+}
+async function runRestic(args, config, options) {
+  if (!await resticVersion()) {
+    throw new Error(`restic is not installed. ${RESTIC_INSTALL_HINT}`);
+  }
+  return exec("restic", args, { cwd: options?.cwd, env: resticEnv(config) });
+}
+var BASE_EXCLUDES = [
+  // dependency trees and build output — rehydrated via lockfiles
+  "node_modules",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "dist",
+  // mind runtime state that is regenerated
+  ".variants",
+  ".worktrees",
+  ".mind/tmp",
+  ".npm",
+  // toolchains and caches minds install into their home. home/.local must NOT
+  // be excluded wholesale: .local/hooks and .local/bin hold mind-authored hooks
+  // and skill shims that are never regenerated — only its toolchain subdirs go.
+  "home/.cache",
+  "home/.npm",
+  "home/.rustup",
+  "home/.cargo",
+  "home/.local/share",
+  "home/.local/state",
+  "home/.local/lib",
+  "home/.local/pipx"
+];
+function systemExcludes() {
+  const sys = voluteSystemDir();
+  return [
+    resolve(sys, "volute.db"),
+    resolve(sys, "volute.db-wal"),
+    resolve(sys, "volute.db-shm"),
+    `${resolve(sys, "extension-data")}/*/data.db`,
+    `${resolve(sys, "extension-data")}/*/data.db-wal`,
+    `${resolve(sys, "extension-data")}/*/data.db-shm`,
+    `${resolve(sys, "state")}/*/logs`,
+    resolve(sys, "daemon.log"),
+    resolve(sys, "daemon.pid"),
+    resolve(sys, "backup-excludes.txt")
+  ];
+}
+var SESSION_EXCLUDES = [
+  "home/.claude/projects",
+  "home/.claude/debug",
+  "home/.claude/telemetry",
+  "home/.claude/todos",
+  "home/.claude/session-env",
+  ".mind/codex/sessions",
+  ".mind/pi-sessions"
+];
+function buildExcludePatterns(config) {
+  const patterns = [...BASE_EXCLUDES, ...systemExcludes()];
+  if (!config.includeSessions) patterns.push(...SESSION_EXCLUDES);
+  return patterns;
+}
+function writeExcludeFile(config) {
+  const path = resolve(voluteSystemDir(), "backup-excludes.txt");
+  writeFileSync(path, `${buildExcludePatterns(config).join("\n")}
+`);
+  return path;
+}
+
+// packages/daemon/src/lib/backup/backup.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { sql } from "drizzle-orm";
+var blog = logger_default.child("backup");
+var DEFAULT_KEEP = { daily: 7, weekly: 4, monthly: 12 };
+function stateFilePath() {
+  return resolve2(voluteSystemDir(), "backup-state.json");
+}
+function readBackupState() {
+  const path = stateFilePath();
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    blog.warn("backup-state.json unreadable, treating as empty", logger_default.errorData(err));
+    return {};
+  }
+}
+function writeBackupState(state) {
+  try {
+    writeFileSync2(stateFilePath(), `${JSON.stringify(state, null, 2)}
+`);
+  } catch (err) {
+    blog.error("failed to write backup-state.json", logger_default.errorData(err));
+  }
+}
+function stagingDir() {
+  return resolve2(voluteSystemDir(), "backup-staging");
+}
+async function stageDatabases() {
+  const staging = stagingDir();
+  rmSync(staging, { recursive: true, force: true });
+  mkdirSync(staging, { recursive: true });
+  const staged = [];
+  const mainTarget = resolve2(staging, "volute.db");
+  const db = await getDb();
+  await db.run(sql.raw(`VACUUM INTO '${mainTarget.replaceAll("'", "''")}'`));
+  staged.push(mainTarget);
+  const extDataDir = resolve2(voluteSystemDir(), "extension-data");
+  if (existsSync(extDataDir)) {
+    const { default: Database } = await import("libsql");
+    for (const id of readdirSync(extDataDir)) {
+      const dbPath = resolve2(extDataDir, id, "data.db");
+      if (!existsSync(dbPath)) continue;
+      const target = resolve2(staging, "extension-data", id, "data.db");
+      mkdirSync(dirname(target), { recursive: true });
+      const extDb = new Database(dbPath);
+      try {
+        extDb.exec(`VACUUM INTO '${target.replaceAll("'", "''")}'`);
+        staged.push(target);
+      } finally {
+        extDb.close();
+      }
+    }
+  }
+  return staged;
+}
+async function backupRoots() {
+  const roots = /* @__PURE__ */ new Set([voluteHome()]);
+  const mindsDir = process.env.VOLUTE_MINDS_DIR;
+  if (mindsDir && existsSync(mindsDir)) roots.add(resolve2(mindsDir));
+  for (const mind of await readAllMinds()) {
+    if (!mind.dir || !existsSync(mind.dir)) continue;
+    const dir = resolve2(mind.dir);
+    if (![...roots].some((root) => dir === root || dir.startsWith(`${root}/`))) {
+      roots.add(dir);
+    }
+  }
+  return [...roots];
+}
+var backupInFlight = false;
+async function runBackup() {
+  if (backupInFlight) throw new Error("A backup is already running");
+  backupInFlight = true;
+  const started = Date.now();
+  try {
+    const config = readGlobalConfig().backup ?? {};
+    if (!config.repository || !config.password) {
+      throw new Error("Backup repository is not configured. Run: volute backup init");
+    }
+    blog.info("starting backup", { repository: config.repository });
+    await stageDatabases();
+    const roots = await backupRoots();
+    const excludeFile = writeExcludeFile(config);
+    const out = await runRestic(
+      [
+        "backup",
+        ...roots,
+        "--exclude-file",
+        excludeFile,
+        "--exclude-caches",
+        "--tag",
+        "volute",
+        "--json"
+      ],
+      config
+    );
+    const summary = parseBackupSummary(out, Date.now() - started);
+    const keep = { ...DEFAULT_KEEP, ...config.keep };
+    let pruneError;
+    try {
+      await runRestic(
+        [
+          "forget",
+          "--tag",
+          "volute",
+          "--keep-daily",
+          String(keep.daily),
+          "--keep-weekly",
+          String(keep.weekly),
+          "--keep-monthly",
+          String(keep.monthly),
+          "--prune"
+        ],
+        config
+      );
+    } catch (err) {
+      pruneError = err instanceof Error ? err.message : String(err);
+      blog.warn("retention prune failed (snapshot is intact)", logger_default.errorData(err));
+    }
+    writeBackupState({
+      lastRun: (/* @__PURE__ */ new Date()).toISOString(),
+      lastSnapshotId: summary.snapshotId,
+      lastDurationMs: summary.durationMs,
+      ...pruneError ? { pruneError } : {}
+    });
+    blog.info("backup complete", { snapshot: summary.snapshotId, ms: summary.durationMs });
+    return summary;
+  } catch (err) {
+    writeBackupState({
+      ...readBackupState(),
+      lastAttempt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastError: err instanceof Error ? err.message : String(err)
+    });
+    throw err;
+  } finally {
+    backupInFlight = false;
+  }
+}
+function parseBackupSummary(output, durationMs) {
+  for (const line of output.trim().split("\n").reverse()) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (msg.message_type !== "summary") continue;
+    if (!msg.snapshot_id) throw new Error("restic summary is missing snapshot_id");
+    return {
+      snapshotId: msg.snapshot_id,
+      filesNew: msg.files_new ?? 0,
+      filesChanged: msg.files_changed ?? 0,
+      dataAdded: msg.data_added ?? 0,
+      totalFilesProcessed: msg.total_files_processed ?? 0,
+      durationMs
+    };
+  }
+  throw new Error("restic backup produced no summary");
+}
+async function listSnapshots() {
+  const config = readGlobalConfig().backup ?? {};
+  const out = await runRestic(["snapshots", "--tag", "volute", "--json"], config);
+  const parsed = JSON.parse(out || "[]");
+  return parsed.map((s) => ({
+    id: s.id,
+    short_id: s.short_id,
+    time: s.time,
+    hostname: s.hostname,
+    paths: s.paths
+  }));
+}
+async function initRepo(config) {
+  try {
+    await runRestic(["init"], config);
+  } catch (err) {
+    const stderr = err.stderr ?? "";
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/already exists|already initialized/i.test(stderr + msg)) return;
+    throw err;
+  }
+}
+function restoreStagedDb(stagedPath, livePath) {
+  if (!existsSync(stagedPath)) return false;
+  mkdirSync(dirname(livePath), { recursive: true });
+  rmSync(livePath, { force: true });
+  rmSync(`${livePath}-wal`, { force: true });
+  rmSync(`${livePath}-shm`, { force: true });
+  renameSync(stagedPath, livePath);
+  return true;
+}
+
+export {
+  RESTIC_INSTALL_HINT,
+  resticVersion,
+  readBackupState,
+  runBackup,
+  listSnapshots,
+  initRepo,
+  restoreStagedDb
+};

package/dist/{chunk-JVK6QQIC.js → chunk-LAXUUY7O.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   setBridgeConfig
-} from "./chunk-57LBQ7JX.js";
+} from "./chunk-FHWUQZXE.js";
 import {
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-XDTKJNW5.js";
+} from "./chunk-5GT7URXJ.js";
 
 // packages/daemon/src/lib/template/import-utils.ts
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";

package/dist/{chunk-C6ESRQZ7.js → chunk-OXXTPILE.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   readGlobalConfig
-} from "./chunk-ONM2AZFL.js";
+} from "./chunk-322KE457.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";

package/dist/{chunk-ATEX3ZPG.js → chunk-Q2XBKQ2D.js}

@@ -2,10 +2,10 @@
 import {
   exec,
   execInherit
-} from "./chunk-PGPLCJPK.js";
+} from "./chunk-3ERIL673.js";
 import {
   voluteSystemDir
-} from "./chunk-YAMO2U3N.js";
+} from "./chunk-H7IYFRAL.js";
 
 // packages/daemon/src/lib/config/service-mode.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-GZJFC76M.js → chunk-QMJJWTNL.js}

@@ -2,7 +2,7 @@
 import {
   mindDir,
   stateDir
-} from "./chunk-YAMO2U3N.js";
+} from "./chunk-H7IYFRAL.js";
 
 // packages/daemon/src/lib/mind/archive.ts
 import { execFileSync } from "child_process";