volute 0.27.0 → 0.29.0

package/dist/{chunk-K5NAC55T.js → chunk-CQ7SNKNI.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-YUIHSKR6.js";
 
 // src/lib/events/mind-activity-tracker.ts
-var IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
+var IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
 var minds = /* @__PURE__ */ new Map();
 function getState(mind) {
   let state = minds.get(mind);

package/dist/{chunk-PHSAT7YL.js → chunk-EHZKEMMV.js}

@@ -2,7 +2,7 @@
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-USUXRNVD.js";
+} from "./chunk-J4IBNXGJ.js";
 import {
   loadMergedEnv
 } from "./chunk-2WPW7OT6.js";
@@ -172,9 +172,9 @@ To reject, delete \${filePath}`,
     category: "mind"
   },
   pre_sleep: {
-    content: "Time to rest. You have this turn to wind down however feels right \u2014 reflect on your day, update your journal or memory, finish any threads of thought, or simply settle.\n\nYour current session will be archived and a fresh one will begin when you wake. Anything in session context that isn't saved to files will be lost.\n\nYou'll wake at ${wakeTime}. ${queuedInfo}",
+    content: "Time to rest. You have this turn to wind down however feels right \u2014 reflect on your day, update your journal or memory, finish any threads of thought, or simply settle.\n\nYour current session will be archived and a fresh one will begin when you wake. Anything in session context that isn't saved to files will be lost.\n\nYou'll wake at ${wakeTime}.",
     description: "Pre-sleep message sent before stopping the mind",
-    variables: ["wakeTime", "queuedInfo"],
+    variables: ["wakeTime"],
     category: "system"
   },
   wake_summary: {
@@ -568,7 +568,7 @@ var MindManager = class {
       if (this.shuttingDown || this.stopping.has(name)) return;
       mlog.error(`mind ${name} exited with code ${code}`);
       try {
-        const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
+        const { getSleepManagerIfReady } = await import("./sleep-manager-G4B5GW5P.js");
         const sleepState = getSleepManagerIfReady()?.getState(name);
         if (sleepState?.sleeping) {
           mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
@@ -577,7 +577,7 @@ var MindManager = class {
       } catch (err) {
         mlog.warn(`failed to check sleep state for ${name}`, logger_default.errorData(err));
       }
-      import("./mind-activity-tracker-EN6XNXPF.js").then(({ markIdle }) => markIdle(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
+      import("./mind-activity-tracker-WRHFI3YW.js").then(({ markIdle }) => markIdle(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
       import("./activity-events-BBIEA2F4.js").then(
         ({ publish }) => publish({ type: "mind_stopped", mind: name, summary: `${name} crashed (exit ${code})` })
       ).catch((err) => mlog.warn(`failed to publish crash event for ${name}`, logger_default.errorData(err)));

package/dist/{chunk-IAYBDWVG.js → chunk-FLZGS4QH.js}

@@ -109,6 +109,53 @@ function publish(conversationId, event) {
 }
 
 // src/lib/events/conversations.ts
+async function migrateGroupDMsToChannels() {
+  const db = await getDb();
+  await db.transaction(async (tx) => {
+    const overloadedDMs = await tx.select({
+      conversationId: conversationParticipants.conversation_id,
+      count: sql`COUNT(*)`
+    }).from(conversationParticipants).innerJoin(conversations, eq(conversationParticipants.conversation_id, conversations.id)).where(eq(conversations.type, "dm")).groupBy(conversationParticipants.conversation_id).having(sql`COUNT(*) > 2`);
+    const dmIds = overloadedDMs.map((r) => r.conversationId);
+    await tx.update(conversations).set({
+      type: "channel",
+      name: sql`COALESCE(${conversations.name}, ${conversations.title})`
+    }).where(eq(conversations.type, "group"));
+    if (dmIds.length > 0) {
+      await tx.update(conversations).set({
+        type: "channel",
+        name: sql`COALESCE(${conversations.name}, ${conversations.title})`
+      }).where(inArray(conversations.id, dmIds));
+    }
+  });
+  await migrateChannelEntryTypes();
+}
+async function migrateChannelEntryTypes() {
+  const { existsSync, readdirSync, readFileSync, writeFileSync } = await import("fs");
+  const { join } = await import("path");
+  const home = join((await import("os")).homedir(), ".volute", "state");
+  if (!existsSync(home)) return;
+  for (const name of readdirSync(home)) {
+    const filePath = join(home, name, "channels.json");
+    if (!existsSync(filePath)) continue;
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const map = JSON.parse(raw);
+      let changed = false;
+      for (const entry of Object.values(map)) {
+        if (entry.type === "group") {
+          entry.type = "channel";
+          changed = true;
+        }
+      }
+      if (changed) {
+        writeFileSync(filePath, `${JSON.stringify(map, null, 2)}
+`);
+      }
+    } catch {
+    }
+  }
+}
 async function createConversation(mindName, channel, opts) {
   const db = await getDb();
   const id = randomUUID();
@@ -380,6 +427,101 @@ async function findDMConversation(mindName, participantIds) {
   }
   return null;
 }
+async function listConversationsForMind(mindName) {
+  const db = await getDb();
+  const byName = await db.select().from(conversations).where(eq(conversations.mind_name, mindName)).orderBy(desc(conversations.updated_at)).all();
+  const mindUser = await db.select({ id: users.id }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
+  const byNameIds = new Set(byName.map((c) => c.id));
+  let byParticipation = [];
+  if (mindUser) {
+    const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq(conversationParticipants.user_id, mindUser.id)).all();
+    const extraIds = participantRows.map((r) => r.conversation_id).filter((id) => !byNameIds.has(id));
+    if (extraIds.length > 0) {
+      byParticipation = await db.select().from(conversations).where(inArray(conversations.id, extraIds)).orderBy(desc(conversations.updated_at)).all();
+    }
+  }
+  const convs = [...byName, ...byParticipation].sort(
+    (a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime()
+  );
+  if (convs.length === 0) return [];
+  const convIds = convs.map((c) => c.id);
+  const rows = await db.select({
+    conversationId: conversationParticipants.conversation_id,
+    userId: users.id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role,
+    displayName: users.display_name,
+    description: users.description,
+    avatar: users.avatar
+  }).from(conversationParticipants).innerJoin(users, eq(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  const byConv = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let arr = byConv.get(r.conversationId);
+    if (!arr) {
+      arr = [];
+      byConv.set(r.conversationId, arr);
+    }
+    arr.push({
+      userId: r.userId,
+      username: r.username,
+      userType: r.userType,
+      role: r.role,
+      displayName: r.displayName,
+      description: r.description,
+      avatar: r.avatar
+    });
+  }
+  const lastMsgIds = await db.select({
+    conversationId: messages.conversation_id,
+    maxId: sql`MAX(${messages.id})`
+  }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
+  const byLastMsg = /* @__PURE__ */ new Map();
+  if (lastMsgIds.length > 0) {
+    const msgRows = await db.select().from(messages).where(
+      inArray(
+        messages.id,
+        lastMsgIds.map((r) => r.maxId)
+      )
+    );
+    for (const m of msgRows) {
+      let text = "";
+      try {
+        const parsed = JSON.parse(m.content);
+        const blocks = Array.isArray(parsed) ? parsed : [];
+        const textBlock = blocks.find((b) => b.type === "text");
+        if (textBlock && "text" in textBlock) text = textBlock.text;
+      } catch {
+        text = m.content;
+      }
+      byLastMsg.set(m.conversation_id, {
+        role: m.role,
+        senderName: m.sender_name,
+        text,
+        createdAt: m.created_at
+      });
+    }
+  }
+  return convs.map((c) => ({
+    ...c,
+    participants: byConv.get(c.id) ?? [],
+    lastMessage: byLastMsg.get(c.id)
+  }));
+}
+async function isConversationForMind(mindName, conversationId) {
+  const db = await getDb();
+  const byName = await db.select({ id: conversations.id }).from(conversations).where(and(eq(conversations.id, conversationId), eq(conversations.mind_name, mindName))).get();
+  if (byName) return true;
+  const mindUser = await db.select({ id: users.id }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
+  if (!mindUser) return false;
+  const participant = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(
+    and(
+      eq(conversationParticipants.conversation_id, conversationId),
+      eq(conversationParticipants.user_id, mindUser.id)
+    )
+  ).get();
+  return !!participant;
+}
 async function deleteConversation(id) {
   const db = await getDb();
   await db.delete(conversations).where(eq(conversations.id, id));
@@ -451,6 +593,7 @@ export {
   initWebhook,
   subscribe2 as subscribe,
   publish,
+  migrateGroupDMsToChannels,
   createConversation,
   getOrCreateConversation,
   getConversation,
@@ -466,6 +609,8 @@ export {
   getMessagesPaginated,
   listConversationsWithParticipants,
   findDMConversation,
+  listConversationsForMind,
+  isConversationForMind,
   deleteConversation,
   createChannel,
   getChannelByName,

package/dist/{chunk-USUXRNVD.js → chunk-J4IBNXGJ.js}

@@ -55,8 +55,6 @@ async function buildDenyRead(mindName, mindDir) {
   const userVoluteHome = voluteUserHome();
   if (userVoluteHome !== home) {
     deny.push(userVoluteHome);
-  } else {
-    deny.push(resolve(home, "systems.json"));
   }
   try {
     const entries = await readRegistry();

package/dist/chunk-MD4C26II.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import {
+  stateDir
+} from "./chunk-H7OZRFJB.js";
+
+// src/lib/file-sharing.ts
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { basename, join, normalize, resolve } from "path";
+function validateFilePath(filePath) {
+  if (!filePath) return "File path is required";
+  const normalized = normalize(filePath);
+  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
+    return "Absolute paths are not allowed";
+  }
+  if (normalized.includes("..")) {
+    return "Path traversal (..) is not allowed";
+  }
+  return null;
+}
+function pendingDir(receiver) {
+  return resolve(stateDir(receiver), "pending-files");
+}
+function validateId(id) {
+  if (!id || id.includes("/") || id.includes("\\") || id.includes("..")) {
+    throw new Error("Invalid pending file id");
+  }
+}
+function generateId(sender) {
+  const ts = Date.now();
+  const rand = randomBytes(2).toString("hex");
+  return `${sender}-${ts}-${rand}`;
+}
+function stageFile(receiver, sender, filename, content, originalPath) {
+  const err = validateFilePath(filename);
+  if (err) throw new Error(err);
+  if (sender.includes("/") || sender.includes("\\")) {
+    throw new Error("Invalid sender name");
+  }
+  const id = generateId(sender);
+  const dir = resolve(pendingDir(receiver), id);
+  mkdirSync(dir, { recursive: true });
+  const metadata = {
+    id,
+    sender,
+    filename: basename(filename),
+    originalPath,
+    size: content.length,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(resolve(dir, "metadata.json"), `${JSON.stringify(metadata, null, 2)}
+`);
+  writeFileSync(resolve(dir, "data"), content);
+  return { id };
+}
+function listPending(receiver) {
+  const dir = pendingDir(receiver);
+  if (!existsSync(dir)) return [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const result = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const metaPath = resolve(dir, entry.name, "metadata.json");
+    if (!existsSync(metaPath)) continue;
+    try {
+      result.push(JSON.parse(readFileSync(metaPath, "utf-8")));
+    } catch (err) {
+      console.warn(`[file-sharing] skipping malformed pending entry ${entry.name}:`, err);
+    }
+  }
+  return result.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function getPending(receiver, id) {
+  validateId(id);
+  const metaPath = resolve(pendingDir(receiver), id, "metadata.json");
+  if (!existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf-8"));
+  } catch (err) {
+    console.warn(`[file-sharing] failed to read pending metadata for ${id}:`, err);
+    return null;
+  }
+}
+function deliverFile(receiverDir, sender, filename, content, inboxPath) {
+  const err = validateFilePath(filename);
+  if (err) throw new Error(err);
+  const inbox = inboxPath ?? "inbox";
+  const inboxErr = validateFilePath(inbox);
+  if (inboxErr) throw new Error(`Invalid inboxPath: ${inboxErr}`);
+  if (sender.includes("/") || sender.includes("\\")) {
+    throw new Error("Invalid sender name");
+  }
+  const destDir = resolve(receiverDir, "home", inbox, sender);
+  mkdirSync(destDir, { recursive: true });
+  const destPath = resolve(destDir, basename(filename));
+  writeFileSync(destPath, content);
+  return join(inbox, sender, basename(filename));
+}
+function acceptPending(receiver, id, receiverDir, dest) {
+  const meta = getPending(receiver, id);
+  if (!meta) throw new Error(`Pending file not found: ${id}`);
+  const dataPath = resolve(pendingDir(receiver), id, "data");
+  const content = readFileSync(dataPath);
+  const inboxPath = dest ?? "inbox";
+  const destPath = deliverFile(receiverDir, meta.sender, meta.filename, content, inboxPath);
+  rmSync(resolve(pendingDir(receiver), id), { recursive: true });
+  return { sender: meta.sender, filename: meta.filename, destPath };
+}
+function rejectPending(receiver, id) {
+  const meta = getPending(receiver, id);
+  if (!meta) throw new Error(`Pending file not found: ${id}`);
+  rmSync(resolve(pendingDir(receiver), id), { recursive: true });
+  return { sender: meta.sender, filename: meta.filename };
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+export {
+  validateFilePath,
+  stageFile,
+  listPending,
+  acceptPending,
+  rejectPending,
+  formatFileSize
+};

package/dist/{chunk-4WXYUOAK.js → chunk-NI5FFCCS.js}

@@ -28,7 +28,14 @@ import { basename, dirname, join, resolve } from "path";
 import { eq, sql } from "drizzle-orm";
 var VALID_SKILL_ID = /^[a-zA-Z0-9_-]+$/;
 var SEED_SKILLS = ["orientation", "memory"];
-var STANDARD_SKILLS = ["volute-mind", "memory", "sessions", "notes", "dreaming"];
+var STANDARD_SKILLS = [
+  "volute-mind",
+  "memory",
+  "sessions",
+  "notes",
+  "dreaming",
+  "shared-files"
+];
 function validateSkillId(id) {
   if (!id || !VALID_SKILL_ID.test(id)) {
     throw new Error(`Invalid skill ID: ${id}`);

package/dist/{chunk-JKOWNZ4P.js → chunk-P72MVS4R.js}

@@ -178,50 +178,11 @@ async function sharedMerge(mindName, mindDir, message) {
     return { ok: true };
   });
 }
-async function sharedPull(mindName, mindDir) {
-  return withSharedLock(async () => {
-    const worktreePath = resolve(mindDir, "home", "shared");
-    const status = (await gitExec(["status", "--porcelain"], { cwd: worktreePath })).trim();
-    if (status) {
-      await gitExec(["add", "-A"], { cwd: worktreePath });
-      await gitExec(
-        ["commit", "--author", `${mindName} <${mindName}@volute>`, "-m", `wip: ${mindName}`],
-        { cwd: worktreePath }
-      );
-    }
-    try {
-      await gitExec(["rebase", "main"], { cwd: worktreePath });
-      rechownWorktree(worktreePath, mindName);
-      return { ok: true };
-    } catch {
-      try {
-        await gitExec(["rebase", "--abort"], { cwd: worktreePath });
-      } catch {
-        return {
-          ok: false,
-          message: "Rebase failed and abort failed \u2014 shared worktree may need manual repair"
-        };
-      }
-      return { ok: false, message: "Rebase failed \u2014 conflicts with main" };
-    }
-  });
-}
-async function sharedLog(limit = 20) {
-  const dir = sharedDir();
-  return gitExec(["log", "--oneline", "-n", String(limit), "main"], { cwd: dir });
-}
-async function sharedStatus(mindName) {
-  const dir = sharedDir();
-  return gitExec(["diff", `main...${mindName}`, "--stat"], { cwd: dir });
-}
 
 export {
   sharedDir,
   ensureSharedRepo,
   addSharedWorktree,
   removeSharedWorktree,
-  sharedMerge,
-  sharedPull,
-  sharedLog,
-  sharedStatus
+  sharedMerge
 };

package/dist/chunk-THUUIU3E.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+import {
+  publish
+} from "./chunk-VIVMW2H2.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  mindDir,
+  readRegistry,
+  voluteHome
+} from "./chunk-H7OZRFJB.js";
+
+// src/lib/pages-watcher.ts
+import { existsSync, readdirSync, statSync, watch } from "fs";
+import { join, resolve } from "path";
+var watchers = /* @__PURE__ */ new Map();
+var homeWatchers = /* @__PURE__ */ new Map();
+var debounceTimers = /* @__PURE__ */ new Map();
+var sitesCache = null;
+var recentPagesCache = null;
+function startPagesWatcher(mindName, pagesDir) {
+  try {
+    const watcher = watch(pagesDir, { recursive: true }, (_eventType, filename) => {
+      if (!filename || !filename.endsWith(".html")) return;
+      const key = `${mindName}:${filename}`;
+      const existing = debounceTimers.get(key);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(
+        key,
+        setTimeout(() => {
+          debounceTimers.delete(key);
+          invalidateCache();
+          publish({
+            type: "page_updated",
+            mind: mindName,
+            summary: `${mindName} updated ${filename}`,
+            metadata: { file: filename }
+          }).catch(
+            (err) => logger_default.error("failed to publish page_updated activity", logger_default.errorData(err))
+          );
+        }, 100)
+      );
+    });
+    watchers.set(mindName, watcher);
+  } catch (err) {
+    logger_default.warn(`failed to start pages watcher for ${mindName}`, logger_default.errorData(err));
+  }
+}
+function startSystemWatcher() {
+  if (watchers.has("_system")) return;
+  const systemPagesDir = resolve(voluteHome(), "shared", "pages");
+  if (!existsSync(systemPagesDir)) return;
+  startPagesWatcher("_system", systemPagesDir);
+}
+function startWatcher(mindName) {
+  if (watchers.has(mindName)) return;
+  const pagesDir = resolve(mindDir(mindName), "home", "public", "pages");
+  if (existsSync(pagesDir)) {
+    startPagesWatcher(mindName, pagesDir);
+    return;
+  }
+  if (homeWatchers.has(mindName)) return;
+  const publicDir = resolve(mindDir(mindName), "home", "public");
+  if (!existsSync(publicDir)) return;
+  try {
+    const hw = watch(publicDir, (_eventType, filename) => {
+      if (filename !== "pages") return;
+      if (!existsSync(pagesDir)) return;
+      hw.close();
+      homeWatchers.delete(mindName);
+      invalidateCache();
+      startPagesWatcher(mindName, pagesDir);
+    });
+    homeWatchers.set(mindName, hw);
+  } catch (err) {
+    logger_default.warn(`failed to start home watcher for ${mindName}`, logger_default.errorData(err));
+  }
+}
+function stopWatcher(mindName) {
+  const watcher = watchers.get(mindName);
+  if (watcher) {
+    watcher.close();
+    watchers.delete(mindName);
+  }
+  const hw = homeWatchers.get(mindName);
+  if (hw) {
+    hw.close();
+    homeWatchers.delete(mindName);
+  }
+  for (const [key, timer] of debounceTimers) {
+    if (key.startsWith(`${mindName}:`)) {
+      clearTimeout(timer);
+      debounceTimers.delete(key);
+    }
+  }
+}
+function stopAllWatchers() {
+  for (const [, watcher] of watchers) {
+    watcher.close();
+  }
+  watchers.clear();
+  for (const [, hw] of homeWatchers) {
+    hw.close();
+  }
+  homeWatchers.clear();
+  for (const [, timer] of debounceTimers) {
+    clearTimeout(timer);
+  }
+  debounceTimers.clear();
+  invalidateCache();
+}
+function invalidateCache() {
+  sitesCache = null;
+  recentPagesCache = null;
+}
+function scanPagesDir(dir, urlPrefix) {
+  const pages = [];
+  let items;
+  try {
+    items = readdirSync(dir);
+  } catch {
+    return pages;
+  }
+  for (const item of items) {
+    if (item.startsWith(".")) continue;
+    const fullPath = resolve(dir, item);
+    try {
+      const s = statSync(fullPath);
+      if (s.isFile() && item.endsWith(".html")) {
+        pages.push({
+          file: item,
+          modified: s.mtime.toISOString(),
+          url: `${urlPrefix}/${item}`
+        });
+      } else if (s.isDirectory()) {
+        const indexPath = resolve(fullPath, "index.html");
+        if (existsSync(indexPath)) {
+          const indexStat = statSync(indexPath);
+          pages.push({
+            file: join(item, "index.html"),
+            modified: indexStat.mtime.toISOString(),
+            url: `${urlPrefix}/${item}/`
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+  return pages;
+}
+async function buildSites() {
+  const sites = [];
+  const systemPagesDir = resolve(voluteHome(), "shared", "pages");
+  if (existsSync(systemPagesDir)) {
+    const systemPages = scanPagesDir(systemPagesDir, "/pages/_system");
+    if (systemPages.length > 0) {
+      sites.push({ name: "_system", label: "System", pages: systemPages });
+    }
+  }
+  const entries = await readRegistry();
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    const pagesDir = resolve(mindDir(entry.name), "home", "public", "pages");
+    if (!existsSync(pagesDir)) continue;
+    const mindPages = scanPagesDir(pagesDir, `/pages/${entry.name}`);
+    if (mindPages.length > 0) {
+      sites.push({ name: entry.name, label: entry.name, pages: mindPages });
+    }
+  }
+  return sites;
+}
+async function buildRecentPages() {
+  const entries = await readRegistry();
+  const pages = [];
+  for (const entry of entries) {
+    const pagesDir = resolve(mindDir(entry.name), "home", "public", "pages");
+    if (!existsSync(pagesDir)) continue;
+    let items;
+    try {
+      items = readdirSync(pagesDir);
+    } catch {
+      continue;
+    }
+    for (const item of items) {
+      if (item.startsWith(".")) continue;
+      const fullPath = resolve(pagesDir, item);
+      try {
+        const s = statSync(fullPath);
+        if (s.isFile() && item.endsWith(".html")) {
+          pages.push({
+            mind: entry.name,
+            file: item,
+            modified: s.mtime.toISOString(),
+            url: `/pages/${entry.name}/${item}`
+          });
+        } else if (s.isDirectory()) {
+          const indexPath = resolve(fullPath, "index.html");
+          if (existsSync(indexPath)) {
+            const indexStat = statSync(indexPath);
+            pages.push({
+              mind: entry.name,
+              file: join(item, "index.html"),
+              modified: indexStat.mtime.toISOString(),
+              url: `/pages/${entry.name}/${item}/`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+  return pages.slice(0, 10);
+}
+async function getCachedSites() {
+  if (!sitesCache) sitesCache = await buildSites();
+  return sitesCache;
+}
+async function getCachedRecentPages() {
+  if (!recentPagesCache) recentPagesCache = await buildRecentPages();
+  return recentPagesCache;
+}
+
+export {
+  startSystemWatcher,
+  startWatcher,
+  stopWatcher,
+  stopAllWatchers,
+  getCachedSites,
+  getCachedRecentPages
+};