qq-codex-bridge 0.1.3 → 0.1.4

package/dist/packages/adapters/codex-desktop/src/codex-local-rollout-reader.js

@@ -0,0 +1,227 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { parseQqMediaSegments } from "../../qq/src/qq-media-parser.js";
+const require = createRequire(import.meta.url);
+const BetterSqlite3 = require("better-sqlite3");
+export class CodexLocalRolloutReader {
+    codexHomeDir;
+    sleep;
+    constructor(options = {}) {
+        this.codexHomeDir =
+            options.codexHomeDir ??
+                process.env.CODEX_HOME ??
+                path.join(os.homedir(), ".codex");
+        this.sleep =
+            options.sleep ??
+                ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    }
+    captureCursorForThreadTitle(title) {
+        const normalizedTitle = title.trim();
+        if (!normalizedTitle) {
+            return null;
+        }
+        const thread = this.findLatestThreadByTitle(normalizedTitle);
+        if (!thread?.rolloutPath) {
+            return null;
+        }
+        if (!fs.existsSync(thread.rolloutPath)) {
+            return null;
+        }
+        return {
+            threadId: thread.threadId,
+            rolloutPath: thread.rolloutPath,
+            lineCount: countNonEmptyLines(thread.rolloutPath),
+            targetTurnId: null,
+            competingTurnStarted: false
+        };
+    }
+    async waitForTurnCompletion(cursor, options) {
+        let currentCursor = cursor;
+        let targetTurnId = cursor.targetTurnId ?? null;
+        let competingTurnStarted = cursor.competingTurnStarted ?? false;
+        const commentaryMessages = [];
+        const seenCommentaryMessages = new Set();
+        let pendingFinalText = null;
+        for (let attempt = 0; attempt < options.pollAttempts; attempt += 1) {
+            const { nextCursor, events } = readRolloutEvents(currentCursor);
+            currentCursor = {
+                ...nextCursor,
+                targetTurnId,
+                competingTurnStarted
+            };
+            for (const event of events) {
+                if (event.type !== "event_msg" || !event.payload) {
+                    continue;
+                }
+                const eventType = event.payload.type;
+                const eventTurnId = normalizeTurnId(event.payload.turn_id);
+                if (eventType === "task_started" && eventTurnId) {
+                    if (!targetTurnId) {
+                        targetTurnId = eventTurnId;
+                        competingTurnStarted = false;
+                        currentCursor.targetTurnId = targetTurnId;
+                        currentCursor.competingTurnStarted = competingTurnStarted;
+                        continue;
+                    }
+                    if (eventTurnId !== targetTurnId) {
+                        competingTurnStarted = true;
+                        currentCursor.competingTurnStarted = competingTurnStarted;
+                    }
+                    continue;
+                }
+                if (eventType === "agent_message"
+                    && event.payload.phase === "commentary"
+                    && typeof event.payload.message === "string") {
+                    if (!shouldCollectTurnScopedMessage(eventTurnId, targetTurnId, competingTurnStarted)) {
+                        continue;
+                    }
+                    const commentary = event.payload.message.trim();
+                    if (commentary && !seenCommentaryMessages.has(commentary)) {
+                        commentaryMessages.push(commentary);
+                        seenCommentaryMessages.add(commentary);
+                    }
+                    continue;
+                }
+                if (eventType === "agent_message"
+                    && event.payload.phase === "final_answer"
+                    && typeof event.payload.message === "string") {
+                    if (!shouldCollectTurnScopedMessage(eventTurnId, targetTurnId, competingTurnStarted)) {
+                        continue;
+                    }
+                    const finalAnswer = event.payload.message.trim();
+                    if (finalAnswer) {
+                        pendingFinalText = finalAnswer;
+                    }
+                    continue;
+                }
+                if (eventType === "task_complete") {
+                    if (targetTurnId && eventTurnId && eventTurnId !== targetTurnId) {
+                        continue;
+                    }
+                    const finalText = normalizeFinalText(event.payload.last_agent_message, pendingFinalText);
+                    if (!finalText) {
+                        continue;
+                    }
+                    if (!targetTurnId) {
+                        targetTurnId = eventTurnId;
+                    }
+                    const fullText = joinMessageParts(commentaryMessages, finalText);
+                    return {
+                        turnId: targetTurnId,
+                        commentaryMessages,
+                        finalText,
+                        fullText,
+                        mediaReferences: extractMediaReferences(fullText)
+                    };
+                }
+            }
+            if (attempt + 1 < options.pollAttempts) {
+                await this.sleep(options.pollIntervalMs);
+            }
+        }
+        return null;
+    }
+    findLatestThreadByTitle(title) {
+        const stateDbPath = path.join(this.codexHomeDir, "state_5.sqlite");
+        if (!fs.existsSync(stateDbPath)) {
+            return null;
+        }
+        let db = null;
+        try {
+            db = new BetterSqlite3(stateDbPath, {
+                readonly: true,
+                fileMustExist: true
+            });
+            const row = db
+                .prepare(`SELECT id AS threadId, rollout_path AS rolloutPath
+           FROM threads
+           WHERE archived = 0
+             AND title = ?
+             AND rollout_path IS NOT NULL
+           ORDER BY updated_at_ms DESC
+           LIMIT 1`)
+                .get(title);
+            return row ?? null;
+        }
+        catch {
+            return null;
+        }
+        finally {
+            db?.close();
+        }
+    }
+}
+function readRolloutEvents(cursor) {
+    if (!fs.existsSync(cursor.rolloutPath)) {
+        return {
+            nextCursor: cursor,
+            events: []
+        };
+    }
+    const contents = fs.readFileSync(cursor.rolloutPath, "utf8");
+    const lines = splitNonEmptyLines(contents);
+    const safeOffset = Math.min(cursor.lineCount, lines.length);
+    const newLines = lines.slice(safeOffset);
+    const events = newLines.flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return {
+        nextCursor: {
+            ...cursor,
+            lineCount: lines.length
+        },
+        events
+    };
+}
+function countNonEmptyLines(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return 0;
+    }
+    return splitNonEmptyLines(fs.readFileSync(filePath, "utf8")).length;
+}
+function splitNonEmptyLines(contents) {
+    return contents
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function normalizeFinalText(lastAgentMessage, pendingFinalText) {
+    if (typeof lastAgentMessage === "string" && lastAgentMessage.trim()) {
+        return lastAgentMessage.trim();
+    }
+    return pendingFinalText?.trim() ?? "";
+}
+function normalizeTurnId(turnId) {
+    if (typeof turnId !== "string") {
+        return null;
+    }
+    const normalized = turnId.trim();
+    return normalized ? normalized : null;
+}
+function shouldCollectTurnScopedMessage(eventTurnId, targetTurnId, competingTurnStarted) {
+    if (!targetTurnId) {
+        return true;
+    }
+    if (eventTurnId) {
+        return eventTurnId === targetTurnId;
+    }
+    return !competingTurnStarted;
+}
+function joinMessageParts(commentaryMessages, finalText) {
+    return [...commentaryMessages, finalText]
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join("\n");
+}
+function extractMediaReferences(text) {
+    return parseQqMediaSegments(text)
+        .filter((segment) => segment.type === "media")
+        .map((segment) => segment.reference);
+}

package/dist/packages/adapters/codex-desktop/src/codex-local-submission-reader.js

@@ -0,0 +1,142 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const BetterSqlite3 = require("better-sqlite3");
+export class CodexLocalSubmissionReader {
+    codexHomeDir;
+    sleep;
+    constructor(options = {}) {
+        this.codexHomeDir =
+            options.codexHomeDir ??
+                process.env.CODEX_HOME ??
+                path.join(os.homedir(), ".codex");
+        this.sleep =
+            options.sleep ??
+                ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    }
+    captureCursorForThreadId(threadId) {
+        const normalizedThreadId = normalizeThreadId(threadId);
+        if (!normalizedThreadId) {
+            return null;
+        }
+        const dbPath = this.resolveLogsDbPath();
+        if (!dbPath) {
+            return null;
+        }
+        let db = null;
+        try {
+            db = new BetterSqlite3(dbPath, {
+                readonly: true,
+                fileMustExist: true
+            });
+            const row = db
+                .prepare("SELECT MAX(id) AS lastLogId FROM logs")
+                .get();
+            return {
+                threadId: normalizedThreadId,
+                lastLogId: Number(row?.lastLogId ?? 0)
+            };
+        }
+        catch {
+            return null;
+        }
+        finally {
+            db?.close();
+        }
+    }
+    async waitForTurnSubmission(cursor, options) {
+        const dbPath = this.resolveLogsDbPath();
+        if (!dbPath) {
+            return {
+                submitted: false,
+                turnId: null,
+                reason: "logs_db_missing"
+            };
+        }
+        for (let attempt = 0; attempt < options.pollAttempts; attempt += 1) {
+            const submission = readSubmissionSince(dbPath, cursor);
+            if (submission) {
+                return submission;
+            }
+            if (attempt + 1 < options.pollAttempts) {
+                await this.sleep(options.pollIntervalMs);
+            }
+        }
+        return {
+            submitted: false,
+            turnId: null,
+            reason: "submission_dispatch_not_observed"
+        };
+    }
+    resolveLogsDbPath() {
+        const dbPath = path.join(this.codexHomeDir, "logs_2.sqlite");
+        return fs.existsSync(dbPath) ? dbPath : null;
+    }
+}
+function readSubmissionSince(dbPath, cursor) {
+    let db = null;
+    try {
+        db = new BetterSqlite3(dbPath, {
+            readonly: true,
+            fileMustExist: true
+        });
+        const rows = db
+            .prepare(`SELECT id, target, feedback_log_body AS feedbackLogBody, thread_id AS threadId
+         FROM logs
+         WHERE id > ?
+         ORDER BY id ASC`)
+            .all(cursor.lastLogId);
+        if (rows.length === 0) {
+            return null;
+        }
+        cursor.lastLogId = rows.at(-1)?.id ?? cursor.lastLogId;
+        for (const row of rows) {
+            if (row.target !== "codex_client::transport") {
+                continue;
+            }
+            const body = typeof row.feedbackLogBody === "string" ? row.feedbackLogBody : "";
+            if (!body.includes("submission_dispatch")) {
+                continue;
+            }
+            if (!matchesSubmissionThread(row.threadId, body, cursor.threadId)) {
+                continue;
+            }
+            return {
+                submitted: true,
+                turnId: extractTurnId(body),
+                reason: "submission_dispatch_logged"
+            };
+        }
+        return null;
+    }
+    catch {
+        return {
+            submitted: false,
+            turnId: null,
+            reason: "logs_db_unreadable"
+        };
+    }
+    finally {
+        db?.close();
+    }
+}
+function matchesSubmissionThread(rowThreadId, body, expectedThreadId) {
+    if (rowThreadId === expectedThreadId) {
+        return true;
+    }
+    return body.includes(`thread.id=${expectedThreadId}`) || body.includes(`thread_id=${expectedThreadId}`);
+}
+function extractTurnId(body) {
+    const match = body.match(/turn(?:\.id|_id)=([^\s}]+)/);
+    if (!match?.[1]) {
+        return null;
+    }
+    const turnId = match[1].trim();
+    return turnId ? turnId : null;
+}
+function normalizeThreadId(threadId) {
+    const normalized = threadId.trim();
+    return normalized ? normalized : null;
+}

package/dist/packages/adapters/weixin/src/weixin-channel-adapter.js

@@ -0,0 +1,15 @@
+import { WeixinHttpClient } from "./weixin-http-client.js";
+import { WeixinSender } from "./weixin-sender.js";
+import { normalizeWeixinInboundMessage } from "./weixin-webhook.js";
+export function createWeixinChannelAdapter(config) {
+    const apiClient = new WeixinHttpClient(config.egressBaseUrl, config.egressToken);
+    return {
+        webhook: {
+            routePath: config.webhookPath,
+            toInboundMessage: (payload) => normalizeWeixinInboundMessage(payload, {
+                accountKey: config.accountKey
+            })
+        },
+        egress: new WeixinSender(apiClient)
+    };
+}

package/dist/packages/adapters/weixin/src/weixin-http-client.js

@@ -0,0 +1,42 @@
+export class WeixinHttpClient {
+    baseUrl;
+    token;
+    fetchFn;
+    constructor(baseUrl, token, options = {}) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.fetchFn = options.fetchFn ?? fetch;
+    }
+    async sendTextMessage(target) {
+        return this.sendMessage({
+            peerId: target.peerId,
+            chatType: target.chatType,
+            content: target.content,
+            ...(target.replyToMessageId ? { replyToMessageId: target.replyToMessageId } : {})
+        });
+    }
+    async sendMessage(target) {
+        const response = await this.fetchFn(`${this.baseUrl}/messages`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.token}`,
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({
+                ...(target.accountKey ? { accountKey: target.accountKey } : {}),
+                ...(target.accountId ? { accountId: target.accountId } : {}),
+                peerId: target.peerId,
+                chatType: target.chatType,
+                ...(target.content ? { content: target.content } : {}),
+                ...(target.mediaArtifacts?.length ? { mediaArtifacts: target.mediaArtifacts } : {}),
+                ...(target.replyToMessageId ? { replyToMessageId: target.replyToMessageId } : {})
+            })
+        });
+        if (!response.ok) {
+            const responseText = await response.text().catch(() => "");
+            throw new Error(`Weixin message send failed: ${response.status}${responseText ? ` ${responseText}` : ""}`);
+        }
+        const payload = (await response.json().catch(() => ({})));
+        return payload.id ?? null;
+    }
+}

package/dist/packages/adapters/weixin/src/weixin-sender.js

@@ -0,0 +1,200 @@
+import { buildMediaArtifactFromReference, parseQqMediaSegments } from "../../qq/src/qq-media-parser.js";
+const WEIXIN_TEXT_SEGMENT_MAX_LENGTH = 1800;
+export class WeixinSender {
+    apiClient;
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async deliver(draft) {
+        const providerMessageId = await this.deliverThroughApiClient(draft);
+        return {
+            jobId: draft.draftId,
+            sessionKey: draft.sessionKey,
+            providerMessageId,
+            deliveredAt: draft.createdAt
+        };
+    }
+    async deliverThroughApiClient(draft) {
+        if (!this.apiClient) {
+            return null;
+        }
+        const target = parseSessionTarget(draft.sessionKey);
+        const parsedArtifacts = parseQqMediaSegments(draft.text)
+            .filter((segment) => segment.type === "media")
+            .map((segment) => buildMediaArtifactFromReference(segment.reference));
+        const mediaArtifacts = dedupeArtifacts([...(draft.mediaArtifacts ?? []), ...parsedArtifacts]);
+        const content = extractTextContent(draft.text);
+        const segments = buildWeixinOutboundSegments({
+            peerId: target.peerId,
+            chatType: target.chatType,
+            accountKey: target.accountKey,
+            accountId: target.accountId,
+            content,
+            mediaArtifacts,
+            replyToMessageId: draft.replyToMessageId
+        });
+        let lastProviderMessageId = null;
+        for (const segment of segments) {
+            lastProviderMessageId = await this.apiClient.sendMessage(segment);
+        }
+        return lastProviderMessageId;
+    }
+}
+function buildWeixinOutboundSegments(input) {
+    const segments = [];
+    for (const contentSegment of splitWeixinTextContent(input.content)) {
+        segments.push({
+            peerId: input.peerId,
+            chatType: input.chatType,
+            accountKey: input.accountKey,
+            accountId: input.accountId,
+            content: contentSegment,
+            ...(input.replyToMessageId ? { replyToMessageId: input.replyToMessageId } : {})
+        });
+    }
+    for (const artifact of input.mediaArtifacts) {
+        segments.push({
+            peerId: input.peerId,
+            chatType: input.chatType,
+            accountKey: input.accountKey,
+            accountId: input.accountId,
+            mediaArtifacts: [artifact],
+            ...(input.replyToMessageId ? { replyToMessageId: input.replyToMessageId } : {})
+        });
+    }
+    return segments;
+}
+function splitWeixinTextContent(content, maxLength = WEIXIN_TEXT_SEGMENT_MAX_LENGTH) {
+    const text = content.trim();
+    if (!text) {
+        return [];
+    }
+    if (text.length <= maxLength) {
+        return [text];
+    }
+    const chunks = [];
+    let current = "";
+    const flushCurrent = () => {
+        const trimmed = current.trim();
+        if (trimmed) {
+            chunks.push(trimmed);
+        }
+        current = "";
+    };
+    const appendPart = (part) => {
+        if (!part) {
+            return;
+        }
+        if (current && current.length + part.length > maxLength) {
+            flushCurrent();
+        }
+        if (part.length <= maxLength) {
+            current += part;
+            return;
+        }
+        for (const piece of splitOversizedPart(part, maxLength)) {
+            if (current && current.length + piece.length > maxLength) {
+                flushCurrent();
+            }
+            if (piece.length > maxLength) {
+                flushCurrent();
+                chunks.push(piece.trim());
+            }
+            else {
+                current += piece;
+            }
+        }
+    };
+    for (const part of splitIntoParagraphParts(text)) {
+        appendPart(part);
+    }
+    flushCurrent();
+    return chunks;
+}
+function splitIntoParagraphParts(text) {
+    const rawParts = text.split(/(\n{2,})/);
+    const parts = [];
+    for (let index = 0; index < rawParts.length; index += 2) {
+        const body = rawParts[index] ?? "";
+        const separator = rawParts[index + 1] ?? "";
+        if (body || separator) {
+            parts.push(`${body}${separator}`);
+        }
+    }
+    return parts;
+}
+function splitOversizedPart(part, maxLength) {
+    const lines = part.split(/(?<=\n)/);
+    const pieces = [];
+    let current = "";
+    const flushCurrent = () => {
+        if (current) {
+            pieces.push(current);
+            current = "";
+        }
+    };
+    for (const line of lines) {
+        if (line.length > maxLength) {
+            flushCurrent();
+            pieces.push(...splitByLength(line, maxLength));
+            continue;
+        }
+        if (current && current.length + line.length > maxLength) {
+            flushCurrent();
+        }
+        current += line;
+    }
+    flushCurrent();
+    return pieces;
+}
+function splitByLength(text, maxLength) {
+    const chars = Array.from(text);
+    const chunks = [];
+    for (let index = 0; index < chars.length; index += maxLength) {
+        chunks.push(chars.slice(index, index + maxLength).join(""));
+    }
+    return chunks;
+}
+function extractTextContent(text) {
+    const parts = parseQqMediaSegments(text)
+        .filter((segment) => segment.type === "text")
+        .map((segment) => segment.text)
+        .join("")
+        .trim();
+    return parts;
+}
+function dedupeArtifacts(artifacts) {
+    const seen = new Set();
+    const deduped = [];
+    for (const artifact of artifacts) {
+        const key = [
+            artifact.kind,
+            artifact.localPath || "",
+            artifact.sourceUrl || "",
+            artifact.originalName || ""
+        ].join("::");
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(artifact);
+    }
+    return deduped;
+}
+function parseSessionTarget(sessionKey) {
+    const parts = sessionKey.split("::");
+    const accountKey = parts.at(0) ?? "";
+    const scope = parts.at(-1) ?? "";
+    const segments = scope.split(":");
+    const chatType = segments.at(-2);
+    const peerId = segments.at(-1);
+    if (!accountKey || (chatType !== "c2c" && chatType !== "group") || !peerId) {
+        throw new Error(`Unable to parse channel session key: ${sessionKey}`);
+    }
+    return {
+        accountKey,
+        accountId: accountKey.startsWith("weixin:") ? accountKey.slice("weixin:".length) : accountKey,
+        chatType,
+        peerId
+    };
+}

package/dist/packages/adapters/weixin/src/weixin-webhook.js

@@ -0,0 +1,35 @@
+export function normalizeWeixinInboundMessage(payload, options) {
+    const chatType = payload.chatType === "group" ? "group" : "c2c";
+    const senderId = String(payload.senderId ?? "").trim();
+    const peerId = String(payload.peerId ?? senderId).trim();
+    const messageId = String(payload.messageId ?? "").trim();
+    const text = String(payload.text ?? "").trim();
+    const receivedAt = normalizeTimestamp(payload.receivedAt);
+    if (!senderId || !peerId || !messageId || !text) {
+        throw new Error("invalid weixin webhook payload");
+    }
+    return {
+        messageId,
+        accountKey: options.accountKey,
+        sessionKey: buildSessionKey(options.accountKey, chatType, peerId),
+        peerKey: buildPeerKey(chatType, peerId),
+        chatType,
+        senderId,
+        text,
+        receivedAt
+    };
+}
+function buildSessionKey(accountKey, chatType, peerId) {
+    return `${accountKey}::wx:${chatType}:${peerId}`;
+}
+function buildPeerKey(chatType, peerId) {
+    return `wx:${chatType}:${peerId}`;
+}
+function normalizeTimestamp(value) {
+    const input = String(value ?? "").trim();
+    if (!input) {
+        return new Date().toISOString();
+    }
+    const parsed = Date.parse(input);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : new Date().toISOString();
+}