qq-codex-bridge 0.1.2 → 0.1.4

package/dist/packages/adapters/chatgpt-desktop/src/driver.js

@@ -0,0 +1,161 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { checkAccessibility, clickChatByTitle, clickNewChat, ensureAppVisible, getCurrentWindowTitle, healthCheck, listRecentChats, sendMessage } from "./ax-client.js";
+import { diffCache, isCacheDirReachable, saveToDest, snapshotCache, waitForCacheImages } from "./image-cache.js";
+import { ChatgptSessionRegistry } from "./session-registry.js";
+const DEFAULT_DEST_DIR = join(process.cwd(), "runtime", "media", "chatgpt");
+const DEFAULT_TEXT_TIMEOUT_MS = 60_000;
+const DEFAULT_IMAGE_TIMEOUT_MS = 180_000;
+export class ChatgptDesktopDriver {
+    registry;
+    destDir;
+    constructor(opts = {}) {
+        this.registry = new ChatgptSessionRegistry(opts.registryPath);
+        this.destDir = opts.destDir ?? DEFAULT_DEST_DIR;
+    }
+    async health() {
+        const { appRunning, accessibility, frontmost } = healthCheck();
+        const cacheDirFound = isCacheDirReachable();
+        return {
+            ok: appRunning && accessibility && cacheDirFound,
+            appRunning,
+            accessibility,
+            cacheDirFound,
+            frontmost
+        };
+    }
+    listChats(maxCount = 20) {
+        return listRecentChats(maxCount);
+    }
+    switchToChat(title) {
+        return clickChatByTitle(title);
+    }
+    markSwitched(sessionKey, threadTitle) {
+        // signal that user manually switched to a thread — next run() should skip clickNewChat
+        this.registry.set(sessionKey, threadTitle ?? "__switched__", null);
+    }
+    newChat(sessionKey) {
+        if (sessionKey) {
+            this.registry.delete(sessionKey);
+        }
+        clickNewChat();
+    }
+    getSessionThreadRef(sessionKey) {
+        return this.registry.get(sessionKey)?.threadRef ?? null;
+    }
+    getCurrentThreadTitle() {
+        return getCurrentWindowTitle();
+    }
+    async run(input) {
+        const t0 = Date.now();
+        const turnId = randomUUID();
+        if (!checkAccessibility()) {
+            return {
+                ok: false,
+                provider: "chatgpt-desktop",
+                errorCode: "accessibility_denied",
+                message: "Accessibility permission not granted. Enable in System Settings > Privacy > Accessibility."
+            };
+        }
+        try {
+            ensureAppVisible();
+        }
+        catch (err) {
+            return {
+                ok: false,
+                provider: "chatgpt-desktop",
+                errorCode: "app_not_ready",
+                message: err instanceof Error ? err.message : String(err)
+            };
+        }
+        // decide whether to open a new thread
+        const existing = input.sessionKey ? this.registry.get(input.sessionKey) : null;
+        // skip clickNewChat if: registry has an entry (continuing thread) OR user manually switched ("__switched__" sentinel)
+        const needNewThread = !existing;
+        if (needNewThread) {
+            try {
+                clickNewChat();
+            }
+            catch {
+                // non-fatal: may already be on a fresh thread
+            }
+        }
+        const beforeCache = await snapshotCache();
+        const timeoutMs = input.timeoutMs ?? (input.mode === "image" ? DEFAULT_IMAGE_TIMEOUT_MS : DEFAULT_TEXT_TIMEOUT_MS);
+        const { confirmed, completed, elapsedMs, replyTexts } = sendMessage(input.prompt, {
+            attachmentPaths: input.attachmentPaths,
+            confirmTimeoutMs: input.attachmentPaths?.length ? 20_000 : 8_000,
+            completionTimeoutMs: timeoutMs
+        });
+        if (!confirmed) {
+            return {
+                ok: false,
+                provider: "chatgpt-desktop",
+                errorCode: "send_failed",
+                message: "Message was sent but 'Stop generating' button never appeared — ChatGPT may not have accepted the input."
+            };
+        }
+        if (!completed) {
+            return {
+                ok: false,
+                provider: "chatgpt-desktop",
+                errorCode: "reply_timeout",
+                message: `Timed out waiting for ChatGPT Desktop reply after ${timeoutMs}ms`
+            };
+        }
+        // collect window title for session registry; use as threadRef so we can navigate back
+        const windowTitle = getCurrentWindowTitle();
+        if (input.sessionKey) {
+            this.registry.set(input.sessionKey, windowTitle ?? existing?.threadRef ?? null, windowTitle);
+        }
+        // collect text reply (replyTexts already diffed inside Swift process)
+        const replyText = replyTexts
+            .filter((t) => t.length > 0)
+            .join("\n")
+            .trim();
+        // collect images (for image mode, or if images appeared in text mode)
+        const media = [];
+        const cacheImages = input.mode === "image"
+            ? await waitForCacheImages(beforeCache, { timeoutMs: 45_000, intervalMs: 1_000 })
+            : await diffCache(beforeCache);
+        const newCacheFiles = input.mode === "image" ? cacheImages.slice(-1) : cacheImages;
+        if (newCacheFiles.length > 0) {
+            const prefix = `chatgpt-${turnId.slice(0, 8)}`;
+            const saved = await saveToDest(newCacheFiles, this.destDir, prefix);
+            for (const s of saved) {
+                media.push({
+                    kind: "image",
+                    localPath: s.localPath,
+                    mimeType: s.mimeType,
+                    fileSize: s.fileSize,
+                    originalName: s.originalName
+                });
+            }
+        }
+        if (input.mode === "image" && media.length === 0) {
+            return {
+                ok: false,
+                provider: "chatgpt-desktop",
+                errorCode: "image_not_found",
+                message: "No new image found in Kingfisher cache after generation completed."
+            };
+        }
+        if (!replyText && media.length === 0) {
+            return {
+                ok: false,
+                provider: "chatgpt-desktop",
+                errorCode: "reply_parse_failed",
+                message: "Reply completed but no text or images were collected from AX tree."
+            };
+        }
+        return {
+            ok: true,
+            provider: "chatgpt-desktop",
+            threadRef: existing?.threadRef ?? null,
+            turnId,
+            text: replyText,
+            media,
+            elapsedMs: Date.now() - t0
+        };
+    }
+}

package/dist/packages/adapters/chatgpt-desktop/src/image-cache.js

@@ -0,0 +1,155 @@
+import { createReadStream, readdirSync } from "node:fs";
+import { copyFile, mkdir, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, relative } from "node:path";
+const DEFAULT_CACHE_DIR = join(homedir(), "Library/Caches/com.openai.chat", "com.onevcat.Kingfisher.ImageCache", "com.onevcat.Kingfisher.ImageCache.com.openai.chat");
+const MIN_IMAGE_BYTES = 50_000;
+function cacheDir() {
+    return process.env.CHATGPT_DESKTOP_CACHE_DIR ?? DEFAULT_CACHE_DIR;
+}
+async function listCacheFiles(dir = cacheDir()) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await listCacheFiles(fullPath);
+            files.push(...nested.map((file) => ({
+                name: relative(dir, file.path),
+                path: file.path
+            })));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push({
+                name: relative(dir, fullPath),
+                path: fullPath
+            });
+        }
+    }
+    return files;
+}
+export async function snapshotCache() {
+    const timestamp = Date.now();
+    try {
+        const files = await listCacheFiles();
+        return { files: new Set(files.map((file) => file.name)), timestamp };
+    }
+    catch {
+        return { files: new Set(), timestamp };
+    }
+}
+async function readMagicBytes(filePath, n) {
+    return new Promise((resolve, reject) => {
+        const buf = [];
+        let collected = 0;
+        const stream = createReadStream(filePath, { start: 0, end: n - 1 });
+        stream.on("data", (chunk) => {
+            const b = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            buf.push(b);
+            collected += b.length;
+        });
+        stream.on("end", () => resolve(Buffer.concat(buf, collected)));
+        stream.on("error", reject);
+    });
+}
+function detectMime(magic) {
+    if (magic.length < 4)
+        return null;
+    if (magic[0] === 0x89 && magic[1] === 0x50 && magic[2] === 0x4e && magic[3] === 0x47)
+        return "image/png";
+    if (magic[0] === 0xff && magic[1] === 0xd8 && magic[2] === 0xff)
+        return "image/jpeg";
+    if (magic[0] === 0x52 && magic[1] === 0x49 && magic[2] === 0x46 && magic[3] === 0x46 &&
+        magic.length >= 12 &&
+        magic[8] === 0x57 && magic[9] === 0x45 && magic[10] === 0x42 && magic[11] === 0x50)
+        return "image/webp";
+    if (magic[0] === 0x47 && magic[1] === 0x49 && magic[2] === 0x46)
+        return "image/gif";
+    return null;
+}
+export async function diffCache(before) {
+    let current;
+    try {
+        current = await listCacheFiles();
+    }
+    catch {
+        return [];
+    }
+    const images = [];
+    for (const { name, path: fullPath } of current) {
+        if (before.files.has(name)) {
+            continue;
+        }
+        try {
+            const info = await stat(fullPath);
+            if (!info.isFile() || info.size < MIN_IMAGE_BYTES)
+                continue;
+            const magic = await readMagicBytes(fullPath, 16);
+            const mimeType = detectMime(magic);
+            if (!mimeType)
+                continue;
+            images.push({
+                sourcePath: fullPath,
+                fileName: name,
+                mimeType,
+                fileSize: info.size,
+                createdAtMs: Math.max(info.birthtimeMs, info.ctimeMs)
+            });
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return images.sort((a, b) => a.createdAtMs - b.createdAtMs);
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export async function waitForCacheImages(before, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    const intervalMs = options.intervalMs ?? 1_000;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const images = await diffCache(before);
+        if (images.length > 0 || Date.now() >= deadline) {
+            return images;
+        }
+        await delay(intervalMs);
+    }
+}
+const EXT = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif"
+};
+export async function saveToDest(images, destDir, prefix) {
+    await mkdir(destDir, { recursive: true });
+    const saved = [];
+    for (let i = 0; i < images.length; i++) {
+        const img = images[i];
+        const ext = EXT[img.mimeType] ?? ".bin";
+        const name = `${prefix}-${String(i + 1).padStart(3, "0")}${ext}`;
+        const dest = join(destDir, name);
+        await copyFile(img.sourcePath, dest);
+        saved.push({
+            localPath: dest,
+            originalName: name,
+            mimeType: img.mimeType,
+            fileSize: img.fileSize
+        });
+    }
+    return saved;
+}
+export function isCacheDirReachable() {
+    try {
+        readdirSync(cacheDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/packages/adapters/chatgpt-desktop/src/session-registry.js

@@ -0,0 +1,48 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const DEFAULT_REGISTRY_PATH = join(homedir(), ".qq-codex-bridge", "chatgpt-session-registry.json");
+export class ChatgptSessionRegistry {
+    path;
+    data;
+    constructor(registryPath) {
+        this.path = registryPath ?? DEFAULT_REGISTRY_PATH;
+        this.data = this.load();
+    }
+    load() {
+        if (!existsSync(this.path)) {
+            return { version: 1, entries: {} };
+        }
+        try {
+            const raw = readFileSync(this.path, "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return { version: 1, entries: {} };
+        }
+    }
+    save() {
+        const dir = join(this.path, "..");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(this.path, JSON.stringify(this.data, null, 2), "utf-8");
+    }
+    get(sessionKey) {
+        return this.data.entries[sessionKey] ?? null;
+    }
+    set(sessionKey, threadRef, windowTitle) {
+        this.data.entries[sessionKey] = {
+            sessionKey,
+            threadRef,
+            windowTitle: windowTitle ?? null,
+            updatedAt: new Date().toISOString()
+        };
+        this.save();
+    }
+    delete(sessionKey) {
+        delete this.data.entries[sessionKey];
+        this.save();
+    }
+    all() {
+        return Object.values(this.data.entries);
+    }
+}

package/dist/packages/adapters/chatgpt-desktop/src/types.js

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