binary-collections 2.0.10 → 2.0.12

package/lib/utils/chatgpt.js

@@ -17,9 +17,31 @@ 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 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.
  *
@@ -63,8 +85,8 @@ function navigatePage(page, url) {
         if (cookies) {
             yield page.setCookie(...cookies);
         }
-        // Navigate and wait until fully loaded
-        yield page.goto(url, { waitUntil: "networkidle0" });
+        // 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;
@@ -104,7 +126,7 @@ function navigatePage(page, url) {
                 }
                 yield new Promise((r) => setTimeout(r, 200)); // poll every 200ms
             }
-            throw new Error("DOM did not stabilize within timeout");
+            throw new Error('DOM did not stabilize within timeout');
         });
         return { waitForDomIdle };
     });
@@ -144,31 +166,41 @@ function _restoreCookies(page_1) {
  */
 function writeQuestion(page, question) {
     return __awaiter(this, void 0, void 0, function* () {
-        const questions = question.split("\n");
-        const promptTextarea = yield page.waitForSelector("#prompt-textarea", { timeout: 30000 });
+        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.");
-        }
-        // Clear the prompt textarea
-        yield page.evaluate(() => {
-            document.querySelector("#prompt-textarea").innerHTML = `<p></p>`;
-        });
-        // Check if the question has newlines
-        if (questions.length === 1) {
-            // If there's only one line, type it directly
-            yield page.type("#prompt-textarea", questions[0], { delay: 100 });
+            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;
         }
-        // Type each question line by line
-        for (const q of questions) {
-            yield page.type("#prompt-textarea", q, { delay: 100 });
-            // Check if the line is not the last one
-            if (q !== questions[questions.length - 1]) {
-                // Simulate pressing Shift + Enter to add a new line
-                yield page.keyboard.down("Shift");
-                yield page.keyboard.press("Enter");
-                yield page.keyboard.up("Shift");
+        // 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);
         }
     });
 }
@@ -176,29 +208,121 @@ function writeQuestion(page, question) {
  * Clicks the submit button in ChatGPT interface, trying different button variants.
  *
  * @param {import('puppeteer').Page} page - Puppeteer page instance.
- * @returns {Promise<void>} Resolves when the submit button is clicked or attempt is made.
+ * @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 fruitjuiceSendButton = yield page.evaluate(() => {
-                return document.querySelector('[data-testid="fruitjuice-send-button"]') !== null;
+            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;
+                }
             });
-            const sendButton = yield page.evaluate(() => {
-                return document.querySelector('[data-testid="send-button"]') !== null;
+            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;
             });
-            if (fruitjuiceSendButton) {
-                yield page.click('[data-testid="fruitjuice-send-button"]');
+            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;
+                    }
+                }
             }
-            else if (sendButton) {
-                yield page.click('[data-testid="send-button"]');
+            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;
             }
-            else {
-                console.log("Neither send button is present");
+            // 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;
         }
     });
 }
@@ -229,16 +353,16 @@ function waitForInitialResponse(page_1) {
             const currentMessageCount = assistantMessages.length;
             if (currentMessageCount > messageCount) {
                 const lastMessage = assistantMessages[assistantMessages.length - 1];
-                const isThinking = yield lastMessage.$(".result-thinking");
+                const isThinking = yield lastMessage.$('.result-thinking');
                 if (!isThinking) {
-                    lastMessageId = yield page.evaluate((element) => element.getAttribute("data-message-id"), lastMessage);
+                    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.");
+        console.log('Timed out waiting for the initial response.');
     });
 }
 /**
@@ -249,15 +373,15 @@ function waitForInitialResponse(page_1) {
  * @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 = "";
+    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);
+                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}`);
@@ -270,7 +394,7 @@ function handleStreamingResponse(page_1) {
                         }
                     }
                     previousText = currentText;
-                    const isStreaming = yield lastMessage.$(".result-streaming");
+                    const isStreaming = yield lastMessage.$('.result-streaming');
                     if (!isStreaming) {
                         newContentDetected = true;
                     }
@@ -283,7 +407,7 @@ function handleStreamingResponse(page_1) {
         }
         if (!is_streaming) {
             console.log(completeResponse.trim());
-            console.log("\n\n");
+            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}`);
@@ -315,41 +439,46 @@ function isLoggedIn(page) {
  */
 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, userDataDir: upath_1.default.join(process.cwd(), "tmp/puppeteer-profile"), 
+        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: [
-                "--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"] }, (process.platform === "win32" && {
-            // Additional Windows-specific options
-            executablePath: undefined // Let Puppeteer find Chrome automatically
+                '--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...");
+            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({ headless: browserOptions.headless || false, args: ["--no-sandbox", "--disable-setuid-sandbox"], ignoreDefaultArgs: false }, browserOptions));
+                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");
+                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}`);
             }
         }
@@ -364,7 +493,7 @@ 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 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);
@@ -373,14 +502,20 @@ function loginToChatGpt() {
             return document.querySelector('[data-testid="login-button"]') !== null;
         });
         if (loginButtonExists) {
-            console.log("Login button found, clicking to log in...");
+            console.log('Login button found, clicking to log in...');
             yield page.click('[data-testid="login-button"]');
-            // Wait for the login process to complete
-            yield page.waitForNavigation({ waitUntil: "networkidle0" });
-            console.log("Login process completed.");
+            // 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.");
+            console.log('No login required - user appears to be already logged in.');
         }
     });
 }
@@ -414,31 +549,57 @@ function runChatGpt() {
         const headless = chatgptOptions.headless !== undefined ? chatgptOptions.headless : true;
         const questionFile = chatgptOptions.questionFile;
         let question = chatgptOptions.question;
-        const responseFile = chatgptOptions.responseFile || upath_1.default.join(process.cwd(), "tmp", "response.txt");
+        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.");
+            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");
+            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 = (yield browser.pages()).length > 0 ? (yield browser.pages())[0] : yield browser.newPage();
+        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 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);
@@ -446,11 +607,11 @@ function runChatGpt() {
                 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");
+                    console.log('Successfully clicked temporary chat button');
                     yield navigate.waitForDomIdle(1000, 10000);
                 }
                 else {
-                    console.log("Temporary chat button not found, proceeding without it.");
+                    console.log('Temporary chat button not found, proceeding without it.');
                 }
             }
             catch (error) {
@@ -459,7 +620,10 @@ function runChatGpt() {
             if (question) {
                 yield writeQuestion(page, question);
                 // Submit the question
-                yield clickSubmitButton(page);
+                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);
@@ -468,14 +632,14 @@ function runChatGpt() {
                 // Save cookies for this host at the end
                 yield saveCookies(page, getCookiePathForUrl(url));
             }
-            else if (questionFile) {
+            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"}`);
+                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.");
+                    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
@@ -490,7 +654,7 @@ function runChatGpt() {
                     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")) {
+                        if (text && text.includes('Add photos') && text.includes('files')) {
                             yield item.hover();
                             clicked = true;
                             break;
@@ -510,16 +674,19 @@ function runChatGpt() {
                             yield fileInput.uploadFile(questionFile);
                             // Wait for the file to be processed
                             yield navigate.waitForDomIdle(2000, 15000);
-                            console.log("File uploaded successfully");
+                            console.log('File uploaded successfully');
                             // Optionally submit after file upload
-                            yield clickSubmitButton(page);
+                            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");
+                            console.log('Could not find file input element');
                         }
                     }
                     catch (error) {

package/lib/utils/chatgpt.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   runChatGpt
-} from "../chunk-GJTGHXRA.mjs";
+} from "../chunk-GAGABICI.mjs";
 import "../chunk-QQ4A6DLD.mjs";
 export {
   runChatGpt

package/lib/utils/findEnvFiles.cjs

@@ -0,0 +1,89 @@
+// src/utils/findEnvFiles.cjs
+var fs = require("fs");
+var path = require("path");
+var glob = require("glob");
+var DEFAULT_IGNORES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/.yarn/**",
+  "**/.pnpm/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/vendor/**",
+  "**/tmp/**",
+  "**/.cache/**",
+  "**/assets/**",
+  "**/logs/**",
+  "**/output/**",
+  "**/public/**",
+  "**/static/**",
+  "**/temp/**",
+  "**/backup/**",
+  "**/backups/**",
+  "**/examples/**",
+  "**/docs/**",
+  "**/tests/**",
+  "**/__tests__/**",
+  "**/spec/**",
+  "**/__specs__/**",
+  "**/scripts/**",
+  "**/bin/**",
+  "**/hooks/**",
+  "**/config/**",
+  "**/configs/**",
+  "**/settings/**",
+  "**/.vscode/**",
+  "**/.idea/**"
+];
+function findEnvFiles(startDir = process.cwd(), filter) {
+  const found = /* @__PURE__ */ new Set();
+  function addFile(file) {
+    const normalized = path.normalize(file);
+    if (typeof filter === "function" && !filter(normalized)) {
+      return;
+    }
+    found.add(normalized);
+  }
+  let current = path.resolve(startDir);
+  while (true) {
+    const envPath = path.join(current, ".env");
+    if (fs.existsSync(envPath)) {
+      addFile(envPath);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  const files = glob.globSync("**/.env*", {
+    cwd: startDir,
+    absolute: true,
+    nodir: true,
+    ignore: DEFAULT_IGNORES
+  });
+  for (const file of files) {
+    addFile(file);
+  }
+  return [...found];
+}
+function findEnvWithToken(startDir = process.cwd(), tokenName = "GITHUB_TOKEN") {
+  const envFiles = findEnvFiles(startDir);
+  return envFiles.find((file) => {
+    try {
+      const content = fs.readFileSync(file, "utf-8");
+      const regex = new RegExp(`^\\s*${tokenName}\\s*=`, "m");
+      return regex.test(content);
+    } catch (err) {
+      console.warn(`Failed to read ${file}: ${err instanceof Error ? err.message : String(err)}`);
+      return false;
+    }
+  });
+}
+module.exports = {
+  DEFAULT_IGNORES,
+  findEnvFiles,
+  findEnvWithToken,
+  default: findEnvFiles
+};