binary-collections 2.0.9 → 2.0.11

package/lib/utils/chatgpt.js

@@ -0,0 +1,708 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChatGpt = runChatGpt;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const puppeteer_extra_1 = __importDefault(require("puppeteer-extra"));
+const puppeteer_extra_plugin_stealth_1 = __importDefault(require("puppeteer-extra-plugin-stealth"));
+const upath_1 = __importDefault(require("upath"));
+const COOKIE_DIR = upath_1.default.join(process.cwd(), "tmp", "cookies");
+const DEFAULT_COOKIE_PATH = upath_1.default.join(COOKIE_DIR, "cookies.json");
+const NAVIGATION_TIMEOUT_MS = 90000;
+const NETWORK_IDLE_TIMEOUT_MS = 15000;
+const MAX_INLINE_QUESTION_FILE_BYTES = 2 * 1024;
+fs_extra_1.default.ensureDirSync(COOKIE_DIR);
+/**
+ * Navigates to a page with a resilient strategy for apps that keep long-lived network connections.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @param {string} url - URL to navigate to.
+ * @returns {Promise<void>} Resolves when the page is at least DOM-ready.
+ */
+function gotoWithFallback(page, url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield page.goto(url, { waitUntil: "domcontentloaded", timeout: NAVIGATION_TIMEOUT_MS });
+        // Best effort: settle initial bursty requests without hard-failing on persistent streams.
+        try {
+            yield page.waitForNetworkIdle({ idleTime: 1000, timeout: NETWORK_IDLE_TIMEOUT_MS });
+        }
+        catch (_a) {
+            // Ignore network-idle timeouts because ChatGPT keeps active connections open.
+        }
+    });
+}
+/**
+ * Saves cookies from a Puppeteer page to a specified file path.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @param {string} [path=DEFAULT_COOKIE_PATH] - Path to save the cookies file.
+ * @returns {Promise<void>} Resolves when cookies are saved.
+ */
+function saveCookies(page_1) {
+    return __awaiter(this, arguments, void 0, function* (page, path = DEFAULT_COOKIE_PATH) {
+        const cookies = yield page.cookies();
+        fs_extra_1.default.writeFileSync(path, JSON.stringify(cookies, null, 2));
+    });
+}
+/**
+ * Returns the cookie file path for a given URL's hostname.
+ *
+ * @param {string} url - The URL to extract the hostname from.
+ * @returns {string} The path to the cookie file for the hostname, or the default cookie path if invalid.
+ */
+function getCookiePathForUrl(url) {
+    try {
+        const { hostname } = new URL(url);
+        return upath_1.default.join(COOKIE_DIR, `cookies_${hostname}.json`);
+    }
+    catch (_a) {
+        return DEFAULT_COOKIE_PATH;
+    }
+}
+/**
+ * Navigates to a URL using Puppeteer, loading cookies for the host and injecting a DOM mutation observer.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @param {string} url - The URL to navigate to.
+ * @returns {Promise<{ waitForDomIdle: (idleMs?: number, timeout?: number) => Promise<boolean> }>} An object containing a function to wait for DOM stability.
+ */
+function navigatePage(page, url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cookiePath = getCookiePathForUrl(url);
+        // Load cookies for the host
+        const cookies = loadCookies(cookiePath);
+        if (cookies) {
+            yield page.setCookie(...cookies);
+        }
+        // Navigate with fallback for pages that keep persistent network connections.
+        yield gotoWithFallback(page, url);
+        // Inject DOM mutation observer to handle dynamic content
+        yield page.evaluate(() => {
+            window.__domStillUpdating = true;
+            if (window.__domObserver) {
+                window.__domObserver.disconnect();
+            }
+            window.__domObserver = new MutationObserver(() => {
+                window.__lastDomMutation = Date.now();
+            });
+            window.__lastDomMutation = Date.now();
+            window.__domObserver.observe(document.body, {
+                childList: true,
+                subtree: true,
+                attributes: true,
+                characterData: true
+            });
+            // Stop tracking after a while (optional)
+            setTimeout(() => {
+                window.__domStillUpdating = false;
+                window.__domObserver.disconnect();
+            }, 30000); // e.g. 30 seconds max
+        });
+        /**
+         * Waits until the DOM has been stable (no mutations) for a specified number of milliseconds.
+         *
+         * @param {number} [idleMs=1000] - The number of milliseconds the DOM must be stable.
+         * @param {number} [timeout=10000] - The maximum time to wait for the DOM to stabilize.
+         * @returns {Promise<boolean>} Resolves to true if the DOM was stable for idleMs within timeout, otherwise throws an error.
+         */
+        const waitForDomIdle = (...args_1) => __awaiter(this, [...args_1], void 0, function* (idleMs = 1000, timeout = 10000) {
+            const start = Date.now();
+            while (Date.now() - start < timeout) {
+                const lastMutation = yield page.evaluate(() => window.__lastDomMutation);
+                const idle = Date.now() - lastMutation;
+                if (idle >= idleMs) {
+                    return true; // DOM has been stable for idleMs
+                }
+                yield new Promise((r) => setTimeout(r, 200)); // poll every 200ms
+            }
+            throw new Error("DOM did not stabilize within timeout");
+        });
+        return { waitForDomIdle };
+    });
+}
+/**
+ * Loads cookies from a specified file path.
+ *
+ * @param {string} [cookieFilePath=DEFAULT_COOKIE_PATH] - Path to the cookie file.
+ * @returns {Array|Null} Parsed cookies array, or null if file does not exist.
+ */
+function loadCookies(cookieFilePath = DEFAULT_COOKIE_PATH) {
+    if (!fs_extra_1.default.existsSync(cookieFilePath))
+        return null;
+    return JSON.parse(fs_extra_1.default.readFileSync(cookieFilePath));
+}
+/**
+ * Restores cookies from a file to a Puppeteer page.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @param {string} [cookieFilePath=DEFAULT_COOKIE_PATH] - Path to the cookie file.
+ * @returns {Promise<void>} Resolves when cookies are restored.
+ */
+function _restoreCookies(page_1) {
+    return __awaiter(this, arguments, void 0, function* (page, cookieFilePath = DEFAULT_COOKIE_PATH) {
+        const cookies = loadCookies(cookieFilePath);
+        if (cookies) {
+            yield page.setCookie(...cookies);
+        }
+    });
+}
+/**
+ * Writes a question to the ChatGPT prompt textarea, handling multi-line questions.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @param {string} question - The question text to write.
+ * @returns {Promise<void>} Resolves when the question is written.
+ */
+function writeQuestion(page, question) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const promptTextarea = yield page.waitForSelector("#prompt-textarea", { timeout: 30000 });
+        if (!promptTextarea) {
+            console.log("Cannot find the prompt input on the webpage. Please check whether you have access to chat.openai.com without logging in via your browser.");
+            return;
+        }
+        // Inject the full prompt instantly and emit input-like events so the UI reacts.
+        yield page.evaluate((text) => {
+            const promptEl = document.querySelector("#prompt-textarea");
+            if (!promptEl) {
+                return;
+            }
+            promptEl.focus();
+            promptEl.innerHTML = "";
+            const lines = String(text).split("\n");
+            for (const line of lines) {
+                const p = document.createElement("p");
+                p.textContent = line;
+                promptEl.appendChild(p);
+            }
+            promptEl.dispatchEvent(new InputEvent("beforeinput", { bubbles: true, inputType: "insertFromPaste", data: text }));
+            promptEl.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertFromPaste", data: text }));
+            promptEl.dispatchEvent(new Event("change", { bubbles: true }));
+        }, question);
+        // If the app state did not pick up the DOM injection, use keyboard insertion as a reliable fallback.
+        const hasPromptText = yield page.evaluate(() => {
+            const promptEl = document.querySelector("#prompt-textarea");
+            return Boolean(promptEl && promptEl.textContent && promptEl.textContent.trim().length > 0);
+        });
+        if (!hasPromptText) {
+            console.log("Prompt state not updated by DOM injection. Falling back to keyboard insertText.");
+            yield promptTextarea.click({ clickCount: 1 });
+            yield page.keyboard.down("Control");
+            yield page.keyboard.press("KeyA");
+            yield page.keyboard.up("Control");
+            yield page.keyboard.insertText(question);
+        }
+    });
+}
+/**
+ * Clicks the submit button in ChatGPT interface, trying different button variants.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @returns {Promise<boolean>} Resolves to true when submission is detected, otherwise false.
+ */
+function clickSubmitButton(page) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Attempting to click the submit button...");
+        try {
+            const userMessageCountBefore = yield page.$$eval('[data-message-author-role="user"]', (elements) => elements.length);
+            const waitForSubmit = (...args_1) => __awaiter(this, [...args_1], void 0, function* (timeout = 5000) {
+                try {
+                    yield page.waitForFunction((previousCount) => {
+                        const currentCount = document.querySelectorAll('[data-message-author-role="user"]').length;
+                        return currentCount > previousCount;
+                    }, { timeout }, userMessageCountBefore);
+                    return true;
+                }
+                catch (_a) {
+                    return false;
+                }
+            });
+            yield page.waitForFunction(() => {
+                const candidates = [
+                    document.querySelector('[data-testid="fruitjuice-send-button"]'),
+                    document.querySelector('#composer-submit-button'),
+                    document.querySelector('[data-testid="send-button"]')
+                ].filter(Boolean);
+                return candidates.some((button) => {
+                    const isDisabled = button.disabled || button.getAttribute("aria-disabled") === "true";
+                    const isVisible = button.offsetParent !== null;
+                    return !isDisabled && isVisible;
+                });
+            }, { timeout: 5000 }).catch(() => {
+                // Continue to diagnostics below even if no enabled button was found within timeout.
+            });
+            const buttonDetails = yield page.evaluate(() => {
+                const selectors = [
+                    '[data-testid="fruitjuice-send-button"]',
+                    "#composer-submit-button",
+                    '[data-testid="send-button"]'
+                ];
+                const details = selectors.map((selector) => {
+                    const el = document.querySelector(selector);
+                    const exists = Boolean(el);
+                    const disabled = exists
+                        ? Boolean(el.disabled || el.getAttribute("aria-disabled") === "true")
+                        : null;
+                    const visible = exists ? el.offsetParent !== null : null;
+                    return { selector, exists, disabled, visible };
+                });
+                return details;
+            });
+            console.log(`Submit button details: ${JSON.stringify(buttonDetails)}`);
+            const clickable = buttonDetails.find((item) => item.exists && item.visible && item.disabled === false);
+            const selectedSelector = clickable ? clickable.selector : null;
+            if (selectedSelector) {
+                yield page.click(selectedSelector);
+                console.log(`Clicked submit button selector: ${selectedSelector}`);
+                if (yield waitForSubmit(5000)) {
+                    console.log("Submission detected after selector click.");
+                    return true;
+                }
+                // Fallback: force a DOM click in case pointer-interception blocked page.click.
+                const forcedClickWorked = yield page.evaluate((selector) => {
+                    const el = document.querySelector(selector);
+                    if (!el) {
+                        return false;
+                    }
+                    el.click();
+                    return true;
+                }, selectedSelector);
+                if (forcedClickWorked) {
+                    console.log(`Forced DOM click on selector: ${selectedSelector}`);
+                    if (yield waitForSubmit(5000)) {
+                        console.log("Submission detected after forced DOM click.");
+                        return true;
+                    }
+                }
+            }
+            console.log("Submit button path did not submit. Trying Enter key fallback on prompt.");
+            yield page.focus("#prompt-textarea");
+            yield page.keyboard.press("Enter");
+            if (yield waitForSubmit(5000)) {
+                console.log("Submission detected after Enter key fallback.");
+                return true;
+            }
+            // Final fallback: submit the nearest composer form.
+            const didRequestSubmit = yield page.evaluate(() => {
+                const prompt = document.querySelector("#prompt-textarea");
+                if (!prompt) {
+                    return false;
+                }
+                const form = prompt.closest("form");
+                if (!form) {
+                    return false;
+                }
+                if (typeof form.requestSubmit === "function") {
+                    form.requestSubmit();
+                }
+                else {
+                    form.submit();
+                }
+                return true;
+            });
+            if (didRequestSubmit) {
+                console.log("Triggered form submit fallback.");
+                if (yield waitForSubmit(5000)) {
+                    console.log("Submission detected after form submit fallback.");
+                    return true;
+                }
+            }
+            console.log("Failed to submit prompt after all strategies.");
+            return false;
+        }
+        catch (e) {
+            console.log(`Failed to click the send button: ${e}`);
+            return false;
+        }
+    });
+}
+let lastMessageId = null;
+let messageCount = 0;
+const is_streaming = false; // Set to true if you want to stream the response
+/**
+ * Creates a promise that resolves after a specified number of milliseconds.
+ *
+ * @param {number} ms - The number of milliseconds to wait.
+ * @returns {Promise<void>} A promise that resolves after the specified delay.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Waits for the initial assistant response to appear and finish thinking.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @param {number} [timeout=30000] - Maximum time to wait for the response (ms).
+ * @returns {Promise<void>} Resolves when the initial response is ready.
+ */
+function waitForInitialResponse(page_1) {
+    return __awaiter(this, arguments, void 0, function* (page, timeout = 30000) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const assistantMessages = yield page.$$('[data-message-author-role="assistant"]');
+            const currentMessageCount = assistantMessages.length;
+            if (currentMessageCount > messageCount) {
+                const lastMessage = assistantMessages[assistantMessages.length - 1];
+                const isThinking = yield lastMessage.$(".result-thinking");
+                if (!isThinking) {
+                    lastMessageId = yield page.evaluate((element) => element.getAttribute("data-message-id"), lastMessage);
+                    messageCount = currentMessageCount;
+                    return;
+                }
+            }
+            yield sleep(100);
+        }
+        console.log("Timed out waiting for the initial response.");
+    });
+}
+/**
+ * Handles streaming response from the assistant, printing output as it arrives.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @param {string} [outputFile] - Path to save the response. Defaults to tmp/response.txt.
+ * @returns {Promise<void>} Resolves when streaming is complete.
+ */
+function handleStreamingResponse(page_1) {
+    return __awaiter(this, arguments, void 0, function* (page, outputFile = upath_1.default.join(process.cwd(), "tmp/response.txt")) {
+        let previousText = "";
+        let completeResponse = "";
+        let newContentDetected = false;
+        while (!newContentDetected) {
+            const assistantMessages = yield page.$$('[data-message-author-role="assistant"]');
+            if (assistantMessages.length > 0) {
+                const lastMessage = assistantMessages[assistantMessages.length - 1];
+                const currentMessageId = yield page.evaluate((element) => element.getAttribute("data-message-id"), lastMessage);
+                if (currentMessageId === lastMessageId) {
+                    const currentText = yield page.evaluate((element) => element.textContent, lastMessage);
+                    console.log(`Current text: ${currentText}`);
+                    if (currentText !== previousText) {
+                        if (is_streaming) {
+                            process.stdout.write(currentText.slice(previousText.length));
+                        }
+                        else {
+                            completeResponse += currentText.slice(previousText.length);
+                        }
+                    }
+                    previousText = currentText;
+                    const isStreaming = yield lastMessage.$(".result-streaming");
+                    if (!isStreaming) {
+                        newContentDetected = true;
+                    }
+                }
+                else {
+                    lastMessageId = currentMessageId;
+                }
+            }
+            yield sleep(100);
+        }
+        if (!is_streaming) {
+            console.log(completeResponse.trim());
+            console.log("\n\n");
+            fs_extra_1.default.ensureDirSync(upath_1.default.dirname(outputFile));
+            fs_extra_1.default.writeFileSync(outputFile, completeResponse.trim());
+            console.log(`Response saved to ${outputFile}`);
+        }
+    });
+}
+/**
+ * Checks if the user is logged into ChatGPT by checking if login button exists and is visible.
+ *
+ * @param {import('puppeteer').Page} page - Puppeteer page instance.
+ * @returns {Promise<boolean>} True if logged in (no visible login button), false if not logged in.
+ */
+function isLoggedIn(page) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield page.evaluate(() => {
+            const loginButton = document.querySelector('[data-testid="login-button"]');
+            // User is NOT logged in if login button exists and is visible
+            return !(loginButton && loginButton.offsetParent !== null);
+        });
+        // Ensure we always return a boolean
+        return result === true;
+    });
+}
+/**
+ * Creates a new Puppeteer browser instance with StealthPlugin enabled.
+ *
+ * @param {Parameters<import("puppeteer-extra").VanillaPuppeteer["launch"]>[0]} [browserOptions={}] - Browser launch options.
+ * @returns {Promise<import("puppeteer-extra").Browser>} The created browser instance.
+ */
+function createBrowser() {
+    return __awaiter(this, arguments, void 0, function* (browserOptions = {}) {
+        const windowsChromeExecutable = "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe";
+        const hasWindowsChrome = process.platform === "win32" && fs_extra_1.default.existsSync(windowsChromeExecutable);
+        /**
+         * @type {Parameters<import("puppeteer-extra").VanillaPuppeteer["launch"]>[0]}
+         */
+        const defaultOptions = Object.assign({ headless: false, defaultViewport: null, userDataDir: upath_1.default.join(process.cwd(), "tmp/puppeteer-profile"), 
+            // Windows-specific options to handle browser launch issues
+            args: [
+                "--start-maximized",
+                "--no-sandbox",
+                "--disable-setuid-sandbox",
+                "--disable-dev-shm-usage",
+                "--disable-accelerated-2d-canvas",
+                "--no-first-run",
+                "--no-zygote",
+                "--disable-gpu",
+                "--disable-background-timer-throttling",
+                "--disable-backgrounding-occluded-windows",
+                "--disable-renderer-backgrounding"
+            ], ignoreDefaultArgs: ["--disable-extensions"] }, (hasWindowsChrome && {
+            // Prefer local Chrome installation when present on Windows.
+            executablePath: windowsChromeExecutable
+        }));
+        try {
+            return yield puppeteer_extra_1.default.use((0, puppeteer_extra_plugin_stealth_1.default)()).launch(Object.assign(Object.assign({}, defaultOptions), browserOptions));
+        }
+        catch (_error) {
+            console.error("Failed to launch browser with default options. Trying fallback options...");
+            // Fallback: Try with minimal options
+            try {
+                return yield puppeteer_extra_1.default.use((0, puppeteer_extra_plugin_stealth_1.default)()).launch(Object.assign(Object.assign({ headless: browserOptions.headless || false, defaultViewport: null, args: ["--start-maximized", "--no-sandbox", "--disable-setuid-sandbox"], ignoreDefaultArgs: false }, (hasWindowsChrome && {
+                    executablePath: windowsChromeExecutable
+                })), browserOptions));
+            }
+            catch (fallbackError) {
+                console.error("Browser launch failed completely. Common solutions:");
+                console.error("1. Install Google Chrome if not installed");
+                console.error("2. Update Node.js to the latest version");
+                console.error("3. Try running: npm install puppeteer --force");
+                console.error("4. Check if antivirus is blocking browser launch");
+                throw new Error(`Browser launch failed: ${fallbackError.message}`);
+            }
+        }
+    });
+}
+/**
+ * Handles the login process for ChatGPT by launching a browser and clicking the login button if needed.
+ *
+ * @returns {Promise<void>} Resolves when the login process is complete.
+ */
+function loginToChatGpt() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const browser = yield createBrowser({ headless: false });
+        const page = (yield browser.pages()).length > 0 ? (yield browser.pages())[0] : yield browser.newPage();
+        const url = "https://chat.openai.com";
+        const navigate = yield navigatePage(page, url);
+        // Wait for page to fully load before checking login status
+        yield navigate.waitForDomIdle(2000, 10000);
+        // Check if the login button exists
+        const loginButtonExists = yield page.evaluate(() => {
+            return document.querySelector('[data-testid="login-button"]') !== null;
+        });
+        if (loginButtonExists) {
+            console.log("Login button found, clicking to log in...");
+            yield page.click('[data-testid="login-button"]');
+            // Wait for the login process to complete without requiring full network idleness.
+            yield page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: NAVIGATION_TIMEOUT_MS });
+            try {
+                yield page.waitForNetworkIdle({ idleTime: 1000, timeout: NETWORK_IDLE_TIMEOUT_MS });
+            }
+            catch (_a) {
+                // Ignore: authentication pages can keep background connections active.
+            }
+            console.log("Login process completed.");
+        }
+        else {
+            console.log("No login required - user appears to be already logged in.");
+        }
+    });
+}
+/**
+ * Automates ChatGPT interactions using Puppeteer. Can send text questions or upload files to ChatGPT.
+ *
+ * @param {Object} [chatgptOptions={}] - Configuration options for ChatGPT automation.
+ * @param {boolean} [chatgptOptions.headless=true] - Whether to run the browser in headless mode.
+ * @param {string} [chatgptOptions.question] - Text question to send to ChatGPT. Either question or questionFile must be provided.
+ * @param {string} [chatgptOptions.questionFile] - Path to a file to upload to ChatGPT. Either question or questionFile must be provided.
+ * @param {string} [chatgptOptions.responseFile] - Path to save the response. Defaults to tmp/response.txt.
+ * @returns {Promise<void>} Resolves when the ChatGPT interaction is complete. Responses are logged to console and saved to specified file.
+ * @throws {Error} Throws an error if neither question nor questionFile is provided.
+ *
+ * @example
+ * // Send a text question
+ * await runChatGpt({
+ *   headless: false,
+ *   question: "What is the capital of France?"
+ * });
+ *
+ * @example
+ * // Upload a file for analysis
+ * await runChatGpt({
+ *   headless: false,
+ *   questionFile: "./path/to/document.txt"
+ * });
+ */
+function runChatGpt() {
+    return __awaiter(this, arguments, void 0, function* (chatgptOptions = {}) {
+        const headless = chatgptOptions.headless !== undefined ? chatgptOptions.headless : true;
+        const questionFile = chatgptOptions.questionFile;
+        let question = chatgptOptions.question;
+        let shouldUploadQuestionFile = Boolean(questionFile);
+        const responseFile = chatgptOptions.responseFile || upath_1.default.join(process.cwd(), "tmp", "response.txt");
+        // Validate input parameters
+        const noInputProvided = !question && !questionFile;
+        const questionIsEmpty = question && question.trim().length === 0;
+        const questionFileIsEmpty = questionFile && questionFile.trim().length === 0;
+        if (noInputProvided || questionIsEmpty || questionFileIsEmpty) {
+            throw new Error("You must provide a question or a question file.");
+        }
+        // For small files, send content as plain text to avoid file-upload login requirements.
+        if (!question && questionFile) {
+            if (!fs_extra_1.default.existsSync(questionFile)) {
+                throw new Error(`Question file does not exist: ${questionFile}`);
+            }
+            const questionFileStats = fs_extra_1.default.statSync(questionFile);
+            if (questionFileStats.size <= MAX_INLINE_QUESTION_FILE_BYTES) {
+                question = fs_extra_1.default.readFileSync(questionFile, "utf8").trim();
+                if (!question) {
+                    throw new Error("Question file is empty.");
+                }
+                shouldUploadQuestionFile = false;
+                console.log(`Question file is ${questionFileStats.size} bytes (<= ${MAX_INLINE_QUESTION_FILE_BYTES}). Sending as text prompt.`);
+            }
+        }
+        let browser;
+        try {
+            browser = yield createBrowser({ headless });
+        }
+        catch (error) {
+            console.error("Error running ChatGPT:", error);
+            console.error("\nTroubleshooting steps:");
+            console.error("1. Make sure Google Chrome is installed");
+            console.error("2. Try running: yarn add puppeteer --force");
+            console.error("3. Check if your antivirus is blocking the browser");
+            console.error("4. Close any running Chrome instances and try again");
+            throw error;
+        }
+        const allPages = yield browser.pages();
+        /** @type {import('puppeteer').Page} */
+        const page = allPages.length > 0 ? allPages[0] : yield browser.newPage();
+        yield page.bringToFront();
+        // Close other pages if more than one page is open.
+        if (allPages.length > 1) {
+            for (const p of allPages) {
+                if (p !== page) {
+                    yield p.close();
+                }
+            }
+        }
+        try {
+            const url = "https://chat.openai.com";
+            const navigate = yield navigatePage(page, url);
+            // Check temporary chat - wait for page to load and try to click temporary chat button
+            yield navigate.waitForDomIdle(2000, 15000);
+            try {
+                const tempChatButton = yield page.$('button[aria-label="Turn on temporary chat"]');
+                if (tempChatButton) {
+                    yield page.evaluate((el) => el.click(), tempChatButton);
+                    console.log("Successfully clicked temporary chat button");
+                    yield navigate.waitForDomIdle(1000, 10000);
+                }
+                else {
+                    console.log("Temporary chat button not found, proceeding without it.");
+                }
+            }
+            catch (error) {
+                console.log(`Failed to click temporary chat button: ${error.message}`);
+            }
+            if (question) {
+                yield writeQuestion(page, question);
+                // Submit the question
+                const didSubmit = yield clickSubmitButton(page);
+                if (!didSubmit) {
+                    throw new Error("Prompt was not submitted. The composer button may be disabled or blocked.");
+                }
+                yield navigate.waitForDomIdle(1000, 30000); // Wait for DOM to stabilize
+                // Wait for the initial response
+                yield waitForInitialResponse(page);
+                // Handle the streaming response
+                yield handleStreamingResponse(page, responseFile);
+                // Save cookies for this host at the end
+                yield saveCookies(page, getCookiePathForUrl(url));
+            }
+            else if (shouldUploadQuestionFile && questionFile) {
+                // Wait for page to fully load before checking login status
+                yield navigate.waitForDomIdle(2000, 10000);
+                // Check if logged in
+                const isUserLoggedIn = yield isLoggedIn(page);
+                console.log(`Login status: ${isUserLoggedIn ? "Logged in" : "Not logged in"}`);
+                if (!isUserLoggedIn) {
+                    console.log("Not logged in. Please log in to ChatGPT in the browser window, then close it and run the command again.");
+                    return loginToChatGpt();
+                }
+                // Upload the question file
+                const plusButtonExists = yield page.evaluate(() => {
+                    const button = document.querySelector('[data-testid="composer-plus-btn"]');
+                    return button !== null;
+                });
+                if (plusButtonExists) {
+                    yield page.click('[data-testid="composer-plus-btn"]');
+                    yield sleep(500); // Wait for the menu to open
+                    const menuItems = yield page.$$('[role="menuitem"]');
+                    let clicked = false;
+                    for (const item of menuItems) {
+                        const text = yield page.evaluate((el) => el.innerText, item);
+                        if (text && text.includes("Add photos") && text.includes("files")) {
+                            yield item.hover();
+                            clicked = true;
+                            break;
+                        }
+                    }
+                    if (!clicked) {
+                        console.log('Could not find the "Add photos & files" menu item.');
+                        return;
+                    }
+                    // Wait for file input to appear and upload the file
+                    try {
+                        yield sleep(1000); // Wait for file dialog to be ready
+                        // Look for the file input element
+                        const fileInput = yield page.waitForSelector('input[type="file"]', { timeout: 10000 });
+                        if (fileInput) {
+                            console.log(`Uploading file: ${questionFile}`);
+                            yield fileInput.uploadFile(questionFile);
+                            // Wait for the file to be processed
+                            yield navigate.waitForDomIdle(2000, 15000);
+                            console.log("File uploaded successfully");
+                            // Optionally submit after file upload
+                            const didSubmit = yield clickSubmitButton(page);
+                            if (!didSubmit) {
+                                throw new Error("Prompt was not submitted after file upload.");
+                            }
+                            yield navigate.waitForDomIdle(1000, 30000);
+                            // Wait for and handle response
+                            yield waitForInitialResponse(page);
+                            yield handleStreamingResponse(page, responseFile);
+                        }
+                        else {
+                            console.log("Could not find file input element");
+                        }
+                    }
+                    catch (error) {
+                        console.log(`Error uploading file: ${error.message}`);
+                    }
+                }
+                else {
+                    console.log('Could not find the [data-testid="composer-plus-btn"] button.');
+                }
+            }
+        }
+        finally {
+            // Always close the browser, even if an error occurred
+            if (browser) {
+                yield browser.close();
+            }
+        }
+    });
+}