qq-codex-bridge 0.1.3 → 0.1.4

package/dist/packages/orchestrator/src/bridge-orchestrator.js

@@ -2,13 +2,14 @@ import { randomUUID } from "node:crypto";
 import { BridgeSessionStatus } from "../../domain/src/session.js";
 import { TurnEventType } from "../../domain/src/message.js";
 import { DesktopDriverError } from "../../domain/src/driver.js";
-import { formatQqOutboundDraft } from "./qq-outbound-format.js";
 export class BridgeOrchestrator {
     deps;
     recentInboundFingerprints = new Map();
     turnStates = new Map();
+    draftFormatter;
     constructor(deps) {
         this.deps = deps;
+        this.draftFormatter = deps.draftFormatter ?? ((draft) => draft);
     }
     async handleInbound(message) {
         const alreadySeen = await this.deps.transcriptStore.hasInbound(message.messageId);
@@ -36,7 +37,9 @@ export class BridgeOrchestrator {
                     chatType: message.chatType,
                     peerId: message.senderId,
                     codexThreadRef: null,
+                    lastCodexTurnId: null,
                     skillContextKey: null,
+                    conversationProvider: null,
                     status: BridgeSessionStatus.Active,
                     lastInboundAt: message.receivedAt,
                     lastOutboundAt: null,
@@ -54,18 +57,25 @@ export class BridgeOrchestrator {
                         return;
                     }
                     deliveredDraftIds.add(draft.draftId);
-                    await this.deps.transcriptStore.recordOutbound(draft);
+                    if (draft.turnId) {
+                        await this.deps.sessionStore.updateLastCodexTurnId(message.sessionKey, draft.turnId);
+                    }
+                    const formattedDraft = this.draftFormatter(draft);
+                    if (isEmptyDraft(formattedDraft)) {
+                        return;
+                    }
+                    await this.deps.transcriptStore.recordOutbound(formattedDraft);
                     try {
-                        await this.deps.qqEgress.deliver(draft);
-                        this.recordDeliveredDraft(draft);
+                        await this.deps.qqEgress.deliver(formattedDraft);
+                        this.recordDeliveredDraft(formattedDraft);
                     }
                     catch (error) {
                         const reason = error instanceof Error ? error.message : String(error);
-                        deliveryErrors.push(`${draft.draftId}: ${reason}`);
+                        deliveryErrors.push(`${formattedDraft.draftId}: ${reason}`);
                         console.warn("[qq-codex-bridge] draft delivery failed", {
                             sessionKey: message.sessionKey,
                             messageId: message.messageId,
-                            draftId: draft.draftId,
+                            draftId: formattedDraft.draftId,
                             error: reason
                         });
                     }
@@ -100,6 +110,7 @@ export class BridgeOrchestrator {
             if (event.sequence <= state.lastSequence) {
                 return;
             }
+            await this.deps.sessionStore.updateLastCodexTurnId(event.sessionKey, event.turnId);
             state.lastSequence = event.sequence;
             state.lastEventAt = event.createdAt;
             if (typeof event.payload.fullText === "string") {
@@ -117,7 +128,7 @@ export class BridgeOrchestrator {
                 state.finalFlushed = true;
                 return;
             }
-            const draft = formatQqOutboundDraft({
+            const draft = this.draftFormatter({
                 draftId: randomUUID(),
                 turnId: event.turnId,
                 sessionKey: event.sessionKey,
@@ -127,48 +138,65 @@ export class BridgeOrchestrator {
                     ? { replyToMessageId: event.payload.replyToMessageId }
                     : {})
             });
-            if (!draft.text.trim()) {
+            const pendingArtifacts = filterPendingArtifacts(draft.mediaArtifacts ?? [], state.sentArtifactKeys);
+            const normalizedDraft = pendingArtifacts.length === (draft.mediaArtifacts?.length ?? 0)
+                ? draft
+                : {
+                    ...draft,
+                    mediaArtifacts: pendingArtifacts
+                };
+            if (isEmptyDraft(normalizedDraft)) {
                 state.sentText = state.assembledText;
                 state.completed = true;
                 state.finalFlushed = true;
                 return;
             }
-            await this.deps.transcriptStore.recordOutbound(draft);
-            await this.deps.qqEgress.deliver(draft);
+            await this.deps.transcriptStore.recordOutbound(normalizedDraft);
+            await this.deps.qqEgress.deliver(normalizedDraft);
+            this.recordDeliveredDraft(normalizedDraft);
             state.sentText = state.assembledText;
             state.completed = true;
             state.finalFlushed = true;
         });
     }
     isLikelyDuplicateInbound(message) {
-        const record = this.recentInboundFingerprints.get(message.sessionKey);
-        if (!record) {
-            return false;
-        }
         const receivedAtMs = Date.parse(message.receivedAt);
         if (!Number.isFinite(receivedAtMs)) {
             return false;
         }
-        return (record.fingerprint === buildInboundFingerprint(message) &&
-            receivedAtMs - record.receivedAtMs >= 0 &&
-            receivedAtMs - record.receivedAtMs <= 90_000);
+        const records = this.getRecentInboundRecords(message.sessionKey, receivedAtMs);
+        if (!records.length) {
+            return false;
+        }
+        const fingerprint = buildInboundFingerprint(message);
+        return records.some((record) => record.fingerprint === fingerprint
+            && receivedAtMs - record.receivedAtMs >= 0
+            && receivedAtMs - record.receivedAtMs <= 90_000);
     }
     rememberInbound(message) {
         const receivedAtMs = Date.parse(message.receivedAt);
         if (!Number.isFinite(receivedAtMs)) {
             return;
         }
-        const now = receivedAtMs;
-        for (const [sessionKey, record] of this.recentInboundFingerprints.entries()) {
-            if (now - record.receivedAtMs > 120_000) {
-                this.recentInboundFingerprints.delete(sessionKey);
-            }
-        }
-        this.recentInboundFingerprints.set(message.sessionKey, {
+        const records = this.getRecentInboundRecords(message.sessionKey, receivedAtMs);
+        records.push({
             fingerprint: buildInboundFingerprint(message),
             receivedAtMs,
             messageId: message.messageId
         });
+        this.recentInboundFingerprints.set(message.sessionKey, records);
+    }
+    getRecentInboundRecords(sessionKey, referenceTimeMs) {
+        for (const [key, records] of this.recentInboundFingerprints.entries()) {
+            const retained = records.filter((record) => referenceTimeMs - record.receivedAtMs <= 120_000);
+            if (retained.length > 0) {
+                this.recentInboundFingerprints.set(key, retained);
+            }
+            else {
+                this.recentInboundFingerprints.delete(key);
+            }
+        }
+        return [...(this.recentInboundFingerprints.get(sessionKey) ?? [])];
     }
     getOrCreateTurnState(event) {
         const key = buildTurnStateKey(event.sessionKey, event.turnId);
@@ -180,6 +208,7 @@ export class BridgeOrchestrator {
             lastSequence: 0,
             assembledText: "",
             sentText: "",
+            sentArtifactKeys: new Set(),
             lastEventAt: null,
             completed: false,
             finalFlushed: false
@@ -188,7 +217,7 @@ export class BridgeOrchestrator {
         return created;
     }
     recordDeliveredDraft(draft) {
-        if (!draft.turnId || !draft.text) {
+        if (!draft.turnId) {
             return;
         }
         const key = buildTurnStateKey(draft.sessionKey, draft.turnId);
@@ -196,11 +225,15 @@ export class BridgeOrchestrator {
             lastSequence: 0,
             assembledText: "",
             sentText: "",
+            sentArtifactKeys: new Set(),
             lastEventAt: null,
             completed: false,
             finalFlushed: false
         };
         state.sentText += draft.text;
+        for (const artifact of draft.mediaArtifacts ?? []) {
+            state.sentArtifactKeys.add(buildArtifactKey(artifact));
+        }
         this.turnStates.set(key, state);
     }
 }
@@ -259,3 +292,17 @@ function findSuffixPrefixOverlap(previous, next) {
 function stripWhitespace(value) {
     return value.replace(/\s+/g, "");
 }
+function filterPendingArtifacts(artifacts, sentArtifactKeys) {
+    return artifacts.filter((artifact) => !sentArtifactKeys.has(buildArtifactKey(artifact)));
+}
+function buildArtifactKey(artifact) {
+    return [
+        artifact.kind,
+        artifact.localPath || "",
+        artifact.sourceUrl || "",
+        artifact.originalName || ""
+    ].join("::");
+}
+function isEmptyDraft(draft) {
+    return !draft.text.trim() && !(draft.mediaArtifacts?.length);
+}

package/dist/packages/orchestrator/src/weixin-outbound-format.js

@@ -0,0 +1,55 @@
+export function formatWeixinOutboundDraft(draft) {
+    const formattedText = formatWeixinOutboundText(draft.text, draft.mediaArtifacts ?? []);
+    if (formattedText === draft.text) {
+        return draft;
+    }
+    return {
+        ...draft,
+        text: formattedText
+    };
+}
+export function formatWeixinOutboundText(text, mediaArtifacts) {
+    if (!text) {
+        return text;
+    }
+    const strippedMediaBlocks = text.replace(/<qqmedia>[\s\S]*?<\/qqmedia>/g, "");
+    const hasMediaArtifacts = mediaArtifacts.length > 0;
+    const pathSet = new Set(mediaArtifacts.flatMap((artifact) => [artifact.localPath, artifact.sourceUrl].filter((value) => typeof value === "string" && value.trim().length > 0)));
+    const normalizedLines = strippedMediaBlocks
+        .split("\n")
+        .filter((line) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return false;
+        }
+        if (trimmed.includes("<qqmedia>") || trimmed.includes("</qqmedia>")) {
+            return false;
+        }
+        if (pathSet.has(stripWrapping(trimmed))) {
+            return false;
+        }
+        if (containsOnlyArtifactPath(trimmed, pathSet)) {
+            return false;
+        }
+        if (hasMediaArtifacts && shouldDropInternalBridgeLine(trimmed)) {
+            return false;
+        }
+        return true;
+    });
+    return normalizedLines.join("\n").trim();
+}
+function containsOnlyArtifactPath(line, paths) {
+    const normalized = stripWrapping(line);
+    return Array.from(paths).some((path) => normalized === stripWrapping(path));
+}
+function stripWrapping(value) {
+    return value.replace(/^[-*]\s*/, "").replace(/^`+/, "").replace(/`+$/, "").trim();
+}
+function shouldDropInternalBridgeLine(line) {
+    return (line.includes("QQBot 桥接程序收到你上传附件后") ||
+        line.includes("临时落盘的运行目录路径") ||
+        line.includes("这里看到的是相对路径") ||
+        line.includes("runtime/media/") ||
+        line.includes("/Volumes/") ||
+        /^[A-Za-z]:[\\/]/.test(line));
+}

package/dist/packages/ports/src/chat.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/store/src/session-repo.js

@@ -13,7 +13,9 @@ export class SqliteSessionStore {
                 chat_type AS chatType,
                 peer_id AS peerId,
                 codex_thread_ref AS codexThreadRef,
+                last_codex_turn_id AS lastCodexTurnId,
                 skill_context_key AS skillContextKey,
+                conversation_provider AS conversationProvider,
                 status,
                 last_inbound_at AS lastInboundAt,
                 last_outbound_at AS lastOutboundAt,
@@ -27,9 +29,10 @@ export class SqliteSessionStore {
         this.db
             .prepare(`INSERT INTO bridge_sessions (
           session_key, account_key, peer_key, chat_type, peer_id,
-          codex_thread_ref, skill_context_key, status, last_inbound_at, last_outbound_at, last_error
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(session.sessionKey, session.accountKey, session.peerKey, session.chatType, session.peerId, session.codexThreadRef, session.skillContextKey, session.status, session.lastInboundAt, session.lastOutboundAt, session.lastError);
+          codex_thread_ref, last_codex_turn_id, skill_context_key, status,
+          last_inbound_at, last_outbound_at, last_error
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(session.sessionKey, session.accountKey, session.peerKey, session.chatType, session.peerId, session.codexThreadRef, session.lastCodexTurnId, session.skillContextKey, session.status, session.lastInboundAt, session.lastOutboundAt, session.lastError);
     }
     async updateSessionStatus(sessionKey, status, lastError = null) {
         this.db
@@ -41,11 +44,21 @@ export class SqliteSessionStore {
             .prepare(`UPDATE bridge_sessions SET codex_thread_ref = ? WHERE session_key = ?`)
             .run(codexThreadRef, sessionKey);
     }
+    async updateLastCodexTurnId(sessionKey, lastCodexTurnId) {
+        this.db
+            .prepare(`UPDATE bridge_sessions SET last_codex_turn_id = ? WHERE session_key = ?`)
+            .run(lastCodexTurnId, sessionKey);
+    }
     async updateSkillContextKey(sessionKey, skillContextKey) {
         this.db
             .prepare(`UPDATE bridge_sessions SET skill_context_key = ? WHERE session_key = ?`)
             .run(skillContextKey, sessionKey);
     }
+    async updateConversationProvider(sessionKey, provider) {
+        this.db
+            .prepare(`UPDATE bridge_sessions SET conversation_provider = ? WHERE session_key = ?`)
+            .run(provider, sessionKey);
+    }
     async withSessionLock(sessionKey, work) {
         // Queue same-session work in-process so the SQLite lock row reflects a real exclusive section.
         const previousTail = this.sessionLockTails.get(sessionKey) ?? Promise.resolve();

package/dist/packages/store/src/sqlite.js

@@ -16,6 +16,7 @@ export function createSqliteDatabase(filePath) {
       chat_type TEXT NOT NULL,
       peer_id TEXT NOT NULL,
       codex_thread_ref TEXT,
+      last_codex_turn_id TEXT,
       skill_context_key TEXT,
       status TEXT NOT NULL,
       last_inbound_at TEXT,
@@ -53,6 +54,8 @@ export function createSqliteDatabase(filePath) {
     );
   `);
     ensureColumn(db, "bridge_sessions", "skill_context_key", "TEXT");
+    ensureColumn(db, "bridge_sessions", "last_codex_turn_id", "TEXT");
+    ensureColumn(db, "bridge_sessions", "conversation_provider", "TEXT");
     return db;
 }
 function ensureColumn(db, tableName, columnName, columnDefinition) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qq-codex-bridge",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "A bridge between QQ Official Bot and Codex Desktop, with media relay, STT, thread management, and incremental reply delivery.",
   "type": "module",
   "homepage": "https://github.com/983033995/qq-codex-bridge",
@@ -21,7 +21,8 @@
     "typescript"
   ],
   "bin": {
-    "qq-codex-bridge": "bin/qq-codex-bridge.js"
+    "qq-codex-bridge": "bin/qq-codex-bridge.js",
+    "qq-codex-weixin-gateway": "bin/qq-codex-weixin-gateway.js"
   },
   "files": [
     "bin",
@@ -37,7 +38,12 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsx --env-file=.env apps/bridge-daemon/src/dev.ts",
+    "gitnexus:detect-changes": "node scripts/gitnexus-detect-changes.mjs",
+    "weixin:login": "tsx --env-file=.env apps/weixin-gateway/src/dev.ts -- --weixin-login",
+    "weixin:login:force": "tsx --env-file=.env apps/weixin-gateway/src/dev.ts -- --weixin-login-force",
+    "weixin:logout": "tsx --env-file=.env apps/weixin-gateway/src/dev.ts -- --weixin-logout",
     "start": "node dist/apps/bridge-daemon/src/cli.js",
+    "start:weixin-gateway": "node dist/apps/weixin-gateway/src/cli.js",
     "debug:codex-workers": "tsx apps/bridge-daemon/src/debug-codex-workers.ts",
     "test": "vitest run",
     "test:watch": "vitest",