qq-codex-bridge 0.1.0

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

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { ZodError } from "zod";
+import { loadConfigFromEnv } from "./config.js";
+import { ensureCodexDesktopForDev } from "./dev-launch.js";
+import { runBridgeDaemon } from "./main.js";
+const REQUIRED_ENV_MAP = {
+    "qqBot.appId": "QQBOT_APP_ID",
+    "qqBot.clientSecret": "QQBOT_CLIENT_SECRET",
+    "codexDesktop.appName": "CODEX_APP_NAME",
+    "codexDesktop.remoteDebuggingPort": "CODEX_REMOTE_DEBUGGING_PORT"
+};
+export async function runCli(rawArgs, deps = {}) {
+    const args = normalizeArgs(rawArgs);
+    const cwd = deps.cwd ?? process.cwd();
+    const env = deps.env ?? process.env;
+    const packageRoot = deps.packageRoot ?? findPackageRoot(path.dirname(fileURLToPath(import.meta.url)));
+    const writeStdout = deps.writeStdout ?? ((line) => console.log(line));
+    const writeStderr = deps.writeStderr ?? ((line) => console.error(line));
+    const ensureDesktop = deps.ensureCodexDesktop ?? ensureCodexDesktopForDev;
+    const startBridge = deps.runBridgeDaemon ?? runBridgeDaemon;
+    if (args[0] === "init") {
+        return initEnvTemplate({
+            cwd,
+            packageRoot,
+            writeStdout,
+            writeStderr
+        });
+    }
+    if (args[0] === "help" || args[0] === "-h" || args[0] === "--help") {
+        printHelp(writeStdout);
+        return 0;
+    }
+    if (args.length > 0) {
+        writeStderr(`[qq-codex-bridge] 未知命令：${args.join(" ")}`);
+        printHelp(writeStdout);
+        return 1;
+    }
+    const envFilePath = path.join(cwd, ".env");
+    if (fs.existsSync(envFilePath)) {
+        const loadEnvFile = deps.loadEnvFile ?? process.loadEnvFile.bind(process);
+        loadEnvFile(envFilePath);
+    }
+    try {
+        const config = loadConfigFromEnv(env);
+        const result = await ensureDesktop({
+            appName: config.codexDesktop.appName,
+            remoteDebuggingPort: config.codexDesktop.remoteDebuggingPort,
+            startupTimeoutMs: Number(env.CODEX_CDP_STARTUP_TIMEOUT_MS ?? "15000"),
+            startupPollIntervalMs: Number(env.CODEX_CDP_POLL_INTERVAL_MS ?? "500")
+        });
+        writeStdout(`[qq-codex-bridge] codex desktop ready { launched: ${String(result.launched)}, remoteDebuggingPort: ${config.codexDesktop.remoteDebuggingPort} }`);
+        await startBridge();
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            writeStderr(formatConfigError(error, cwd));
+            return 1;
+        }
+        const cause = error instanceof Error ? error.cause : undefined;
+        writeStderr(`[qq-codex-bridge] fatal: ${error instanceof Error ? error.message : String(error)}`);
+        if (cause !== undefined) {
+            writeStderr(`  caused by: ${String(cause)}`);
+        }
+        if (error instanceof Error && error.stack) {
+            writeStderr(`  stack: ${error.stack}`);
+        }
+        return 1;
+    }
+}
+export async function runCliFromProcess() {
+    process.exitCode = await runCli(process.argv.slice(2));
+}
+function initEnvTemplate(options) {
+    const targetPath = path.join(options.cwd, ".env");
+    if (fs.existsSync(targetPath)) {
+        options.writeStderr(`[qq-codex-bridge] .env 已存在：${targetPath}`);
+        options.writeStderr("[qq-codex-bridge] 如需重新生成，请先手动备份或删除现有文件。");
+        return 1;
+    }
+    const templatePath = path.join(options.packageRoot, ".env.example");
+    const template = fs.readFileSync(templatePath, "utf8");
+    fs.writeFileSync(targetPath, template, "utf8");
+    options.writeStdout(`[qq-codex-bridge] 已生成配置模板：${targetPath}`);
+    options.writeStdout("[qq-codex-bridge] 请先填写 QQBOT_APP_ID 和 QQBOT_CLIENT_SECRET，再执行 `qq-codex-bridge`。");
+    return 0;
+}
+function printHelp(writeStdout) {
+    writeStdout("qq-codex-bridge");
+    writeStdout("");
+    writeStdout("用法：");
+    writeStdout("  qq-codex-bridge        启动桥接守护进程");
+    writeStdout("  qq-codex-bridge init   在当前目录生成 .env");
+    writeStdout("  qq-codex-bridge help   查看帮助");
+}
+function formatConfigError(error, cwd) {
+    const missingVars = Array.from(new Set(error.issues
+        .map((issue) => REQUIRED_ENV_MAP[issue.path.join(".")])
+        .filter((value) => Boolean(value))));
+    const lines = [`[qq-codex-bridge] 配置不完整，无法启动。`];
+    if (missingVars.length > 0) {
+        lines.push(`[qq-codex-bridge] 缺少或无效的关键变量：${missingVars.join(", ")}`);
+    }
+    lines.push(`[qq-codex-bridge] 请在当前目录准备 .env：${path.join(cwd, ".env")}`);
+    lines.push("[qq-codex-bridge] 如果还没有配置文件，可先执行：qq-codex-bridge init");
+    return lines.join("\n");
+}
+function normalizeArgs(args) {
+    return args.filter((arg) => arg.length > 0);
+}
+function findPackageRoot(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        if (fs.existsSync(path.join(currentDir, "package.json"))) {
+            return currentDir;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            throw new Error(`Unable to locate package root from ${startDir}`);
+        }
+        currentDir = parentDir;
+    }
+}
+const isEntrypoint = (() => {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        return false;
+    }
+    try {
+        return fileURLToPath(import.meta.url) === path.resolve(entrypoint);
+    }
+    catch {
+        return false;
+    }
+})();
+if (isEntrypoint) {
+    void runCliFromProcess();
+}

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

@@ -0,0 +1,109 @@
+import { z } from "zod";
+export const appConfigSchema = z.object({
+    databasePath: z.string().min(1),
+    runtime: z.object({
+        listenHost: z.string().min(1),
+        listenPort: z.number().int().positive(),
+        webhookPath: z.string().startsWith("/")
+    }),
+    qqBot: z.object({
+        appId: z.string().min(1),
+        clientSecret: z.string().min(1),
+        markdownSupport: z.boolean(),
+        stt: z
+            .union([
+            z.object({
+                provider: z.literal("local-whisper-cpp"),
+                binaryPath: z.string().min(1),
+                modelPath: z.string().min(1),
+                language: z.string().min(1).optional()
+            }),
+            z.object({
+                provider: z.literal("openai-compatible"),
+                baseUrl: z.string().url(),
+                apiKey: z.string().min(1),
+                model: z.string().min(1)
+            }),
+            z.object({
+                provider: z.literal("volcengine-flash"),
+                endpoint: z.string().url(),
+                appId: z.string().min(1),
+                accessKey: z.string().min(1),
+                resourceId: z.string().min(1),
+                model: z.string().min(1)
+            })
+        ])
+            .nullable()
+    }),
+    codexDesktop: z.object({
+        appName: z.string().min(1),
+        remoteDebuggingPort: z.number().int().positive()
+    })
+});
+export function loadConfigFromEnv(env) {
+    return appConfigSchema.parse({
+        databasePath: env.QQ_CODEX_DATABASE_PATH ?? "runtime/qq-codex-bridge.sqlite",
+        runtime: {
+            listenHost: env.QQ_CODEX_LISTEN_HOST ?? "127.0.0.1",
+            listenPort: Number(env.QQ_CODEX_LISTEN_PORT ?? "3100"),
+            webhookPath: env.QQ_CODEX_WEBHOOK_PATH ?? "/webhooks/qq"
+        },
+        qqBot: {
+            appId: env.QQBOT_APP_ID,
+            clientSecret: env.QQBOT_CLIENT_SECRET,
+            markdownSupport: env.QQBOT_MARKDOWN_SUPPORT === "true",
+            stt: resolveSttConfig(env)
+        },
+        codexDesktop: {
+            appName: env.CODEX_APP_NAME ?? "Codex",
+            remoteDebuggingPort: Number(env.CODEX_REMOTE_DEBUGGING_PORT ?? "9229")
+        }
+    });
+}
+function resolveSttConfig(env) {
+    if (env.QQBOT_STT_ENABLED === "false") {
+        return null;
+    }
+    if (env.QQBOT_STT_PROVIDER === "local-whisper-cpp") {
+        const binaryPath = env.QQBOT_STT_BINARY_PATH;
+        const modelPath = env.QQBOT_STT_MODEL_PATH;
+        if (!binaryPath || !modelPath) {
+            return null;
+        }
+        return {
+            provider: "local-whisper-cpp",
+            binaryPath,
+            modelPath,
+            ...(env.QQBOT_STT_LANGUAGE ? { language: env.QQBOT_STT_LANGUAGE } : {})
+        };
+    }
+    if (env.QQBOT_STT_PROVIDER === "volcengine-flash") {
+        const appId = env.QQBOT_STT_APP_ID;
+        const accessKey = env.QQBOT_STT_ACCESS_KEY;
+        const resourceId = env.QQBOT_STT_RESOURCE_ID;
+        if (!appId || !accessKey || !resourceId) {
+            return null;
+        }
+        return {
+            provider: "volcengine-flash",
+            endpoint: env.QQBOT_STT_ENDPOINT ??
+                "https://openspeech.bytedance.com/api/v3/auc/bigmodel/recognize/flash",
+            appId,
+            accessKey,
+            resourceId,
+            model: env.QQBOT_STT_MODEL ?? "bigmodel"
+        };
+    }
+    const apiKey = env.QQBOT_STT_API_KEY ?? env.OPENAI_API_KEY;
+    if (!apiKey) {
+        return null;
+    }
+    const baseUrl = env.QQBOT_STT_BASE_URL ?? env.OPENAI_BASE_URL ?? "https://api.openai.com/v1";
+    const model = env.QQBOT_STT_MODEL ?? "whisper-1";
+    return {
+        provider: "openai-compatible",
+        baseUrl,
+        apiKey,
+        model
+    };
+}

package/dist/apps/bridge-daemon/src/debug-codex-workers.js

@@ -0,0 +1,309 @@
+import WebSocket from "ws";
+class RawCdpClient {
+    socket = null;
+    nextId = 1;
+    pending = new Map();
+    listeners = new Map();
+    async connect(browserWebSocketUrl) {
+        const socket = new WebSocket(browserWebSocketUrl);
+        await new Promise((resolve, reject) => {
+            socket.once("open", () => resolve());
+            socket.once("error", (error) => reject(error));
+        });
+        socket.on("message", (raw) => {
+            const payload = JSON.parse(String(raw));
+            if (typeof payload.id === "number") {
+                const pending = this.pending.get(payload.id);
+                if (!pending) {
+                    return;
+                }
+                this.pending.delete(payload.id);
+                if (payload.error) {
+                    pending.reject(new Error(JSON.stringify(payload.error)));
+                }
+                else {
+                    pending.resolve(payload.result);
+                }
+                return;
+            }
+            if (typeof payload.method === "string") {
+                const handlers = this.listeners.get(payload.method) ?? [];
+                for (const handler of handlers) {
+                    handler(payload.params, payload.sessionId);
+                }
+            }
+        });
+        this.socket = socket;
+    }
+    on(method, handler) {
+        const handlers = this.listeners.get(method) ?? [];
+        handlers.push(handler);
+        this.listeners.set(method, handlers);
+    }
+    async send(method, params = {}, sessionId, timeoutMs = 5_000) {
+        const socket = this.socket;
+        if (!socket) {
+            throw new Error("CDP browser socket not connected");
+        }
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`CDP command timed out: ${method}`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject });
+            socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }), (error) => {
+                if (!error) {
+                    return;
+                }
+                clearTimeout(timeout);
+                this.pending.delete(id);
+                reject(error);
+            });
+            const originalResolve = resolve;
+            const originalReject = reject;
+            this.pending.set(id, {
+                resolve: (value) => {
+                    clearTimeout(timeout);
+                    originalResolve(value);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    originalReject(error);
+                }
+            });
+        });
+    }
+}
+async function main() {
+    const options = parseArgs(process.argv.slice(2), process.env);
+    const version = (await fetchJson(`http://127.0.0.1:${options.remoteDebuggingPort}/json/version`));
+    const browserWebSocketUrl = version.webSocketDebuggerUrl;
+    if (!browserWebSocketUrl) {
+        throw new Error("CDP version response missing webSocketDebuggerUrl");
+    }
+    const targets = (await fetchJson(`http://127.0.0.1:${options.remoteDebuggingPort}/json/list`));
+    const page = targets.find((target) => target.type === "page");
+    if (!page) {
+        throw new Error("No page target found in Codex Desktop");
+    }
+    const client = new RawCdpClient();
+    await client.connect(browserWebSocketUrl);
+    const targetsToAttach = options.pageOnly ? [page] : targets;
+    const attachedTargets = [];
+    console.log(JSON.stringify({
+        discoveredTargets: targetsToAttach.map((target) => ({
+            id: target.id,
+            type: target.type,
+            title: target.title,
+            url: target.url
+        })),
+        monitorDurationMs: options.durationMs,
+        promptRequested: Boolean(options.prompt)
+    }, null, 2));
+    for (const target of targetsToAttach) {
+        console.log(`[debug-codex-workers] attaching ${target.type}:${target.id} ...`);
+        let attachResult = null;
+        try {
+            attachResult = (await client.send("Target.attachToTarget", {
+                targetId: target.id,
+                flatten: true
+            }, undefined, 1_500));
+        }
+        catch (error) {
+            console.warn(`[debug-codex-workers] attach failed for ${target.type}:${target.id}`, error);
+            continue;
+        }
+        if (!attachResult?.sessionId) {
+            console.warn(`[debug-codex-workers] attach returned no session for ${target.type}:${target.id}`);
+            continue;
+        }
+        attachedTargets.push({
+            targetId: target.id,
+            targetType: target.type,
+            sessionId: attachResult.sessionId
+        });
+        await client.send("Network.enable", {}, attachResult.sessionId, 800).catch((error) => {
+            console.warn(`[debug-codex-workers] Network.enable failed for ${target.type}:${target.id}`, error);
+        });
+        await client.send("Runtime.enable", {}, attachResult.sessionId, 800).catch((error) => {
+            console.warn(`[debug-codex-workers] Runtime.enable failed for ${target.type}:${target.id}`, error);
+        });
+    }
+    const startedAt = Date.now();
+    const captured = [];
+    const lookupTarget = (sessionId) => attachedTargets.find((target) => target.sessionId === sessionId);
+    client.on("Network.requestWillBeSent", (params, sessionId) => {
+        const meta = lookupTarget(sessionId);
+        captured.push({
+            kind: "request",
+            t: Date.now() - startedAt,
+            targetType: meta?.targetType,
+            targetId: meta?.targetId,
+            requestId: params.requestId,
+            method: params.request?.method,
+            url: params.request?.url,
+            postData: typeof params.request?.postData === "string"
+                ? params.request.postData.slice(0, 1200)
+                : null
+        });
+    });
+    client.on("Network.responseReceived", (params, sessionId) => {
+        const meta = lookupTarget(sessionId);
+        captured.push({
+            kind: "response",
+            t: Date.now() - startedAt,
+            targetType: meta?.targetType,
+            targetId: meta?.targetId,
+            requestId: params.requestId,
+            status: params.response?.status,
+            mimeType: params.response?.mimeType,
+            url: params.response?.url
+        });
+    });
+    client.on("Network.webSocketFrameReceived", (params, sessionId) => {
+        const meta = lookupTarget(sessionId);
+        captured.push({
+            kind: "ws_in",
+            t: Date.now() - startedAt,
+            targetType: meta?.targetType,
+            targetId: meta?.targetId,
+            requestId: params.requestId,
+            payload: String(params.response?.payloadData ?? "").slice(0, 1200)
+        });
+    });
+    client.on("Network.webSocketFrameSent", (params, sessionId) => {
+        const meta = lookupTarget(sessionId);
+        captured.push({
+            kind: "ws_out",
+            t: Date.now() - startedAt,
+            targetType: meta?.targetType,
+            targetId: meta?.targetId,
+            requestId: params.requestId,
+            payload: String(params.response?.payloadData ?? "").slice(0, 1200)
+        });
+    });
+    console.log(JSON.stringify({
+        attachedTargets,
+        monitorDurationMs: options.durationMs,
+        promptInjected: Boolean(options.prompt)
+    }, null, 2));
+    if (options.prompt) {
+        const pageSession = attachedTargets.find((target) => target.targetId === page.id)?.sessionId;
+        if (!pageSession) {
+            throw new Error("Page target was not attached");
+        }
+        console.log("[debug-codex-workers] injecting prompt...");
+        await sendPromptThroughPage(client, pageSession, options.prompt);
+        console.log("[debug-codex-workers] prompt injected");
+    }
+    await sleep(options.durationMs);
+    const filtered = captured.filter((event) => {
+        const haystack = `${event.url ?? ""}\n${event.payload ?? ""}\n${event.postData ?? ""}`;
+        return /api|backend|chat|conversation|response|message|thread|openai|codex|graphql|assistant|turn/i.test(haystack);
+    });
+    console.log(JSON.stringify(filtered, null, 2));
+}
+async function sendPromptThroughPage(client, sessionId, prompt) {
+    await client.send("Runtime.evaluate", {
+        expression: `(() => {
+        const input = document.querySelector('[data-codex-composer="true"], textarea, input[type="text"], [contenteditable="true"], [role="textbox"]');
+        if (!(input instanceof HTMLElement)) {
+          return { ok: false, reason: 'input_not_found' };
+        }
+        input.focus();
+        return { ok: true };
+      })()`,
+        returnByValue: true,
+        awaitPromise: true
+    }, sessionId, 5_000);
+    await client.send("Input.dispatchKeyEvent", { type: "keyDown", commands: ["selectAll"] }, sessionId, 5_000);
+    await client.send("Input.dispatchKeyEvent", {
+        type: "keyDown",
+        key: "Backspace",
+        code: "Backspace",
+        windowsVirtualKeyCode: 8,
+        nativeVirtualKeyCode: 8
+    }, sessionId, 5_000);
+    await client.send("Input.dispatchKeyEvent", {
+        type: "keyUp",
+        key: "Backspace",
+        code: "Backspace",
+        windowsVirtualKeyCode: 8,
+        nativeVirtualKeyCode: 8
+    }, sessionId, 5_000);
+    await client.send("Input.insertText", { text: prompt }, sessionId, 5_000);
+    await client.send("Runtime.evaluate", {
+        expression: `(() => {
+        const sendButton = Array.from(document.querySelectorAll('button, [role="button"]')).find((candidate) => {
+          if (!(candidate instanceof HTMLElement)) {
+            return false;
+          }
+          const rect = candidate.getBoundingClientRect();
+          const label = [
+            candidate.textContent || '',
+            candidate.getAttribute('aria-label') || '',
+            candidate.getAttribute('title') || '',
+            candidate.className || ''
+          ].join(' ');
+          return rect.y >= window.innerHeight - 140
+            && rect.x >= window.innerWidth - 120
+            && /size-token-button-composer|send|发送|submit|开始构建|继续|run|resume/i.test(label);
+        });
+        if (!(sendButton instanceof HTMLElement)) {
+          return { ok: false, reason: 'send_button_not_found' };
+        }
+        sendButton.click();
+        return { ok: true };
+      })()`,
+        returnByValue: true,
+        awaitPromise: true
+    }, sessionId, 5_000);
+}
+async function fetchJson(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.status}`);
+    }
+    return response.json();
+}
+function parseArgs(argv, env) {
+    let durationMs = 10_000;
+    let prompt = null;
+    let remoteDebuggingPort = Number(env.CODEX_REMOTE_DEBUGGING_PORT ?? 9229);
+    let pageOnly = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const current = argv[index];
+        if (current === "--duration-ms") {
+            durationMs = Number(argv[index + 1] ?? durationMs);
+            index += 1;
+            continue;
+        }
+        if (current === "--prompt") {
+            prompt = argv[index + 1] ?? null;
+            index += 1;
+            continue;
+        }
+        if (current === "--remote-debugging-port") {
+            remoteDebuggingPort = Number(argv[index + 1] ?? remoteDebuggingPort);
+            index += 1;
+            continue;
+        }
+        if (current === "--page-only") {
+            pageOnly = true;
+        }
+    }
+    return {
+        remoteDebuggingPort,
+        durationMs: Number.isFinite(durationMs) ? durationMs : 10_000,
+        prompt,
+        pageOnly
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+void main().catch((error) => {
+    console.error("[qq-codex-bridge] debug-codex-workers failed", error);
+    process.exitCode = 1;
+});

package/dist/apps/bridge-daemon/src/dev-launch.js

@@ -0,0 +1,73 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+export async function ensureCodexDesktopForDev(config, deps = {}) {
+    const fetchFn = deps.fetchFn ?? fetch;
+    const launchApp = deps.launchApp ?? ((appName, port) => launchCodexDesktop(appName, port));
+    const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    if (await isCdpReachable(config.remoteDebuggingPort, fetchFn)) {
+        return { launched: false };
+    }
+    await launchApp(config.appName, config.remoteDebuggingPort);
+    const deadline = Date.now() + config.startupTimeoutMs;
+    while (Date.now() <= deadline) {
+        if (await isCdpReachable(config.remoteDebuggingPort, fetchFn)) {
+            return { launched: true };
+        }
+        await sleep(config.startupPollIntervalMs);
+    }
+    throw new Error(`Timed out waiting for Codex desktop CDP endpoint on port ${config.remoteDebuggingPort}`);
+}
+export function launchCodexDesktop(appName, port, deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const spawnFn = deps.spawnFn ?? spawn;
+    const portArg = `--remote-debugging-port=${port}`;
+    if (platform === "darwin") {
+        const executablePath = deps.appExecutablePath ?? resolveDarwinAppExecutablePath(appName);
+        const child = spawnFn(executablePath, [portArg], {
+            detached: true,
+            stdio: "ignore"
+        });
+        child.unref();
+        return;
+    }
+    if (platform === "linux") {
+        const child = spawnFn(appName, [portArg], {
+            detached: true,
+            stdio: "ignore"
+        });
+        child.unref();
+        return;
+    }
+    throw new Error(`Unsupported platform for automatic Codex launch: ${platform}`);
+}
+async function isCdpReachable(port, fetchFn) {
+    try {
+        const response = await fetchFn(`http://127.0.0.1:${port}/json/version`);
+        if (!response.ok) {
+            return false;
+        }
+        const payload = (await response.json());
+        return typeof payload.webSocketDebuggerUrl === "string" && payload.webSocketDebuggerUrl.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveDarwinAppExecutablePath(appName, deps = {}) {
+    const searchRoots = deps.searchRoots ?? [
+        "/Applications",
+        path.join(process.env.HOME ?? "", "Applications")
+    ];
+    const existsSyncFn = deps.existsSyncFn ?? fs.existsSync;
+    const appNames = Array.from(new Set([appName, "Codex"]));
+    for (const searchRoot of searchRoots) {
+        for (const candidateName of appNames) {
+            const candidate = path.join(searchRoot, `${candidateName}.app`, "Contents", "MacOS", candidateName);
+            if (candidate && existsSyncFn(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return path.join("/Applications", `${appName}.app`, "Contents", "MacOS", appName);
+}

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

@@ -0,0 +1,28 @@
+import { loadConfigFromEnv } from "./config.js";
+import { ensureCodexDesktopForDev } from "./dev-launch.js";
+import { runBridgeDaemon } from "./main.js";
+async function runDev() {
+    const config = loadConfigFromEnv(process.env);
+    const result = await ensureCodexDesktopForDev({
+        appName: config.codexDesktop.appName,
+        remoteDebuggingPort: config.codexDesktop.remoteDebuggingPort,
+        startupTimeoutMs: Number(process.env.CODEX_CDP_STARTUP_TIMEOUT_MS ?? "15000"),
+        startupPollIntervalMs: Number(process.env.CODEX_CDP_POLL_INTERVAL_MS ?? "500")
+    });
+    console.log("[qq-codex-bridge] codex desktop ready", {
+        launched: result.launched,
+        remoteDebuggingPort: config.codexDesktop.remoteDebuggingPort
+    });
+    await runBridgeDaemon();
+}
+runDev().catch((error) => {
+    const cause = error instanceof Error ? error.cause : undefined;
+    console.error("[qq-codex-bridge] fatal:", error instanceof Error ? error.message : String(error));
+    if (cause !== undefined) {
+        console.error("  caused by:", cause);
+    }
+    if (error instanceof Error && error.stack) {
+        console.error("  stack:", error.stack);
+    }
+    process.exitCode = 1;
+});