qq-codex-bridge 0.1.0

package/dist/packages/orchestrator/src/qq-outbound-draft.js

@@ -0,0 +1,38 @@
+import { buildMediaArtifactFromReference, parseQqMediaSegments } from "../../adapters/qq/src/qq-media-parser.js";
+export function enrichQqOutboundDraft(draft) {
+    const parsedArtifacts = parseQqMediaSegments(draft.text)
+        .filter((segment) => segment.type === "media")
+        .map((segment) => buildMediaArtifactFromReference(segment.reference));
+    const mergedArtifacts = dedupeArtifacts([
+        ...(draft.mediaArtifacts ?? []),
+        ...parsedArtifacts
+    ]);
+    if (mergedArtifacts.length === 0) {
+        return draft;
+    }
+    return {
+        ...draft,
+        mediaArtifacts: mergedArtifacts
+    };
+}
+function dedupeArtifacts(artifacts) {
+    const seen = new Set();
+    const deduped = [];
+    for (const artifact of artifacts) {
+        const key = buildArtifactKey(artifact);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(artifact);
+    }
+    return deduped;
+}
+function buildArtifactKey(artifact) {
+    return [
+        artifact.kind,
+        artifact.localPath || "",
+        artifact.sourceUrl || "",
+        artifact.originalName || ""
+    ].join("::");
+}

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

@@ -0,0 +1,51 @@
+export function formatQqOutboundDraft(draft) {
+    const formattedText = formatQqOutboundText(draft.text, draft.mediaArtifacts ?? []);
+    if (formattedText === draft.text) {
+        return draft;
+    }
+    return {
+        ...draft,
+        text: formattedText
+    };
+}
+export function formatQqOutboundText(text, mediaArtifacts) {
+    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 lines = text.split("\n");
+    const normalizedLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            normalizedLines.push("");
+            continue;
+        }
+        if (pathSet.has(stripWrapping(trimmed))) {
+            continue;
+        }
+        if (containsOnlyArtifactPath(trimmed, pathSet)) {
+            continue;
+        }
+        if (hasMediaArtifacts && shouldDropInternalBridgeLine(trimmed)) {
+            continue;
+        }
+        normalizedLines.push(line);
+    }
+    return normalizedLines
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\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/"));
+}

package/dist/packages/orchestrator/src/qqbot-skill-context.js

@@ -0,0 +1,13 @@
+export function buildQqbotSkillContext(message) {
+    const lines = [
+        `会话类型：${message.chatType === "group" ? "QQ 群聊" : "QQ 私聊"}`,
+        "给 QQ 用户发图片、语音、视频、文件时，必须输出 <qqmedia>绝对路径或URL</qqmedia>。",
+        "如果已经准备好本地文件，直接输出媒体标签，不要解释 bridge、runtime/media、相对路径或内部实现。",
+        "多个媒体用多个 <qqmedia> 标签；正文只保留用户真正需要看的说明。",
+        "大小限制：图片 30MB、语音 20MB、视频/文件 100MB。"
+    ];
+    return lines.join("\n");
+}
+export function shouldInjectQqbotSkillContext(message) {
+    return message.accountKey.startsWith("qqbot:");
+}

package/dist/packages/orchestrator/src/session-key.js

@@ -0,0 +1,6 @@
+export function buildPeerKey(input) {
+    return input.chatType === "c2c" ? `qq:c2c:${input.peerId}` : `qq:group:${input.peerId}`;
+}
+export function buildSessionKey(input) {
+    return `${input.accountKey}::${input.peerKey}`;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+import { createHash } from "node:crypto";
+function digest(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export class SqliteTranscriptStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async recordInbound(message) {
+        this.db
+            .prepare(`INSERT OR IGNORE INTO message_ledger (
+          message_id, session_key, direction, qq_message_ref, codex_turn_ref,
+          content_digest, payload_json, created_at
+        ) VALUES (?, ?, 'inbound', ?, NULL, ?, ?, ?)`)
+            .run(message.messageId, message.sessionKey, message.messageId, digest(message.text), JSON.stringify(message), message.receivedAt);
+    }
+    async recordOutbound(draft) {
+        this.db
+            .prepare(`INSERT OR IGNORE INTO delivery_jobs (
+          job_id, session_key, status, attempt_count, payload_json, last_error, created_at, updated_at
+        ) VALUES (?, ?, 'pending', 0, ?, NULL, ?, ?)`)
+            .run(draft.draftId, draft.sessionKey, JSON.stringify(draft), draft.createdAt, draft.createdAt);
+    }
+    async hasInbound(messageId) {
+        const row = this.db.prepare(`SELECT 1 FROM message_ledger WHERE message_id = ? AND direction = 'inbound'`).get(messageId);
+        return row !== undefined && row !== null;
+    }
+    async listRecentConversation(sessionKey, limit) {
+        const rows = this.db
+            .prepare(`SELECT direction, text, created_at AS createdAt
+         FROM (
+           SELECT direction,
+                  json_extract(payload_json, '$.text') AS text,
+                  created_at
+           FROM message_ledger
+           WHERE session_key = ?
+
+           UNION ALL
+
+           SELECT 'outbound' AS direction,
+                  json_extract(payload_json, '$.text') AS text,
+                  created_at
+           FROM delivery_jobs
+           WHERE session_key = ?
+         )
+         WHERE text IS NOT NULL AND text != ''
+         ORDER BY createdAt DESC
+         LIMIT ?`)
+            .all(sessionKey, sessionKey, limit);
+        return rows.reverse();
+    }
+}

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

@@ -0,0 +1,80 @@
+import { randomUUID } from "node:crypto";
+export class SqliteSessionStore {
+    db;
+    sessionLockTails = new Map();
+    constructor(db) {
+        this.db = db;
+    }
+    async getSession(sessionKey) {
+        const row = this.db
+            .prepare(`SELECT session_key AS sessionKey,
+                account_key AS accountKey,
+                peer_key AS peerKey,
+                chat_type AS chatType,
+                peer_id AS peerId,
+                codex_thread_ref AS codexThreadRef,
+                skill_context_key AS skillContextKey,
+                status,
+                last_inbound_at AS lastInboundAt,
+                last_outbound_at AS lastOutboundAt,
+                last_error AS lastError
+         FROM bridge_sessions
+         WHERE session_key = ?`)
+            .get(sessionKey);
+        return row ?? null;
+    }
+    async createSession(session) {
+        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);
+    }
+    async updateSessionStatus(sessionKey, status, lastError = null) {
+        this.db
+            .prepare(`UPDATE bridge_sessions SET status = ?, last_error = ? WHERE session_key = ?`)
+            .run(status, lastError, sessionKey);
+    }
+    async updateBinding(sessionKey, codexThreadRef) {
+        this.db
+            .prepare(`UPDATE bridge_sessions SET codex_thread_ref = ? WHERE session_key = ?`)
+            .run(codexThreadRef, sessionKey);
+    }
+    async updateSkillContextKey(sessionKey, skillContextKey) {
+        this.db
+            .prepare(`UPDATE bridge_sessions SET skill_context_key = ? WHERE session_key = ?`)
+            .run(skillContextKey, 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();
+        let releaseCurrent;
+        const currentTail = new Promise((resolve) => {
+            releaseCurrent = resolve;
+        });
+        const queuedTail = previousTail.then(() => currentTail);
+        this.sessionLockTails.set(sessionKey, queuedTail);
+        await previousTail;
+        const owner = randomUUID();
+        const lockedAt = new Date().toISOString();
+        const expiresAt = new Date(Date.now() + 60_000).toISOString();
+        this.db
+            .prepare(`DELETE FROM session_locks WHERE session_key = ?`)
+            .run(sessionKey);
+        this.db
+            .prepare(`INSERT OR REPLACE INTO session_locks (session_key, owner, locked_at, expires_at)
+         VALUES (?, ?, ?, ?)`)
+            .run(sessionKey, owner, lockedAt, expiresAt);
+        try {
+            return await work();
+        }
+        finally {
+            this.db.prepare(`DELETE FROM session_locks WHERE session_key = ? AND owner = ?`).run(sessionKey, owner);
+            releaseCurrent();
+            if (this.sessionLockTails.get(sessionKey) === queuedTail) {
+                this.sessionLockTails.delete(sessionKey);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const BetterSqlite3 = require("better-sqlite3");
+export function createSqliteDatabase(filePath) {
+    if (filePath !== ":memory:") {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    const db = new BetterSqlite3(filePath);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS bridge_sessions (
+      session_key TEXT PRIMARY KEY,
+      account_key TEXT NOT NULL,
+      peer_key TEXT NOT NULL,
+      chat_type TEXT NOT NULL,
+      peer_id TEXT NOT NULL,
+      codex_thread_ref TEXT,
+      skill_context_key TEXT,
+      status TEXT NOT NULL,
+      last_inbound_at TEXT,
+      last_outbound_at TEXT,
+      last_error TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS message_ledger (
+      message_id TEXT PRIMARY KEY,
+      session_key TEXT NOT NULL,
+      direction TEXT NOT NULL,
+      qq_message_ref TEXT,
+      codex_turn_ref TEXT,
+      content_digest TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS delivery_jobs (
+      job_id TEXT PRIMARY KEY,
+      session_key TEXT NOT NULL,
+      status TEXT NOT NULL,
+      attempt_count INTEGER NOT NULL,
+      payload_json TEXT NOT NULL,
+      last_error TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS session_locks (
+      session_key TEXT PRIMARY KEY,
+      owner TEXT NOT NULL,
+      locked_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL
+    );
+  `);
+    ensureColumn(db, "bridge_sessions", "skill_context_key", "TEXT");
+    return db;
+}
+function ensureColumn(db, tableName, columnName, columnDefinition) {
+    const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
+    const hasColumn = columns.some((column) => column.name === columnName);
+    if (!hasColumn) {
+        db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${columnDefinition}`);
+    }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "qq-codex-bridge",
+  "version": "0.1.0",
+  "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",
+  "bugs": {
+    "url": "https://github.com/983033995/qq-codex-bridge/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/983033995/qq-codex-bridge.git"
+  },
+  "keywords": [
+    "bridge",
+    "cdp",
+    "codex",
+    "electron",
+    "qq",
+    "qq-bot",
+    "typescript"
+  ],
+  "bin": {
+    "qq-codex-bridge": "bin/qq-codex-bridge.js"
+  },
+  "files": [
+    "bin",
+    "dist/apps",
+    "dist/packages",
+    ".env.example",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx --env-file=.env apps/bridge-daemon/src/dev.ts",
+    "start": "node dist/apps/bridge-daemon/src/cli.js",
+    "debug:codex-workers": "tsx apps/bridge-daemon/src/debug-codex-workers.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepare-release": "pnpm run build && npm pack --dry-run",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.7.0",
+    "ws": "^8.18.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "@types/ws": "^8.5.14",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "vitest": "^3.1.1"
+  }
+}