@crowi/api 2.0.0-alpha.0

package/dist/crowi/index.js

@@ -0,0 +1,726 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_server_1 = require("@hono/node-server");
+const csrf_1 = __importDefault(require("csrf"));
+const debug_1 = __importDefault(require("debug"));
+const http_1 = __importDefault(require("http"));
+const mongoose_1 = __importDefault(require("mongoose"));
+const path_1 = __importStar(require("path"));
+const redis_1 = require("redis");
+const attach_1 = require("../collab/attach");
+const events_1 = __importDefault(require("../events"));
+const mention_dispatch_1 = require("../events/mention-dispatch");
+const render_cache_1 = require("../events/render-cache");
+const hono_1 = require("../hono");
+const path_rewrite_1 = require("../hono/path-rewrite");
+const models_1 = __importDefault(require("../models"));
+const attach_2 = require("../notifications/attach");
+const plugin_1 = require("../plugin");
+const attach_3 = require("../presence/attach");
+const renderer_1 = require("../renderer");
+const mail_1 = require("../service/mail");
+const crypto_1 = require("../util/crypto");
+const oauth_client_seed_1 = require("../util/oauth-client-seed");
+const run_boot_migrations_1 = require("../migration/run-boot-migrations");
+const boot_reporter_1 = require("../util/boot-reporter");
+const redis_opts_1 = require("../util/redis-opts");
+const config_1 = __importDefault(require("../service/config"));
+const lru_1 = __importDefault(require("../service/lru"));
+const pkg = require('../../package.json');
+const debug = (0, debug_1.default)('crowi:crowi');
+const bootDebug = (0, debug_1.default)('crowi:boot');
+/**
+ * Emit a `crowi:boot` log after each init phase so we can tell which step
+ * dominates a slow dev startup. Per-phase duration is read off `debug`'s
+ * built-in `+Xms` (gap to the previous log on the same namespace); we
+ * only need to name the phase here.
+ */
+async function step(name, fn) {
+    const result = await fn();
+    bootDebug(name);
+    return result;
+}
+class Crowi {
+    version;
+    rootDir;
+    pluginDir;
+    publicDir;
+    resourceDir;
+    tmpDir;
+    cacheDir;
+    mongoose = null;
+    // FIXME after service/config typed
+    config;
+    mailer = null;
+    lru = {};
+    tokens;
+    // FIXME: {} をアサインしないで済む方法を捜す
+    models = {};
+    events = {};
+    env;
+    baseUrl = null;
+    node_env;
+    port;
+    redis = null;
+    redisUrl;
+    redisOpts;
+    /**
+     * PluginManager + resolved registries. Available after `setupPlugins`
+     * runs in `init()`. `null` until then so a half-booted process is
+     * obvious in stack traces.
+     */
+    pluginManager = null;
+    pluginRegistries = null;
+    /**
+     * Markdown renderer pipeline + registry. Available after
+     * `setupRenderer` runs in `init()` (between `setupModels` and
+     * `setupPlugins` — so PluginManager can layer external plugins on
+     * top of the core registrations).
+     */
+    renderer = null;
+    /**
+     * Hocuspocus engine attach handle (RFC-0003 Phase 9 same-process).
+     * Built lazily in `start()` after the http.Server is listening so
+     * the `'upgrade'` event can be wired before any client connects.
+     * `null` outside of the running server (= `init()` finished but
+     * `start()` hasn't run yet, or after `shutdown()`).
+     */
+    collabAttachment = null;
+    /**
+     * Presence WebSocket attach handle (RFC-0005). Built in `start()`
+     * alongside `collabAttachment`; wires the `/presence` ws noServer
+     * handler so page viewers get the live-presence row. `null` outside
+     * of the running server.
+     */
+    presenceAttachment = null;
+    /**
+     * Notifications realtime invalidation WebSocket attach handle. Built
+     * in `start()` next to `collabAttachment` / `presenceAttachment`;
+     * wires the `/notifications/<userId>` ws noServer handler so the
+     * NotificationBell can drop its 30-second polling loop in favour of
+     * Redis-pub/sub-driven invalidation. `null` outside of the running
+     * server.
+     */
+    notificationsAttachment = null;
+    /**
+     * Docker-style boot progress reporter (feature-boot-progress-ui). Spans
+     * `init()` (core/config/services layers) and `start()` (server layer), so it
+     * lives on the instance rather than a local. `null` for the CLI lightweight
+     * init (`initForCli`) which keeps the legacy quiet UX.
+     */
+    bootReporter = null;
+    initialized = false;
+    /**
+     * In-flight fire-and-forget side effects (EventEmitter listeners +
+     * Mongoose `post('save')` hooks that start an un-awaited DB/redis write).
+     * `trackSideEffect` adds the promise here and removes it on settle;
+     * `drainSideEffects` awaits the set until it is empty.
+     *
+     * Production never calls `drainSideEffects`, so tracking is the only
+     * runtime cost on the request path (a Set add/delete per side effect) and
+     * the drain primitive is a no-op there. The test harness drains before
+     * disconnecting Mongo so settling writes do not race the close.
+     */
+    inFlightSideEffects = new Set();
+    constructor(rootdir, env) {
+        this.version = pkg.version;
+        this.env = env;
+        this.baseUrl = this.env.BASE_URL || null;
+        this.node_env = this.env.NODE_ENV || 'production';
+        this.port = this.env.PORT ? Number.parseInt(this.env.PORT) : 4301;
+        // Remove REDISTOGO_URL in the near future.
+        this.redisUrl = this.env.REDISTOGO_URL || this.env.REDIS_TLS_URL || this.env.REDIS_URL || null;
+        const redisRejectUnauthorized = this.env.REDIS_REJECT_UNAUTHORIZED !== '0';
+        this.redisOpts = this.buildRedisOpts(this.redisUrl, redisRejectUnauthorized);
+        this.rootDir = rootdir;
+        this.pluginDir = path_1.default.join(this.rootDir, 'node_modules') + path_1.sep;
+        this.publicDir = path_1.default.join(this.rootDir, 'public') + path_1.sep;
+        this.resourceDir = path_1.default.join(this.rootDir, 'resource') + path_1.sep;
+        this.tmpDir = path_1.default.join(this.rootDir, 'tmp') + path_1.sep;
+        this.cacheDir = path_1.default.join(this.tmpDir, 'cache');
+        this.setupEvents();
+        this.tokens = new csrf_1.default();
+    }
+    async init() {
+        const initStart = Date.now();
+        // Baseline log so the first phase's `+Xms` measures its own duration
+        // rather than reading +0ms (debug's default when there's no prior log
+        // on the namespace).
+        bootDebug('init start');
+        // Boot progress reporter — owns stdout (debug-independent) so operators
+        // see layered spinner/✓ progress without `DEBUG=crowi:*`. Degrades to
+        // structured plain lines on non-TTY (prod / `| cat`) or when DEBUG is set.
+        // Silenced under jest: each of the 100+ test files boots Crowi, so the
+        // per-layer `[boot] … ok` lines would otherwise flood the test output.
+        const reporter = (0, boot_reporter_1.createBootReporter)({ quiet: Boolean(process.env.JEST_WORKER_ID) });
+        this.bootReporter = reporter;
+        // A step throwing (DB/Redis down is the common dev case) rejects out of
+        // init(); without this guard the spinner interval keeps redrawing the same
+        // line — overwriting the fatal stack `exitOnError` prints — and the hidden
+        // cursor never comes back. Stop the spinner before the rejection
+        // propagates. `dispose()` is idempotent, so `exitOnError` calling it again
+        // is harmless.
+        try {
+            await this.runInitLayers(reporter);
+        }
+        catch (err) {
+            reporter.dispose();
+            throw err;
+        }
+        bootDebug(`init complete in ${Date.now() - initStart}ms`);
+        this.initialized = true;
+    }
+    async runInitLayers(reporter) {
+        // ── core: encryption / database / models / redis ──
+        reporter.beginLayer('core');
+        await step('setupEncryption', () => this.setupEncryption());
+        await step('setupDatabase', () => this.setupDatabase());
+        await step('setupModels', () => this.setupModels());
+        await step('setupRedisClient', () => this.setupRedisClient());
+        reporter.endLayer();
+        // ── config: load / migrations / oauth seed ──
+        reporter.beginLayer('config');
+        await step('setupConfig', () => this.setupConfig());
+        // RFC-0008: the migration framework's boot step. Applies any pending
+        // `layer:'boot'` migrations (currently `page-status-default`, the
+        // RFC-0004 backfill that stamps `status='published'` onto legacy pages
+        // predating the `Page.status` field — see
+        // `migration/migrations/page-status-default.ts`) and probes
+        // `layer:'preflight'` migrations, refusing boot when any is unapplied
+        // under the default `block` policy (§4.2.1/§4.2.7). `broadcastForceReload`
+        // is intentionally omitted here: the live Hocuspocus handle is attached
+        // later in `start()`, after init, so boot migrations rely on
+        // persistence-layer Yjs invalidation only.
+        await step('runBootMigrations', () => (0, run_boot_migrations_1.runBootMigrations)(this));
+        // RFC-0010 Phase 3: seed the first-party `crowi-cli` OAuth client.
+        // Idempotent upsert (`$setOnInsert`) — runs after setupModels so the
+        // OAuthClient model is registered; disjoint from the migrations above.
+        await step('seedOAuthClients', () => (0, oauth_client_seed_1.runOAuthClientSeed)(this));
+        reporter.endLayer();
+        // ── services: renderer / plugins / mailer / lru ──
+        reporter.beginLayer('services');
+        // Renderer must boot BEFORE plugins so PluginManager.activate()
+        // can hand plugins a registry that already has the core 4
+        // transforms (TOC / wikilinks / mentions / codeBlockLanguages)
+        // registered. External plugins append; they cannot insert before
+        // core in v2.1 phase 2.
+        await step('setupRenderer', () => this.setupRenderer());
+        // RFC-0003 Phase 9 (same-process attach): the cross-process
+        // pageEvent subscriber that used to fan collab saves into the
+        // api event loop is gone — the embedded Hocuspocus engine (see
+        // `src/collab/attach.ts`) calls `crowi.event('Page').emit(...)`
+        // directly after a save flow completes.
+        // Plugins must boot AFTER config/models are ready (so PluginContext
+        // can read config and access models) but BEFORE the legacy
+        // mailer initialiser — that is migrating to plugin-provided drivers
+        // and any conflict should fail noisily here.
+        await step('setupPlugins', () => this.setupPlugins());
+        await step('setupMailer', () => this.setupMailer());
+        await step('setupLRU', () => this.setupLRU());
+        reporter.endLayer();
+    }
+    /**
+     * Lightweight init for the `@crowi/admin-cli` operator CLI. Brings up
+     * just what's needed to read Config + reach storage drivers — Redis
+     * / mailer / search / LRU / the boot-time AWS migration are
+     * all skipped (the migration belongs to `init()` so the long-running
+     * server runs it once; the CLI shouldn't mutate Mongo as a side
+     * effect of starting up).
+     *
+     * `setupConfig` works without Redis because `service/config.ts:setupPubSub`
+     * short-circuits when `redisOpts === null`.
+     *
+     * The CLI follows up with `teardownForCli()` to disconnect Mongo so
+     * the Node process exits cleanly.
+     */
+    async initForCli() {
+        this.setupEncryption();
+        await this.setupDatabase();
+        await this.setupModels();
+        await this.setupConfig();
+        // Skip the page-save side-effect listeners (mention dispatch / render-cache
+        // invalidation): a migration's `updatePage` writes must not @-ping users or
+        // race the teardown connection close — see `setupRenderer`.
+        this.setupRenderer({ registerPageEventListeners: false });
+        await this.setupPlugins();
+        this.initialized = true;
+    }
+    /**
+     * Reverse of `initForCli`. Closes any connection the CLI helper opened
+     * so the Node process exits without dangling handles. Defensive about
+     * Redis (we never opened it in CLI mode, but a future helper might).
+     */
+    async teardownForCli() {
+        if (this.redis) {
+            try {
+                await this.redis.quit();
+            }
+            catch {
+                // best-effort — process is exiting anyway
+            }
+            this.redis = null;
+        }
+        if (this.mongoose) {
+            await this.mongoose.disconnect();
+            this.mongoose = null;
+        }
+    }
+    /**
+     * Track a fire-and-forget side effect so the test harness can drain it
+     * before tearing the connection down. The promise is removed from the
+     * in-flight set once it settles (resolve OR reject); we deliberately do
+     * NOT re-throw or alter the rejection — the caller keeps its own
+     * `.catch` and error-swallowing posture unchanged. This is purely
+     * drain bookkeeping.
+     *
+     * INVARIANT: a tracked side effect MUST be a finite chain. Never track
+     * work that re-schedules itself (recurring / periodic timers, retry
+     * loops with no terminal condition) — `drainSideEffects()` loops until
+     * the set empties, so a self-rescheduling effect makes the drain
+     * (`afterEach` + the test response barrier in `test/setup.ts`) never
+     * settle, and every HTTP test then hangs until jest's `testTimeout`.
+     * Multi-level fan-out is fine (each level settles); unbounded
+     * re-arming is not.
+     */
+    trackSideEffect(p) {
+        this.inFlightSideEffects.add(p);
+        p.finally(() => {
+            this.inFlightSideEffects.delete(p);
+        });
+    }
+    /**
+     * Wait until every tracked side effect has settled. Loops because a
+     * side effect can spawn a second-level fire-and-forget while draining
+     * (Activity `post('save')` → Notification fan-out; `userEvent`
+     * 'activated' → user-page creation → page events → backlink/watch/
+     * mention), and those are tracked too. Resolves once the set is empty.
+     *
+     * Production never calls this — it is the test-teardown drain hook.
+     */
+    async drainSideEffects() {
+        while (this.inFlightSideEffects.size > 0) {
+            await Promise.allSettled([...this.inFlightSideEffects]);
+        }
+    }
+    setupRenderer(options = {}) {
+        this.renderer = (0, renderer_1.createRenderer)(this);
+        // The page-save side-effect listeners below are skipped in CLI mode
+        // (`initForCli`): a bulk migration that rewrites page bodies via
+        // `updatePage` would otherwise fire mention notifications (wrong — nobody
+        // should be @-pinged by a syntax migration) and per-page render-cache
+        // invalidation (pointless in a one-shot process — and it races the CLI's
+        // `teardownForCli` connection close, logging spurious "client was closed"
+        // warnings). Deliberate cache rebuilds use `crowi-admin rebuild renderer`.
+        if (options.registerPageEventListeners ?? true) {
+            // Register cache invalidation listeners on pageEvent. Needs to
+            // happen here (not in setupEvents) because the listener captures
+            // the renderer.cache handle constructed one line above.
+            (0, render_cache_1.registerRenderCacheInvalidation)(this);
+            // RFC-0002 Phase 8: dispatch `@username` mention notifications on
+            // page save. Wired here (not in `setupEvents`) because the dispatcher
+            // reads `Revision.meta.mentions[]` produced by the renderer pipeline,
+            // so it must register after `setupRenderer` has run.
+            (0, mention_dispatch_1.registerMentionDispatch)(this);
+        }
+        // Eagerly initialise heavy ESM-only deps (jiti + shiki +
+        // remark-*). The first pipeline run otherwise pays ~200ms cold-
+        // load latency; we move that cost to boot time. Fire-and-forget —
+        // a warmup failure is logged inside `Renderer.warmup` and does
+        // not block boot.
+        if (this.renderer) {
+            void this.renderer.warmup();
+        }
+    }
+    /**
+     * Markdown renderer (parse → transform pipeline + extension registry).
+     * Throws if accessed before `setupRenderer` ran.
+     */
+    getRenderer() {
+        if (!this.renderer) {
+            throw new Error('Renderer has not been booted yet — call init() first.');
+        }
+        return this.renderer;
+    }
+    async setupPlugins() {
+        this.pluginManager = new plugin_1.PluginManager(this);
+        this.pluginRegistries = await this.pluginManager.bootstrap();
+        const loaded = this.pluginManager.getLoadedPlugins();
+        const summary = `[crowi] Loaded ${loaded.length} plugin(s): ${loaded.map((p) => `${p.name}@${p.version}`).join(', ')}`;
+        // Route through `bootNote` so the summary clears/re-draws the in-progress
+        // `services` spinner instead of corrupting it (plain console.log outside
+        // boot / in plain mode).
+        this.bootNote(() => console.log(summary));
+    }
+    /**
+     * Active storage / search / auth / notifier drivers resolved from
+     * `crowi.config.json`. Throws if accessed before `setupPlugins` ran.
+     */
+    getPlugins() {
+        if (!this.pluginRegistries) {
+            throw new Error('PluginManager has not been bootstrapped yet — call init() first.');
+        }
+        return this.pluginRegistries;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    isPageId(pageId) {
+        if (!pageId) {
+            return false;
+        }
+        if (typeof pageId === 'string' && pageId.match(/^[\da-f]{24}$/)) {
+            return true;
+        }
+    }
+    setConfig(config) {
+        this.config.update(config);
+    }
+    getConfig() {
+        return this.config.get();
+    }
+    getConfigService() {
+        return this.config;
+    }
+    /**
+     * The site's public origin (the web app), used to build absolute URLs
+     * in emails (invite / activation / reset / email-change links) and for
+     * CORS. Sourced solely from the `CLIENT_URL` env — no fallback.
+     *
+     * Deliberately NOT derived from the incoming request: trusting the
+     * Host / Origin header here would let an attacker poison reset /
+     * activation links in a victim's inbox (host-header injection). When
+     * `CLIENT_URL` is unset this returns `null` and mail links fall back to
+     * relative paths — `setupMailer` warns about that at boot.
+     */
+    getBaseUrl() {
+        return this.env.CLIENT_URL || null;
+    }
+    /**
+     * The address the api server itself is listening on (`this.port`, default
+     * 4301). Used for the boot reporter's `🚀 API ready` banner and the
+     * `@@crowi:ready api <url>` marker that `scripts/dev.mjs` keys on.
+     *
+     * Deliberately NOT `getBaseUrl()`: that is `CLIENT_URL` / `app:url`, the
+     * public site origin, which in dev is the web app on :4302 — using it here
+     * would mislabel the api as the web port.
+     */
+    getApiReadyUrl() {
+        return `http://localhost:${this.port}`;
+    }
+    /**
+     * Emit a boot-time line (warning / error / info such as the plugin summary)
+     * without corrupting the live progress spinner. When the reporter is active
+     * it clears the current spinner line, runs `write`, then re-draws; otherwise
+     * (no reporter / plain mode) it just runs `write`. Keeps the existing
+     * console.warn/error/log visibility intact (these are not gated on DEBUG).
+     */
+    bootNote(write) {
+        if (this.bootReporter) {
+            this.bootReporter.note(write);
+        }
+        else {
+            write();
+        }
+    }
+    getEnv() {
+        return this.env;
+    }
+    buildRedisOpts(redisUrl, redisRejectUnauthorized) {
+        // Thin wrapper kept for back-compat with existing `crowi.buildRedisOpts`
+        // callers; the actual translation lives in `util/redis-opts.ts` so
+        // the collab process can pull the same helper through `api-dist.ts`.
+        return (0, redis_opts_1.buildRedisOpts)(redisUrl, redisRejectUnauthorized);
+    }
+    // getter/setter of model instance
+    //
+    model(name, model) {
+        if (model) {
+            return (this.models[name] = model);
+        }
+        return this.models[name];
+    }
+    // getter/setter of event instance
+    event(name, event) {
+        if (event) {
+            return (this.events[name] = event);
+        }
+        return this.events[name];
+    }
+    /**
+     * Validate CROWI_ENCRYPTION_KEY at boot. When set, it must base64-decode to
+     * exactly 32 bytes (AES-256). When unset we log a warning and let Config
+     * fall back to plaintext at-rest storage — same behaviour as pre-encryption
+     * deployments — so a missing key never blocks boot.
+     */
+    setupEncryption() {
+        const raw = process.env.CROWI_ENCRYPTION_KEY;
+        if (!raw) {
+            // `note()` clears the live boot spinner before warning so the line
+            // isn't corrupted (no-op passthrough outside boot / in plain mode).
+            this.bootNote(() => {
+                console.warn('[crowi] CROWI_ENCRYPTION_KEY is not set — sensitive Config values will be stored as plaintext (legacy mode).');
+                console.warn('[crowi] Generate a 32-byte key with: openssl rand -base64 32');
+            });
+            return;
+        }
+        const buf = Buffer.from(raw, 'base64');
+        if (buf.length !== 32) {
+            throw new Error(`Invalid CROWI_ENCRYPTION_KEY: expected 32 bytes after base64 decode, got ${buf.length}. Generate one with \`openssl rand -base64 32\`.`);
+        }
+        // Drop any cached key from a previous init in long-lived test processes.
+        (0, crypto_1.resetKeyProvider)();
+        debug('CROWI_ENCRYPTION_KEY is configured (sensitive Config values will be encrypted at rest)');
+    }
+    async setupDatabase() {
+        // mongoUri = mongodb://user:password@host/dbname
+        mongoose_1.default.Promise = global.Promise;
+        // Set strictQuery to true for schema consistency and query safety
+        mongoose_1.default.set('strictQuery', true);
+        const mongoUri = this.env.MONGOLAB_URI || // for B.C.
+            this.env.MONGODB_URI || // MONGOLAB changes their env name
+            this.env.MONGOHQ_URL ||
+            this.env.MONGO_URI ||
+            'mongodb://localhost/crowi';
+        try {
+            // mongoose 7 removed the callback form of connect(); it is promise-only.
+            await mongoose_1.default.connect(mongoUri);
+            this.mongoose = mongoose_1.default;
+            return mongoose_1.default;
+        }
+        catch (e) {
+            debug('DB Connect Error: ', e);
+            debug('DB Connect Error: ', mongoUri);
+            // Fold the underlying driver message (ECONNREFUSED / auth / DNS) into
+            // the thrown error so the root cause is visible with DEBUG off — the
+            // raw `e` only ever reached the silenced debug line above. `cause`
+            // keeps the original error for anything that inspects it.
+            const err = e;
+            throw new Error(`Cannot connect to Database Server: ${err.message}`, { cause: e });
+        }
+    }
+    async setupRedisClient() {
+        if (this.redisOpts) {
+            try {
+                const redisClient = (0, redis_1.createClient)(this.redisOpts);
+                await redisClient.connect();
+                this.redis = redisClient;
+                debug('Redis client connected successfully');
+            }
+            catch (error) {
+                debug('Failed to connect to Redis:', error.message);
+                this.bootNote(() => console.warn('Redis connection failed. Continuing without Redis...'));
+                this.redis = null;
+            }
+        }
+    }
+    async setupModels() {
+        const keys = Object.keys(models_1.default);
+        keys.forEach((key) => {
+            this.model(key, models_1.default[key](this));
+        });
+    }
+    setupEvents() {
+        return Object.entries(events_1.default).forEach(([key, Event]) => {
+            this.event(key, new Event(this));
+        });
+    }
+    getMongo() {
+        return this.mongoose;
+    }
+    /**
+     * True when the Mongoose connection is in the `connected` state
+     * (`readyState === 1`). Used to guard fire-and-forget deferred writes:
+     * a side effect scheduled by a synchronous `emit()` / `post('save')`
+     * can fire after the harness has begun tearing the connection down
+     * (`connecting=2` / `disconnecting=3` / `disconnected=0`), at which
+     * point the write would throw a teardown-noise `MongoNotConnectedError`
+     * / `MongoPoolClosedError`. We skip the write instead. In normal
+     * operation `readyState === 1` always holds, so production behaviour is
+     * unchanged.
+     */
+    isMongoConnected() {
+        return this.mongoose?.connection?.readyState === 1;
+    }
+    getIo() {
+        // return this.io
+        return null;
+    }
+    /**
+     * Backwards-compat shim for legacy controllers that still reference
+     * `crowi.getSearcher()`. Returns the active search driver from the
+     * plugin registry, or `null` if none is configured / registered.
+     * New code should read `crowi.getPlugins().active.search` directly.
+     */
+    getSearcher() {
+        if (!this.pluginRegistries)
+            return null;
+        return this.pluginRegistries.active.search;
+    }
+    getMailer() {
+        if (!this.mailer) {
+            this.mailer = new mail_1.MailService(this);
+        }
+        return this.mailer;
+    }
+    async setupConfig() {
+        this.config = new config_1.default(this);
+        await this.config.setupPubSub();
+        return this.config.load();
+    }
+    setupMailer() {
+        // The MailService resolves the active sender lazily from the plugin
+        // registry on each send, so there is no transport state to build
+        // here — just construct the service. Kept as a boot step so the
+        // boot sequence reads uniformly and future eager checks have a home.
+        this.mailer = new mail_1.MailService(this);
+        // Absolute links in emails (invite / activation / reset /
+        // email-change) require a public origin. It comes solely from
+        // CLIENT_URL; without it links would be relative and unusable.
+        if (!this.getBaseUrl()) {
+            this.bootNote(() => console.warn('[crowi] CLIENT_URL is not set — links in outgoing emails (invite / activation / password reset / ' +
+                'email change) will be relative and will not work. Set CLIENT_URL to the web app origin ' +
+                '(e.g. https://wiki.example.com).'));
+        }
+    }
+    setupLRU() {
+        this.lru = new lru_1.default(this);
+    }
+    getTokens() {
+        return this.tokens;
+    }
+    start = async () => {
+        if (!this.initialized) {
+            throw new Error('Must call init() before start().');
+        }
+        // RFC-0006 Phase 6 Sub-batch D — Hono is the sole HTTP host.
+        //
+        // `buildHonoApp(crowi)` returns the `/api/v2/*` route surface.
+        // Routes are registered at their un-prefixed paths
+        // (`/app/info`, `/pages/:id`, ...) to keep the inferred AppType
+        // chain shallow for the `hc<AppType>` client; the `/api/v2`
+        // prefix is stripped by `stripApiV2Prefix` on the boundary so
+        // production URLs match.
+        //
+        // We use `createAdaptorServer` instead of `serve` so the
+        // WebSocket `'upgrade'` handlers (collab / presence) can be
+        // wired **before** `server.listen()` runs — the upstream
+        // `serve()` helper listens immediately, which would race the
+        // first WS client against the upgrade hook.
+        // The server layer spans build → attach (collab/presence/notifications) →
+        // listen. The reporter was created in `init()`; if `start()` is somehow
+        // called without it (defensive), make a fresh one so the banner/marker
+        // still emit.
+        const reporter = this.bootReporter ?? (0, boot_reporter_1.createBootReporter)({ quiet: Boolean(process.env.JEST_WORKER_ID) });
+        this.bootReporter = reporter;
+        reporter.beginLayer('server');
+        const honoApp = (0, hono_1.buildHonoApp)(this);
+        const fetchFn = (request) => honoApp.fetch((0, path_rewrite_1.stripApiV2Prefix)(request));
+        const server = (0, node_server_1.createAdaptorServer)({
+            fetch: fetchFn,
+            createServer: http_1.default.createServer,
+            port: this.port,
+        });
+        // RFC-0003 Phase 9 — attach Hocuspocus to the http.Server
+        // **before** `listen()` so the `'upgrade'` event handler is wired
+        // when the first WebSocket client races the listen callback. The
+        // attach is async because it builds the editor-cap counter
+        // (Redis SCARD round-trip when configured); we await it here so
+        // the boot sequence stays serial and `start()` resolves only
+        // when the api is fully ready to accept WebSocket upgrades.
+        this.collabAttachment = await (0, attach_1.attachCollabServer)(server, this);
+        // RFC-0005 — attach the `/presence` WebSocket alongside `/collab`.
+        // Same `noServer` pattern; both upgrade handlers path-filter so
+        // they coexist on the one http.Server listener.
+        this.presenceAttachment = await (0, attach_3.attachPresenceServer)(server, this);
+        // Notifications realtime invalidation — third `ws noServer`
+        // handler alongside collab + presence. Path-filters on
+        // `/notifications/*`, so it coexists with the other two on the
+        // same http.Server listener. Redis subscriber is built lazily
+        // inside; when `crowi.redis === null` the handler still attaches
+        // and accepts connections but no pub/sub fan-out runs.
+        this.notificationsAttachment = await (0, attach_2.attachNotificationsServer)(server, this);
+        // Promisify `server.listen` so `start()` resolves only after the
+        // socket is actually bound. Callers (the bin entry, smoke tests)
+        // can then `await crowi.start()` and assume the api accepts
+        // connections — without this the previous async chain returned
+        // before listen() finished its background bind.
+        await new Promise((resolveListen, rejectListen) => {
+            const onError = (err) => {
+                server.off('listening', onListening);
+                rejectListen(err);
+            };
+            const onListening = () => {
+                server.off('error', onError);
+                // Close the server layer (✓ + duration), then emit the human banner
+                // and the machine-readable readiness marker. The marker is the only
+                // contract `scripts/dev.mjs` depends on; it is emitted TTY or not.
+                reporter.endLayer();
+                reporter.finish('api', this.getApiReadyUrl());
+                resolveListen();
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen(this.port);
+        });
+        return server;
+    };
+    // Arrow property so `this` stays bound when passed as
+    // `.catch(crowi.exitOnError)` from `app.ts` (the bare method would lose
+    // `this` and the dispose() below would throw).
+    exitOnError = (err) => {
+        debug('Critical error occured.');
+        // Tear the boot reporter down *first*: stop the spinner interval and
+        // restore the cursor so the fatal stack trace below isn't overwritten /
+        // the terminal isn't left cursorless. Idempotent — the init()/start()
+        // try-path may already have disposed.
+        this.bootReporter?.dispose();
+        // Machine-readable failure marker (own stdout line, mirrors the readiness
+        // marker). `scripts/dev.mjs` watches for this to tear the whole dev tree
+        // (api · web · deps) down — otherwise `tsx watch` survives the crash and
+        // web keeps serving against a dead api. Harmless in prod (a grep-able line
+        // before exit). Reason is the first line of the error, length-capped.
+        const reason = (err instanceof Error ? err.message : String(err)).split('\n')[0].slice(0, 200);
+        process.stdout.write(`${(0, boot_reporter_1.formatFailMarker)('api', reason)}\n`);
+        console.error(err);
+        console.error(err.stack);
+        process.exit(1);
+    };
+}
+exports.default = Crowi;
+//# sourceMappingURL=index.js.map