volute 0.33.0 → 0.35.0

package/dist/chunk-A2A4KLFE.js

@@ -1,1528 +0,0 @@
-#!/usr/bin/env node
-import {
-  getAllSites,
-  getPublishedPages,
-  getRecentPages,
-  initDb,
-  syncPublishedPages
-} from "./chunk-PB65JZK2.js";
-import {
-  getUser,
-  getUserByUsername
-} from "./chunk-JYVGHWEJ.js";
-import {
-  publish
-} from "./chunk-KVK2DLWI.js";
-import {
-  hashSkillDir,
-  importSkillFromDir,
-  sharedSkillsDir
-} from "./chunk-C7I35G4R.js";
-import {
-  logger_default
-} from "./chunk-YUIHSKR6.js";
-import {
-  mindDir,
-  voluteHome,
-  voluteSystemDir
-} from "./chunk-LRCG2JLP.js";
-
-// src/lib/extensions.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { dirname, resolve as resolve6 } from "path";
-
-// packages/extensions/notes/src/index.ts
-import { resolve } from "path";
-
-// packages/extensions/sdk/src/index.ts
-var VALID_EXTENSION_ID = /^[a-z0-9][a-z0-9_-]*$/;
-function createExtension(manifest) {
-  if (!manifest.id) throw new Error("Extension manifest requires an id");
-  if (!VALID_EXTENSION_ID.test(manifest.id))
-    throw new Error(
-      "Extension id must be lowercase alphanumeric with hyphens/underscores, starting with a letter or digit"
-    );
-  if (typeof manifest.routes !== "function")
-    throw new Error("Extension manifest requires a routes function");
-  return manifest;
-}
-
-// packages/extensions/notes/src/notes.ts
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-async function createNote(db, getUser2, authorId, title, content, replyToId) {
-  let slug = slugify(title) || "untitled";
-  const existing = db.prepare("SELECT slug FROM notes WHERE author_id = ?").all(authorId);
-  const existingSlugs = new Set(existing.map((r) => r.slug));
-  if (existingSlugs.has(slug)) {
-    let i = 2;
-    while (existingSlugs.has(`${slug}-${i}`)) i++;
-    slug = `${slug}-${i}`;
-  }
-  const row = db.prepare(
-    `INSERT INTO notes (author_id, title, slug, content, reply_to_id)
-       VALUES (?, ?, ?, ?, ?)
-       RETURNING *`
-  ).get(authorId, title, slug, content, replyToId ?? null);
-  const author = await getUser2(authorId);
-  return {
-    ...row,
-    author_username: author?.username ?? "unknown",
-    author_display_name: author?.display_name ?? null,
-    comment_count: 0
-  };
-}
-async function getNote(db, getUser2, getUserByUsername2, authorUsername, slug) {
-  const author = await getUserByUsername2(authorUsername);
-  if (!author) return null;
-  const row = db.prepare("SELECT * FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
-  if (!row) return null;
-  const comments = await getComments(db, getUser2, row.id);
-  const reactions = await getReactions(db, getUser2, row.id);
-  let reply_to = null;
-  if (row.reply_to_id) {
-    const parent = db.prepare("SELECT * FROM notes WHERE id = ?").get(row.reply_to_id);
-    if (parent) {
-      const parentAuthor = await getUser2(parent.author_id);
-      reply_to = {
-        author_username: parentAuthor?.username ?? "unknown",
-        slug: parent.slug,
-        title: parent.title
-      };
-    }
-  }
-  const replyRows = db.prepare("SELECT * FROM notes WHERE reply_to_id = ? ORDER BY created_at").all(row.id);
-  const replies = [];
-  for (const r of replyRows) {
-    const replyAuthor = await getUser2(r.author_id);
-    replies.push({
-      author_username: replyAuthor?.username ?? "unknown",
-      slug: r.slug,
-      title: r.title,
-      created_at: r.created_at
-    });
-  }
-  return {
-    ...row,
-    author_username: authorUsername,
-    author_display_name: author.display_name ?? null,
-    comment_count: comments.length,
-    comments,
-    reactions,
-    reply_to,
-    replies
-  };
-}
-async function listNotes(db, getUser2, getUserByUsername2, opts) {
-  const limit = opts?.limit ?? 50;
-  const offset = opts?.offset ?? 0;
-  let authorId;
-  if (opts?.authorUsername) {
-    const author = await getUserByUsername2(opts.authorUsername);
-    if (!author) return [];
-    authorId = author.id;
-  }
-  const rows = authorId ? db.prepare(
-    "SELECT * FROM notes WHERE author_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?"
-  ).all(authorId, limit, offset) : db.prepare("SELECT * FROM notes ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
-  if (rows.length === 0) return [];
-  const noteIds = rows.map((r) => r.id);
-  const commentCounts = db.prepare(
-    `SELECT note_id, COUNT(*) as count FROM note_comments
-       WHERE note_id IN (${noteIds.map(() => "?").join(",")})
-       GROUP BY note_id`
-  ).all(...noteIds);
-  const countMap = new Map(commentCounts.map((r) => [r.note_id, r.count]));
-  const allReactions = db.prepare(
-    `SELECT note_id, emoji, COUNT(*) as count FROM note_reactions
-       WHERE note_id IN (${noteIds.map(() => "?").join(",")})
-       GROUP BY note_id, emoji`
-  ).all(...noteIds);
-  const reactionMap = /* @__PURE__ */ new Map();
-  for (const r of allReactions) {
-    if (!reactionMap.has(r.note_id)) reactionMap.set(r.note_id, []);
-    reactionMap.get(r.note_id).push({ emoji: r.emoji, count: r.count });
-  }
-  const replyToIds = [
-    ...new Set(rows.filter((r) => r.reply_to_id).map((r) => r.reply_to_id))
-  ];
-  const replyToMap = /* @__PURE__ */ new Map();
-  if (replyToIds.length > 0) {
-    const parents = db.prepare(`SELECT * FROM notes WHERE id IN (${replyToIds.map(() => "?").join(",")})`).all(...replyToIds);
-    for (const parent of parents) {
-      const parentAuthor = await getUser2(parent.author_id);
-      replyToMap.set(parent.id, {
-        author_username: parentAuthor?.username ?? "unknown",
-        slug: parent.slug,
-        title: parent.title
-      });
-    }
-  }
-  const authorCache = /* @__PURE__ */ new Map();
-  const result = [];
-  for (const r of rows) {
-    if (!authorCache.has(r.author_id)) {
-      const u = await getUser2(r.author_id);
-      authorCache.set(r.author_id, {
-        username: u?.username ?? "unknown",
-        display_name: u?.display_name ?? null
-      });
-    }
-    const authorInfo = authorCache.get(r.author_id);
-    const reactions = reactionMap.get(r.id);
-    const topReactions = reactions ? reactions.sort((a, b) => b.count - a.count).slice(0, 3).map((rx) => ({ ...rx, usernames: [] })) : void 0;
-    result.push({
-      ...r,
-      author_username: authorInfo.username,
-      author_display_name: authorInfo.display_name,
-      comment_count: countMap.get(r.id) ?? 0,
-      reactions: topReactions,
-      reply_to: r.reply_to_id ? replyToMap.get(r.reply_to_id) ?? null : null
-    });
-  }
-  return result;
-}
-async function updateNote(db, getUser2, getUserByUsername2, authorUsername, slug, updates) {
-  const author = await getUserByUsername2(authorUsername);
-  if (!author) return null;
-  const existing = db.prepare("SELECT id FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
-  if (!existing) return null;
-  const sets = ["updated_at = datetime('now')"];
-  const params = [];
-  if (updates.title !== void 0) {
-    sets.push("title = ?");
-    params.push(updates.title);
-  }
-  if (updates.content !== void 0) {
-    sets.push("content = ?");
-    params.push(updates.content);
-  }
-  params.push(existing.id);
-  db.prepare(`UPDATE notes SET ${sets.join(", ")} WHERE id = ?`).run(...params);
-  const full = await getNote(db, getUser2, getUserByUsername2, authorUsername, slug);
-  if (!full) return null;
-  const { comments, replies, ...note } = full;
-  return note;
-}
-async function deleteNote(db, getUserByUsername2, authorUsername, slug, authorId) {
-  const author = await getUserByUsername2(authorUsername);
-  if (!author) return false;
-  const existing = db.prepare("SELECT id, author_id FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
-  if (!existing || existing.author_id !== authorId) return false;
-  db.prepare("DELETE FROM notes WHERE id = ?").run(existing.id);
-  return true;
-}
-async function addComment(db, getUser2, noteId, authorId, content) {
-  const row = db.prepare(`INSERT INTO note_comments (note_id, author_id, content) VALUES (?, ?, ?) RETURNING *`).get(noteId, authorId, content);
-  const author = await getUser2(authorId);
-  return {
-    ...row,
-    author_username: author?.username ?? "unknown",
-    author_display_name: author?.display_name ?? null
-  };
-}
-async function getComments(db, getUser2, noteId) {
-  const rows = db.prepare("SELECT * FROM note_comments WHERE note_id = ? ORDER BY created_at").all(noteId);
-  const result = [];
-  for (const row of rows) {
-    const author = await getUser2(row.author_id);
-    result.push({
-      ...row,
-      author_username: author?.username ?? "unknown",
-      author_display_name: author?.display_name ?? null
-    });
-  }
-  return result;
-}
-async function deleteComment(db, commentId, authorId) {
-  const existing = db.prepare("SELECT id, author_id FROM note_comments WHERE id = ?").get(commentId);
-  if (!existing || existing.author_id !== authorId) return false;
-  db.prepare("DELETE FROM note_comments WHERE id = ?").run(existing.id);
-  return true;
-}
-function toggleReaction(db, noteId, userId, emoji) {
-  const existing = db.prepare("SELECT id FROM note_reactions WHERE note_id = ? AND user_id = ? AND emoji = ?").get(noteId, userId, emoji);
-  if (existing) {
-    db.prepare("DELETE FROM note_reactions WHERE id = ?").run(existing.id);
-    return { added: false };
-  }
-  db.prepare("INSERT INTO note_reactions (note_id, user_id, emoji) VALUES (?, ?, ?)").run(
-    noteId,
-    userId,
-    emoji
-  );
-  return { added: true };
-}
-async function getReactions(db, getUser2, noteId) {
-  const rows = db.prepare("SELECT * FROM note_reactions WHERE note_id = ? ORDER BY emoji").all(noteId);
-  const userCache = /* @__PURE__ */ new Map();
-  const grouped = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    if (!grouped.has(r.emoji)) grouped.set(r.emoji, []);
-    grouped.get(r.emoji).push(r.user_id);
-  }
-  const result = [];
-  for (const [emoji, userIds] of grouped) {
-    const usernames = [];
-    for (const uid of userIds) {
-      if (!userCache.has(uid)) {
-        const u = await getUser2(uid);
-        userCache.set(uid, u?.username ?? "unknown");
-      }
-      usernames.push(userCache.get(uid));
-    }
-    result.push({ emoji, count: userIds.length, usernames });
-  }
-  return result;
-}
-async function resolveNoteId(db, getUserByUsername2, authorSlug) {
-  const [authorName, slug] = authorSlug.split("/", 2);
-  if (!authorName || !slug) return null;
-  const author = await getUserByUsername2(authorName);
-  if (!author) return null;
-  const row = db.prepare("SELECT id FROM notes WHERE author_id = ? AND slug = ?").get(author.id, slug);
-  return row?.id ?? null;
-}
-
-// packages/extensions/notes/src/commands.ts
-function getFlag(args, flag) {
-  const idx = args.indexOf(flag);
-  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
-  return void 0;
-}
-function createCommands() {
-  return {
-    write: {
-      description: "Write a new note",
-      usage: 'volute notes write "title" ["content"] [--reply-to author/slug]  (content can be piped via stdin)',
-      handler: async (args, ctx) => {
-        if (!ctx.db) return { error: "Notes extension requires a database" };
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const user = await ctx.getUserByUsername(mindName);
-        if (!user) return { error: `Unknown mind: ${mindName}` };
-        const title = args[0];
-        const content = args[1] ?? ctx.stdin;
-        if (!title || !content)
-          return { error: 'Usage: volute notes write "title" "content" [--reply-to author/slug]' };
-        let replyToId;
-        const replyTo = getFlag(args, "--reply-to");
-        if (replyTo) {
-          const id = await resolveNoteId(ctx.db, ctx.getUserByUsername, replyTo);
-          if (id === null) return { error: `Reply target not found: ${replyTo}` };
-          replyToId = id;
-        }
-        const note = await createNote(ctx.db, ctx.getUser, user.id, title, content, replyToId);
-        ctx.publishActivity({
-          type: "note_created",
-          mind: user.username,
-          summary: `${user.username} wrote "${title}"`,
-          metadata: { author: user.username, slug: note.slug, bodyHtml: content.slice(0, 500) }
-        });
-        return { output: `Published: ${note.author_username}/${note.slug}` };
-      }
-    },
-    list: {
-      description: "List notes",
-      usage: "volute notes list [--author name] [--limit N]",
-      handler: async (args, ctx) => {
-        if (!ctx.db) return { error: "Notes extension requires a database" };
-        const author = getFlag(args, "--author");
-        const limit = parseInt(getFlag(args, "--limit") ?? "10", 10);
-        const notes = await listNotes(ctx.db, ctx.getUser, ctx.getUserByUsername, {
-          authorUsername: author,
-          limit
-        });
-        if (notes.length === 0) return { output: "No notes found." };
-        const lines = notes.map((n) => {
-          const date = new Date(n.created_at).toLocaleDateString();
-          return `  ${n.author_username}/${n.slug}  "${n.title}"  (${date})`;
-        });
-        return { output: lines.join("\n") };
-      }
-    },
-    read: {
-      description: "Read a note",
-      usage: "volute notes read <author/slug>",
-      handler: async (args, ctx) => {
-        if (!ctx.db) return { error: "Notes extension requires a database" };
-        const ref = args[0];
-        if (!ref || !ref.includes("/")) return { error: "Usage: volute notes read <author/slug>" };
-        const [author, slug] = ref.split("/", 2);
-        const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
-        if (!note) return { error: "Note not found" };
-        const lines = [
-          `# ${note.title}
-`,
-          `By ${note.author_username} \u2014 ${new Date(note.created_at).toLocaleString()}
-`,
-          note.content
-        ];
-        if (note.reactions?.length) {
-          lines.push(
-            `
-Reactions: ${note.reactions.map((r) => `${r.emoji} (${r.count})`).join("  ")}`
-          );
-        }
-        if (note.comments?.length) {
-          lines.push(`
-Comments (${note.comments.length}):`);
-          for (const c of note.comments) {
-            lines.push(`  ${c.author_username}: ${c.content}`);
-          }
-        }
-        return { output: lines.join("\n") };
-      }
-    },
-    comment: {
-      description: "Comment on a note",
-      usage: 'volute notes comment <author/slug> ["content"]  (content can be piped via stdin)',
-      handler: async (args, ctx) => {
-        if (!ctx.db) return { error: "Notes extension requires a database" };
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const user = await ctx.getUserByUsername(mindName);
-        if (!user) return { error: `Unknown mind: ${mindName}` };
-        const ref = args[0];
-        const content = args[1] ?? ctx.stdin;
-        if (!ref || !ref.includes("/") || !content) {
-          return { error: 'Usage: volute notes comment <author/slug> "content"' };
-        }
-        const [author, slug] = ref.split("/", 2);
-        const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
-        if (!note) return { error: "Note not found" };
-        await addComment(ctx.db, ctx.getUser, note.id, user.id, content);
-        return { output: "Comment added." };
-      }
-    },
-    react: {
-      description: "React to a note",
-      usage: 'volute notes react <author/slug> "emoji"',
-      handler: async (args, ctx) => {
-        if (!ctx.db) return { error: "Notes extension requires a database" };
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const user = await ctx.getUserByUsername(mindName);
-        if (!user) return { error: `Unknown mind: ${mindName}` };
-        const ref = args[0];
-        const emoji = args[1];
-        if (!ref || !ref.includes("/") || !emoji) {
-          return { error: 'Usage: volute notes react <author/slug> "emoji"' };
-        }
-        const [author, slug] = ref.split("/", 2);
-        const note = await getNote(ctx.db, ctx.getUser, ctx.getUserByUsername, author, slug);
-        if (!note) return { error: "Note not found" };
-        const result = toggleReaction(ctx.db, note.id, user.id, emoji);
-        return { output: result.added ? "Reaction added." : "Reaction removed." };
-      }
-    },
-    delete: {
-      description: "Delete your own note",
-      usage: "volute notes delete <author/slug>",
-      handler: async (args, ctx) => {
-        if (!ctx.db) return { error: "Notes extension requires a database" };
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const user = await ctx.getUserByUsername(mindName);
-        if (!user) return { error: `Unknown mind: ${mindName}` };
-        const ref = args[0];
-        if (!ref || !ref.includes("/"))
-          return { error: "Usage: volute notes delete <author/slug>" };
-        const [author, slug] = ref.split("/", 2);
-        const deleted = await deleteNote(ctx.db, ctx.getUserByUsername, author, slug, user.id);
-        if (!deleted) return { error: "Note not found or not authorized" };
-        return { output: "Note deleted." };
-      }
-    }
-  };
-}
-
-// packages/extensions/notes/src/db.ts
-function initDb2(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS notes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      author_id INTEGER NOT NULL,
-      title TEXT NOT NULL,
-      slug TEXT NOT NULL,
-      content TEXT NOT NULL,
-      reply_to_id INTEGER,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_notes_author_slug ON notes(author_id, slug);
-    CREATE INDEX IF NOT EXISTS idx_notes_created_at ON notes(created_at);
-    CREATE INDEX IF NOT EXISTS idx_notes_reply_to ON notes(reply_to_id);
-
-    CREATE TABLE IF NOT EXISTS note_comments (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
-      author_id INTEGER NOT NULL,
-      content TEXT NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_note_comments_note_id ON note_comments(note_id);
-
-    CREATE TABLE IF NOT EXISTS note_reactions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
-      user_id INTEGER NOT NULL,
-      emoji TEXT NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_note_reactions_unique ON note_reactions(note_id, user_id, emoji);
-    CREATE INDEX IF NOT EXISTS idx_note_reactions_note_id ON note_reactions(note_id);
-  `);
-}
-
-// packages/extensions/notes/src/routes.ts
-import { Hono } from "hono";
-async function parseJson(c) {
-  try {
-    return await c.req.json();
-  } catch {
-    return null;
-  }
-}
-function resolveUserId(c) {
-  const user = c.get("user");
-  if (!user || user.id === 0) return null;
-  return { id: user.id, username: user.username };
-}
-function createRoutes(ctx) {
-  if (!ctx.db) throw new Error("Notes extension requires a database");
-  const db = ctx.db;
-  const { getUser: getUser2, getUserByUsername: getUserByUsername2 } = ctx;
-  const app = new Hono().get("/", async (c) => {
-    const author = c.req.query("author");
-    const rawLimit = c.req.query("limit");
-    const rawOffset = c.req.query("offset");
-    const limit = rawLimit ? parseInt(rawLimit, 10) : void 0;
-    const offset = rawOffset ? parseInt(rawOffset, 10) : void 0;
-    if (limit !== void 0 && Number.isNaN(limit) || offset !== void 0 && Number.isNaN(offset)) {
-      return c.json({ error: "Invalid limit or offset parameter" }, 400);
-    }
-    const result = await listNotes(db, getUser2, getUserByUsername2, {
-      authorUsername: author,
-      limit,
-      offset
-    });
-    return c.json(result);
-  }).post("/", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    const body = await parseJson(c);
-    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
-    if (!body.title || !body.content) {
-      return c.json({ error: "title and content are required" }, 400);
-    }
-    let replyToId;
-    if (body.reply_to) {
-      const id = await resolveNoteId(db, getUserByUsername2, body.reply_to);
-      if (id === null) return c.json({ error: `Reply target not found: ${body.reply_to}` }, 404);
-      replyToId = id;
-    }
-    const note = await createNote(db, getUser2, actor.id, body.title, body.content, replyToId);
-    ctx.publishActivity({
-      type: "note_created",
-      mind: actor.username,
-      summary: `${actor.username} wrote "${body.title}"`,
-      metadata: {
-        author: actor.username,
-        slug: note.slug,
-        bodyHtml: body.content.slice(0, 500)
-      }
-    });
-    return c.json(note, 201);
-  }).get("/:author/:slug", async (c) => {
-    const { author, slug } = c.req.param();
-    const note = await getNote(db, getUser2, getUserByUsername2, author, slug);
-    if (!note) return c.json({ error: "Note not found" }, 404);
-    return c.json(note);
-  }).put("/:author/:slug", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    const { author, slug } = c.req.param();
-    if (actor.username !== author) return c.json({ error: "Forbidden" }, 403);
-    const body = await parseJson(c);
-    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
-    const note = await updateNote(db, getUser2, getUserByUsername2, author, slug, body);
-    if (!note) return c.json({ error: "Note not found" }, 404);
-    return c.json(note);
-  }).delete("/:author/:slug", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    const { author, slug } = c.req.param();
-    const deleted = await deleteNote(db, getUserByUsername2, author, slug, actor.id);
-    if (!deleted) return c.json({ error: "Note not found or not authorized" }, 404);
-    return c.json({ ok: true });
-  }).post("/:author/:slug/reactions", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    const { author, slug } = c.req.param();
-    const note = await getNote(db, getUser2, getUserByUsername2, author, slug);
-    if (!note) return c.json({ error: "Note not found" }, 404);
-    const body = await parseJson(c);
-    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
-    if (!body.emoji) return c.json({ error: "emoji is required" }, 400);
-    const result = toggleReaction(db, note.id, actor.id, body.emoji);
-    const reactions = await getReactions(db, getUser2, note.id);
-    return c.json({ ...result, reactions });
-  }).post("/:author/:slug/comments", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    const { author, slug } = c.req.param();
-    const note = await getNote(db, getUser2, getUserByUsername2, author, slug);
-    if (!note) return c.json({ error: "Note not found" }, 404);
-    const body = await parseJson(c);
-    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
-    if (!body.content) return c.json({ error: "content is required" }, 400);
-    const comment = await addComment(db, getUser2, note.id, actor.id, body.content);
-    return c.json(comment, 201);
-  }).delete("/:author/:slug/comments/:id", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    const commentId = parseInt(c.req.param("id"), 10);
-    if (Number.isNaN(commentId)) return c.json({ error: "Invalid comment ID" }, 400);
-    const deleted = await deleteComment(db, commentId, actor.id);
-    if (!deleted) return c.json({ error: "Comment not found or not authorized" }, 404);
-    return c.json({ ok: true });
-  }).get("/feed", async (c) => {
-    const rawFeedLimit = c.req.query("limit");
-    const limit = rawFeedLimit ? parseInt(rawFeedLimit, 10) : 8;
-    if (Number.isNaN(limit)) return c.json({ error: "Invalid limit parameter" }, 400);
-    const mind = c.req.query("mind");
-    const notes = await listNotes(db, getUser2, getUserByUsername2, {
-      limit,
-      ...mind ? { authorUsername: mind } : {}
-    });
-    return c.json(
-      notes.map((n) => ({
-        id: `note-${n.author_username}-${n.slug}`,
-        title: n.title,
-        url: `/minds/${n.author_username}/notes/${n.slug}`,
-        date: n.created_at,
-        author: n.author_username,
-        bodyHtml: n.content,
-        icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M4 2h6l4 4v8H4V2z"/><path d="M10 2v4h4"/><path d="M6 9h6M6 12h4"/></svg>',
-        color: "yellow"
-      }))
-    );
-  });
-  return app;
-}
-
-// packages/extensions/notes/src/index.ts
-var assetsDir = resolve(import.meta.dirname, "../dist/ui");
-var skillsDir = resolve(import.meta.dirname, "../skills");
-var src_default = createExtension({
-  id: "notes",
-  name: "Notes",
-  version: "0.1.0",
-  description: "Public notes for sharing thoughts, reflections, and ideas",
-  icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M3 4h10M3 7h8M3 10h6M3 13h9"/></svg>',
-  color: "yellow",
-  routes: (ctx) => createRoutes(ctx),
-  commands: createCommands(),
-  initDb: initDb2,
-  skillsDir,
-  standardSkill: true,
-  ui: {
-    assetsDir,
-    systemSection: { id: "notes", label: "Notes", urlPatterns: ["/notes", "/notes/:author/:slug"] },
-    mindSections: [{ id: "notes", label: "Notes" }],
-    feedSource: {
-      endpoint: "/api/ext/notes/feed"
-    }
-  }
-});
-
-// packages/extensions/pages/src/index.ts
-import { resolve as resolve4 } from "path";
-
-// packages/extensions/pages/src/commands.ts
-import { cpSync, existsSync, readdirSync, readFileSync, rmSync, statSync } from "fs";
-import { relative, resolve as resolve2 } from "path";
-function createCommands2() {
-  return {
-    publish: {
-      description: "Publish all pages (copy to public snapshot)",
-      usage: "volute pages publish [--remote]",
-      handler: async (args, ctx) => {
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const remote = args.includes("--remote");
-        const mindDir2 = ctx.getMindDir(mindName);
-        if (!mindDir2) return { error: `Mind not found: ${mindName}` };
-        const sourceDir = resolve2(mindDir2, "home", "public", "pages");
-        if (!existsSync(sourceDir))
-          return { error: "No pages directory found (home/public/pages/)" };
-        const db = ctx.db;
-        if (!db) return { error: "Database not available" };
-        const snapshotDir = resolve2(ctx.dataDir, "sites", mindName);
-        try {
-          if (existsSync(snapshotDir)) rmSync(snapshotDir, { recursive: true });
-          cpSync(sourceDir, snapshotDir, { recursive: true });
-        } catch (err) {
-          return { error: `Failed to publish snapshot: ${err.message}` };
-        }
-        const htmlFiles = collectHtmlFiles(snapshotDir, snapshotDir);
-        let diff;
-        try {
-          diff = syncPublishedPages(db, mindName, htmlFiles);
-        } catch (err) {
-          return { error: `Failed to update page database: ${err.message}` };
-        }
-        for (const file of diff.added) {
-          ctx.publishActivity({
-            type: "page_published",
-            mind: mindName,
-            summary: `${mindName} published ${file}`,
-            metadata: { file, iframeUrl: `/ext/pages/public/${mindName}/${file}` }
-          });
-        }
-        for (const file of diff.removed) {
-          ctx.publishActivity({
-            type: "page_removed",
-            mind: mindName,
-            summary: `${mindName} removed ${file}`,
-            metadata: { file }
-          });
-        }
-        let output = `Published ${htmlFiles.length} files`;
-        const parts = [];
-        if (diff.added.length > 0) parts.push(`${diff.added.length} new`);
-        if (diff.updated.length > 0) parts.push(`${diff.updated.length} updated`);
-        if (diff.removed.length > 0) parts.push(`${diff.removed.length} removed`);
-        if (parts.length > 0) output += ` (${parts.join(", ")})`;
-        if (remote) {
-          const config = ctx.getSystemsConfig();
-          if (!config)
-            return {
-              error: "Not connected to volute.systems. Run volute systems register or login first."
-            };
-          const allFiles = collectAllFiles(snapshotDir, snapshotDir);
-          const files = {};
-          for (const f of allFiles) {
-            const fp = resolve2(snapshotDir, f);
-            files[f] = readFileSync(fp).toString("base64");
-          }
-          try {
-            const res = await fetch(`${config.apiUrl}/api/pages/publish/${mindName}`, {
-              method: "PUT",
-              headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${config.apiKey}`
-              },
-              body: JSON.stringify({ files })
-            });
-            const data = await res.json().catch(() => ({}));
-            if (!res.ok) {
-              const errMsg = data.error || `HTTP ${res.status}`;
-              output += `
-Warning: remote publish failed: ${errMsg}`;
-            } else if (data.url) {
-              output += `
-Remote: ${data.url}`;
-            }
-          } catch (err) {
-            output += `
-Warning: remote publish failed: ${err.message}`;
-          }
-        }
-        return { output };
-      }
-    },
-    list: {
-      description: "List pages with publish status",
-      usage: "volute pages list [--all]",
-      handler: async (args, ctx) => {
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const db = ctx.db;
-        if (!db) return { error: "Database not available" };
-        const allFlag = args.includes("--all");
-        const port = process.env.VOLUTE_DAEMON_PORT || "1618";
-        if (allFlag) {
-          const { getAllSites: getAllSites2 } = await import("./db-RA45JBFG.js");
-          const sites = getAllSites2(db);
-          const lines2 = [];
-          for (const site of sites) {
-            for (const f of site.files) {
-              const url = `http://localhost:${port}/ext/pages/public/${site.mind}/${f.file}`;
-              lines2.push(`${site.mind.padEnd(15)} ${f.file.padEnd(25)} ${url}`);
-            }
-          }
-          return { output: lines2.length > 0 ? lines2.join("\n") : "No published pages found." };
-        }
-        const mindDir2 = ctx.getMindDir(mindName);
-        if (!mindDir2) return { error: `Mind not found: ${mindName}` };
-        const sourceDir = resolve2(mindDir2, "home", "public", "pages");
-        const published = new Set(getPublishedPages(db, mindName).map((p) => p.file));
-        const draftFiles = existsSync(sourceDir) ? collectHtmlFiles(sourceDir, sourceDir) : [];
-        const allFiles = /* @__PURE__ */ new Set([...published, ...draftFiles]);
-        if (allFiles.size === 0) return { output: "No pages found." };
-        const lines = [...allFiles].sort().map((file) => {
-          const isPublished = published.has(file);
-          const status = isPublished ? "published" : "draft";
-          const url = isPublished ? `http://localhost:${port}/ext/pages/public/${mindName}/${file}` : "";
-          return `${status.padEnd(11)} ${file.padEnd(25)} ${url}`;
-        });
-        return { output: lines.join("\n") };
-      }
-    }
-  };
-}
-function collectHtmlFiles(dir, baseDir) {
-  const files = [];
-  let items;
-  try {
-    items = readdirSync(dir);
-  } catch (err) {
-    console.error(`[pages] failed to read directory ${dir}: ${err.message}`);
-    return files;
-  }
-  for (const item of items) {
-    if (item.startsWith(".")) continue;
-    const fullPath = resolve2(dir, item);
-    try {
-      const s = statSync(fullPath);
-      if (s.isFile() && item.endsWith(".html")) {
-        files.push(relative(baseDir, fullPath));
-      } else if (s.isDirectory()) {
-        files.push(...collectHtmlFiles(fullPath, baseDir));
-      }
-    } catch (err) {
-      console.error(`[pages] failed to stat ${fullPath}: ${err.message}`);
-    }
-  }
-  return files.sort();
-}
-function collectAllFiles(dir, baseDir) {
-  const files = [];
-  let items;
-  try {
-    items = readdirSync(dir);
-  } catch (err) {
-    console.error(`[pages] failed to read directory ${dir}: ${err.message}`);
-    return files;
-  }
-  for (const item of items) {
-    if (item.startsWith(".")) continue;
-    const fullPath = resolve2(dir, item);
-    try {
-      const s = statSync(fullPath);
-      if (s.isFile()) {
-        files.push(relative(baseDir, fullPath));
-      } else if (s.isDirectory()) {
-        files.push(...collectAllFiles(fullPath, baseDir));
-      }
-    } catch (err) {
-      console.error(`[pages] failed to stat ${fullPath}: ${err.message}`);
-    }
-  }
-  return files.sort();
-}
-
-// packages/extensions/pages/src/routes.ts
-import { readFile, stat } from "fs/promises";
-import { extname, resolve as resolve3 } from "path";
-import { Hono as Hono2 } from "hono";
-
-// packages/extensions/pages/src/cache.ts
-function getSites(db) {
-  const sites = getAllSites(db);
-  return sites.map((site) => ({
-    name: site.mind,
-    label: site.mind,
-    pages: site.files.map((f) => ({
-      file: f.file,
-      modified: f.updated_at,
-      url: `/ext/pages/public/${site.mind}/${f.file}`
-    }))
-  }));
-}
-function getRecentPagesList(db, opts) {
-  const rows = getRecentPages(db, opts);
-  return rows.map((r) => ({
-    mind: r.mind,
-    file: r.file,
-    modified: r.updated_at,
-    url: `/ext/pages/public/${r.mind}/${r.file}`
-  }));
-}
-
-// packages/extensions/pages/src/routes.ts
-var MIME_TYPES = {
-  ".html": "text/html",
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".txt": "text/plain",
-  ".xml": "application/xml"
-};
-function createRoutes2(ctx) {
-  return new Hono2().get("/", async (c) => {
-    if (!ctx.db) return c.json({ error: "Pages database not available" }, 503);
-    const sites = getSites(ctx.db);
-    const recentPages = getRecentPagesList(ctx.db);
-    return c.json({ sites, recentPages });
-  }).get("/feed", async (c) => {
-    if (!ctx.db) return c.json({ error: "Pages database not available" }, 503);
-    const mind = c.req.query("mind");
-    const rawLimit = c.req.query("limit");
-    const limit = rawLimit ? parseInt(rawLimit, 10) || 8 : 8;
-    const recentPages = getRecentPagesList(ctx.db, { mind: mind || void 0, limit });
-    return c.json(
-      recentPages.map((p) => ({
-        id: `page-${p.mind}-${p.file}`,
-        title: `${p.mind}/${p.file}`,
-        url: p.url ?? `/minds/${p.mind}/pages/${p.file}`,
-        date: p.modified,
-        author: p.mind,
-        bodyHtml: `<p>Page updated</p>`,
-        iframeUrl: `/ext/pages/public/${p.mind}/${p.file}`,
-        icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="8" r="6"/><path d="M2 8h12M8 2c-2 2-2 10 0 12M8 2c2 2 2 10 0 12"/></svg>',
-        color: "purple"
-      }))
-    );
-  }).put("/publish/:name", async (c) => {
-    const user = ctx.resolveUser(c);
-    if (!user) return c.json({ error: "Unauthorized" }, 401);
-    const name = c.req.param("name");
-    if (user.role !== "admin" && user.username !== name) {
-      return c.json({ error: "Forbidden" }, 403);
-    }
-    const config = ctx.getSystemsConfig();
-    if (!config) return c.json({ error: "Not connected to volute.systems" }, 400);
-    const body = await c.req.text();
-    try {
-      const res = await fetch(`${config.apiUrl}/api/pages/publish/${name}`, {
-        method: "PUT",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${config.apiKey}`
-        },
-        body
-      });
-      const data = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
-      return c.json(data, res.status);
-    } catch (err) {
-      return c.json({ error: `Connection failed: ${err.message}` }, 502);
-    }
-  }).get("/status/:name", async (c) => {
-    const user = ctx.resolveUser(c);
-    if (!user) return c.json({ error: "Unauthorized" }, 401);
-    const name = c.req.param("name");
-    if (user.role !== "admin" && user.username !== name) {
-      return c.json({ error: "Forbidden" }, 403);
-    }
-    const config = ctx.getSystemsConfig();
-    if (!config) return c.json({ error: "Not connected to volute.systems" }, 400);
-    try {
-      const res = await fetch(`${config.apiUrl}/api/pages/status/${name}`, {
-        headers: { Authorization: `Bearer ${config.apiKey}` }
-      });
-      const data = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
-      return c.json(data, res.status);
-    } catch (err) {
-      return c.json({ error: `Connection failed: ${err.message}` }, 502);
-    }
-  });
-}
-var _voluteHome = null;
-async function getVoluteHome() {
-  if (_voluteHome) return _voluteHome();
-  const mod = await import("./registry-PJ4S5PHQ.js");
-  _voluteHome = mod.voluteHome;
-  return _voluteHome();
-}
-function createPublicRoutes(ctx) {
-  return new Hono2().get("/:name/*", async (c) => {
-    const name = c.req.param("name");
-    if (name.includes("/") || name.includes("\\") || name === "." || name === "..")
-      return c.text("Not found", 404);
-    let pagesRoot;
-    if (name === "_system") {
-      const home = await getVoluteHome();
-      pagesRoot = resolve3(home, "shared", "pages");
-    } else {
-      pagesRoot = resolve3(ctx.dataDir, "sites", name);
-    }
-    const prefix = `/public/${name}`;
-    const idx = c.req.path.indexOf(prefix);
-    const wildcard = idx >= 0 ? c.req.path.slice(idx + prefix.length) : "/";
-    const requestedPath = resolve3(pagesRoot, wildcard.slice(1));
-    if (requestedPath !== pagesRoot && !requestedPath.startsWith(`${pagesRoot}/`))
-      return c.text("Forbidden", 403);
-    let fileToServe = requestedPath;
-    let fileStat = await stat(requestedPath).catch(() => null);
-    if (fileStat?.isDirectory()) {
-      const indexPath = resolve3(requestedPath, "index.html");
-      fileStat = await stat(indexPath).catch(() => null);
-      if (fileStat?.isFile()) {
-        fileToServe = indexPath;
-      } else {
-        return c.text("Not found", 404);
-      }
-    } else if (!fileStat?.isFile()) {
-      return c.text("Not found", 404);
-    }
-    const ext = extname(fileToServe);
-    const mime = MIME_TYPES[ext] || "application/octet-stream";
-    try {
-      const body = await readFile(fileToServe);
-      return c.body(body, 200, { "Content-Type": mime });
-    } catch (err) {
-      const code = err.code;
-      if (code === "EACCES") return c.text("Forbidden", 403);
-      if (code === "ENOENT") return c.text("Not found", 404);
-      return c.text("Internal server error", 500);
-    }
-  });
-}
-
-// packages/extensions/pages/src/index.ts
-var assetsDir2 = resolve4(import.meta.dirname, "../dist/ui");
-var skillsDir2 = resolve4(import.meta.dirname, "../skills");
-var src_default2 = createExtension({
-  id: "pages",
-  name: "Pages",
-  version: "0.1.0",
-  description: "Publish and serve web pages from mind directories",
-  initDb,
-  routes: (ctx) => createRoutes2(ctx),
-  publicRoutes: (ctx) => createPublicRoutes(ctx),
-  commands: createCommands2(),
-  skillsDir: skillsDir2,
-  standardSkill: true,
-  icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="1" y="2" width="14" height="12" rx="1.5"/><path d="M1 5h14"/><circle cx="3" cy="3.5" r="0.5" fill="currentColor" stroke="none"/><circle cx="5" cy="3.5" r="0.5" fill="currentColor" stroke="none"/></svg>',
-  color: "purple",
-  ui: {
-    assetsDir: assetsDir2,
-    systemSection: {
-      id: "pages",
-      label: "Pages",
-      urlPatterns: ["/pages", "/pages/:site", "/pages/:site/:path"]
-    },
-    mindSections: [{ id: "pages", label: "Pages" }],
-    feedSource: {
-      endpoint: "/api/ext/pages/feed"
-    }
-  }
-});
-
-// src/lib/systems-config.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
-import { resolve as resolve5 } from "path";
-var DEFAULT_API_URL = "https://volute.systems";
-function configPath() {
-  return resolve5(voluteSystemDir(), "systems.json");
-}
-function readSystemsConfig() {
-  const path = configPath();
-  if (!existsSync2(path)) return null;
-  const raw = readFileSync2(path, "utf-8");
-  let data;
-  try {
-    data = JSON.parse(raw);
-  } catch {
-    console.error(
-      `Warning: ${path} contains invalid JSON. Run "volute systems logout" and re-login.`
-    );
-    return null;
-  }
-  if (!data.apiKey || !data.system) return null;
-  return {
-    apiKey: data.apiKey,
-    system: data.system,
-    apiUrl: data.apiUrl || DEFAULT_API_URL
-  };
-}
-function writeSystemsConfig(config) {
-  mkdirSync(voluteSystemDir(), { recursive: true });
-  writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}
-`, { mode: 384 });
-}
-function deleteSystemsConfig() {
-  try {
-    unlinkSync(configPath());
-    return true;
-  } catch (err) {
-    if (err.code === "ENOENT") return false;
-    throw err;
-  }
-}
-
-// src/lib/extensions.ts
-var VALID_EXTENSION_ID2 = /^[a-z0-9][a-z0-9_-]*$/;
-var loaded = [];
-function extensionsBaseDir() {
-  return resolve6(voluteHome(), "extensions");
-}
-function extensionDataDir(id) {
-  return resolve6(voluteSystemDir(), "extension-data", id);
-}
-function extensionsConfigPath() {
-  return resolve6(voluteHome(), "system", "extensions.json");
-}
-function readExtensionsConfig() {
-  const configPath2 = extensionsConfigPath();
-  if (!existsSync3(configPath2)) return [];
-  try {
-    const data = JSON.parse(readFileSync3(configPath2, "utf-8"));
-    return Array.isArray(data) ? data : [];
-  } catch (err) {
-    logger_default.warn("failed to read extensions config, ignoring installed extensions", {
-      path: configPath2,
-      error: err.message
-    });
-    return [];
-  }
-}
-var _LibsqlDatabase = null;
-async function getLibsqlDatabase() {
-  if (_LibsqlDatabase) return _LibsqlDatabase;
-  const mod = await import("libsql");
-  _LibsqlDatabase = mod.default ?? mod;
-  return _LibsqlDatabase;
-}
-async function openExtensionDb(_id, dataDir) {
-  const dbPath = resolve6(dataDir, "data.db");
-  const Database = await getLibsqlDatabase();
-  return new Database(dbPath);
-}
-async function buildContext(manifest, dataDir, authMw) {
-  let db = null;
-  if (manifest.initDb) {
-    const realDb = await openExtensionDb(manifest.id, dataDir);
-    try {
-      manifest.initDb(realDb);
-    } catch (err) {
-      realDb.close();
-      throw new Error(`initDb failed for extension ${manifest.id}: ${err.message}`);
-    }
-    db = realDb;
-  }
-  return {
-    db,
-    authMiddleware: authMw,
-    resolveUser: (c) => {
-      const user = c.get("user");
-      if (!user || typeof user !== "object") return null;
-      return user;
-    },
-    getUser: async (id) => getUser(id),
-    getUserByUsername: async (username) => getUserByUsername(username),
-    publishActivity: (event) => {
-      const enriched = {
-        ...event,
-        metadata: {
-          ...event.metadata,
-          ...manifest.icon && !event.metadata?.icon ? { icon: manifest.icon } : {},
-          ...manifest.color && !event.metadata?.color ? { color: manifest.color } : {}
-        }
-      };
-      publish(enriched).catch(
-        (err) => logger_default.error(`extension ${manifest.id}: failed to publish activity`, logger_default.errorData(err))
-      );
-    },
-    getMindDir: (name) => {
-      try {
-        const dir = mindDir(name);
-        return existsSync3(dir) ? dir : null;
-      } catch (err) {
-        logger_default.warn(
-          `extension ${manifest.id}: failed to resolve mind dir for ${name}`,
-          logger_default.errorData(err)
-        );
-        return null;
-      }
-    },
-    getSystemsConfig: () => readSystemsConfig(),
-    dataDir
-  };
-}
-async function loadExtension(manifest, app, authMw) {
-  if (!VALID_EXTENSION_ID2.test(manifest.id)) {
-    logger_default.error(`invalid extension ID "${manifest.id}", skipping (must match ${VALID_EXTENSION_ID2})`);
-    return;
-  }
-  const dataDir = extensionDataDir(manifest.id);
-  mkdirSync2(dataDir, { recursive: true });
-  const context = await buildContext(manifest, dataDir, authMw);
-  const routesApp = manifest.routes(context);
-  const extApiPath = `/api/ext/${manifest.id}`;
-  app.use(extApiPath, authMw);
-  app.use(`${extApiPath}/*`, authMw);
-  app.route(extApiPath, routesApp);
-  if (manifest.publicRoutes) {
-    const publicApp = manifest.publicRoutes(context);
-    app.route(`/ext/${manifest.id}/public`, publicApp);
-  }
-  if (manifest.commands) {
-    for (const [cmdName, cmd] of Object.entries(manifest.commands)) {
-      app.post(`${extApiPath}/commands/${cmdName}`, async (c) => {
-        let body;
-        try {
-          body = await c.req.json();
-        } catch {
-          return c.json({ error: "Invalid JSON in request body" }, 400);
-        }
-        const user = c.get("user");
-        const mindName = body.mind || user?.username;
-        const session = c.get("mindSession");
-        try {
-          const activityPromises = [];
-          const result = await cmd.handler(body.args ?? [], {
-            ...context,
-            publishActivity: (rawEvent) => {
-              const event = {
-                ...rawEvent,
-                metadata: {
-                  ...rawEvent.metadata,
-                  ...manifest.icon && !rawEvent.metadata?.icon ? { icon: manifest.icon } : {},
-                  ...manifest.color && !rawEvent.metadata?.color ? { color: manifest.color } : {}
-                }
-              };
-              activityPromises.push(
-                publish(event).catch((err) => {
-                  logger_default.error(
-                    `extension ${manifest.id}: failed to publish activity`,
-                    logger_default.errorData(err)
-                  );
-                  return 0;
-                })
-              );
-            },
-            mindName,
-            session,
-            stdin: body.stdin
-          });
-          const activityIds = (await Promise.all(activityPromises)).filter((id) => id > 0);
-          const markers = activityIds.map((id) => `[volute:activity:${id}]`).join("");
-          const output = result && typeof result === "object" && "output" in result ? { ...result, output: `${result.output}${markers}` } : markers ? { ...result, output: markers } : result;
-          return c.json(output);
-        } catch (err) {
-          logger_default.error(`extension command ${manifest.id}/${cmdName} failed`, logger_default.errorData(err));
-          return c.json({ error: err.message }, 500);
-        }
-      });
-    }
-  }
-  let resolvedAssetsDir = manifest.ui?.assetsDir ?? "";
-  if (resolvedAssetsDir && !existsSync3(resolvedAssetsDir)) {
-    let searchDir = dirname(new URL(import.meta.url).pathname);
-    for (let i = 0; i < 5; i++) {
-      const candidate = resolve6(searchDir, "packages", "extensions", manifest.id, "dist", "ui");
-      if (existsSync3(candidate)) {
-        resolvedAssetsDir = candidate;
-        break;
-      }
-      searchDir = dirname(searchDir);
-    }
-  }
-  if (resolvedAssetsDir && existsSync3(resolvedAssetsDir)) {
-    const assetsDir3 = resolvedAssetsDir;
-    const { readFile: readFile2, stat: fsStat } = await import("fs/promises");
-    const { extname: ext } = await import("path");
-    const mimeTypes = {
-      ".html": "text/html",
-      ".js": "application/javascript",
-      ".css": "text/css",
-      ".json": "application/json",
-      ".svg": "image/svg+xml",
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".ico": "image/x-icon",
-      ".woff": "font/woff",
-      ".woff2": "font/woff2"
-    };
-    const prefix = `/ext/${manifest.id}`;
-    const indexPath = resolve6(assetsDir3, "index.html");
-    const serveExtAssets = async (c) => {
-      const urlPath = new URL(c.req.url).pathname;
-      const relativePath = urlPath.slice(prefix.length).replace(/^\//, "") || "index.html";
-      const filePath = resolve6(assetsDir3, relativePath);
-      if (filePath !== assetsDir3 && !filePath.startsWith(assetsDir3 + "/"))
-        return c.text("Forbidden", 403);
-      const s = await fsStat(filePath).catch(() => null);
-      if (s?.isFile()) {
-        const mime = mimeTypes[ext(filePath)] || "application/octet-stream";
-        const body = await readFile2(filePath);
-        return c.body(body, 200, { "Content-Type": mime });
-      }
-      if (existsSync3(indexPath)) {
-        const body = await readFile2(indexPath, "utf-8");
-        return c.html(body);
-      }
-      return c.text("Not found", 404);
-    };
-    app.get(`${prefix}/*`, serveExtAssets);
-    app.get(prefix, serveExtAssets);
-  }
-  const skillsDir3 = resolveSkillsDir(manifest);
-  if (skillsDir3) {
-    let entries;
-    try {
-      entries = readdirSync2(skillsDir3, { withFileTypes: true });
-    } catch (err) {
-      logger_default.error(`failed to read skills dir for extension ${manifest.id}`, logger_default.errorData(err));
-      entries = [];
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      try {
-        const skillPath = resolve6(skillsDir3, entry.name);
-        const sourceHash = hashSkillDir(skillPath);
-        const destDir = resolve6(sharedSkillsDir(), entry.name);
-        if (existsSync3(destDir)) {
-          const destHash = hashSkillDir(destDir);
-          if (sourceHash === destHash) continue;
-        }
-        await importSkillFromDir(skillPath, `ext:${manifest.id}`);
-        logger_default.info(`synced skill "${entry.name}" for extension: ${manifest.id}`);
-      } catch (err) {
-        logger_default.error(
-          `failed to sync skill "${entry.name}" for extension ${manifest.id}`,
-          logger_default.errorData(err)
-        );
-      }
-    }
-  }
-  if (manifest.standardSkill && !manifest.skillsDir) {
-    logger_default.warn(`extension ${manifest.id}: standardSkill is true but no skillsDir declared`);
-  }
-  loaded.push({ manifest, context });
-  logger_default.info(`loaded extension: ${manifest.id} v${manifest.version}`);
-}
-function resolveSkillsDir(manifest) {
-  if (!manifest.skillsDir) return null;
-  let searchDir = dirname(new URL(import.meta.url).pathname);
-  for (let i = 0; i < 5; i++) {
-    const candidate = resolve6(searchDir, "packages", "extensions", manifest.id, "skills");
-    if (existsSync3(candidate)) return candidate;
-    searchDir = dirname(searchDir);
-  }
-  if (existsSync3(manifest.skillsDir)) return manifest.skillsDir;
-  logger_default.warn(`skills dir not found for extension ${manifest.id}: ${manifest.skillsDir}`);
-  return null;
-}
-function discoverBuiltinExtensions() {
-  return [src_default, src_default2];
-}
-async function discoverInstalledExtensions() {
-  const manifests = [];
-  const packages = readExtensionsConfig();
-  const npmDir = resolve6(voluteHome(), "extensions", "_npm");
-  const { createRequire } = await import("module");
-  for (const pkg of packages) {
-    try {
-      let resolved = pkg;
-      const npmPkgDir = resolve6(npmDir, "node_modules", pkg);
-      if (existsSync3(npmPkgDir)) {
-        const require2 = createRequire(resolve6(npmDir, "noop.js"));
-        resolved = require2.resolve(pkg);
-      }
-      const mod = await import(resolved);
-      const manifest = mod.default ?? mod.extension ?? mod;
-      if (!validateManifest(manifest, `package ${pkg}`)) continue;
-      manifests.push(manifest);
-    } catch (err) {
-      logger_default.error(`failed to load extension package: ${pkg}`, logger_default.errorData(err));
-    }
-  }
-  return manifests;
-}
-function validateManifest(manifest, source) {
-  if (!manifest || typeof manifest !== "object") {
-    logger_default.warn(`extension from ${source} does not export a valid manifest`);
-    return false;
-  }
-  const m = manifest;
-  if (!m.id || typeof m.id !== "string") {
-    logger_default.warn(`extension from ${source} is missing a valid id`);
-    return false;
-  }
-  if (!VALID_EXTENSION_ID2.test(m.id)) {
-    logger_default.warn(`extension from ${source} has invalid id "${m.id}"`);
-    return false;
-  }
-  if (typeof m.routes !== "function") {
-    logger_default.warn(`extension from ${source} is missing a routes function`);
-    return false;
-  }
-  if (!m.name || typeof m.name !== "string") {
-    logger_default.warn(`extension "${m.id}" from ${source} is missing a name`);
-    return false;
-  }
-  if (!m.version || typeof m.version !== "string") {
-    logger_default.warn(`extension "${m.id}" from ${source} is missing a version`);
-    return false;
-  }
-  return true;
-}
-async function discoverLocalExtensions() {
-  const baseDir = extensionsBaseDir();
-  if (!existsSync3(baseDir)) return [];
-  const manifests = [];
-  let entries;
-  try {
-    entries = readdirSync2(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name !== "_npm").map((d) => d.name);
-  } catch (err) {
-    logger_default.error("failed to read local extensions directory", logger_default.errorData(err));
-    return [];
-  }
-  for (const dir of entries) {
-    const extDir = resolve6(baseDir, dir);
-    const candidates = [resolve6(extDir, "src", "index.js"), resolve6(extDir, "index.js")];
-    const entryPoint = candidates.find((p) => existsSync3(p));
-    if (!entryPoint) continue;
-    try {
-      const mod = await import(entryPoint);
-      const manifest = mod.default ?? mod.extension ?? mod;
-      if (!validateManifest(manifest, `local dir ${extDir}`)) continue;
-      manifests.push(manifest);
-      logger_default.info(`discovered local extension: ${manifest.id} from ${extDir}`);
-    } catch (err) {
-      logger_default.error(`failed to load local extension from ${extDir}`, logger_default.errorData(err));
-    }
-  }
-  return manifests;
-}
-async function loadAllExtensions(app, authMw) {
-  const builtins = discoverBuiltinExtensions();
-  const installed = await discoverInstalledExtensions();
-  const local = await discoverLocalExtensions();
-  const all = [...builtins, ...installed, ...local];
-  const seen = /* @__PURE__ */ new Set();
-  for (const manifest of all) {
-    if (seen.has(manifest.id)) {
-      logger_default.warn(`duplicate extension ID: ${manifest.id}, skipping`);
-      continue;
-    }
-    seen.add(manifest.id);
-    try {
-      await loadExtension(manifest, app, authMw);
-    } catch (err) {
-      logger_default.error(`failed to load extension: ${manifest.id}`, logger_default.errorData(err));
-    }
-  }
-  app.get("/api/extensions/commands", (c) => {
-    const result = {};
-    for (const { manifest } of loaded) {
-      if (!manifest.commands) continue;
-      const cmds = {};
-      for (const [name, cmd] of Object.entries(manifest.commands)) {
-        cmds[name] = { description: cmd.description, ...cmd.usage ? { usage: cmd.usage } : {} };
-      }
-      result[manifest.id] = { commands: cmds };
-    }
-    return c.json(result);
-  });
-}
-function getLoadedExtensions() {
-  return loaded.map(({ manifest }) => {
-    let commands;
-    if (manifest.commands) {
-      commands = {};
-      for (const [name, cmd] of Object.entries(manifest.commands)) {
-        commands[name] = {
-          description: cmd.description,
-          ...cmd.usage ? { usage: cmd.usage } : {}
-        };
-      }
-    }
-    return {
-      id: manifest.id,
-      name: manifest.name,
-      version: manifest.version,
-      description: manifest.description,
-      icon: manifest.icon,
-      systemSection: manifest.ui?.systemSection,
-      mindSections: manifest.ui?.mindSections,
-      feedSource: manifest.ui?.feedSource,
-      commands
-    };
-  });
-}
-function getExtensionStandardSkills() {
-  const skills = [];
-  for (const { manifest } of loaded) {
-    if (!manifest.standardSkill) continue;
-    const dir = resolveSkillsDir(manifest);
-    if (!dir) continue;
-    try {
-      for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-        if (entry.isDirectory()) skills.push(entry.name);
-      }
-    } catch (err) {
-      logger_default.warn(`failed to read skills dir for extension ${manifest.id}`, logger_default.errorData(err));
-    }
-  }
-  return skills;
-}
-function notifyExtensionsDaemonStart() {
-  for (const { manifest } of loaded) {
-    try {
-      manifest.onDaemonStart?.();
-    } catch (err) {
-      logger_default.error(`extension ${manifest.id}: onDaemonStart failed`, logger_default.errorData(err));
-    }
-  }
-}
-function notifyExtensionsDaemonStop() {
-  for (const { manifest, context } of loaded) {
-    try {
-      manifest.onDaemonStop?.();
-    } catch (err) {
-      logger_default.error(`extension ${manifest.id}: onDaemonStop failed`, logger_default.errorData(err));
-    }
-    try {
-      context.db?.close();
-    } catch (err) {
-      logger_default.warn(`extension ${manifest.id}: failed to close db`, logger_default.errorData(err));
-    }
-  }
-  loaded.length = 0;
-}
-function notifyExtensionsMindStart(mindName) {
-  for (const { manifest } of loaded) {
-    try {
-      manifest.onMindStart?.(mindName);
-    } catch (err) {
-      logger_default.error(`extension ${manifest.id}: onMindStart failed for ${mindName}`, logger_default.errorData(err));
-    }
-  }
-}
-function notifyExtensionsMindStop(mindName) {
-  for (const { manifest } of loaded) {
-    try {
-      manifest.onMindStop?.(mindName);
-    } catch (err) {
-      logger_default.error(`extension ${manifest.id}: onMindStop failed for ${mindName}`, logger_default.errorData(err));
-    }
-  }
-}
-
-export {
-  readSystemsConfig,
-  writeSystemsConfig,
-  deleteSystemsConfig,
-  loadAllExtensions,
-  getLoadedExtensions,
-  getExtensionStandardSkills,
-  notifyExtensionsDaemonStart,
-  notifyExtensionsDaemonStop,
-  notifyExtensionsMindStart,
-  notifyExtensionsMindStop
-};