@crowi/api 2.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Sotaro KARASAWA <sotaro.k@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/app.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Crowi::app.js
+ *
+ * @package Crowi
+ * @author  Sotaro KARASAWA <sotarok@crocos.co.jp>
+ */
+export {};

package/dist/app.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Crowi::app.js
+ *
+ * @package Crowi
+ * @author  Sotaro KARASAWA <sotarok@crocos.co.jp>
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const crowi_1 = __importDefault(require("./crowi"));
+const path_1 = require("path");
+// load .env
+dotenv_1.default.config();
+const crowi = new crowi_1.default((0, path_1.resolve)((0, path_1.join)(__dirname, '..')), process.env);
+crowi.init().then(crowi.start).catch(crowi.exitOnError);
+/**
+ * RFC-0003 — graceful shutdown for the embedded Hocuspocus engine.
+ *
+ * Two routes can fire the teardown:
+ *   - `SIGINT` (Ctrl-C in dev / orchestrator stop)
+ *   - `SIGTERM` (docker stop / systemd / k8s)
+ *
+ * `shutdown()` flushes pending Y.Doc checkpoints before dropping
+ * connections — without this hook, an unsaved-debounce window's worth
+ * of edits would be lost on every process restart. We defer the actual
+ * `process.exit` to Node's default behaviour after the handler resolves
+ * so any other registered shutdown logic still runs.
+ */
+let shuttingDown = false;
+const shutdown = async (signal) => {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    console.log(`[crowi] ${signal} received — shutting down`);
+    try {
+        await crowi.collabAttachment?.shutdown();
+    }
+    catch (err) {
+        console.error('[crowi] collabAttachment.shutdown failed:', err);
+    }
+    try {
+        await crowi.presenceAttachment?.shutdown();
+    }
+    catch (err) {
+        console.error('[crowi] presenceAttachment.shutdown failed:', err);
+    }
+    try {
+        await crowi.notificationsAttachment?.shutdown();
+    }
+    catch (err) {
+        console.error('[crowi] notificationsAttachment.shutdown failed:', err);
+    }
+    process.exit(0);
+};
+process.on('SIGINT', () => {
+    void shutdown('SIGINT');
+});
+process.on('SIGTERM', () => {
+    void shutdown('SIGTERM');
+});
+//# sourceMappingURL=app.js.map

package/dist/app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.js","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":";;AACA;;;;;GAKG;;;;;AAEH,oDAA4B;AAC5B,sDAA8B;AAC9B,+BAAqC;AAErC,YAAY;AACZ,gBAAM,CAAC,MAAM,EAAE,CAAC;AAEhB,MAAM,KAAK,GAAG,IAAI,eAAK,CAAC,IAAA,cAAO,EAAC,IAAA,WAAI,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;AAErE,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AAExD;;;;;;;;;;;;GAYG;AACH,IAAI,YAAY,GAAG,KAAK,CAAC;AACzB,MAAM,QAAQ,GAAG,KAAK,EAAE,MAAc,EAAiB,EAAE;IACvD,IAAI,YAAY;QAAE,OAAO;IACzB,YAAY,GAAG,IAAI,CAAC;IACpB,OAAO,CAAC,GAAG,CAAC,WAAW,MAAM,2BAA2B,CAAC,CAAC;IAC1D,IAAI,CAAC;QACH,MAAM,KAAK,CAAC,gBAAgB,EAAE,QAAQ,EAAE,CAAC;IAC3C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,2CAA2C,EAAE,GAAG,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,CAAC;QACH,MAAM,KAAK,CAAC,kBAAkB,EAAE,QAAQ,EAAE,CAAC;IAC7C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,6CAA6C,EAAE,GAAG,CAAC,CAAC;IACpE,CAAC;IACD,IAAI,CAAC;QACH,MAAM,KAAK,CAAC,uBAAuB,EAAE,QAAQ,EAAE,CAAC;IAClD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,kDAAkD,EAAE,GAAG,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC;AACF,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;IACxB,KAAK,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAC1B,CAAC,CAAC,CAAC;AACH,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;IACzB,KAAK,QAAQ,CAAC,SAAS,CAAC,CAAC;AAC3B,CAAC,CAAC,CAAC"}

package/dist/collab/attach.d.ts

@@ -0,0 +1,33 @@
+import type { Server as HttpServer } from 'node:http';
+import type Crowi from '../crowi';
+/**
+ * Public surface returned from `attachCollabServer`. The api boot
+ * keeps the handle so SIGINT teardown can flush pending stores,
+ * destroy the engine, and disconnect the cap counter before mongoose
+ * shuts down.
+ */
+export interface AttachedCollab {
+    /**
+     * Detach + tear down the Hocuspocus engine. Idempotent and safe to
+     * call from a SIGINT handler that also calls other shutdown hooks.
+     * `flushPendingStores` is fired so the next-after-debounce
+     * `onStoreDocument` actually runs before the engine drops references
+     * to live Y.Docs.
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Wire the `@crowi/collab` Hocuspocus engine into the api's existing
+ * Express http.Server. The engine handles `ws://<api-host>/collab/:pageId?token=<wsToken>`
+ * via the `ws` library's `noServer` mode — same Node process, same
+ * event loop, same Mongoose connection, same Redis client.
+ *
+ * Replaces the standalone `@crowi/collab` CLI from RFC-0003 Phase 3-8.
+ * The motivation + design lives in `.feature-state/specs/feature-collab-embed-into-api.md`.
+ *
+ * Boot order: must be called **after** `setupModels` + `setupRenderer`
+ * (renderer pipeline is read by `Revision.prepareRevision` from the
+ * save flow). The api's `Crowi.start` invokes this right before
+ * `server.listen`.
+ */
+export declare function attachCollabServer(httpServer: HttpServer, crowi: Crowi): Promise<AttachedCollab>;

package/dist/collab/attach.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachCollabServer = attachCollabServer;
+const debug_1 = __importDefault(require("debug"));
+const ws_1 = require("ws");
+const collab_cap_1 = require("../util/collab-cap");
+const ws_token_1 = require("../util/ws-token");
+const presence_1 = require("../service/presence");
+const extension_redis_1 = require("./extension-redis");
+const debug = (0, debug_1.default)('crowi:collab:attach');
+/**
+ * Path namespace the Hocuspocus engine answers on. HocuspocusProvider
+ * uses `url` verbatim as the WebSocket endpoint and sends the document
+ * name (= pageId) through the protocol after the handshake, so the
+ * path the browser hits is `/collab` (no document segment). The
+ * upgrade filter accepts both `/collab` and `/collab/...` so future
+ * variants that *do* include the document in the path keep working,
+ * and so sibling WebSocket handlers (socket.io etc.) can coexist on
+ * the same listener.
+ */
+const COLLAB_PATH = '/collab';
+/**
+ * Default Hocuspocus debounce window (ms) — matches the upstream v4
+ * default (`debounce: 2000`). Re-declared here so the api-side attach
+ * can pin it explicitly without importing private upstream constants.
+ */
+const DEFAULT_DEBOUNCE_MS = 2000;
+const DEFAULT_MAX_DEBOUNCE_MS = 10000;
+/**
+ * Graceful-drain window between asking sockets to close politely and
+ * force-terminating any stragglers. Clients normally close within a
+ * round-trip; this gives them ~500 ms to flush their final `update`
+ * frame before SIGINT kicks them off.
+ */
+const SHUTDOWN_DRAIN_MS = 500;
+/**
+ * Wire the `@crowi/collab` Hocuspocus engine into the api's existing
+ * Express http.Server. The engine handles `ws://<api-host>/collab/:pageId?token=<wsToken>`
+ * via the `ws` library's `noServer` mode — same Node process, same
+ * event loop, same Mongoose connection, same Redis client.
+ *
+ * Replaces the standalone `@crowi/collab` CLI from RFC-0003 Phase 3-8.
+ * The motivation + design lives in `.feature-state/specs/feature-collab-embed-into-api.md`.
+ *
+ * Boot order: must be called **after** `setupModels` + `setupRenderer`
+ * (renderer pipeline is read by `Revision.prepareRevision` from the
+ * save flow). The api's `Crowi.start` invokes this right before
+ * `server.listen`.
+ */
+async function attachCollabServer(httpServer, crowi) {
+    // Reach for the api-side models — they were already wired by
+    // `setupModels` against the same Mongoose connection collab will
+    // use, so save / load / compaction all operate on the same row
+    // identities the HTTP path observes.
+    const models = {
+        Page: crowi.model('Page'),
+        Revision: crowi.model('Revision'),
+        PageYjsUpdate: crowi.model('PageYjsUpdate'),
+        User: crowi.model('User'),
+        PluginRenderCache: crowi.model('PluginRenderCache'),
+    };
+    // Same sign+verify pair the wsToken HTTP handler uses. In the
+    // RFC-0003 same-process attach world, the api signs in
+    // `routes/ts-rest/page-collab.ts` and verifies here against the
+    // **same closure-captured secret** — no env distribution drift.
+    const wsTokenUtil = (0, ws_token_1.createWsTokenUtil)();
+    // Process-wide cap counter shared with the wsToken HTTP handler
+    // (`util/collab-cap.ts:checkEditorCap`). Both call sites route
+    // through `getEditorCapCounter(crowi)` so sign-time `peek` and
+    // connect-time `tryAcquire` operate on the same instance — one
+    // Redis client, one cap key, one in-process cache. When
+    // `crowi.redis` is null (REDIS_URL unset) the counter degrades to
+    // its built-in no-op shape (same fail-open posture as Phase 6).
+    const editorCapCounter = await (0, collab_cap_1.getEditorCapCounter)(crowi);
+    // pageEvent in-process adapter: the collab save flow publishes
+    // `update` after a successful checkpoint, and we forward it to the
+    // api's local `EventEmitter` so render-cache invalidation /
+    // mention-dispatch / search indexing react as if the save had
+    // happened over HTTP. Re-fetching Page + User mirrors what the
+    // cross-process subscriber did in `service/page-event-pubsub.ts`,
+    // so listeners can read the latest state without worrying about
+    // BSON ↔ JSON round-trips dropping fields.
+    const pageEventPublisher = {
+        async publish(eventName, payload) {
+            try {
+                const Page = crowi.model('Page');
+                const User = crowi.model('User');
+                // `revision` MUST be populated: `Page.updatePage` / `pushRevision`
+                // emit the event with `revision` as the full Revision document,
+                // and listeners rely on it — `events/page.ts` reads
+                // `revision.body` to build backlinks, `mention-dispatch` reads
+                // `revision.meta`. A bare ObjectId here makes those silently
+                // no-op (the backlink builder throws "no revision/body" and the
+                // error is swallowed at debug level).
+                const [pageDoc, userDoc] = await Promise.all([Page.findById(payload.pageId).populate('revision').exec(), User.findById(payload.userId).exec()]);
+                if (!pageDoc) {
+                    debug('pageEventPublisher: page %s not found, skipping emit', payload.pageId);
+                    return;
+                }
+                // Same wire shape as `Page.updatePage` / `Page.createPage` so
+                // api-side listeners (events/page.ts, events/render-cache.ts,
+                // events/mention-dispatch.ts) don't need a collab-specific
+                // branch. The 4th arg flags "a new revision was created": a collab
+                // save always pushes a new revision (save-flow Step 2), so
+                // forward `true` for 'update' so events/page.ts fans out an UPDATE
+                // notification on the realtime path too.
+                crowi.event('Page').emit(eventName, pageDoc, userDoc, payload.bookmarkCount ?? 0, eventName === 'update');
+                debug('pageEventPublisher: emitted %s for page %s', eventName, payload.pageId);
+            }
+            catch (err) {
+                // Save already committed — fan-out is best-effort.
+                console.warn(`[crowi:collab] pageEventPublisher.publish failed for page ${payload.pageId}:`, err.message);
+            }
+        },
+    };
+    // Phase 6 cap peek used by `on-authenticate`. The collab hook OR's
+    // this peek result with the token's readonly bit, so a Redis-reported
+    // cap-reached reading downgrades the connection to readonly even
+    // when the token was minted editable. Same `peek` implementation
+    // the wsToken endpoint uses → no drift between sign-time and
+    // connect-time cap state.
+    const checkEditorCap = async (pageId) => {
+        const { count, cap } = await editorCapCounter.peek(pageId);
+        return { readonly: count >= cap };
+    };
+    // Phase 9 — when this api process has a Redis client wired
+    // (`REDIS_URL` set), attach `@hocuspocus/extension-redis` so cross-
+    // instance Y.Doc updates + awareness fan out via Redis pub/sub.
+    // When `crowi.redis === null` (single-instance dev) the extensions
+    // array stays empty and Hocuspocus runs in standalone mode — same
+    // shape as Phase 8.5 landed.
+    //
+    // The extension creates its own ioredis clients (pub + sub) via the
+    // `createClient` callback we provide; api's existing node-redis v4
+    // client is not shared (the two libraries have incompatible APIs).
+    const extensions = [];
+    const redisExtension = (0, extension_redis_1.buildCollabRedisExtension)(crowi);
+    if (redisExtension !== null) {
+        extensions.push(redisExtension);
+    }
+    // Lazy `require()` so Jest never tries to parse `crossws`'s ESM
+    // bundle during test collection (the api boot graph reaches this
+    // file via `src/crowi/index.ts` even when tests don't actually
+    // call `start()`). The collab dist is plain CJS so the require
+    // resolves cleanly under both jest and the dev runner.
+    //
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const collab = require('@crowi/collab');
+    // RFC-0005 — the api-side presence adapter so a collab connect /
+    // disconnect records a short-lived editing signal (the `✏️` badge).
+    // `@crowi/collab` is crowi-agnostic; this adapter resolves the
+    // process-shared presence service lazily and swallows failures. It
+    // also owns a periodic refresher whose timer must be stopped on
+    // shutdown — hence the handle is kept (see `shutdown()` below).
+    const presenceDeps = (0, presence_1.createPresenceCollabDeps)(crowi);
+    const hocuspocus = collab.createCollabServer({
+        models,
+        wsTokenUtil,
+        debounce: DEFAULT_DEBOUNCE_MS,
+        maxDebounce: DEFAULT_MAX_DEBOUNCE_MS,
+        checkEditorCap,
+        editorCapCounter,
+        pageEventPublisher,
+        extensions,
+        presence: presenceDeps,
+    });
+    // `noServer: true` — the upgrade handshake is owned by the api
+    // process; we forward only `/collab/*` upgrades into Hocuspocus.
+    const wss = new ws_1.WebSocketServer({ noServer: true });
+    // Track sockets so `shutdown` can terminate any still-open
+    // connections without waiting for them to drain (test harnesses
+    // / abnormal client behaviour leave sockets in CLOSE_WAIT
+    // otherwise, and `server.close()` would hang).
+    const liveSockets = new Set();
+    /**
+     * Wire one `ws.WebSocket` to its Hocuspocus `ClientConnection`.
+     * Hocuspocus delivers events into the connection via
+     * `handleMessage` / `handleClose` — when running through the
+     * `Server` wrapper (crossws) it's done by the adapter; here we do
+     * it manually so the dependency on `ws` stays narrow.
+     *
+     * Buffer → Uint8Array: the default `binaryType` for the `ws`
+     * server is `nodebuffer`, and Hocuspocus expects `Uint8Array` in
+     * `handleMessage`. `Buffer` inherits from `Uint8Array` so a
+     * direct pass-through is structurally valid, but we coerce
+     * explicitly so a future `binaryType` flip stays safe.
+     */
+    const wireConnection = (ws, request) => {
+        liveSockets.add(ws);
+        const clientConnection = hocuspocus.handleConnection(ws, request);
+        ws.on('message', (data) => {
+            // `ws` default `binaryType: 'nodebuffer'` → Buffer (extends
+            // Uint8Array, structurally compatible with Hocuspocus). The
+            // ArrayBuffer branch covers `binaryType: 'arraybuffer'` if it
+            // ever flips. We don't request `'fragments'` mode, so the
+            // `Buffer[]` shape never reaches us.
+            const view = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+            clientConnection.handleMessage(view);
+        });
+        ws.on('close', (code, reason) => {
+            liveSockets.delete(ws);
+            clientConnection.handleClose({ code, reason: reason?.toString?.() ?? '' });
+        });
+        ws.on('error', (err) => {
+            // Don't crash the api process on a single bad socket. Mirror
+            // Hocuspocus's upstream Server behaviour (`console.error` +
+            // continue).
+            console.error('[crowi:collab] websocket error', err);
+        });
+    };
+    /**
+     * `'upgrade'` event handler. Path filter the request first so
+     * sibling upgrade handlers (none today, but planned: socket.io for
+     * notifications) keep their slots. `socket.destroy()` is **not**
+     * called on a no-match — letting Node.js move on to the next
+     * registered listener is the documented behaviour for cooperating
+     * upgrade handlers.
+     */
+    const upgradeHandler = (request, socket, head) => {
+        // HTTP request lines look like `/path?query` — strip at the
+        // first `?` to get the pathname. A full WHATWG URL parse here
+        // would allocate on every upgrade for no extra correctness.
+        const rawUrl = request.url ?? '';
+        const queryIdx = rawUrl.indexOf('?');
+        const pathname = queryIdx < 0 ? rawUrl : rawUrl.slice(0, queryIdx);
+        // Accept the bare path (`/collab`, what HocuspocusProvider hits
+        // today) and the namespaced path (`/collab/anything`) — leaves
+        // room for a future variant that includes the document name in
+        // the URL without forcing a server-side migration.
+        if (pathname !== COLLAB_PATH && !pathname.startsWith(`${COLLAB_PATH}/`)) {
+            // Not ours — let other handlers attempt the upgrade.
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wireConnection(ws, request);
+        });
+    };
+    httpServer.on('upgrade', upgradeHandler);
+    debug('collab attached to http.Server (path=%s)', COLLAB_PATH);
+    let didShutdown = false;
+    return {
+        async shutdown() {
+            // Re-entry from a second SIGINT (operator impatient with Ctrl-C)
+            // or from app.ts orchestration. The first call owns the teardown.
+            if (didShutdown)
+                return;
+            didShutdown = true;
+            // 1. Refuse new connections first so the rest of the sequence
+            //    operates on a closed front door — no `'upgrade'` event can
+            //    add to `liveSockets` while we drain.
+            try {
+                httpServer.off('upgrade', upgradeHandler);
+            }
+            catch {
+                // best-effort — the api may already be tearing the server down
+            }
+            // 2. Ask Hocuspocus to close connections politely. Clients see
+            //    a normal close frame and can flush their last `update`
+            //    message to the server before they disconnect — which the
+            //    next step then persists.
+            try {
+                hocuspocus.closeConnections();
+            }
+            catch (err) {
+                console.error('[crowi:collab] closeConnections failed during shutdown:', err);
+            }
+            // 3. Brief drain window so any in-flight client `update` frames
+            //    actually deliver before we terminate sockets. Cheap insurance
+            //    against the "SIGINT mid-edit" data-loss window.
+            if (liveSockets.size > 0) {
+                await new Promise((resolveDrain) => setTimeout(resolveDrain, SHUTDOWN_DRAIN_MS));
+            }
+            // 4. Flush any in-flight `onStoreDocument` debounces now that
+            //    sockets have had a chance to deliver their final updates.
+            //    The next-after-debounce `onStoreDocument` actually runs
+            //    before we drop references to the Y.Docs.
+            try {
+                hocuspocus.flushPendingStores();
+            }
+            catch (err) {
+                console.error('[crowi:collab] flushPendingStores failed during shutdown:', err);
+            }
+            // 5. Force-terminate any straggler sockets. Required because
+            //    `wss.close()` waits for normal close handshakes otherwise,
+            //    which can hang on abnormal teardown (test harness with a
+            //    dropped client, mis-behaving browser).
+            try {
+                for (const ws of liveSockets) {
+                    try {
+                        ws.terminate();
+                    }
+                    catch {
+                        // ignore — best-effort
+                    }
+                }
+                liveSockets.clear();
+                wss.close();
+            }
+            catch (err) {
+                console.error('[crowi:collab] wss.close failed during shutdown:', err);
+            }
+            // 5b. Stop the RFC-0005 presence editing-hash refresher so its
+            //     `setInterval` does not outlive the collab engine. The
+            //     timer is already `.unref()`-d (it never blocks process
+            //     exit), but a test harness that calls `shutdown()` and
+            //     keeps the process alive would otherwise see it tick on.
+            try {
+                presenceDeps.shutdown();
+            }
+            catch (err) {
+                console.error('[crowi:collab] presence refresher shutdown failed:', err);
+            }
+            // 6. Disconnect the cap counter last. With a shared `crowi.redis`
+            //    this is a documented no-op, but we still await it so a
+            //    future per-counter client doesn't silently regress this
+            //    ordering.
+            //
+            // Note (Phase 9): registered Hocuspocus extensions
+            // (`@hocuspocus/extension-redis`) define `onDestroy` lifecycle
+            // hooks, but the pure `Hocuspocus` engine we use here doesn't
+            // expose a `destroy()` method — only the wrapping `Server`
+            // class (= the crossws adapter we replaced with our own ws
+            // attach) calls extension `onDestroy`. The extension's pub +
+            // sub ioredis clients therefore live until process exit,
+            // which the OS reaps along with everything else. Test
+            // harnesses that call `shutdown()` and keep the process alive
+            // are the only ones that observe the leak; jest exits its
+            // worker after the suite anyway, so this is acceptable.
+            try {
+                await editorCapCounter.disconnect();
+            }
+            catch (err) {
+                console.error('[crowi:collab] editorCapCounter.disconnect failed during shutdown:', err);
+            }
+        },
+    };
+}
+//# sourceMappingURL=attach.js.map

package/dist/collab/attach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach.js","sourceRoot":"","sources":["../../src/collab/attach.ts"],"names":[],"mappings":"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"}

package/dist/collab/extension-redis.d.ts

@@ -0,0 +1,25 @@
+import type { Extension } from '@hocuspocus/server';
+import type Crowi from '../crowi';
+/**
+ * Build the `@hocuspocus/extension-redis` instance the api injects into
+ * `createCollabServer` for cross-instance pub/sub of Y.Doc updates +
+ * awareness state. Returns `null` when this api process is not wired
+ * to Redis (`crowi.redis === null` ⇔ `REDIS_URL` unset) — single-
+ * instance dev keeps working unchanged.
+ *
+ * Design (Phase 9):
+ * - api uses node-redis v4 (`crowi.redis`); the extension expects
+ *   ioredis. The two clients can't be shared, so the extension creates
+ *   its own pub + sub ioredis clients via the `createClient` callback
+ *   we hand it. `crowi.redisUrl` is parsed into the host/port/auth/tls
+ *   shape ioredis accepts.
+ * - `identifier` is `process.env.HOSTNAME ?? crowi-<pid>`. In docker /
+ *   k8s `HOSTNAME` is set to the container / pod name automatically,
+ *   which is the right cross-instance discriminator; bare-metal dev
+ *   falls back to the pid.
+ * - When `REDIS_URL` is set but `crowi.redis === null` (boot warned
+ *   that Redis is unreachable), we still skip the extension —
+ *   `crowi.redis` is the single source of truth for "Redis is
+ *   actually usable from this process".
+ */
+export declare function buildCollabRedisExtension(crowi: Crowi): Extension | null;

package/dist/collab/extension-redis.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCollabRedisExtension = buildCollabRedisExtension;
+const node_url_1 = __importDefault(require("node:url"));
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('crowi:collab:extension-redis');
+/**
+ * Namespace for the Redis keys + pub/sub channels owned by
+ * `@hocuspocus/extension-redis`. The extension's own prefix is
+ * concatenated with sub-keys like `:awareness:<docname>` / `:y-update:<docname>`,
+ * so this prefix is **disjoint** from the Phase 6 editor cap
+ * counter's keyspace (`crowi:collab:editors:<pageId>` — `editors`
+ * segment is the discriminator). Documenting the carve-up here so a
+ * future operator-side prefix override doesn't accidentally collide.
+ */
+const COLLAB_REDIS_PREFIX = 'crowi:collab';
+/**
+ * Build the `@hocuspocus/extension-redis` instance the api injects into
+ * `createCollabServer` for cross-instance pub/sub of Y.Doc updates +
+ * awareness state. Returns `null` when this api process is not wired
+ * to Redis (`crowi.redis === null` ⇔ `REDIS_URL` unset) — single-
+ * instance dev keeps working unchanged.
+ *
+ * Design (Phase 9):
+ * - api uses node-redis v4 (`crowi.redis`); the extension expects
+ *   ioredis. The two clients can't be shared, so the extension creates
+ *   its own pub + sub ioredis clients via the `createClient` callback
+ *   we hand it. `crowi.redisUrl` is parsed into the host/port/auth/tls
+ *   shape ioredis accepts.
+ * - `identifier` is `process.env.HOSTNAME ?? crowi-<pid>`. In docker /
+ *   k8s `HOSTNAME` is set to the container / pod name automatically,
+ *   which is the right cross-instance discriminator; bare-metal dev
+ *   falls back to the pid.
+ * - When `REDIS_URL` is set but `crowi.redis === null` (boot warned
+ *   that Redis is unreachable), we still skip the extension —
+ *   `crowi.redis` is the single source of truth for "Redis is
+ *   actually usable from this process".
+ */
+function buildCollabRedisExtension(crowi) {
+    // `crowi.redis` is the api's node-redis client; null when REDIS_URL
+    // is unset OR when the boot-time connection failed. Either way we
+    // can't safely run the extension here — fall back to single-instance
+    // mode and let the operator notice the boot-time Redis warning.
+    if (crowi.redis === null) {
+        debug('skip extension-redis: crowi.redis is null (single-instance mode)');
+        return null;
+    }
+    if (!crowi.redisUrl) {
+        // Defensive: `crowi.redis` non-null without `redisUrl` should be
+        // unreachable today, but guard so a future refactor that injects
+        // a client without an URL doesn't silently mint an extension with
+        // no connection target. `debug` instead of `console.warn` because
+        // this only fires on bug, not on operator misconfiguration.
+        debug('skip extension-redis: crowi.redis set but redisUrl missing (likely a refactor regression)');
+        return null;
+    }
+    // Always include `pid` so two api processes on the same host (= same
+    // `HOSTNAME`, common in systemd / bare-metal multi-worker setups)
+    // don't dedupe their extension-redis broadcasts under the same
+    // identifier. In docker / k8s the `HOSTNAME` part is the container
+    // / pod id and pid is typically `1`, but the suffix keeps the shape
+    // consistent across runtimes.
+    const identifier = `${process.env.HOSTNAME ?? 'crowi'}-${process.pid}`;
+    const ioredisOptions = parseRedisUrlForIoredis(crowi.redisUrl);
+    // Lazy `require()` so this module's TS surface doesn't pull
+    // `@hocuspocus/extension-redis` into Jest's CJS loader at test
+    // collect time (the package's transitive dep graph is fine, but
+    // keeping the require local matches the pattern used for
+    // `@crowi/collab` in `attach.ts`). `ioredis` is loaded the same way
+    // — we don't import it statically because it's a transitive dep of
+    // the extension (no @types/ioredis needed in api's package.json).
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { Redis: RedisExtension } = require('@hocuspocus/extension-redis');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-explicit-any
+    const IORedisModule = require('ioredis');
+    // ioredis exports both CJS (default) and ESM (named) shapes; pick
+    // whichever the loader handed us.
+    const IORedisCtor = IORedisModule.default ?? IORedisModule.Redis ?? IORedisModule;
+    debug('attaching extension-redis (identifier=%s, prefix=%s)', identifier, COLLAB_REDIS_PREFIX);
+    return new RedisExtension({
+        identifier,
+        prefix: COLLAB_REDIS_PREFIX,
+        // The extension wants two long-lived ioredis connections (one for
+        // PUB, one for SUB). The `createClient` callback is invoked twice
+        // internally and we hand back a fresh ioredis client each time
+        // pointing at the same Redis as `crowi.redis`.
+        //
+        // `lazyConnect: true` defers the TCP `connect()` until the
+        // extension actually uses the client — without this, a slow /
+        // misconfigured Redis would hang the api's `start()` (which
+        // awaits `attachCollabServer`) indefinitely while ioredis retries
+        // the initial socket. `connectTimeout: 10000` puts a hard ceiling
+        // on individual connection attempts so a permanent outage surfaces
+        // as a logged error instead of a silent stall.
+        //
+        // Cast on return because we intentionally don't drag ioredis
+        // types into api's surface; `RedisInstance` (the extension's own
+        // type) is structurally compatible.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        createClient: () => new IORedisCtor({ ...ioredisOptions, lazyConnect: true, connectTimeout: 10_000 }),
+    });
+}
+/**
+ * Parse a `redis://` / `rediss://` URL into the option shape ioredis
+ * accepts via its constructor.  Mirrors the field-level translation
+ * `src/util/redis-opts.ts` does for node-redis v4, with ioredis-native
+ * keys: `host`, `port`, `username`, `password`, `tls`. ioredis also
+ * accepts a URL string directly but going through this parse lets us
+ * apply the same `REDIS_REJECT_UNAUTHORIZED` env override the api's
+ * primary client respects.
+ */
+function parseRedisUrlForIoredis(redisUrl) {
+    const { hostname, port, auth, protocol } = node_url_1.default.parse(redisUrl);
+    const host = hostname ?? '127.0.0.1';
+    const portNumber = port ? Number.parseInt(port, 10) : 6379;
+    const opts = { host, port: portNumber };
+    if (auth) {
+        const [user, pass] = auth.split(':');
+        if (user)
+            opts.username = decodeURIComponent(user);
+        if (pass !== undefined)
+            opts.password = decodeURIComponent(pass);
+    }
+    if (protocol === 'rediss:') {
+        const rejectUnauthorized = process.env.REDIS_REJECT_UNAUTHORIZED !== '0';
+        opts.tls = { rejectUnauthorized };
+    }
+    return opts;
+}
+//# sourceMappingURL=extension-redis.js.map