@abraca/nuxt 0.2.0 → 1.5.0

package/dist/runtime/server/api/_abracadabra/resolve/[...slug].get.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    docId: string;
+    slug: string;
+    html: string;
+    title: any;
+    type: any;
+    meta: any;
+    description: any;
+    ogImage: any;
+    source: "none" | "crdt-cache";
+}>>;
+export default _default;

package/dist/runtime/server/api/_abracadabra/resolve/[...slug].get.js

@@ -0,0 +1,44 @@
+import { defineEventHandler, getRouterParam, createError } from "h3";
+import { getDocIdFromSlug } from "../../../utils/slugMap.js";
+import { getCachedHTML, getCachedJSON } from "../../../utils/docCache.js";
+function extractFirstParagraph(html) {
+  if (!html) return "";
+  const pMatch = html.match(/<p[^>]*>(.*?)<\/p>/is);
+  const raw = pMatch?.[1] ?? html;
+  const text = raw.replace(/<[^>]+>/g, "").replace(/&[a-z]+;/gi, " ").trim();
+  if (!text) return "";
+  return text.length > 160 ? text.slice(0, 157) + "..." : text;
+}
+function extractFirstImage(html) {
+  if (!html) return "";
+  const match = html.match(/<img[^>]+src=["']([^"']+)["']/i);
+  return match?.[1] ?? "";
+}
+export default defineEventHandler(async (event) => {
+  const slugParam = getRouterParam(event, "slug");
+  if (!slugParam) {
+    throw createError({ statusCode: 400, message: "slug is required" });
+  }
+  const slug = slugParam;
+  const docId = getDocIdFromSlug(slug);
+  if (!docId) {
+    throw createError({ statusCode: 404, message: `Document not found for slug: ${slug}` });
+  }
+  const [cachedHtml, cachedJson] = await Promise.all([
+    getCachedHTML(docId),
+    getCachedJSON(docId)
+  ]);
+  const html = cachedHtml ?? "";
+  const treeEntry = cachedJson?.["doc-tree"]?.[docId] ?? {};
+  return {
+    docId,
+    slug,
+    html,
+    title: treeEntry.label ?? "",
+    type: treeEntry.type ?? "doc",
+    meta: treeEntry.meta ?? {},
+    description: treeEntry.meta?.note ?? treeEntry.meta?.description ?? extractFirstParagraph(html),
+    ogImage: treeEntry.meta?.coverImage ?? extractFirstImage(html),
+    source: cachedHtml !== null ? "crdt-cache" : "none"
+  };
+});

package/dist/runtime/server/api/_abracadabra/slugs.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_abracadabra/slugs.get.js

@@ -0,0 +1,8 @@
+import { getSlugMapData } from "../../utils/slugMap.js";
+import { defineCachedEventHandler } from "#imports";
+export default defineCachedEventHandler(async () => {
+  return getSlugMapData();
+}, {
+  maxAge: 30,
+  getKey: () => "abra:slugs"
+});

package/dist/runtime/server/api/_abracadabra/spaces.get.d.ts

@@ -1,11 +1,2 @@
-/**
- * GET /api/_abracadabra/spaces
- *
- * Proxies the Abracadabra REST space list endpoint.
- * Enables app devs to server-side render space navigation.
- *
- * Usage:
- *   const { data } = await useFetch('/api/_abracadabra/spaces')
- */
-declare const _default: any;
+declare const _default: import("h3").EventHandler<Omit<import("h3").EventHandlerRequest, "body">, Promise<never[] | unknown[]>>;
 export default _default;

package/dist/runtime/server/api/_abracadabra/spaces.get.js

@@ -1,3 +1,6 @@
+import { createError, getHeader } from "h3";
+import { defineCachedEventHandler } from "nitropack/runtime";
+import { useRuntimeConfig } from "nitropack/runtime/config";
 export default defineCachedEventHandler(async (event) => {
   const config = useRuntimeConfig();
   const baseUrl = config.public?.abracadabra?.url;

package/dist/runtime/server/plugins/abracadabra-service.js

@@ -4,6 +4,7 @@ import { useStorage } from "nitropack/runtime/storage";
 import { registerServerPlugin, bootRunners, shutdownAllRunners } from "../utils/serverRunner.js";
 import { createDocCacheAPI } from "../utils/docCache.js";
 import { docTreeCacheRunner } from "../runners/doc-tree-cache.js";
+import { initSlugMap, loadPersistedSlugMap } from "../utils/slugMap.js";
 function fromBase64Url(str) {
   const b = atob(str.replace(/-/g, "+").replace(/_/g, "/").padEnd(str.length + (4 - str.length % 4) % 4, "="));
   const a = new Uint8Array(b.length);
@@ -18,6 +19,9 @@ function toBase64Url(bytes) {
 export default defineNitroPlugin(async (nitroApp) => {
   const config = useRuntimeConfig();
   const abraConfig = config.abracadabra;
+  const storage = useStorage();
+  initSlugMap(storage);
+  await loadPersistedSlugMap();
   const pubKeyB64 = abraConfig?.servicePublicKey ?? "";
   const privKeyB64 = abraConfig?.servicePrivateKey ?? "";
   const rootDocIdOverride = abraConfig?.serviceRootDocId ?? "";
@@ -28,20 +32,20 @@ export default defineNitroPlugin(async (nitroApp) => {
   let wsp = null;
   try {
     const [
-      { AbracadabraClient, AbracadabraProvider, HocuspocusProviderWebsocket },
+      { AbracadabraClient, AbracadabraProvider, AbracadabraWS },
       ed,
       { sha512 },
       Y
     ] = await Promise.all([
       import("@abraca/dabra"),
       import("@noble/ed25519"),
-      import("@noble/hashes/sha2.js"),
+      import("@noble/hashes/sha512"),
       import("yjs")
     ]);
-    ed.etc = ed.etc ?? {};
-    ed.etc.sha512Sync = (m) => sha512(m);
+    ed.hashes.sha512 = (m) => sha512(m);
     const privKey = fromBase64Url(privKeyB64);
     const client = new AbracadabraClient({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Nuxt runtime config augmentation not resolved in Nitro
       url: config.public?.abracadabra?.url,
       persistAuth: false
     });
@@ -51,14 +55,14 @@ export default defineNitroPlugin(async (nitroApp) => {
     });
     console.log("[abracadabra-service] Authenticated as service role");
     const wsUrl = client.wsUrl;
-    wsp = new HocuspocusProviderWebsocket({
+    wsp = new AbracadabraWS({
       url: wsUrl,
       delay: 1e3,
       minDelay: 1e3,
       maxDelay: 3e4,
       factor: 2,
       jitter: true,
-      maxAttempts: 0
+      maxAttempts: 50
     });
     let rootDocId = rootDocIdOverride;
     if (!rootDocId) {
@@ -79,21 +83,34 @@ export default defineNitroPlugin(async (nitroApp) => {
       document: rootDoc,
       name: rootDocId,
       websocketProvider: wsp,
-      disableOfflineStore: true
+      disableOfflineStore: true,
+      cryptoIdentity: { publicKey: pubKeyB64 },
+      signChallenge: async (challenge) => {
+        const sig = await ed.sign(fromBase64Url(challenge), privKey);
+        return toBase64Url(sig);
+      }
     });
-    rootProvider.attach?.();
+    rootProvider.attach();
     await Promise.race([
-      new Promise((resolve) => rootProvider.on("synced", resolve)),
+      new Promise((resolve) => {
+        const handler = ({ state }) => {
+          if (state) {
+            rootProvider.off("synced", handler);
+            resolve();
+          }
+        };
+        rootProvider.on("synced", handler);
+      }),
       new Promise((_, reject) => setTimeout(() => reject(new Error("sync timeout")), 3e4))
     ]);
     console.log("[abracadabra-service] Root doc synced");
-    const storage = useStorage();
+    const storage2 = useStorage();
     const ctx = {
       client,
       wsp,
       rootDoc,
       rootProvider,
-      storage,
+      storage: storage2,
       docCache: createDocCacheAPI(rootDoc)
     };
     const publicConfig = config.public?.abracadabra;
@@ -113,7 +130,7 @@ export default defineNitroPlugin(async (nitroApp) => {
       console.log("[abracadabra-service] Shutdown complete");
     });
   } catch (err) {
-    console.error("[abracadabra-service] Failed to initialize:", err?.message ?? err);
+    console.error("[abracadabra-service] Failed to initialize:", err instanceof Error ? err.message : err);
     wsp?.destroy?.();
   }
 });

package/dist/runtime/server/runners/doc-tree-cache.js

@@ -1,5 +1,6 @@
 import { initDocCache, observeDoc, unobserveDoc } from "../utils/docCache.js";
 import { getServerPlugins } from "../utils/serverRunner.js";
+import { initSlugMap, rebuildSlugMapSync, rebuildSlugMap } from "../utils/slugMap.js";
 export const docTreeCacheRunner = {
   name: "abracadabra:doc-tree-cache",
   async start(ctx) {
@@ -9,6 +10,7 @@ export const docTreeCacheRunner = {
     const pendingDocs = /* @__PURE__ */ new Set();
     const serverExts = getServerPlugins().flatMap((p) => p.serverExtensions?.() ?? []);
     initDocCache(storage, serverExts);
+    initSlugMap(storage);
     async function trackDoc(docId) {
       if (loadedDocs.has(docId) || pendingDocs.has(docId)) return;
       pendingDocs.add(docId);
@@ -42,6 +44,7 @@ export const docTreeCacheRunner = {
     treeMap.forEach((_val, docId) => {
       trackDoc(docId);
     });
+    rebuildSlugMapSync(treeMap);
     const observer = (event) => {
       event.keysChanged.forEach((docId) => {
         if (treeMap.has(docId)) {
@@ -52,6 +55,7 @@ export const docTreeCacheRunner = {
           console.log(`[abracadabra:doc-tree-cache] Untracked: ${docId}`);
         }
       });
+      rebuildSlugMap(treeMap);
     };
     treeMap.observe(observer);
     return () => {

package/dist/runtime/server/utils/docCache.d.ts

@@ -6,20 +6,22 @@
  *
  * Used by the built-in doc-tree-cache server runner and by the SSR render route.
  */
-import type { DocCacheAPI } from '../../../runtime/types.js';
+import type { AnyExtension } from '@tiptap/core';
+import type * as Y from 'yjs';
+import type { DocCacheAPI, NitroStorage } from '../../../runtime/types.js';
 /**
  * Initialize the cache with a Nitro storage handle and optional extra extensions.
  * Must be called before observeDoc().
  */
-export declare function initDocCache(storage: any, extraExtensions?: any[]): void;
+export declare function initDocCache(storage: NitroStorage, extraExtensions?: AnyExtension[]): void;
 export declare function getCachedHTML(docId: string): Promise<string | null>;
-export declare function getCachedJSON(docId: string): Promise<any | null>;
-export declare function invalidateDoc(docId: string, ydoc?: any): Promise<void>;
+export declare function getCachedJSON(docId: string): Promise<Record<string, unknown> | null>;
+export declare function invalidateDoc(docId: string, ydoc?: Y.Doc): Promise<void>;
 /**
  * Start observing a Y.Doc for changes with debounced re-rendering.
  * Renders immediately on first observe.
  */
-export declare function observeDoc(docId: string, ydoc: any): void;
+export declare function observeDoc(docId: string, ydoc: Y.Doc): void;
 export declare function unobserveDoc(docId: string): void;
 /** Build the DocCacheAPI object for the ServerRunnerContext. */
-export declare function createDocCacheAPI(rootDoc: any): DocCacheAPI;
+export declare function createDocCacheAPI(rootDoc: Y.Doc): DocCacheAPI;

package/dist/runtime/server/utils/docCache.js

@@ -18,7 +18,7 @@ async function renderDocToHTML(ydoc) {
     return generateHTML(json, [StarterKit, ..._extensions]);
   } catch (e) {
     console.warn("[abracadabra:doc-cache] HTML render failed:", e);
-    return "";
+    return null;
   }
 }
 async function renderDocToJSON(ydoc) {
@@ -61,8 +61,8 @@ export async function invalidateDoc(docId, ydoc) {
     renderDocToJSON(doc)
   ]);
   await Promise.all([
-    _storage.setItem(htmlKey(docId), html),
-    _storage.setItem(jsonKey(docId), json)
+    html !== null ? _storage.setItem(htmlKey(docId), html) : Promise.resolve(),
+    json !== null ? _storage.setItem(jsonKey(docId), json) : Promise.resolve()
   ]);
 }
 export function observeDoc(docId, ydoc) {

package/dist/runtime/server/utils/serverPluginLoader.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Dynamic server plugin loader.
+ *
+ * Loads AbracadabraPlugin modules from ESM URLs at runtime.
+ * Appends `.server.js` to the base URL, fetches the module text,
+ * and imports it via a data: URL (stable in Node 22+).
+ *
+ * Ported from cou-sh/server/utils/serverPluginLoader.ts.
+ */
+import type { AbracadabraPlugin } from '../../types.js';
+/**
+ * Load a server plugin from an ESM URL.
+ * Appends `.server.js` to the base URL, fetches the module text,
+ * and imports it via a data: URL (stable in Node 22+).
+ */
+export declare function loadServerPlugin(baseUrl: string): Promise<AbracadabraPlugin>;
+/** Clear the entire module cache (e.g. for reloading updated plugins). */
+export declare function clearPluginCache(): void;
+/** Evict a single URL from the cache. */
+export declare function evictPlugin(baseUrl: string): void;

package/dist/runtime/server/utils/serverPluginLoader.js

@@ -0,0 +1,42 @@
+const _moduleCache = /* @__PURE__ */ new Map();
+const _allowlist = (() => {
+  const raw = process.env.ABRA_PLUGIN_ALLOWLIST;
+  if (!raw) return [];
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+})();
+export async function loadServerPlugin(baseUrl) {
+  const url = `${baseUrl}.server.js`;
+  const cached = _moduleCache.get(url);
+  if (cached) return cached;
+  if (_allowlist.length > 0 && !_allowlist.some((prefix) => url.startsWith(prefix))) {
+    throw new Error(`[plugin-loader] URL not in allowlist: ${url}`);
+  }
+  console.log(`[plugin-loader] Fetching: ${url}`);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`[plugin-loader] HTTP ${response.status} fetching ${url}`);
+  }
+  const code = await response.text();
+  const encoded = Buffer.from(code).toString("base64");
+  const dataUrl = `data:text/javascript;base64,${encoded}`;
+  const mod = await import(
+    /* @vite-ignore */
+    dataUrl
+  );
+  const plugin = mod.default ?? mod;
+  if (!plugin?.name) {
+    throw new Error(`[plugin-loader] Module at ${url} does not export a valid AbracadabraPlugin (missing name)`);
+  }
+  if (!plugin.serverRunners?.length) {
+    console.warn(`[plugin-loader] Plugin "${plugin.name}" from ${url} has no serverRunners`);
+  }
+  _moduleCache.set(url, plugin);
+  console.log(`[plugin-loader] Loaded plugin: ${plugin.name}${plugin.version ? ` v${plugin.version}` : ""}`);
+  return plugin;
+}
+export function clearPluginCache() {
+  _moduleCache.clear();
+}
+export function evictPlugin(baseUrl) {
+  _moduleCache.delete(`${baseUrl}.server.js`);
+}

package/dist/runtime/server/utils/serverRunner.d.ts

@@ -12,7 +12,7 @@
  *     })
  *   })
  */
-import type { AbracadabraPlugin, ServerRunnerContext } from '../../types.js';
+import type { AbracadabraPlugin, ServerRunnerDefinition, ServerRunnerContext } from '../../types.js';
 /**
  * Register a plugin that may declare serverRunners.
  * Must be called before bootRunners() (e.g. inside the 'abracadabra:before-runners' hook).
@@ -22,7 +22,16 @@ export declare function registerServerPlugin(plugin: AbracadabraPlugin): void;
 export declare function getServerPlugins(): readonly AbracadabraPlugin[];
 /** Boot all runners from all registered plugins. Called once after auth + sync. */
 export declare function bootRunners(ctx: ServerRunnerContext): Promise<void>;
-/** Stop a single runner by name and remove it from the registry. */
+/**
+ * Start a single runner. Optionally namespace-prefix the key for per-space isolation.
+ * When namespace is provided, the runner key becomes `${namespace}:${def.name}`.
+ */
+export declare function startRunner(def: ServerRunnerDefinition, ctx?: ServerRunnerContext, namespace?: string): Promise<void>;
+/** Stop a single runner by its full key and remove it from the registry. */
 export declare function stopRunner(name: string): Promise<void>;
+/** Stop all runners whose key starts with the given prefix (for space teardown). */
+export declare function stopRunnersWithPrefix(prefix: string): Promise<void>;
+/** Get all running runner keys. */
+export declare function getRunnerKeys(): string[];
 /** Shutdown all runners gracefully. Called on server close. */
 export declare function shutdownAllRunners(): Promise<void>;

package/dist/runtime/server/utils/serverRunner.js

@@ -15,27 +15,29 @@ export async function bootRunners(ctx) {
   _serverCtx = ctx;
   for (const plugin of _plugins) {
     for (const def of plugin.serverRunners ?? []) {
-      await _startRunner(def);
+      await startRunner(def, ctx);
     }
   }
 }
-async function _startRunner(def) {
-  if (_runners.has(def.name)) {
-    console.warn(`[abracadabra-service] Runner "${def.name}" already running`);
+export async function startRunner(def, ctx, namespace) {
+  const key = namespace ? `${namespace}:${def.name}` : def.name;
+  if (_runners.has(key)) {
+    console.warn(`[abracadabra-service] Runner "${key}" already running`);
     return;
   }
-  if (!_serverCtx) {
+  const runCtx = ctx ?? _serverCtx;
+  if (!runCtx) {
     throw new Error("[abracadabra-service] Server context not initialized");
   }
   const state = { definition: def, cleanup: void 0, running: false };
-  _runners.set(def.name, state);
+  _runners.set(key, state);
   try {
-    console.log(`[abracadabra-service] Starting runner: ${def.name}`);
-    state.cleanup = await def.start(_serverCtx);
+    console.log(`[abracadabra-service] Starting runner: ${key}`);
+    state.cleanup = await def.start(runCtx);
     state.running = true;
   } catch (err) {
-    console.error(`[abracadabra-service] Runner "${def.name}" failed to start:`, err);
-    _runners.delete(def.name);
+    console.error(`[abracadabra-service] Runner "${key}" failed to start:`, err);
+    _runners.delete(key);
   }
 }
 export async function stopRunner(name) {
@@ -49,6 +51,15 @@ export async function stopRunner(name) {
   _runners.delete(name);
   console.log(`[abracadabra-service] Stopped runner: ${name}`);
 }
+export async function stopRunnersWithPrefix(prefix) {
+  const keys = [..._runners.keys()].filter((k) => k.startsWith(prefix));
+  for (const key of keys) {
+    await stopRunner(key);
+  }
+}
+export function getRunnerKeys() {
+  return [..._runners.keys()];
+}
 export async function shutdownAllRunners() {
   for (const [name] of _runners) {
     await stopRunner(name);

package/dist/runtime/server/utils/slugMap.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Server-side slug map singleton.
+ *
+ * Maintains bidirectional slug↔docId maps, persists them to Nitro storage,
+ * and loads them on startup so slug routes work even before CRDT sync.
+ */
+import { type SlugMap } from '../../utils/slugify.js';
+/**
+ * Initialize slug map with a Nitro storage handle.
+ * Call early in the service plugin lifecycle.
+ */
+export declare function initSlugMap(storage: any): void;
+/**
+ * Load persisted slug map from storage.
+ * Call on startup before CRDT connects so slug routes work immediately.
+ */
+export declare function loadPersistedSlugMap(): Promise<void>;
+/**
+ * Rebuild the slug map from a Y.Map tree (debounced).
+ * Called by the doc-tree-cache runner when the tree changes.
+ */
+export declare function rebuildSlugMap(treeMap: any): void;
+/**
+ * Rebuild immediately (used for initial load).
+ */
+export declare function rebuildSlugMapSync(treeMap: any): void;
+/** Resolve a slug path to a docId. Returns null if not found. */
+export declare function getDocIdFromSlug(slug: string): string | null;
+/** Get the slug for a docId. Returns null if not found. */
+export declare function getSlugFromDocId(docId: string): string | null;
+/** Get the full current slug map (for the slugs API endpoint). */
+export declare function getSlugMapData(): SlugMap;

package/dist/runtime/server/utils/slugMap.js

@@ -0,0 +1,58 @@
+import { buildSlugMap } from "../../utils/slugify.js";
+let _slugMap = { slugToId: {}, idToSlug: {} };
+let _storage = null;
+let _rebuildTimer = null;
+const SLUG_STORAGE_KEY = "doc-cache:slug-map";
+const REBUILD_DEBOUNCE_MS = 2e3;
+export function initSlugMap(storage) {
+  _storage = storage;
+}
+export async function loadPersistedSlugMap() {
+  if (!_storage) return;
+  try {
+    const stored = await _storage.getItem(SLUG_STORAGE_KEY);
+    if (stored && typeof stored === "object" && stored.slugToId && stored.idToSlug) {
+      _slugMap = stored;
+      console.log(`[abracadabra:slug-map] Loaded ${Object.keys(_slugMap.slugToId).length} slugs from cache`);
+    }
+  } catch (e) {
+    console.warn("[abracadabra:slug-map] Failed to load persisted slug map:", e);
+  }
+}
+export function rebuildSlugMap(treeMap) {
+  if (_rebuildTimer) clearTimeout(_rebuildTimer);
+  _rebuildTimer = setTimeout(() => {
+    _rebuildTimer = null;
+    rebuildSlugMapSync(treeMap);
+  }, REBUILD_DEBOUNCE_MS);
+}
+export function rebuildSlugMapSync(treeMap) {
+  try {
+    const raw = treeMap.toJSON();
+    const entries = Object.entries(raw).map(([id, entry]) => ({
+      id,
+      label: entry.label ?? "",
+      parentId: entry.parentId ?? null,
+      order: entry.order ?? 0,
+      trashed: entry.trashed ?? false
+    }));
+    _slugMap = buildSlugMap(entries);
+    if (_storage) {
+      _storage.setItem(SLUG_STORAGE_KEY, _slugMap).catch((e) => {
+        console.warn("[abracadabra:slug-map] Failed to persist:", e);
+      });
+    }
+    console.log(`[abracadabra:slug-map] Rebuilt: ${Object.keys(_slugMap.slugToId).length} slugs`);
+  } catch (e) {
+    console.warn("[abracadabra:slug-map] Rebuild failed:", e);
+  }
+}
+export function getDocIdFromSlug(slug) {
+  return _slugMap.slugToId[slug] ?? null;
+}
+export function getSlugFromDocId(docId) {
+  return _slugMap.idToSlug[docId] ?? null;
+}
+export function getSlugMapData() {
+  return _slugMap;
+}

package/dist/runtime/server/utils/spaceManager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Per-space lifecycle manager.
+ *
+ * Discovers spaces from the Abracadabra server, connects to each one,
+ * starts per-space doc-tree-cache runners, and observes the space-plugins
+ * Y.Map for dynamic plugin loading/unloading.
+ *
+ * Ported from cou-sh/server/utils/spaceManager.ts.
+ */
+import type { AbracadabraClient, AbracadabraWS } from '@abraca/dabra';
+import type { NitroStorage } from '../../types.js';
+interface BaseCtx {
+    client: AbracadabraClient;
+    wsp: AbracadabraWS;
+    storage: NitroStorage;
+}
+/**
+ * Initialize the space manager. Discovers spaces and starts polling.
+ */
+export declare function initSpaceManager(baseCtx: BaseCtx): Promise<void>;
+/** Shutdown all spaces and stop polling. */
+export declare function shutdownSpaceManager(): Promise<void>;
+/** Get all connected space IDs. */
+export declare function getConnectedSpaces(): string[];
+export {};