@abraca/nuxt 0.3.0 → 1.5.0

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

@@ -32,38 +32,37 @@ 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")
     ]);
-    if (ed.etc && !ed.etc.sha512Sync) {
-      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
     });
     await client.loginWithKey(pubKeyB64, async (challenge) => {
-      const sig = await ed.signAsync(fromBase64Url(challenge), privKey);
+      const sig = await ed.sign(fromBase64Url(challenge), privKey);
       return toBase64Url(sig);
     });
     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) {
@@ -84,11 +83,24 @@ 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");
@@ -118,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/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/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 {};

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

@@ -0,0 +1,188 @@
+import { startRunner, stopRunner, stopRunnersWithPrefix } from "./serverRunner.js";
+import { createDocCacheAPI } from "./docCache.js";
+import { loadServerPlugin } from "./serverPluginLoader.js";
+import { docTreeCacheRunner } from "../runners/doc-tree-cache.js";
+const _spaces = /* @__PURE__ */ new Map();
+let _baseCtx = null;
+let _pollInterval = null;
+const POLL_INTERVAL_MS = 6e4;
+export async function initSpaceManager(baseCtx) {
+  _baseCtx = baseCtx;
+  globalThis.__ABRACA_SHARED__ = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- shared globals bridge
+    ...globalThis.__ABRACA_SHARED__
+  };
+  await discoverSpaces();
+  _pollInterval = setInterval(() => {
+    discoverSpaces().catch(
+      (err) => console.error("[space-manager] Poll failed:", err)
+    );
+  }, POLL_INTERVAL_MS);
+}
+export async function shutdownSpaceManager() {
+  if (_pollInterval) {
+    clearInterval(_pollInterval);
+    _pollInterval = null;
+  }
+  const spaceIds = [..._spaces.keys()];
+  for (const spaceId of spaceIds) {
+    await disconnectSpace(spaceId);
+  }
+}
+export function getConnectedSpaces() {
+  return [..._spaces.keys()];
+}
+async function discoverSpaces() {
+  if (!_baseCtx) return;
+  let spaces;
+  try {
+    spaces = await _baseCtx.client.listSpaces();
+  } catch (err) {
+    console.error("[space-manager] Failed to list spaces:", err);
+    return;
+  }
+  const currentIds = new Set(spaces.map((s) => s.id));
+  for (const meta of spaces) {
+    if (meta.is_hub) continue;
+    if (!_spaces.has(meta.id)) {
+      await connectSpace(meta);
+    }
+  }
+  const existingIds = [..._spaces.keys()];
+  for (const spaceId of existingIds) {
+    if (!currentIds.has(spaceId)) {
+      await disconnectSpace(spaceId);
+    }
+  }
+}
+async function connectSpace(meta) {
+  if (!_baseCtx || _spaces.has(meta.id)) return;
+  console.log(`[space-manager] Connecting space: ${meta.name} (${meta.id})`);
+  const Y = await import("yjs");
+  const doc = new Y.Doc();
+  const { AbracadabraProvider } = await import("@abraca/dabra");
+  const provider = new AbracadabraProvider({
+    client: _baseCtx.client,
+    document: doc,
+    name: meta.doc_id,
+    websocketProvider: _baseCtx.wsp,
+    disableOfflineStore: true
+  });
+  provider.attach();
+  await new Promise((resolve) => {
+    const done = () => {
+      provider.off("synced", done);
+      resolve();
+    };
+    provider.on("synced", done);
+    setTimeout(resolve, 1e4);
+  });
+  const conn = {
+    spaceId: meta.id,
+    docId: meta.doc_id,
+    meta,
+    provider,
+    doc,
+    pluginObserver: null,
+    loadedPlugins: /* @__PURE__ */ new Map()
+  };
+  _spaces.set(meta.id, conn);
+  console.log(`[space-manager] Space synced: ${meta.name}`);
+  const spaceCtx = buildSpaceContext(conn);
+  await startRunner(docTreeCacheRunner, spaceCtx, meta.doc_id);
+  observeSpacePlugins(conn);
+}
+async function disconnectSpace(spaceId) {
+  const conn = _spaces.get(spaceId);
+  if (!conn) return;
+  console.log(`[space-manager] Disconnecting space: ${conn.meta.name} (${spaceId})`);
+  if (conn.pluginObserver) {
+    try {
+      const pluginsMap = conn.doc.getMap("space-plugins");
+      pluginsMap.unobserve(conn.pluginObserver);
+    } catch {
+    }
+  }
+  await stopRunnersWithPrefix(conn.docId);
+  conn.provider.destroy();
+  conn.doc.destroy();
+  _spaces.delete(spaceId);
+}
+function observeSpacePlugins(conn) {
+  const pluginsMap = conn.doc.getMap("space-plugins");
+  processPluginMap(conn, pluginsMap);
+  conn.pluginObserver = (event) => {
+    processPluginMapChanges(conn, pluginsMap, event);
+  };
+  pluginsMap.observe(conn.pluginObserver);
+}
+async function processPluginMap(conn, pluginsMap) {
+  const Y = await import("yjs");
+  const toLoad = [];
+  pluginsMap.forEach((value, pluginName) => {
+    const entry = value instanceof Y.Map ? value.toJSON() : value;
+    if (entry?.enabled && entry?.url) {
+      toLoad.push({ name: pluginName, url: entry.url });
+    }
+  });
+  for (const { name, url } of toLoad) {
+    await loadAndStartPlugin(conn, name, url);
+  }
+}
+async function processPluginMapChanges(conn, pluginsMap, event) {
+  const Y = await import("yjs");
+  for (const key of event.keysChanged) {
+    const value = pluginsMap.get(key);
+    if (!value) {
+      await stopPluginRunners(conn, key);
+      continue;
+    }
+    const entry = value instanceof Y.Map ? value.toJSON() : value;
+    if (entry?.enabled && entry?.url) {
+      if (!conn.loadedPlugins.has(key)) {
+        await loadAndStartPlugin(conn, key, entry.url);
+      }
+    } else {
+      await stopPluginRunners(conn, key);
+    }
+  }
+}
+async function loadAndStartPlugin(conn, pluginName, url) {
+  try {
+    const plugin = await loadServerPlugin(url);
+    if (!plugin.serverRunners?.length) {
+      console.warn(`[space-manager] Plugin "${pluginName}" has no server runners`);
+      return;
+    }
+    const spaceCtx = buildSpaceContext(conn);
+    const runnerKeys = [];
+    for (const def of plugin.serverRunners) {
+      const key = `${conn.docId}:${def.name}`;
+      await startRunner(def, spaceCtx, conn.docId);
+      runnerKeys.push(key);
+    }
+    conn.loadedPlugins.set(pluginName, runnerKeys);
+    console.log(`[space-manager] Started plugin "${pluginName}" in space "${conn.meta.name}" (${plugin.serverRunners.length} runners)`);
+  } catch (err) {
+    console.error(`[space-manager] Failed to load plugin "${pluginName}" from ${url}:`, err);
+  }
+}
+async function stopPluginRunners(conn, pluginName) {
+  const keys = conn.loadedPlugins.get(pluginName);
+  if (!keys) return;
+  for (const key of keys) {
+    await stopRunner(key);
+  }
+  conn.loadedPlugins.delete(pluginName);
+  console.log(`[space-manager] Stopped plugin "${pluginName}" in space "${conn.meta.name}"`);
+}
+function buildSpaceContext(conn) {
+  return {
+    client: _baseCtx.client,
+    wsp: _baseCtx.wsp,
+    rootDoc: conn.doc,
+    rootProvider: conn.provider,
+    storage: _baseCtx.storage,
+    docCache: createDocCacheAPI(conn.doc)
+  };
+}