qq-codex-bridge 0.1.3 → 0.1.4

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

@@ -1,7 +1,9 @@
 import { pathToFileURL } from "node:url";
+import { randomUUID } from "node:crypto";
 import { bootstrap, INTERNAL_TURN_EVENT_PATH } from "./bootstrap.js";
-import { createInternalTurnEventServer } from "./http-server.js";
+import { createBridgeHttpServer } from "./http-server.js";
 import { ThreadCommandHandler } from "./thread-command-handler.js";
+import { startWeixinGatewayService } from "../../weixin-gateway/src/cli.js";
 export function createIngressMessageHandler(deps) {
     return async (message) => {
         try {
@@ -12,56 +14,188 @@ export function createIngressMessageHandler(deps) {
             await deps.orchestrator.handleInbound(message);
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
             console.error("[qq-codex-bridge] message handling failed", {
                 messageId: message.messageId,
                 sessionKey: message.sessionKey,
-                error: error instanceof Error ? error.message : String(error)
+                error: errorMessage
             });
             if (error instanceof Error && error.stack) {
                 console.error("  stack:", error.stack);
             }
+            if (deps.errorEgress) {
+                try {
+                    const errorDraft = {
+                        draftId: randomUUID(),
+                        sessionKey: message.sessionKey,
+                        text: `[桥接层错误] ${errorMessage}`,
+                        createdAt: new Date().toISOString(),
+                        replyToMessageId: message.messageId
+                    };
+                    await deps.errorEgress.deliver(errorDraft);
+                }
+                catch (replyError) {
+                    console.warn("[qq-codex-bridge] failed to send error reply", {
+                        replyError: replyError instanceof Error ? replyError.message : String(replyError)
+                    });
+                }
+            }
         }
     };
 }
 export async function runBridgeDaemon() {
     const app = bootstrap();
-    const internalTurnEventServer = createInternalTurnEventServer({
-        routePath: INTERNAL_TURN_EVENT_PATH,
-        ingress: {
-            dispatchTurnEvent: async (payload) => {
-                await app.orchestrator.handleTurnEvent(payload);
-            }
-        },
-        onDispatchError: (error, payload) => {
-            console.warn("[qq-codex-bridge] internal turn event dispatch failed", {
-                error: error.message,
-                payload
-            });
+    const managedServices = [];
+    const configuredAccountKeys = Object.keys(app.orchestrators.byAccountKey);
+    const qqIngressHandlers = Object.entries(app.adapters.qqByAccountKey).map(([accountKey, adapter]) => {
+        const orchestrator = app.orchestrators.byAccountKey[accountKey];
+        if (!orchestrator) {
+            throw new Error(`missing orchestrator for ${accountKey}`);
         }
+        const threadCommandHandler = new ThreadCommandHandler({
+            sessionStore: app.sessionStore,
+            transcriptStore: app.transcriptStore,
+            desktopDriver: app.adapters.codexDesktop,
+            qqEgress: adapter.egress,
+            chatgptDriver: app.chatgptDriver,
+            accountKeys: configuredAccountKeys
+        });
+        return {
+            accountKey,
+            adapter,
+            ingressHandler: createIngressMessageHandler({
+                threadCommandHandler,
+                orchestrator,
+                errorEgress: adapter.egress
+            })
+        };
     });
-    const threadCommandHandler = new ThreadCommandHandler({
-        sessionStore: app.sessionStore,
-        transcriptStore: app.transcriptStore,
-        desktopDriver: app.adapters.codexDesktop,
-        qqEgress: app.adapters.qq.egress
+    const weixinRoutes = Object.entries(app.adapters.weixinByAccountKey).map(([accountKey, adapter]) => {
+        const orchestrator = app.orchestrators.byAccountKey[accountKey];
+        if (!orchestrator) {
+            throw new Error(`missing orchestrator for ${accountKey}`);
+        }
+        const threadCommandHandler = new ThreadCommandHandler({
+            sessionStore: app.sessionStore,
+            transcriptStore: app.transcriptStore,
+            desktopDriver: app.adapters.codexDesktop,
+            qqEgress: adapter.egress,
+            chatgptDriver: app.chatgptDriver,
+            accountKeys: configuredAccountKeys
+        });
+        return {
+            accountKey,
+            adapter,
+            ingressHandler: createIngressMessageHandler({
+                threadCommandHandler,
+                orchestrator,
+                errorEgress: adapter.egress
+            })
+        };
     });
+    const bridgeHttpServer = createBridgeHttpServer([
+        {
+            routePath: INTERNAL_TURN_EVENT_PATH,
+            allowOnlyLocal: true,
+            dispatchPayload: async (payload) => {
+                const event = payload;
+                await resolveTurnEventOrchestrator(event, app.orchestrators).handleTurnEvent(event);
+            },
+            onDispatchError: (error, payload) => {
+                console.warn("[qq-codex-bridge] internal turn event dispatch failed", {
+                    error: error.message,
+                    payload
+                });
+            }
+        },
+        ...weixinRoutes.map((route) => ({
+            routePath: route.adapter.webhook.routePath,
+            dispatchPayload: async (payload) => {
+                const message = route.adapter.webhook.toInboundMessage(payload);
+                await route.ingressHandler(message);
+            },
+            onDispatchError: (error, payload) => {
+                console.warn("[qq-codex-bridge] weixin webhook dispatch failed", {
+                    accountKey: route.accountKey,
+                    error: error.message,
+                    payload
+                });
+            }
+        }))
+    ]);
     await new Promise((resolve, reject) => {
-        internalTurnEventServer.once("error", reject);
-        internalTurnEventServer.listen(app.config.runtime.listenPort, "127.0.0.1", () => {
-            internalTurnEventServer.off("error", reject);
+        bridgeHttpServer.once("error", reject);
+        bridgeHttpServer.listen(app.config.runtime.listenPort, app.config.runtime.listenHost, () => {
+            bridgeHttpServer.off("error", reject);
             resolve();
         });
     });
-    await app.adapters.qq.ingress.onMessage(createIngressMessageHandler({
-        threadCommandHandler,
-        orchestrator: app.orchestrator
-    }));
-    await app.adapters.qq.ingress.start();
+    for (const entry of qqIngressHandlers) {
+        await entry.adapter.ingress.onMessage(entry.ingressHandler);
+        await entry.adapter.ingress.start();
+    }
+    const channelSet = new Set(qqIngressHandlers.map((entry) => entry.accountKey));
+    if (app.config.weixin.enabled) {
+        const weixinService = await startWeixinGatewayService();
+        managedServices.push(weixinService);
+        channelSet.add(`weixin:${weixinService.status.accountId}`);
+        console.log("[qq-codex-bridge] channel ready", {
+            channel: "weixin",
+            listenHost: weixinService.status.listenHost,
+            listenPort: weixinService.status.listenPort,
+            loggedIn: weixinService.status.loggedIn,
+            accountId: weixinService.status.accountId
+        });
+    }
+    for (const route of weixinRoutes) {
+        channelSet.add(route.accountKey);
+    }
+    const channels = [...channelSet];
     console.log("[qq-codex-bridge] ready", {
         transport: "qq-gateway-websocket",
-        accountKey: "qqbot:default",
-        internalTurnEventPath: INTERNAL_TURN_EVENT_PATH
+        accountKeys: channels,
+        conversationProvider: app.config.conversationProvider,
+        listenHost: app.config.runtime.listenHost,
+        listenPort: app.config.runtime.listenPort,
+        internalTurnEventPath: INTERNAL_TURN_EVENT_PATH,
+        ...(weixinRoutes.length > 0
+            ? {
+                weixinWebhookPaths: weixinRoutes.map((route) => route.adapter.webhook.routePath)
+            }
+            : {}),
+        channels
     });
+    return {
+        channels,
+        shutdown: async () => {
+            await Promise.allSettled([
+                ...qqIngressHandlers.map((entry) => new Promise((resolve) => {
+                    const maybeClose = entry.adapter.ingress;
+                    Promise.resolve(maybeClose.stop?.()).finally(() => resolve());
+                })),
+                ...managedServices.map((service) => service.shutdown())
+            ]);
+            await new Promise((resolve) => bridgeHttpServer.close(() => resolve()));
+        }
+    };
+}
+export function resolveTurnEventOrchestrator(event, orchestrators) {
+    const accountKey = extractAccountKey(event.sessionKey);
+    if (accountKey && orchestrators.byAccountKey?.[accountKey]) {
+        return orchestrators.byAccountKey[accountKey];
+    }
+    if (event.sessionKey.startsWith("weixin:") && orchestrators.weixin) {
+        return orchestrators.weixin;
+    }
+    return orchestrators.qq;
+}
+function extractAccountKey(sessionKey) {
+    const separatorIndex = sessionKey.indexOf("::");
+    if (separatorIndex < 0) {
+        return null;
+    }
+    const accountKey = sessionKey.slice(0, separatorIndex).trim();
+    return accountKey || null;
 }
 function handleFatal(error) {
     const cause = error instanceof Error ? error.cause : undefined;