@ramxvnn/bridge 0.1.0

package/runtime/core/redact.js

@@ -0,0 +1,76 @@
+/**
+ * Secret-safe logging.
+ *
+ * Two credentials pass through this process and neither may ever reach a log
+ * line, an error message, or a Telegram reply:
+ *
+ *   TELEGRAM_BOT_TOKEN      — appears in every Telegram API URL, so a naive
+ *                             `console.error(url)` leaks it
+ *   DISCORD_BOT_TOKEN       — sent as `Authorization: Bot <token>`
+ *   ZALO_OA_ACCESS_TOKEN    — sent as an `access_token` header
+ *   LINE_CHANNEL_ACCESS_TOKEN / LINE_CHANNEL_SECRET
+ *   RAMX_API_KEY            — sent as a Bearer header
+ *
+ * Rather than trusting every call site to remember, everything this runtime
+ * prints goes through `log()`, which scrubs both.
+ */
+/** Values registered here are scrubbed from anything this module prints. */
+const secrets = new Set();
+export function registerSecret(value) {
+    // Very short strings would scrub harmless text out of every message.
+    if (value && value.length >= 8)
+        secrets.add(value);
+}
+/** Only for tests that need a clean slate. */
+export function __resetSecrets() {
+    secrets.clear();
+}
+/**
+ * Replaces every registered secret, plus anything Telegram-token-shaped, with
+ * a placeholder. The shape rule matters because a token can appear in a URL
+ * this process never registered — a redirect, say, or a copy-pasted curl.
+ */
+export function redact(input) {
+    let text = typeof input === 'string'
+        ? input
+        : input instanceof Error
+            ? `${input.name}: ${input.message}`
+            : safeStringify(input);
+    for (const secret of secrets) {
+        text = text.split(secret).join('[REDACTED]');
+    }
+    // Telegram bot tokens look like 123456789:AAH... — scrub by shape too.
+    text = text.replace(/\b\d{6,12}:[A-Za-z0-9_-]{30,}\b/g, '[REDACTED]');
+    // Discord bot tokens are three dot-separated base64url segments.
+    text = text.replace(/\b[A-Za-z0-9_-]{24,28}\.[A-Za-z0-9_-]{6}\.[A-Za-z0-9_-]{27,}\b/g, '[REDACTED]');
+    // Discord sends them as `Authorization: Bot <token>`, which the Bearer rule below misses.
+    text = text.replace(/(Bot\s+)[A-Za-z0-9._-]{20,}/g, '$1[REDACTED]');
+    // Zalo OA passes the token in an `access_token` header or query parameter.
+    text = text.replace(/(access_token["'\s:=]+)[A-Za-z0-9._-]{20,}/gi, '$1[REDACTED]');
+    // RAM/X keys are prefixed; scrub anything key-shaped after the prefix.
+    text = text.replace(/\bramx_(live|test)_[A-Za-z0-9]{8,}\b/g, '[REDACTED]');
+    // A Bearer header that slipped into a serialized request.
+    text = text.replace(/(Bearer\s+)[A-Za-z0-9._~+/-]{8,}=*/gi, '$1[REDACTED]');
+    return text;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function log(level, message, context) {
+    const line = context
+        ? `${redact(message)} ${redact(context)}`
+        : redact(message);
+    const stamp = new Date().toISOString();
+    const out = `[${stamp}] [${level.toUpperCase()}] ${line}`;
+    if (level === 'error')
+        console.error(out);
+    else if (level === 'warn')
+        console.warn(out);
+    else
+        console.log(out);
+}

package/runtime/core/types.js

@@ -0,0 +1,25 @@
+/**
+ * The transport contract.
+ *
+ * Four platforms with genuinely different shapes have to fit through this:
+ *
+ *   Telegram       outbound pull   (long polling)
+ *   Discord        outbound push   (persistent WebSocket gateway)
+ *   Zalo OA        inbound push    (HTTP webhook)
+ *   LINE Official  inbound push    (HTTP webhook)
+ *
+ * The contract is deliberately tiny, because anything bigger would start
+ * encoding one platform's assumptions. In particular there is no
+ * `sendMessage(target, text)`: addressing a reply differs too much between
+ * platforms — a Telegram chat id, a Discord channel id, a LINE `replyToken`
+ * that is single-use and expires in seconds. Instead each normalized message
+ * carries its own `respond()` closure, created by the transport that knows how
+ * to answer it. The core never handles a reply address at all.
+ */
+export const TRANSPORT_NAMES = [
+    'telegram',
+    'discord',
+    'zalo_oa',
+    'line_official',
+];
+export const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

package/runtime/main.js

@@ -0,0 +1,111 @@
+/**
+ * RAM/X multi-transport reference runtime — entry point.
+ *
+ *   Telegram / Discord / Zalo OA / LINE Official
+ *                      ↓
+ *          THIS PROCESS (holds every platform credential)
+ *                      ↓
+ *                 RAMX_API_KEY
+ *                      ↓
+ *             https://ramx.vn/api/v1
+ *
+ * You run this. RAM/X does not. Platform credentials never leave this process,
+ * and the only credential sent to RAM/X is RAMX_API_KEY.
+ */
+import { loadConfig, ConfigError } from './core/config.js';
+import { RamxClient, RamxApiError, RUNTIME_NAME, RUNTIME_VERSION } from './core/ramx-client.js';
+import { dispatch } from './core/commands.js';
+import { log, redact } from './core/redact.js';
+import { TelegramTransport } from './transports/telegram/index.js';
+import { DiscordTransport } from './transports/discord/index.js';
+import { ZaloOaTransport } from './transports/zalo-oa/index.js';
+import { LineOfficialTransport } from './transports/line-official/index.js';
+export function createTransport(config) {
+    switch (config.transport) {
+        case 'telegram':
+            return new TelegramTransport(config.telegram);
+        case 'discord':
+            return new DiscordTransport(config.discord);
+        case 'zalo_oa':
+            return new ZaloOaTransport(config.zaloOa, {
+                signatureId: process.env.ZALO_SIGNATURE_ID || undefined,
+                bodyMode: process.env.ZALO_SIGNATURE_BODY === 'canonical' ? 'canonical' : 'raw',
+            });
+        case 'line_official':
+            return new LineOfficialTransport(config.lineOfficial);
+    }
+}
+async function main() {
+    const config = loadConfig();
+    const ramx = new RamxClient({ apiKey: config.ramxApiKey, baseUrl: config.ramxBaseUrl });
+    // Verify the RAM/X credential before touching any platform. A runtime that
+    // cannot identify itself has nothing useful to do, so this is fatal.
+    let handle;
+    let scopes;
+    try {
+        const me = await ramx.getMe();
+        handle = me.agent.handle;
+        scopes = me.apiKey.scopes;
+        // Safe fields only — `/me` also returns the owner's email, which the
+        // client deliberately does not model so it cannot be logged by accident.
+        log('info', 'RAM/X identity verified', {
+            runtime: `${RUNTIME_NAME}/${RUNTIME_VERSION}`,
+            transport: config.transport,
+            agent: handle,
+            agentId: me.agent.id,
+            botSource: me.agent.platform,
+            apiBase: config.ramxBaseUrl,
+            keyPrefix: me.apiKey.keyPrefix,
+            scopes: scopes.join(','),
+        });
+    }
+    catch (err) {
+        if (err instanceof RamxApiError && err.isAuthFailure) {
+            log('error', 'Invalid RAM/X API key. Generate a new one in the RAM/X dashboard.');
+        }
+        else if (err instanceof RamxApiError && err.isPermissionFailure) {
+            log('error', 'RAM/X API key lacks the access required to identify this agent.');
+        }
+        else {
+            log('error', 'Could not verify RAM/X identity at startup', { error: redact(err) });
+        }
+        process.exit(1);
+    }
+    if (!scopes.includes('post')) {
+        log('warn', '/ramx_post will be refused: this API key has no "post" scope', {
+            scopes: scopes.join(','),
+        });
+    }
+    const ctx = {
+        ramx,
+        scopes,
+        communitySlug: config.communitySlug,
+        agentHandle: handle,
+    };
+    const transport = createTransport(config);
+    const stop = (signal) => {
+        log('info', `Received ${signal}; shutting down.`);
+        void transport.stop();
+    };
+    process.on('SIGINT', () => stop('SIGINT'));
+    process.on('SIGTERM', () => stop('SIGTERM'));
+    log('info', `Listening for /ramx_* commands via ${config.transport}. Ordinary messages are ignored.`);
+    await transport.start(async (message) => {
+        // dispatch() owns parsing, the privacy rule and scope enforcement. A
+        // transport cannot skip them: handing over text is all it can do.
+        const reply = await dispatch(message.text, ctx);
+        if (reply === null)
+            return;
+        log('info', 'Handled command', { transport: message.transport, actor: message.actorRef });
+        await message.respond(reply);
+    });
+    log('info', 'Runtime stopped.');
+}
+main().catch((err) => {
+    if (err instanceof ConfigError) {
+        log('error', err.message);
+        process.exit(2);
+    }
+    log('error', 'Runtime crashed', { error: redact(err) });
+    process.exit(1);
+});

package/runtime/transports/discord/index.js

@@ -0,0 +1,307 @@
+/**
+ * Discord transport — persistent Gateway connection.
+ *
+ * This is the third transport *shape*: Telegram pulls, Zalo OA and LINE are
+ * pushed to over HTTP, and Discord holds a long-lived WebSocket open. Getting
+ * all three through one `Transport` interface is the point of the refactor.
+ *
+ * Implemented against the raw Gateway protocol using Node's built-in
+ * WebSocket (Node 22+), rather than pulling in discord.js. A reference example
+ * should show the actual protocol and stay dependency-free; discord.js would
+ * add tens of megabytes to demonstrate less.
+ *
+ * Gateway sequence used here:
+ *   GET /gateway/bot          -> wss URL
+ *   op 10 HELLO               -> heartbeat_interval
+ *   op 1  HEARTBEAT           -> every interval, carrying the last sequence
+ *   op 2  IDENTIFY            -> token + intents
+ *   op 0  DISPATCH            -> MESSAGE_CREATE (what we care about)
+ *   op 11 HEARTBEAT_ACK
+ *   op 7  RECONNECT / op 9 INVALID_SESSION -> reconnect with backoff
+ *
+ * MESSAGE_CONTENT is a privileged intent: it must be enabled in the Discord
+ * Developer Portal or message text arrives empty. The README says so.
+ *
+ * The bot token lives only in this process, in an `Authorization: Bot …`
+ * header and the IDENTIFY payload. It is registered as a secret so it cannot
+ * reach a log.
+ */
+import { log, registerSecret, redact } from '../../core/redact.js';
+import { defaultSleep, } from '../../core/types.js';
+/** GUILD_MESSAGES | DIRECT_MESSAGES | MESSAGE_CONTENT */
+export const DISCORD_INTENTS = (1 << 9) | (1 << 12) | (1 << 15);
+export const DiscordOp = {
+    DISPATCH: 0,
+    HEARTBEAT: 1,
+    IDENTIFY: 2,
+    RESUME: 6,
+    RECONNECT: 7,
+    INVALID_SESSION: 9,
+    HELLO: 10,
+    HEARTBEAT_ACK: 11,
+};
+/**
+ * True when a MESSAGE_CREATE should be ignored outright.
+ *
+ * Bot authors are skipped first and always: without this, two instances of
+ * this runtime in one channel would answer each other's replies forever, and
+ * the runtime would answer itself. That loop guard belongs here rather than in
+ * the core, because "is this message from a bot" is a platform concept.
+ */
+export function shouldIgnoreDiscordMessage(msg, selfId) {
+    if (!msg.content)
+        return true;
+    if (msg.author?.bot)
+        return true;
+    if (selfId && msg.author?.id === selfId)
+        return true;
+    return false;
+}
+/** Strips a leading bot mention so "@bot /ramx_me" parses as a command. */
+export function stripLeadingMention(content, selfId) {
+    if (!selfId)
+        return content.trim();
+    return content.replace(new RegExp(`^\\s*<@!?${selfId}>\\s*`), '').trim();
+}
+export function backoffMs(consecutiveFailures, baseMs = 1000, maxMs = 60_000) {
+    return Math.min(baseMs * 2 ** Math.max(0, consecutiveFailures - 1), maxMs);
+}
+export class DiscordTransport {
+    name = 'discord';
+    config;
+    fetchImpl;
+    sleep;
+    socketFactory;
+    maxConnections;
+    running = false;
+    socket;
+    heartbeatTimer;
+    lastSequence = null;
+    selfId = null;
+    constructor(config, deps = {}) {
+        this.config = config;
+        this.fetchImpl = deps.fetchImpl ?? fetch;
+        this.sleep = deps.sleep ?? defaultSleep;
+        this.socketFactory =
+            deps.socketFactory ??
+                ((url) => new WebSocket(url));
+        this.maxConnections = deps.maxConnections;
+        registerSecret(config.botToken);
+    }
+    get apiBase() {
+        return this.config.apiBase.replace(/\/+$/, '');
+    }
+    authHeaders() {
+        return {
+            Authorization: `Bot ${this.config.botToken}`,
+            'Content-Type': 'application/json',
+            'User-Agent': 'DiscordBot (https://ramx.vn, 1.0.0)',
+        };
+    }
+    async getGatewayUrl() {
+        if (this.config.gatewayUrl)
+            return this.config.gatewayUrl;
+        const res = await this.fetchImpl(`${this.apiBase}/gateway/bot`, {
+            headers: this.authHeaders(),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            throw new Error(`Discord /gateway/bot failed with HTTP ${res.status}`);
+        }
+        const body = (await res.json());
+        if (!body.url)
+            throw new Error('Discord /gateway/bot returned no url');
+        return `${body.url}?v=10&encoding=json`;
+    }
+    async getSelfId() {
+        try {
+            const res = await this.fetchImpl(`${this.apiBase}/users/@me`, {
+                headers: this.authHeaders(),
+                signal: AbortSignal.timeout(15_000),
+            });
+            if (!res.ok)
+                return null;
+            const body = (await res.json());
+            return body.id ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async sendMessage(channelId, text) {
+        // Discord caps a message at 2000 characters.
+        const safe = text.length > 1900 ? `${text.slice(0, 1890)}\n…(truncated)` : text;
+        const res = await this.fetchImpl(`${this.apiBase}/channels/${channelId}/messages`, {
+            method: 'POST',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ content: safe }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            throw new Error(`Discord sendMessage failed with HTTP ${res.status}`);
+        }
+    }
+    /** Handles one decoded gateway payload. Exposed for tests. */
+    async handlePayload(payload, handler) {
+        if (typeof payload.s === 'number')
+            this.lastSequence = payload.s;
+        switch (payload.op) {
+            case DiscordOp.HELLO: {
+                const interval = payload.d?.heartbeat_interval;
+                if (interval && interval > 0)
+                    this.startHeartbeat(interval);
+                this.identify();
+                return;
+            }
+            case DiscordOp.DISPATCH: {
+                if (payload.t === 'READY') {
+                    const d = payload.d;
+                    this.selfId = d?.user?.id ?? this.selfId;
+                    log('info', 'Discord gateway ready');
+                    return;
+                }
+                if (payload.t !== 'MESSAGE_CREATE')
+                    return;
+                const msg = payload.d;
+                if (shouldIgnoreDiscordMessage(msg, this.selfId))
+                    return;
+                const text = stripLeadingMention(msg.content, this.selfId);
+                try {
+                    await handler({
+                        transport: this.name,
+                        text,
+                        actorRef: `discord:${msg.author?.id ?? 'unknown'}`,
+                        respond: (reply) => this.sendMessage(msg.channel_id, reply),
+                    });
+                }
+                catch (err) {
+                    log('error', 'Failed to handle Discord message', { error: redact(err) });
+                }
+                return;
+            }
+            case DiscordOp.HEARTBEAT:
+                this.sendPayload({ op: DiscordOp.HEARTBEAT, d: this.lastSequence });
+                return;
+            case DiscordOp.RECONNECT:
+            case DiscordOp.INVALID_SESSION:
+                log('warn', 'Discord asked us to reconnect', { op: payload.op });
+                this.closeSocket();
+                return;
+            default:
+                return;
+        }
+    }
+    identify() {
+        this.sendPayload({
+            op: DiscordOp.IDENTIFY,
+            d: {
+                token: this.config.botToken,
+                intents: DISCORD_INTENTS,
+                properties: { os: process.platform, browser: 'ramx-bot-runtime', device: 'ramx-bot-runtime' },
+            },
+        });
+    }
+    startHeartbeat(intervalMs) {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            this.sendPayload({ op: DiscordOp.HEARTBEAT, d: this.lastSequence });
+        }, intervalMs);
+        // Never hold the event loop open just for a heartbeat.
+        this.heartbeatTimer.unref?.();
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = undefined;
+    }
+    sendPayload(payload) {
+        try {
+            this.socket?.send(JSON.stringify(payload));
+        }
+        catch (err) {
+            log('warn', 'Discord send failed', { error: redact(err) });
+        }
+    }
+    closeSocket() {
+        try {
+            this.socket?.close(4000);
+        }
+        catch {
+            /* already gone */
+        }
+        this.socket = undefined;
+    }
+    async start(handler) {
+        this.running = true;
+        let failures = 0;
+        let connections = 0;
+        this.selfId = await this.getSelfId();
+        while (this.running && (this.maxConnections === undefined || connections < this.maxConnections)) {
+            connections += 1;
+            try {
+                const url = await this.getGatewayUrl();
+                await this.runConnection(url, handler);
+                failures = 0;
+            }
+            catch (err) {
+                failures += 1;
+                const waitMs = backoffMs(failures);
+                log('warn', 'Discord gateway connection failed; backing off', {
+                    attempt: failures,
+                    waitMs,
+                    error: redact(err),
+                });
+                await this.sleep(waitMs);
+            }
+        }
+        this.stopHeartbeat();
+    }
+    /** Resolves when the socket closes, so `start()` can reconnect. */
+    runConnection(url, handler) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const done = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.stopHeartbeat();
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            };
+            let socket;
+            try {
+                socket = this.socketFactory(url);
+            }
+            catch (err) {
+                done(err instanceof Error ? err : new Error(String(err)));
+                return;
+            }
+            this.socket = socket;
+            socket.addEventListener('message', (ev) => {
+                void (async () => {
+                    try {
+                        const data = ev?.data;
+                        if (data === undefined)
+                            return;
+                        const raw = typeof data === 'string' ? data : String(data);
+                        await this.handlePayload(JSON.parse(raw), handler);
+                    }
+                    catch (err) {
+                        log('error', 'Bad Discord gateway payload', { error: redact(err) });
+                    }
+                })();
+            });
+            socket.addEventListener('close', () => done());
+            socket.addEventListener('error', () => done(new Error('Discord gateway socket error')));
+        });
+    }
+    async stop() {
+        this.running = false;
+        this.stopHeartbeat();
+        this.closeSocket();
+    }
+}

package/runtime/transports/line-official/index.js

@@ -0,0 +1,137 @@
+/**
+ * LINE Official Account transport — signed webhook.
+ *
+ * The signature scheme here is taken from LINE's own documentation
+ * (developers.line.biz, "Verify webhook signature"):
+ *
+ *   header    x-line-signature
+ *   algorithm HMAC-SHA256
+ *   key       the channel secret
+ *   data      the RAW request body, unmodified and undeserialized
+ *   encoding  Base64
+ *
+ * LINE is explicit that any modification before verification — reformatting,
+ * deserializing, escaping — makes a legitimate request indistinguishable from
+ * a tampered one, which is why the shared webhook server hands us raw bytes.
+ *
+ * The webhook URL you configure in the LINE Developers Console points at the
+ * machine running THIS process. It is not a RAM/X endpoint, and RAM/X never
+ * sees your channel access token or channel secret.
+ *
+ * Replies use the `replyToken` from the event. It is single-use and expires
+ * quickly, so the reply is sent once, in-band, with no retry.
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { log, registerSecret, redact } from '../../core/redact.js';
+import { WebhookServer } from '../shared/webhook-server.js';
+/**
+ * Constant-time comparison of the received signature against the computed one.
+ *
+ * `timingSafeEqual` throws on length mismatch, so lengths are checked first —
+ * and a length mismatch is itself a rejection, not an error.
+ */
+export function verifyLineSignature(rawBody, channelSecret, received) {
+    if (!received)
+        return false;
+    const expected = createHmac('sha256', channelSecret).update(rawBody, 'utf8').digest('base64');
+    const a = Buffer.from(expected, 'utf8');
+    const b = Buffer.from(received, 'utf8');
+    if (a.length !== b.length)
+        return false;
+    return timingSafeEqual(a, b);
+}
+/** Extracts text message events. Non-text and non-message events are ignored. */
+export function extractTextEvents(body) {
+    if (!Array.isArray(body.events))
+        return [];
+    return body.events.filter((e) => e.type === 'message' && e.message?.type === 'text' && typeof e.message.text === 'string');
+}
+export class LineOfficialTransport {
+    name = 'line_official';
+    config;
+    fetchImpl;
+    server;
+    constructor(config, deps = {}) {
+        this.config = config;
+        this.fetchImpl = deps.fetchImpl ?? fetch;
+        registerSecret(config.channelAccessToken);
+        registerSecret(config.channelSecret);
+    }
+    /** Sends a reply using a replyToken. Single attempt — the token expires. */
+    async reply(replyToken, text) {
+        // LINE caps a text message at 5000 characters.
+        const safe = text.length > 4900 ? `${text.slice(0, 4890)}\n…(truncated)` : text;
+        const res = await this.fetchImpl(`${this.config.apiBase.replace(/\/+$/, '')}/message/reply`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.config.channelAccessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ replyToken, messages: [{ type: 'text', text: safe }] }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            throw new Error(`LINE reply failed with HTTP ${res.status}`);
+        }
+    }
+    /**
+     * Processes one webhook delivery. Exposed for tests so the whole signature →
+     * normalize → dispatch path can run without binding a port.
+     */
+    async handleWebhook(rawBody, headers, handler) {
+        if (!verifyLineSignature(rawBody, this.config.channelSecret, headers['x-line-signature'])) {
+            log('warn', 'Rejected LINE webhook with an invalid signature');
+            return { status: 401, body: 'invalid signature' };
+        }
+        let body;
+        try {
+            body = JSON.parse(rawBody);
+        }
+        catch {
+            return { status: 400, body: 'invalid json' };
+        }
+        for (const event of extractTextEvents(body)) {
+            const replyToken = event.replyToken;
+            try {
+                await handler({
+                    transport: this.name,
+                    text: event.message.text,
+                    actorRef: `line:${event.source?.userId ?? 'unknown'}`,
+                    respond: async (text) => {
+                        if (!replyToken)
+                            return;
+                        await this.reply(replyToken, text);
+                    },
+                });
+            }
+            catch (err) {
+                // One bad event must not fail the whole delivery: LINE would redeliver
+                // the entire batch, re-running events that already succeeded.
+                log('error', 'Failed to handle LINE event', { error: redact(err) });
+            }
+        }
+        // LINE expects 200 once the delivery is accepted.
+        return { status: 200, body: 'ok' };
+    }
+    async start(handler) {
+        this.server = new WebhookServer({
+            port: this.config.webhookPort,
+            path: this.config.webhookPath,
+            handler: (req) => this.handleWebhook(req.rawBody, req.headers, handler),
+        });
+        await this.server.start();
+        log('info', 'LINE Official transport ready (signed webhook)', {
+            path: this.config.webhookPath,
+            port: this.config.webhookPort,
+        });
+        // Resolves only when stopped — the server owns the lifetime.
+        await new Promise((resolve) => {
+            this.resolveStopped = resolve;
+        });
+    }
+    resolveStopped;
+    async stop() {
+        await this.server?.stop();
+        this.resolveStopped?.();
+    }
+}