@youdie006/prodex 0.2.0

package/dist/chatgpt-browser.js

@@ -0,0 +1,857 @@
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants, statSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+export class ChatGptBrowserBlockerError extends Error {
+    blocker;
+    constructor(blocker) {
+        super(formatBlockerError(blocker) ?? blocker.message);
+        this.name = "ChatGptBrowserBlockerError";
+        this.blocker = blocker;
+    }
+}
+export const CHATGPT_RUNTIME_BLOCKER_TEXT_EXCLUDED_ANCESTORS = '[data-message-author-role],script,style,noscript,[aria-hidden="true"],div[role="textbox"],textarea,[contenteditable="true"]';
+export const CHATGPT_COMPOSER_CANDIDATE_EXCLUDED_ANCESTORS = '[data-message-author-role],script,style,noscript,[aria-hidden="true"]';
+export const PRODEX_ACTIVE_COMPOSER_ATTRIBUTE = "data-prodex-active-composer";
+const MAX_PAGE_DISCOVERY_TIMEOUT_MS = 5_000;
+const PAGE_VISIBILITY_PROBE_TIMEOUT_MS = 1_000;
+const CHATGPT_GENERATING_CONTROL_PATTERN = /\bstop\s+(?:generating|responding|response)\b|응답\s*중지|생성\s*중지/i;
+export function defaultChatGptProfileDir() {
+    return path.join(os.homedir(), ".local", "share", "prodex", "chrome-chatgpt-pro");
+}
+export function buildChromeLaunchArgs(options) {
+    return [
+        "--remote-debugging-address=127.0.0.1",
+        `--remote-debugging-port=${options.port}`,
+        `--user-data-dir=${options.profileDir}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--new-window",
+        options.url
+    ];
+}
+export function inferLoggedInLikely(text, visibleButtonLabels = []) {
+    // Only sign-up prompts and explicit login/sign-up buttons count as logged-out signals. Bare
+    // "Log in"/"로그인" substrings appear in the menus and footers of a logged-in page, so matching
+    // them against the full page text falsely reported logged-in Pro users as logged out.
+    const hasLoginPrompt = text.includes("Sign up for free") ||
+        text.includes("무료로 가입") ||
+        visibleButtonLabels.some((label) => /^(log in|sign up|로그인|회원가입)$/i.test(label.trim()));
+    const hasNewChat = text.includes("New chat") || text.includes("새 채팅");
+    const hasProjectNav = text.includes("Projects") || text.includes("프로젝트");
+    const hasProfileButton = visibleButtonLabels.some((label) => /profile|account|프로필|계정/i.test(label));
+    const hasPlanHint = /\bPro\b|Plus|Team|Enterprise|매우 높음|Extra High/i.test(text);
+    return !hasLoginPrompt && hasNewChat && (hasProfileButton || hasProjectNav || hasPlanHint);
+}
+export function isUsableChatGptAnswer(answer) {
+    const normalized = answer.trim();
+    if (!normalized)
+        return false;
+    if (/^(생각 중|thinking|thought for|thought about)/i.test(normalized.replace(/\.+$/, ""))) {
+        return normalized.split(/\r?\n/).filter(Boolean).length > 1;
+    }
+    return true;
+}
+export function hasFreshChatGptAnswer(previousAssistantMessageCount, state) {
+    return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer) && !state.generating;
+}
+export function hasChatGptPromptAcceptance(previous, state) {
+    return state.userMessageCount > previous.userMessageCount || state.assistantMessageCount > previous.assistantMessageCount;
+}
+export function chatGptBusyBlocker(generating) {
+    if (!generating)
+        return undefined;
+    return {
+        code: "response_in_progress",
+        message: "ChatGPT is still generating a previous response.",
+        retryable: true,
+        next_step: "Wait for the visible response to finish, or stop it manually in the browser, then retry."
+    };
+}
+export function isLikelyChatGptSubmitButton(label, dataTestId) {
+    const normalized = label.trim().toLowerCase();
+    return dataTestId === "send-button" || /\b(send|submit)\b|보내기|전송/.test(normalized);
+}
+export function isLikelyChatGptGeneratingControl(label) {
+    return CHATGPT_GENERATING_CONTROL_PATTERN.test(label.trim());
+}
+export function detectChatGptBlocker(text, visibleButtonLabels = []) {
+    const haystack = `${text}\n${visibleButtonLabels.join("\n")}`.toLowerCase();
+    if (/just a moment|checking if the site connection is secure|verify you are human|잠시만 기다려|연결이 안전한지/i.test(haystack)) {
+        return {
+            code: "cloudflare_check",
+            message: "ChatGPT is showing a Cloudflare or human-verification interstitial.",
+            retryable: true,
+            next_step: "Complete the visible browser check manually, then retry."
+        };
+    }
+    if (hasLikelyChatGptLoginPrompt(haystack)) {
+        return {
+            code: "login_required",
+            message: "ChatGPT is asking you to log in.",
+            retryable: true,
+            next_step: "Log in manually in the visible browser, then retry."
+        };
+    }
+    // Match real captcha / human-verification phrasing only. Bare words like "robot"/"로봇"/"자동화"
+    // appear in ordinary chat titles and sidebar history, so matching them on the full page text
+    // wrongly flagged logged-in users as captcha-blocked.
+    if (/captcha|보안문자|i'?m not a robot|verify you are (?:not a robot|human)|로봇이 아닙니다|사람인지 확인|자동화된 트래픽/i.test(haystack)) {
+        return {
+            code: "captcha_required",
+            message: "ChatGPT is asking for captcha or human verification.",
+            retryable: true,
+            next_step: "Solve it manually in the visible browser, then retry."
+        };
+    }
+    if (/message limit|usage limit|model limit|rate limit|you.?ve reached|try again later|limit resets|사용 한도|메시지 한도|모델 한도|요금 제한|나중에 다시/i.test(haystack)) {
+        return {
+            code: "usage_limit",
+            message: "ChatGPT is reporting a usage, message, model, or rate limit.",
+            retryable: true,
+            next_step: "Wait for the limit to reset or choose an available model in the browser."
+        };
+    }
+    if (/additional verification|required verification|verify your account|permission required|account verification|권한|추가 인증|계정 인증|인증 필요/i.test(haystack)) {
+        return {
+            code: "permission_required",
+            message: "ChatGPT requires account verification or permission handling.",
+            retryable: true,
+            next_step: "Complete the visible account or permission prompt manually, then retry."
+        };
+    }
+    return undefined;
+}
+export function detectChatGptPageBlocker(state) {
+    return detectChatGptBlocker(state.blockerTextSample ?? state.textSample, state.visibleButtonLabels);
+}
+export function inferChatGptPageLoggedInLikely(state) {
+    return inferLoggedInLikely(state.blockerTextSample ?? state.textSample, state.visibleButtonLabels);
+}
+function hasLikelyChatGptLoginPrompt(haystack) {
+    const hasSpecificSignup = /sign up for free|무료로 가입/i.test(haystack);
+    const hasLogin = /\blog in\b|로그인/i.test(haystack);
+    const hasSignup = /\bsign up\b|가입/i.test(haystack);
+    const hasSessionPrompt = /log in to|login to|sign in to|session expired|logged out|다시 로그인|로그인이 필요/i.test(haystack);
+    return hasSpecificSignup || (hasLogin && hasSignup) || hasSessionPrompt;
+}
+export function chatGptBlockerErrorFromAnswerState(state) {
+    return formatBlockerError(chatGptBlockerFromAnswerState(state));
+}
+export function chatGptBlockerFromAnswerState(state) {
+    return detectChatGptPageBlocker(state);
+}
+export function computePromptAcceptanceDeadline(timeoutMs, startedAt) {
+    return startedAt + Math.max(1, timeoutMs);
+}
+export function computePageDiscoveryTimeout(timeoutMs) {
+    return Math.max(1, Math.min(timeoutMs, MAX_PAGE_DISCOVERY_TIMEOUT_MS));
+}
+export function normalizeChatGptTargetUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("Target URL must be a ChatGPT web URL.");
+    }
+    if (url.protocol !== "https:" || url.hostname !== "chatgpt.com") {
+        throw new Error("Target URL must be a ChatGPT web URL.");
+    }
+    url.hash = "";
+    url.search = "";
+    url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+    return url.toString();
+}
+export function chatGptUrlsReferToSameTarget(currentUrl, expectedUrl) {
+    try {
+        return normalizeChatGptTargetUrl(currentUrl) === normalizeChatGptTargetUrl(expectedUrl);
+    }
+    catch {
+        return false;
+    }
+}
+export function selectChatGptPage(pages, targetUrl, visibilityByPage = new Map()) {
+    const chatGptPages = pages.filter((page) => page.type === "page" && isChatGptPageUrl(page.url));
+    if (chatGptPageSelectionBlocker(pages, targetUrl, visibilityByPage))
+        return undefined;
+    if (!targetUrl) {
+        return (chatGptPages.find((page) => visibilityByPage.get(page.webSocketDebuggerUrl) === "visible") ??
+            chatGptPages.find((page) => isVisibilityUnknown(page, visibilityByPage)) ??
+            chatGptPages[0]);
+    }
+    const targetMatches = chatGptPages.filter((page) => chatGptUrlsReferToSameTarget(page.url, targetUrl));
+    return (targetMatches.find((page) => visibilityByPage.get(page.webSocketDebuggerUrl) === "visible") ??
+        targetMatches.find((page) => isVisibilityUnknown(page, visibilityByPage)) ??
+        targetMatches[0]);
+}
+export function chatGptPageSelectionBlocker(pages, targetUrl, visibilityByPage = new Map()) {
+    if (targetUrl)
+        return undefined;
+    const possiblyVisibleChatGptPages = pages.filter((page) => page.type === "page" && isChatGptPageUrl(page.url) && isChatGptPagePossiblyVisible(page, visibilityByPage));
+    if (possiblyVisibleChatGptPages.length <= 1)
+        return undefined;
+    const urls = possiblyVisibleChatGptPages
+        .map((page) => `${page.url} (${visibilityByPage.get(page.webSocketDebuggerUrl) ?? "unknown"})`)
+        .slice(0, 5)
+        .join(", ");
+    return {
+        code: "ambiguous_chatgpt_tabs",
+        message: `Multiple visible or unverified ChatGPT tabs or windows are available: ${urls}.`,
+        retryable: true,
+        next_step: "Close extra ChatGPT windows, leave only the intended tab visible, or pass --target-url with --confirm-target."
+    };
+}
+function isChatGptPagePossiblyVisible(page, visibilityByPage) {
+    const visibility = visibilityByPage.get(page.webSocketDebuggerUrl);
+    return visibility === "visible" || visibility === undefined;
+}
+function isVisibilityUnknown(page, visibilityByPage) {
+    return visibilityByPage.get(page.webSocketDebuggerUrl) === undefined;
+}
+export function assertVisibleChatGptTab(visibilityState, url, targetUrl) {
+    if (visibilityState === "visible")
+        return;
+    const blocker = chatGptVisibilityBlocker(visibilityState, targetUrl ?? url);
+    if (blocker)
+        throw new ChatGptBrowserBlockerError(blocker);
+}
+export function assertChatGptTargetUrlMatches(currentUrl, targetUrl) {
+    if (chatGptUrlsReferToSameTarget(currentUrl, targetUrl))
+        return;
+    throw new ChatGptBrowserBlockerError({
+        code: "target_url_mismatch",
+        message: "ChatGPT tab is not at the confirmed target URL.",
+        retryable: true,
+        next_step: `Open ${targetUrl} in the visible browser and retry. Current: ${currentUrl}`
+    });
+}
+export function assertChatGptTargetTabAvailable(targetUrl) {
+    throw new ChatGptBrowserBlockerError({
+        code: "target_tab_missing",
+        message: "No open ChatGPT tab matches the confirmed target URL.",
+        retryable: true,
+        next_step: `Open ${targetUrl} in the dedicated browser and retry.`
+    });
+}
+export function assertChatGptPageAvailable() {
+    throw new ChatGptBrowserBlockerError(chatGptPageMissingBlocker());
+}
+function chatGptPageMissingBlocker() {
+    return {
+        code: "chatgpt_page_missing",
+        message: "Chrome debug port is reachable, but no chatgpt.com tab is open.",
+        retryable: true,
+        next_step: "Open https://chatgpt.com/ in the dedicated Chrome profile, or run `prodex pro browser login` to reopen it."
+    };
+}
+export function assertChatGptReadyForPrompt(loggedInLikely, hasComposer) {
+    if (loggedInLikely && hasComposer)
+        return;
+    const missing = [
+        loggedInLikely ? undefined : "a clear logged-in ChatGPT session",
+        hasComposer ? undefined : "a visible prompt composer"
+    ].filter(Boolean);
+    throw new ChatGptBrowserBlockerError({
+        code: "chatgpt_not_ready",
+        message: `ChatGPT browser is reachable, but it is missing ${missing.join(" and ")}.`,
+        retryable: true,
+        next_step: "Log in manually and open a normal chat or Project thread with the prompt composer visible, then retry."
+    });
+}
+export function chatGptVisibilityBlocker(visibilityState, url) {
+    if (visibilityState === "visible")
+        return undefined;
+    const visibility = visibilityState ?? "unknown";
+    return {
+        code: "tab_not_visible",
+        message: `Selected ChatGPT tab is ${visibility}, not the active visible tab.`,
+        retryable: true,
+        next_step: `Select ${url ?? "the ChatGPT tab"} in the dedicated browser, then retry.`
+    };
+}
+export function openChatGptBrowser(options = {}) {
+    const command = resolveChromeCommand();
+    const port = options.port ?? 9333;
+    const profileDir = options.profileDir ?? defaultChatGptProfileDir();
+    const args = buildChromeLaunchArgs({
+        port,
+        profileDir,
+        url: options.url ?? "https://chatgpt.com/"
+    });
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    let earlyExit;
+    const earlyExitWaiters = new Set();
+    const recordEarlyExit = (exit) => {
+        if (earlyExit)
+            return;
+        earlyExit = exit;
+        for (const waiter of earlyExitWaiters)
+            waiter(exit);
+        earlyExitWaiters.clear();
+    };
+    child.once("exit", (code, signal) => recordEarlyExit({ code, signal }));
+    child.once("error", (error) => recordEarlyExit({ error: error.message }));
+    child.unref();
+    return {
+        command,
+        args,
+        profileDir,
+        port,
+        waitForEarlyExit: (timeoutMs = 1000) => {
+            if (earlyExit)
+                return Promise.resolve(earlyExit);
+            return new Promise((resolve) => {
+                const resolveExit = (exit) => {
+                    clearTimeout(timer);
+                    resolve(exit);
+                };
+                const timer = setTimeout(() => {
+                    earlyExitWaiters.delete(resolveExit);
+                    resolve(undefined);
+                }, timeoutMs);
+                earlyExitWaiters.add(resolveExit);
+            });
+        }
+    };
+}
+export async function getChatGptBrowserStatus(options = {}) {
+    const port = options.port ?? 9333;
+    const page = await findChatGptPage(port, options.timeoutMs ?? 1500);
+    if (!page.ok) {
+        return {
+            reachable: false,
+            loggedInLikely: false,
+            hasComposer: false,
+            modelHints: [],
+            blocker: page.blocker
+        };
+    }
+    if (!page.page) {
+        if (page.blocker) {
+            return {
+                reachable: true,
+                loggedInLikely: false,
+                hasComposer: false,
+                modelHints: [],
+                blocker: page.blocker
+            };
+        }
+        return {
+            reachable: true,
+            loggedInLikely: false,
+            hasComposer: false,
+            modelHints: [],
+            blocker: chatGptPageMissingBlocker()
+        };
+    }
+    const state = await evaluateOnPage(page.page, statusExpression());
+    const loggedInLikely = inferChatGptPageLoggedInLikely(state);
+    const blocker = chatGptVisibilityBlocker(state.visibilityState, state.url) ?? detectChatGptPageBlocker(state) ?? chatGptBusyBlocker(state.generating);
+    return {
+        reachable: true,
+        loggedInLikely,
+        hasComposer: state.hasComposer,
+        visibilityState: state.visibilityState,
+        url: state.url,
+        title: state.title,
+        modelHints: state.modelHints,
+        blocker
+    };
+}
+export async function sendChatGptPrompt(options) {
+    const port = options.port ?? 9333;
+    const timeoutMs = options.timeoutMs ?? 90_000;
+    const normalizedTargetUrl = options.targetUrl ? normalizeChatGptTargetUrl(options.targetUrl) : undefined;
+    const pageResult = await findChatGptPage(port, computePageDiscoveryTimeout(timeoutMs), normalizedTargetUrl);
+    if (!pageResult.ok) {
+        throwBlockerOrError(pageResult.blocker, "ChatGPT browser page is not available");
+    }
+    if (!pageResult.page) {
+        if (pageResult.blocker) {
+            throw new ChatGptBrowserBlockerError(pageResult.blocker);
+        }
+        if (normalizedTargetUrl) {
+            assertChatGptTargetTabAvailable(normalizedTargetUrl);
+        }
+        assertChatGptPageAvailable();
+    }
+    const page = pageResult.page;
+    const status = await evaluateOnPage(page, statusExpression());
+    const blocker = detectChatGptPageBlocker(status);
+    if (blocker) {
+        throw new ChatGptBrowserBlockerError(blocker);
+    }
+    assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer);
+    if (normalizedTargetUrl)
+        assertChatGptTargetUrlMatches(status.url, normalizedTargetUrl);
+    assertVisibleChatGptTab(status.visibilityState, status.url, normalizedTargetUrl);
+    const busyBlocker = chatGptBusyBlocker(status.generating);
+    if (busyBlocker) {
+        throw new ChatGptBrowserBlockerError(busyBlocker);
+    }
+    const beforeSubmit = await evaluateOnPage(page, answerExpression());
+    const cdp = await connectCdp(page.webSocketDebuggerUrl);
+    try {
+        await cdp.send("Runtime.enable");
+        const inserted = await cdp.evaluate(setComposerTextExpression(options.prompt));
+        if (!inserted.ok)
+            throw new Error(inserted.reason ?? "Could not insert text into ChatGPT composer");
+        await sleep(300);
+        const submitted = await cdp.evaluate(submitExpression());
+        if (!submitted.ok) {
+            await cdp.send("Input.dispatchKeyEvent", enterKeyEvent("keyDown"));
+            await cdp.send("Input.dispatchKeyEvent", enterKeyEvent("keyUp"));
+        }
+    }
+    finally {
+        cdp.close();
+    }
+    const started = Date.now();
+    const acceptDeadline = computePromptAcceptanceDeadline(timeoutMs, started);
+    let accepted = false;
+    let finalState;
+    while (Date.now() < acceptDeadline) {
+        await sleep(500);
+        finalState = await evaluateOnPage(page, answerExpression());
+        const runtimeBlocker = chatGptBlockerFromAnswerState(finalState);
+        if (runtimeBlocker)
+            throw new ChatGptBrowserBlockerError(runtimeBlocker);
+        if (hasChatGptPromptAcceptance(beforeSubmit, finalState)) {
+            accepted = true;
+            break;
+        }
+    }
+    if (!accepted) {
+        throw new Error("Timed out waiting for ChatGPT to accept the prompt.");
+    }
+    let stableAnswer;
+    let stableConfirmations = 0;
+    while (Date.now() - started < timeoutMs) {
+        await sleep(1000);
+        finalState = await evaluateOnPage(page, answerExpression());
+        const runtimeBlocker = chatGptBlockerFromAnswerState(finalState);
+        if (runtimeBlocker)
+            throw new ChatGptBrowserBlockerError(runtimeBlocker);
+        if (!hasFreshChatGptAnswer(beforeSubmit.assistantMessageCount, finalState))
+            continue;
+        // A "fresh" answer must also be stable: ChatGPT can momentarily look done mid-stream, so accept
+        // it only once the text stops changing across polls. Otherwise trailing tokens (e.g. the final
+        // "_OK" of the smoke token) get dropped.
+        if (finalState.answer === stableAnswer) {
+            stableConfirmations += 1;
+            if (stableConfirmations >= 1)
+                break;
+        }
+        else {
+            stableAnswer = finalState.answer;
+            stableConfirmations = 0;
+        }
+    }
+    const completed = finalState;
+    if (!completed || !hasFreshChatGptAnswer(beforeSubmit.assistantMessageCount, completed)) {
+        throw new Error("Timed out waiting for ChatGPT response.");
+    }
+    return {
+        url: completed.url,
+        title: completed.title,
+        answer: completed.answer.trim(),
+        modelHints: completed.modelHints,
+        warnings: []
+    };
+}
+async function findChatGptPage(port, timeoutMs, targetUrl) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(timeoutMs) });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        const pages = (await response.json());
+        const visibilityByPage = await getChatGptPageVisibility(pages);
+        const blocker = chatGptPageSelectionBlocker(pages, targetUrl, visibilityByPage);
+        if (blocker)
+            return { ok: true, blocker };
+        return { ok: true, page: selectChatGptPage(pages, targetUrl, visibilityByPage) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            blocker: {
+                code: "browser_unreachable",
+                message: `No Chrome DevTools endpoint is reachable on 127.0.0.1:${port}.`,
+                retryable: true,
+                next_step: "Run `prodex pro browser login`, log in, then retry.",
+                ...(error instanceof Error ? { detail: error.message } : {})
+            }
+        };
+    }
+}
+async function getChatGptPageVisibility(pages) {
+    const visibilityByPage = new Map();
+    await Promise.all(pages
+        .filter((page) => page.type === "page" && isChatGptPageUrl(page.url))
+        .map(async (page) => {
+        try {
+            visibilityByPage.set(page.webSocketDebuggerUrl, await evaluateOnPage(page, "document.visibilityState", { timeoutMs: PAGE_VISIBILITY_PROBE_TIMEOUT_MS }));
+        }
+        catch {
+            // Leave visibility unknown; untargeted sends treat unknown ChatGPT pages conservatively.
+        }
+    }));
+    return visibilityByPage;
+}
+function isChatGptPageUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" && url.hostname === "chatgpt.com";
+    }
+    catch {
+        return false;
+    }
+}
+function formatBlockerError(blocker) {
+    if (!blocker)
+        return undefined;
+    return `${blocker.message}${blocker.next_step ? ` Next: ${blocker.next_step}` : ""}`;
+}
+function throwBlockerOrError(blocker, fallback) {
+    if (blocker)
+        throw new ChatGptBrowserBlockerError(blocker);
+    throw new Error(fallback);
+}
+async function evaluateOnPage(page, expression, options = {}) {
+    const cdp = await connectCdp(page.webSocketDebuggerUrl, options.timeoutMs);
+    try {
+        await cdp.send("Runtime.enable");
+        return await cdp.evaluate(expression);
+    }
+    finally {
+        cdp.close();
+    }
+}
+async function connectCdp(webSocketUrl, timeoutMs) {
+    const ws = new WebSocket(webSocketUrl);
+    let id = 0;
+    const pending = new Map();
+    ws.addEventListener("message", (event) => {
+        const data = typeof event.data === "string" ? event.data : Buffer.from(event.data).toString("utf8");
+        const message = JSON.parse(data);
+        if (message.id && pending.has(message.id)) {
+            const waiter = pending.get(message.id);
+            if (waiter.timer)
+                clearTimeout(waiter.timer);
+            waiter.resolve(message);
+            pending.delete(message.id);
+        }
+    });
+    ws.addEventListener("close", () => {
+        for (const [messageId, waiter] of pending) {
+            if (waiter.timer)
+                clearTimeout(waiter.timer);
+            waiter.reject(new Error("Chrome DevTools websocket closed"));
+            pending.delete(messageId);
+        }
+    });
+    await new Promise((resolve, reject) => {
+        const timer = timeoutMs
+            ? setTimeout(() => {
+                ws.close();
+                reject(new Error("Chrome DevTools websocket timed out"));
+            }, Math.max(1, timeoutMs))
+            : undefined;
+        ws.addEventListener("open", () => {
+            if (timer)
+                clearTimeout(timer);
+            resolve();
+        }, { once: true });
+        ws.addEventListener("error", () => {
+            if (timer)
+                clearTimeout(timer);
+            reject(new Error("Chrome DevTools websocket failed"));
+        }, { once: true });
+    });
+    const send = (method, params = {}) => {
+        const messageId = ++id;
+        return new Promise((resolve, reject) => {
+            const timer = timeoutMs
+                ? setTimeout(() => {
+                    pending.delete(messageId);
+                    ws.close();
+                    reject(new Error(`Chrome DevTools command timed out: ${method}`));
+                }, Math.max(1, timeoutMs))
+                : undefined;
+            pending.set(messageId, { resolve, reject, timer });
+            ws.send(JSON.stringify({ id: messageId, method, params }));
+        });
+    };
+    const evaluate = async (expression) => {
+        const response = await send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true });
+        if (response.error?.message)
+            throw new Error(response.error.message);
+        if (response.result?.exceptionDetails)
+            throw new Error("Runtime.evaluate failed");
+        return response.result?.result?.value;
+    };
+    return { send, evaluate, close: () => ws.close() };
+}
+export function statusExpression() {
+    const excludedTextSelector = JSON.stringify(CHATGPT_RUNTIME_BLOCKER_TEXT_EXCLUDED_ANCESTORS);
+    const generatingControlPattern = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.source);
+    const generatingControlFlags = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.flags);
+    return `(() => {
+    ${composerExpressionHelpers()}
+    const text = document.body?.innerText || "";
+    const runtimeExcludedTextSelector = ${excludedTextSelector};
+    const generatingControlPattern = new RegExp(${generatingControlPattern}, ${generatingControlFlags});
+    const visibleTextOutsideMessages = () => {
+      if (!document.body) return "";
+      const parts = [];
+      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+      while (walker.nextNode()) {
+        const node = walker.currentNode;
+        const parent = node.parentElement;
+        const value = node.nodeValue?.trim();
+        if (!parent || !value) continue;
+        if (parent.closest(runtimeExcludedTextSelector)) continue;
+        const style = window.getComputedStyle(parent);
+        if (style.display === "none" || style.visibility === "hidden") continue;
+        if (!(parent.offsetWidth || parent.offsetHeight || parent.getClientRects().length)) continue;
+        parts.push(value);
+      }
+      return parts.join(String.fromCharCode(10));
+    };
+    const blockerText = visibleTextOutsideMessages();
+    const lines = text.split(String.fromCharCode(10)).map((line) => line.trim()).filter(Boolean);
+    const visibleButtonLabels = [...document.querySelectorAll('button,a,[role="button"]')]
+      .filter((el) => !!(el.offsetWidth || el.offsetHeight || el.getClientRects().length))
+      .filter((el) => !el.closest(runtimeExcludedTextSelector))
+      .map((el) => (el.innerText || el.getAttribute("aria-label") || el.getAttribute("data-testid") || "").trim())
+      .filter(Boolean);
+    const messages = [...document.querySelectorAll('[data-message-author-role]')].map((node) => ({
+      role: node.getAttribute('data-message-author-role'),
+      text: node.innerText || ""
+    }));
+    const assistant = messages.filter((message) => message.role === "assistant").at(-1);
+    const answer = assistant?.text || "";
+    const placeholder = /^(생각 중|thinking|thought for|thought about)/i.test(answer.trim().replace(/\\.+$/, ""));
+    const hasComposer = Boolean(findChatGptComposerCandidate());
+    return {
+      title: document.title,
+      url: location.href,
+      visibilityState: document.visibilityState,
+      textSample: text.slice(0, 12000),
+      blockerTextSample: blockerText.slice(0, 12000),
+      visibleButtonLabels,
+      hasComposer,
+      generating: placeholder || visibleButtonLabels.some((label) => generatingControlPattern.test(label)),
+      modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30)
+    };
+  })()`;
+}
+export function setComposerTextExpression(text) {
+    const serializedText = JSON.stringify(text);
+    return `(() => {
+    ${composerExpressionHelpers()}
+    const el = findChatGptComposerCandidate();
+    if (!el) return { ok: false, reason: "No visible composer" };
+    const root = findChatGptComposerRoot(el);
+    if (root) markChatGptComposerRoot(root);
+    el.focus();
+    const text = ${serializedText};
+    const dispatchInput = () => {
+      el.dispatchEvent(new InputEvent("input", { inputType: "insertText", data: text, bubbles: true, composed: true }));
+      el.dispatchEvent(new Event("change", { bubbles: true }));
+    };
+    if ("value" in el) {
+      const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+      const setter = Object.getOwnPropertyDescriptor(proto, "value")?.set;
+      if (setter) setter.call(el, text);
+      else el.value = text;
+      dispatchInput();
+    } else {
+      const selection = window.getSelection();
+      const range = document.createRange();
+      range.selectNodeContents(el);
+      range.deleteContents();
+      range.collapse(true);
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+      document.execCommand("insertText", false, text);
+      const current = el.innerText || el.textContent || "";
+      if (!current.trim()) {
+        el.textContent = text;
+        dispatchInput();
+      }
+    }
+    const actualText = ("value" in el ? el.value : el.innerText || el.textContent || "").trim();
+    return actualText ? { ok: true, actualText: actualText.slice(0, 120) } : { ok: false, reason: "Composer stayed empty after text insertion" };
+  })()`;
+}
+export function submitExpression() {
+    return `(() => {
+    ${composerExpressionHelpers()}
+    const markedRoot = findMarkedChatGptComposerRoot();
+    const composer = markedRoot ? undefined : findChatGptComposerCandidate();
+    const root = markedRoot || (composer ? findChatGptComposerRoot(composer) : undefined);
+    const button = root ? findChatGptSubmitButton(root) : undefined;
+    if (!button) return { ok: false, reason: "No enabled submit button" };
+    button.click();
+    return { ok: true };
+  })()`;
+}
+function composerExpressionHelpers() {
+    const excludedTextSelector = JSON.stringify(CHATGPT_COMPOSER_CANDIDATE_EXCLUDED_ANCESTORS);
+    const activeComposerAttribute = JSON.stringify(PRODEX_ACTIVE_COMPOSER_ATTRIBUTE);
+    return `
+    const excludedTextSelector = ${excludedTextSelector};
+    const activeComposerAttribute = ${activeComposerAttribute};
+    const isVisible = (node) => !!(node.offsetWidth || node.offsetHeight || node.getClientRects().length);
+    const isEditableComposer = (node) => isVisible(node) && !(node.parentElement && node.parentElement.closest(excludedTextSelector));
+    const findChatGptComposerRoot = (node) =>
+      node.closest('form') ||
+      node.closest('[data-testid*="composer"],[data-testid*="prompt"],[class*="composer"]') ||
+      node.parentElement;
+    const isChatGptSubmitLikeButton = (node) => {
+      const label = (node.innerText || node.getAttribute("aria-label") || node.getAttribute("data-testid") || "").toLowerCase();
+      const dataTestId = node.getAttribute("data-testid");
+      return isVisible(node) && (dataTestId === "send-button" || /\\b(send|submit)\\b|보내기|전송/.test(label));
+    };
+    const isEnabledButton = (node) => !node.disabled && node.getAttribute("aria-disabled") !== "true";
+    const findChatGptSubmitButton = (root, requireEnabled = true) =>
+      [...root.querySelectorAll('button')].find((node) => isChatGptSubmitLikeButton(node) && (!requireEnabled || isEnabledButton(node)));
+    const markChatGptComposerRoot = (root) => {
+      document.querySelectorAll('[' + activeComposerAttribute + '="true"]').forEach((node) => node.removeAttribute(activeComposerAttribute));
+      root.setAttribute(activeComposerAttribute, "true");
+    };
+    const findMarkedChatGptComposerRoot = () => document.querySelector('[' + activeComposerAttribute + '="true"]');
+    const isChatGptComposerRootEl = (root) =>
+      root.tagName === 'FORM' || (root.matches && root.matches('[data-testid*="composer"],[data-testid*="prompt"],[class*="composer"]'));
+    const findChatGptComposerCandidate = () => {
+      const candidates = [...document.querySelectorAll('textarea[data-testid="prompt-textarea"], div[role="textbox"], textarea, [contenteditable="true"]')]
+        .filter(isEditableComposer);
+      // Prefer a composer whose root still shows a submit button.
+      const withSubmit = candidates.find((node) => {
+        const root = findChatGptComposerRoot(node);
+        return root && findChatGptSubmitButton(root, false);
+      });
+      if (withSubmit) return withSubmit;
+      // ChatGPT hides the send button until text is entered, so also accept an editable inside a
+      // composer form/container even when no submit button is visible on an empty composer.
+      return candidates.find((node) => {
+        const root = findChatGptComposerRoot(node);
+        return root && isChatGptComposerRootEl(root);
+      });
+    };
+  `;
+}
+function answerExpression() {
+    const excludedTextSelector = JSON.stringify(CHATGPT_RUNTIME_BLOCKER_TEXT_EXCLUDED_ANCESTORS);
+    const generatingControlPattern = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.source);
+    const generatingControlFlags = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.flags);
+    return `(() => {
+    const text = document.body?.innerText || "";
+    const excludedTextSelector = ${excludedTextSelector};
+    const generatingControlPattern = new RegExp(${generatingControlPattern}, ${generatingControlFlags});
+    const visibleTextOutsideMessages = () => {
+      if (!document.body) return "";
+      const parts = [];
+      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+      while (walker.nextNode()) {
+        const node = walker.currentNode;
+        const parent = node.parentElement;
+        const value = node.nodeValue?.trim();
+        if (!parent || !value) continue;
+        if (parent.closest(excludedTextSelector)) continue;
+        const style = window.getComputedStyle(parent);
+        if (style.display === "none" || style.visibility === "hidden") continue;
+        if (!(parent.offsetWidth || parent.offsetHeight || parent.getClientRects().length)) continue;
+        parts.push(value);
+      }
+      return parts.join(String.fromCharCode(10));
+    };
+    const lines = text.split(String.fromCharCode(10)).map((line) => line.trim()).filter(Boolean);
+    const messages = [...document.querySelectorAll('[data-message-author-role]')].map((node) => ({
+      role: node.getAttribute('data-message-author-role'),
+      text: node.innerText || ""
+    }));
+    const assistantMessages = messages.filter((message) => message.role === "assistant");
+    const userMessages = messages.filter((message) => message.role === "user");
+    const assistant = assistantMessages.at(-1);
+    const buttons = [...document.querySelectorAll('button,[role="button"]')]
+      .filter((node) => !!(node.offsetWidth || node.offsetHeight || node.getClientRects().length))
+      .filter((node) => !node.closest(excludedTextSelector))
+      .map((node) => (node.innerText || node.getAttribute("aria-label") || node.getAttribute("data-testid") || "").trim())
+      .filter(Boolean);
+    const answer = assistant?.text || "";
+    const placeholder = /^(생각 중|thinking|thought for|thought about)/i.test(answer.trim().replace(/\\.+$/, ""));
+    return {
+      title: document.title,
+      url: location.href,
+      answer: answer || text.slice(-4000),
+      textSample: text.slice(0, 12000),
+      blockerTextSample: visibleTextOutsideMessages().slice(0, 12000),
+      visibleButtonLabels: buttons,
+      generating: placeholder || buttons.some((label) => generatingControlPattern.test(label)),
+      assistantMessageCount: assistantMessages.length,
+      userMessageCount: userMessages.length,
+      modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30)
+    };
+  })()`;
+}
+function enterKeyEvent(type) {
+    return { type, key: "Enter", code: "Enter", windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 };
+}
+function resolveChromeCommand() {
+    const fromEnv = process.env.PRODEX_CHROME;
+    if (fromEnv) {
+        assertChromeCommandAvailable(fromEnv, "PRODEX_CHROME");
+        return fromEnv;
+    }
+    for (const command of ["google-chrome", "chromium", "chromium-browser", "microsoft-edge", "brave-browser"]) {
+        if (isCommandOnPath(command) && hasChromeLikeVersion(command))
+            return command;
+    }
+    throw new Error("Could not find Chrome/Chromium. Set PRODEX_CHROME to the browser executable.");
+}
+function assertChromeCommandAvailable(command, label) {
+    if (isPathLikeCommand(command)) {
+        try {
+            if (!statSync(command).isFile()) {
+                throw new Error("not a file");
+            }
+            accessSync(command, constants.X_OK);
+        }
+        catch {
+            throw new Error(`${label} does not point to an executable browser: ${command}`);
+        }
+    }
+    else if (!isCommandOnPath(command)) {
+        throw new Error(`${label} browser command was not found on PATH: ${command}`);
+    }
+    assertChromeLikeVersion(command, label);
+}
+function isPathLikeCommand(command) {
+    return path.isAbsolute(command) || command.includes("/") || command.includes("\\");
+}
+function isCommandOnPath(command) {
+    const lookup = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync(lookup, [command], { stdio: "ignore" });
+    return result.status === 0;
+}
+function assertChromeLikeVersion(command, label) {
+    if (!hasChromeLikeVersion(command)) {
+        throw new Error(`${label} must point to a Chrome/Chromium-compatible browser executable: ${command}`);
+    }
+}
+function hasChromeLikeVersion(command) {
+    const result = spawnSync(command, ["--version"], {
+        encoding: "utf8",
+        timeout: 3000,
+        maxBuffer: 1024 * 1024
+    });
+    const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+    return !result.error && result.status === 0 && /Chrome|Chromium|Brave|Microsoft Edge/i.test(output);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=chatgpt-browser.js.map