qq-codex-bridge 0.1.2 → 0.1.4

package/bin/qq-codex-weixin-gateway.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import("../dist/apps/weixin-gateway/src/cli.js")
+  .then(({ runCliFromProcess }) => runCliFromProcess())
+  .catch((error) => {
+    console.error(
+      "[qq-codex-weixin-gateway] fatal:",
+      error instanceof Error ? error.message : String(error)
+    );
+    if (error instanceof Error && error.stack) {
+      console.error("  stack:", error.stack);
+    }
+    process.exitCode = 1;
+  });

package/dist/apps/bridge-daemon/src/bootstrap.js

@@ -2,7 +2,12 @@ import path from "node:path";
 import { QqApiClient } from "../../../packages/adapters/qq/src/qq-api-client.js";
 import { createQqChannelAdapter } from "../../../packages/adapters/qq/src/qq-channel-adapter.js";
 import { FileQqGatewaySessionStore } from "../../../packages/adapters/qq/src/qq-gateway-session-store.js";
+import { createWeixinChannelAdapter } from "../../../packages/adapters/weixin/src/weixin-channel-adapter.js";
 import { CdpSession } from "../../../packages/adapters/codex-desktop/src/cdp-session.js";
+import { CodexAppServerDriver } from "../../../packages/adapters/codex-desktop/src/codex-app-server-driver.js";
+import { CodexDesktopAppUiNotificationForwarder } from "../../../packages/adapters/codex-desktop/src/codex-app-ui-notification-forwarder.js";
+import { CodexLocalRolloutReader } from "../../../packages/adapters/codex-desktop/src/codex-local-rollout-reader.js";
+import { CodexLocalSubmissionReader } from "../../../packages/adapters/codex-desktop/src/codex-local-submission-reader.js";
 import { CodexDesktopDriver } from "../../../packages/adapters/codex-desktop/src/codex-desktop-driver.js";
 import { BridgeSessionStatus } from "../../../packages/domain/src/session.js";
 import { BridgeOrchestrator } from "../../../packages/orchestrator/src/bridge-orchestrator.js";
@@ -10,37 +15,89 @@ import { buildCodexInboundText } from "../../../packages/orchestrator/src/media-
 import { formatQqOutboundDraft } from "../../../packages/orchestrator/src/qq-outbound-format.js";
 import { enrichQqOutboundDraft } from "../../../packages/orchestrator/src/qq-outbound-draft.js";
 import { shouldInjectQqbotSkillContext } from "../../../packages/orchestrator/src/qqbot-skill-context.js";
+import { formatWeixinOutboundDraft } from "../../../packages/orchestrator/src/weixin-outbound-format.js";
 import { SqliteTranscriptStore } from "../../../packages/store/src/message-repo.js";
 import { SqliteSessionStore } from "../../../packages/store/src/session-repo.js";
 import { createSqliteDatabase } from "../../../packages/store/src/sqlite.js";
 import { loadConfigFromEnv } from "./config.js";
+import { ChatgptDesktopProvider } from "../../../packages/adapters/chatgpt-desktop/src/bridge-provider.js";
 const INTERNAL_TURN_EVENT_PATH = "/internal/codex-turn-events";
+function formatDraftForQq(draft) {
+    return formatQqOutboundDraft(enrichQqOutboundDraft(draft));
+}
+function formatDraftForWeixin(draft) {
+    return formatWeixinOutboundDraft(enrichQqOutboundDraft(draft));
+}
 export function bootstrap() {
     const config = loadConfigFromEnv(process.env);
     const db = createSqliteDatabase(config.databasePath);
     const sessionStore = new SqliteSessionStore(db);
     const transcriptStore = new SqliteTranscriptStore(db);
-    const qqApiClient = new QqApiClient(config.qqBot.appId, config.qqBot.clientSecret, {
-        markdownSupport: config.qqBot.markdownSupport
+    const runtimeDir = path.dirname(config.databasePath);
+    const useDomTransport = process.env.CODEX_DESKTOP_TRANSPORT === "dom";
+    const forwardAppServerUiEvents = process.env.CODEX_APP_SERVER_FORWARD_UI_EVENTS === "1";
+    const cdpSession = new CdpSession({
+        appName: config.codexDesktop.appName,
+        remoteDebuggingPort: config.codexDesktop.remoteDebuggingPort
     });
-    const accountKey = "qqbot:default";
-    const qqGatewaySessionStore = new FileQqGatewaySessionStore(path.join(path.dirname(config.databasePath), "qq-gateway-session.json"), accountKey, config.qqBot.appId);
-    const adapters = {
-        qq: createQqChannelAdapter({
+    const legacyDomDriver = new CodexDesktopDriver(cdpSession, {
+        localRolloutReader: new CodexLocalRolloutReader(),
+        localSubmissionReader: new CodexLocalSubmissionReader()
+    });
+    const codexDriver = useDomTransport
+        ? legacyDomDriver
+        : new CodexAppServerDriver({
+            controlFallback: legacyDomDriver,
+            notificationForwarder: forwardAppServerUiEvents
+                ? new CodexDesktopAppUiNotificationForwarder(cdpSession)
+                : null
+        });
+    const qqAdapters = config.qqBots.map((bot) => {
+        const accountKey = `qqbot:${bot.accountId}`;
+        const qqApiClient = new QqApiClient(bot.appId, bot.clientSecret, {
+            markdownSupport: bot.markdownSupport
+        });
+        const qqGatewaySessionStore = new FileQqGatewaySessionStore(path.join(runtimeDir, `qq-gateway-session-${safePathSegment(bot.accountId)}.json`), accountKey, bot.appId);
+        return {
             accountKey,
-            appId: config.qqBot.appId,
-            apiClient: qqApiClient,
-            sessionStore: qqGatewaySessionStore,
-            mediaDownloadDir: path.join(path.dirname(config.databasePath), "media"),
-            stt: config.qqBot.stt
-        }),
-        codexDesktop: new CodexDesktopDriver(new CdpSession({
-            appName: config.codexDesktop.appName,
-            remoteDebuggingPort: config.codexDesktop.remoteDebuggingPort
-        }))
+            adapter: createQqChannelAdapter({
+                accountKey,
+                appId: bot.appId,
+                apiClient: qqApiClient,
+                sessionStore: qqGatewaySessionStore,
+                mediaDownloadDir: path.join(runtimeDir, "media", "qq", safePathSegment(bot.accountId)),
+                stt: bot.stt
+            }),
+            sessionStore: qqGatewaySessionStore
+        };
+    });
+    const defaultQqAdapter = qqAdapters[0];
+    if (!defaultQqAdapter) {
+        throw new Error("at least one QQ bot must be configured");
+    }
+    const adapters = {
+        qq: defaultQqAdapter.adapter,
+        qqByAccountKey: Object.fromEntries(qqAdapters.map((entry) => [entry.accountKey, entry.adapter])),
+        codexDesktop: codexDriver
     };
-    const conversationProvider = {
-        runTurn: async (message, options) => {
+    let desktopTurnTail = Promise.resolve();
+    const runWithDesktopTurnLock = async (work) => {
+        const previous = desktopTurnTail;
+        let release;
+        desktopTurnTail = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await work();
+        }
+        finally {
+            release();
+        }
+    };
+    const runCodexTurn = async (work) => useDomTransport ? runWithDesktopTurnLock(work) : work();
+    const codexConversationProvider = {
+        runTurn: async (message, options) => runCodexTurn(async () => {
             await adapters.codexDesktop.ensureAppReady();
             const session = await sessionStore.getSession(message.sessionKey);
             const currentBinding = session
@@ -61,19 +118,23 @@ export function bootstrap() {
                     includeSkillContext: shouldIncludeSkillContext
                 })
             });
-            if (session?.codexThreadRef !== binding.codexThreadRef) {
-                await sessionStore.updateBinding(message.sessionKey, binding.codexThreadRef);
+            const stableBinding = await resolveStableBinding(adapters.codexDesktop, binding);
+            if (session?.codexThreadRef !== stableBinding.codexThreadRef) {
+                await sessionStore.updateBinding(message.sessionKey, stableBinding.codexThreadRef);
             }
             if (shouldIncludeSkillContext) {
-                await sessionStore.updateSkillContextKey(message.sessionKey, skillContextKey);
+                const stableSkillContextKey = skillContextKey !== null
+                    ? `${stableBinding.codexThreadRef ?? "unbound"}:qqbot-skill-v2`
+                    : null;
+                await sessionStore.updateSkillContextKey(message.sessionKey, stableSkillContextKey);
             }
-            const drafts = await adapters.codexDesktop.collectAssistantReply(binding, {
+            const drafts = await adapters.codexDesktop.collectAssistantReply(stableBinding, {
                 onDraft: options?.onDraft
                     ? async (draft) => {
-                        await options.onDraft(formatQqOutboundDraft(enrichQqOutboundDraft({
+                        await options.onDraft({
                             ...draft,
                             replyToMessageId: message.messageId
-                        })));
+                        });
                     }
                     : undefined,
                 onTurnEvent: async (event) => {
@@ -86,26 +147,92 @@ export function bootstrap() {
                     });
                 }
             });
-            return drafts.map((draft) => formatQqOutboundDraft(enrichQqOutboundDraft({
+            return drafts.map((draft) => ({
                 ...draft,
                 replyToMessageId: message.messageId
-            })));
+            }));
+        })
+    };
+    const chatgptProvider = new ChatgptDesktopProvider({ outDir: "runtime/media/chatgpt" });
+    const conversationProvider = {
+        runTurn: async (message, options) => {
+            const session = await sessionStore.getSession(message.sessionKey);
+            const effectiveProvider = session?.conversationProvider ?? config.conversationProvider;
+            if (effectiveProvider === "chatgpt-desktop") {
+                return chatgptProvider.runTurn(message, options);
+            }
+            return codexConversationProvider.runTurn(message, options);
         }
     };
-    const orchestrator = new BridgeOrchestrator({
+    const createChannelOrchestrator = (egress, draftFormatter) => new BridgeOrchestrator({
         sessionStore,
         transcriptStore,
         conversationProvider,
-        qqEgress: adapters.qq.egress
+        qqEgress: egress,
+        draftFormatter
     });
+    const qqOrchestrators = Object.fromEntries(qqAdapters.map((entry) => [
+        entry.accountKey,
+        createChannelOrchestrator(entry.adapter.egress, formatDraftForQq)
+    ]));
+    const weixinAdapters = config.weixinAccounts
+        .filter((account) => account.enabled && account.egressBaseUrl && account.egressToken)
+        .map((account) => {
+        const accountKey = `weixin:${account.accountId}`;
+        return {
+            accountKey,
+            adapter: createWeixinChannelAdapter({
+                accountKey,
+                webhookPath: account.webhookPath,
+                egressBaseUrl: account.egressBaseUrl,
+                egressToken: account.egressToken
+            })
+        };
+    });
+    const weixinOrchestrators = Object.fromEntries(weixinAdapters.map((entry) => [
+        entry.accountKey,
+        createChannelOrchestrator(entry.adapter.egress, formatDraftForWeixin)
+    ]));
+    const defaultWeixinAdapter = weixinAdapters[0]?.adapter;
+    const defaultWeixinOrchestrator = weixinAdapters[0]
+        ? weixinOrchestrators[weixinAdapters[0].accountKey]
+        : undefined;
+    const channelOrchestrators = {
+        qq: qqOrchestrators[defaultQqAdapter.accountKey],
+        ...(defaultWeixinOrchestrator ? { weixin: defaultWeixinOrchestrator } : {}),
+        byAccountKey: {
+            ...qqOrchestrators,
+            ...weixinOrchestrators
+        }
+    };
+    const allAdapters = {
+        ...adapters,
+        ...(defaultWeixinAdapter ? { weixin: defaultWeixinAdapter } : {}),
+        weixinByAccountKey: Object.fromEntries(weixinAdapters.map((entry) => [entry.accountKey, entry.adapter]))
+    };
     return {
         config,
         db,
         sessionStore,
         transcriptStore,
-        adapters,
-        orchestrator,
-        qqGatewaySessionStore
+        adapters: allAdapters,
+        orchestrator: channelOrchestrators.qq,
+        orchestrators: channelOrchestrators,
+        qqGatewaySessionStore: defaultQqAdapter.sessionStore,
+        chatgptDriver: chatgptProvider.desktopDriver
+    };
+}
+async function resolveStableBinding(desktopDriver, binding) {
+    if (!binding.codexThreadRef?.startsWith("cdp-target:")) {
+        return binding;
+    }
+    const currentThread = (await desktopDriver.listRecentThreads(200)).find((thread) => thread.isCurrent);
+    if (!currentThread) {
+        return binding;
+    }
+    return {
+        sessionKey: binding.sessionKey,
+        codexThreadRef: currentThread.threadRef
     };
 }
 async function postTurnEvent(port, event) {
@@ -127,3 +254,6 @@ async function postTurnEvent(port, event) {
     }
 }
 export { INTERNAL_TURN_EVENT_PATH };
+function safePathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_") || "default";
+}

package/dist/apps/bridge-daemon/src/cli.js

@@ -52,7 +52,11 @@ export async function runCli(rawArgs, deps = {}) {
             startupPollIntervalMs: Number(env.CODEX_CDP_POLL_INTERVAL_MS ?? "500")
         });
         writeStdout(`[qq-codex-bridge] codex desktop ready { launched: ${String(result.launched)}, remoteDebuggingPort: ${config.codexDesktop.remoteDebuggingPort} }`);
-        await startBridge();
+        const runtime = await startBridge();
+        const channels = Array.isArray(runtime?.channels)
+            ? runtime.channels
+            : ["qq"];
+        writeStdout(`[qq-codex-bridge] channels active: ${channels.join(", ")}`);
         return 0;
     }
     catch (error) {

package/dist/apps/bridge-daemon/src/config.js

@@ -1,4 +1,41 @@
 import { z } from "zod";
+const qqBotConfigSchema = z.object({
+    accountId: z.string().min(1),
+    appId: z.string().min(1),
+    clientSecret: z.string().min(1),
+    markdownSupport: z.boolean(),
+    stt: z
+        .union([
+        z.object({
+            provider: z.literal("local-whisper-cpp"),
+            binaryPath: z.string().min(1),
+            modelPath: z.string().min(1),
+            language: z.string().min(1).optional()
+        }),
+        z.object({
+            provider: z.literal("openai-compatible"),
+            baseUrl: z.string().url(),
+            apiKey: z.string().min(1),
+            model: z.string().min(1)
+        }),
+        z.object({
+            provider: z.literal("volcengine-flash"),
+            endpoint: z.string().url(),
+            appId: z.string().min(1),
+            accessKey: z.string().min(1),
+            resourceId: z.string().min(1),
+            model: z.string().min(1)
+        })
+    ])
+        .nullable()
+});
+const weixinConfigSchema = z.object({
+    enabled: z.boolean(),
+    accountId: z.string().min(1),
+    webhookPath: z.string().startsWith("/"),
+    egressBaseUrl: z.string().url().nullable(),
+    egressToken: z.string().min(1).nullable()
+});
 export const appConfigSchema = z.object({
     databasePath: z.string().min(1),
     runtime: z.object({
@@ -6,41 +43,31 @@ export const appConfigSchema = z.object({
         listenPort: z.number().int().positive(),
         webhookPath: z.string().startsWith("/")
     }),
-    qqBot: z.object({
-        appId: z.string().min(1),
-        clientSecret: z.string().min(1),
-        markdownSupport: z.boolean(),
-        stt: z
-            .union([
-            z.object({
-                provider: z.literal("local-whisper-cpp"),
-                binaryPath: z.string().min(1),
-                modelPath: z.string().min(1),
-                language: z.string().min(1).optional()
-            }),
-            z.object({
-                provider: z.literal("openai-compatible"),
-                baseUrl: z.string().url(),
-                apiKey: z.string().min(1),
-                model: z.string().min(1)
-            }),
-            z.object({
-                provider: z.literal("volcengine-flash"),
-                endpoint: z.string().url(),
-                appId: z.string().min(1),
-                accessKey: z.string().min(1),
-                resourceId: z.string().min(1),
-                model: z.string().min(1)
-            })
-        ])
-            .nullable()
-    }),
+    qqBot: qqBotConfigSchema,
+    qqBots: z.array(qqBotConfigSchema).min(1),
+    weixin: weixinConfigSchema,
+    weixinAccounts: z.array(weixinConfigSchema),
     codexDesktop: z.object({
         appName: z.string().min(1),
         remoteDebuggingPort: z.number().int().positive()
-    })
+    }),
+    conversationProvider: z.enum(["codex-desktop", "chatgpt-desktop"])
 });
 export function loadConfigFromEnv(env) {
+    const fallbackQqBot = {
+        accountId: env.QQBOT_ACCOUNT_ID ?? "default",
+        appId: env.QQBOT_APP_ID,
+        clientSecret: env.QQBOT_CLIENT_SECRET,
+        markdownSupport: env.QQBOT_MARKDOWN_SUPPORT === "true",
+        stt: resolveSttConfig(env)
+    };
+    const fallbackWeixin = {
+        enabled: env.WEIXIN_ENABLED === "true",
+        accountId: env.WEIXIN_ACCOUNT_ID ?? "default",
+        webhookPath: env.WEIXIN_WEBHOOK_PATH ?? "/webhooks/weixin",
+        egressBaseUrl: env.WEIXIN_EGRESS_BASE_URL ?? null,
+        egressToken: env.WEIXIN_EGRESS_TOKEN ?? null
+    };
     return appConfigSchema.parse({
         databasePath: env.QQ_CODEX_DATABASE_PATH ?? "runtime/qq-codex-bridge.sqlite",
         runtime: {
@@ -48,18 +75,78 @@ export function loadConfigFromEnv(env) {
             listenPort: Number(env.QQ_CODEX_LISTEN_PORT ?? "3100"),
             webhookPath: env.QQ_CODEX_WEBHOOK_PATH ?? "/webhooks/qq"
         },
-        qqBot: {
-            appId: env.QQBOT_APP_ID,
-            clientSecret: env.QQBOT_CLIENT_SECRET,
-            markdownSupport: env.QQBOT_MARKDOWN_SUPPORT === "true",
-            stt: resolveSttConfig(env)
-        },
+        qqBot: fallbackQqBot,
+        qqBots: resolveQqBotConfigs(env, fallbackQqBot),
+        weixin: fallbackWeixin,
+        weixinAccounts: resolveWeixinConfigs(env, fallbackWeixin),
         codexDesktop: {
             appName: env.CODEX_APP_NAME ?? "Codex",
             remoteDebuggingPort: Number(env.CODEX_REMOTE_DEBUGGING_PORT ?? "9229")
-        }
+        },
+        conversationProvider: (env.BRIDGE_CONVERSATION_PROVIDER === "chatgpt-desktop"
+            ? "chatgpt-desktop"
+            : "codex-desktop")
     });
 }
+function resolveQqBotConfigs(env, fallback) {
+    const jsonConfigs = parseJsonArray(env.QQBOTS_JSON ?? env.QQBOT_ACCOUNTS_JSON);
+    if (jsonConfigs) {
+        return jsonConfigs.map((item, index) => {
+            const record = asRecord(item);
+            return {
+                accountId: stringValue(record.accountId ?? record.id, `bot${index + 1}`),
+                appId: stringValue(record.appId ?? record.appID ?? record.qqbotAppId, ""),
+                clientSecret: stringValue(record.clientSecret ?? record.secret ?? record.qqbotClientSecret, ""),
+                markdownSupport: booleanValue(record.markdownSupport, fallback.markdownSupport),
+                stt: fallback.stt
+            };
+        });
+    }
+    const accountIds = splitList(env.QQBOT_ACCOUNT_IDS);
+    if (accountIds.length > 0) {
+        return accountIds.map((accountId, index) => {
+            const suffix = envNameSuffix(accountId);
+            return {
+                accountId,
+                appId: env[`QQBOT_${suffix}_APP_ID`] ?? (index === 0 ? fallback.appId : undefined),
+                clientSecret: env[`QQBOT_${suffix}_CLIENT_SECRET`] ?? (index === 0 ? fallback.clientSecret : undefined),
+                markdownSupport: booleanEnv(env[`QQBOT_${suffix}_MARKDOWN_SUPPORT`], fallback.markdownSupport),
+                stt: fallback.stt
+            };
+        });
+    }
+    return [fallback];
+}
+function resolveWeixinConfigs(env, fallback) {
+    const jsonConfigs = parseJsonArray(env.WEIXIN_ACCOUNTS_JSON);
+    if (jsonConfigs) {
+        return jsonConfigs.map((item, index) => {
+            const record = asRecord(item);
+            const accountId = stringValue(record.accountId ?? record.id, `account${index + 1}`);
+            return {
+                enabled: booleanValue(record.enabled, true),
+                accountId,
+                webhookPath: stringValue(record.webhookPath, `/webhooks/weixin/${accountId}`),
+                egressBaseUrl: nullableString(record.egressBaseUrl ?? record.baseUrl),
+                egressToken: nullableString(record.egressToken ?? record.token)
+            };
+        });
+    }
+    const accountIds = splitList(env.WEIXIN_ACCOUNT_IDS);
+    if (accountIds.length > 0) {
+        return accountIds.map((accountId, index) => {
+            const suffix = envNameSuffix(accountId);
+            return {
+                enabled: booleanEnv(env[`WEIXIN_${suffix}_ENABLED`], true),
+                accountId,
+                webhookPath: env[`WEIXIN_${suffix}_WEBHOOK_PATH`] ?? `/webhooks/weixin/${accountId}`,
+                egressBaseUrl: env[`WEIXIN_${suffix}_EGRESS_BASE_URL`] ?? (index === 0 ? fallback.egressBaseUrl : null),
+                egressToken: env[`WEIXIN_${suffix}_EGRESS_TOKEN`] ?? (index === 0 ? fallback.egressToken : null)
+            };
+        });
+    }
+    return fallback.enabled ? [fallback] : [];
+}
 function resolveSttConfig(env) {
     if (env.QQBOT_STT_ENABLED === "false") {
         return null;
@@ -107,3 +194,47 @@ function resolveSttConfig(env) {
         model
     };
 }
+function parseJsonArray(value) {
+    if (!value?.trim()) {
+        return null;
+    }
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : null;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringValue(value, fallback) {
+    const text = String(value ?? "").trim();
+    return text || fallback;
+}
+function nullableString(value) {
+    const text = String(value ?? "").trim();
+    return text || null;
+}
+function booleanValue(value, fallback) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        return booleanEnv(value, fallback);
+    }
+    return fallback;
+}
+function booleanEnv(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    return value === "true" || value === "1";
+}
+function splitList(value) {
+    return (value ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function envNameSuffix(value) {
+    return value.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+}

package/dist/apps/bridge-daemon/src/http-server.js

@@ -1,27 +1,39 @@
 import { createServer } from "node:http";
 export function createQqWebhookServer(deps) {
     return createJsonServer({
-        routePath: deps.webhookPath,
-        dispatchPayload: deps.ingress.dispatchPayload,
-        onDispatchError: deps.onDispatchError
+        routes: [
+            {
+                routePath: deps.webhookPath,
+                dispatchPayload: deps.ingress.dispatchPayload,
+                onDispatchError: deps.onDispatchError
+            }
+        ]
     });
 }
 export function createInternalTurnEventServer(deps) {
     return createJsonServer({
-        routePath: deps.routePath,
-        dispatchPayload: deps.ingress.dispatchTurnEvent,
-        onDispatchError: deps.onDispatchError,
-        allowOnlyLocal: true
+        routes: [
+            {
+                routePath: deps.routePath,
+                dispatchPayload: deps.ingress.dispatchTurnEvent,
+                onDispatchError: deps.onDispatchError,
+                allowOnlyLocal: true
+            }
+        ]
     });
 }
+export function createBridgeHttpServer(routes) {
+    return createJsonServer({ routes });
+}
 function createJsonServer(deps) {
     return createServer(async (request, response) => {
-        if (request.url !== deps.routePath) {
+        const route = deps.routes.find((candidate) => candidate.routePath === request.url);
+        if (!route) {
             response.statusCode = 404;
             response.end("not found");
             return;
         }
-        if (deps.allowOnlyLocal && !isLocalRequest(request)) {
+        if (route.allowOnlyLocal && !isLocalRequest(request)) {
             response.statusCode = 403;
             response.end("forbidden");
             return;
@@ -45,10 +57,10 @@ function createJsonServer(deps) {
             return;
         }
         Promise.resolve()
-            .then(() => deps.dispatchPayload(payload))
+            .then(() => route.dispatchPayload(payload))
             .catch((error) => {
             const normalized = error instanceof Error ? error : new Error(typeof error === "string" ? error : "dispatch failed");
-            deps.onDispatchError?.(normalized, payload);
+            route.onDispatchError?.(normalized, payload);
         });
         response.statusCode = 202;
         response.end("accepted");