binary-collections 2.0.8 → 2.0.10

package/lib/utils/chatgpt.js

@@ -0,0 +1,541 @@
+"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");
+fs_extra_1.default.ensureDirSync(COOKIE_DIR);
+/**
+ * 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 and wait until fully loaded
+        yield page.goto(url, { waitUntil: "networkidle0" });
+        // 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 questions = question.split("\n");
+        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 });
+            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");
+            }
+        }
+    });
+}
+/**
+ * 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.
+ */
+function clickSubmitButton(page) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const fruitjuiceSendButton = yield page.evaluate(() => {
+                return document.querySelector('[data-testid="fruitjuice-send-button"]') !== null;
+            });
+            const sendButton = yield page.evaluate(() => {
+                return document.querySelector('[data-testid="send-button"]') !== null;
+            });
+            if (fruitjuiceSendButton) {
+                yield page.click('[data-testid="fruitjuice-send-button"]');
+            }
+            else if (sendButton) {
+                yield page.click('[data-testid="send-button"]');
+            }
+            else {
+                console.log("Neither send button is present");
+            }
+        }
+        catch (e) {
+            console.log(`Failed to click the send button: ${e}`);
+        }
+    });
+}
+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 = {}) {
+        /**
+         * @type {Parameters<import("puppeteer-extra").VanillaPuppeteer["launch"]>[0]}
+         */
+        const defaultOptions = Object.assign({ headless: false, 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
+        }));
+        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({ headless: browserOptions.headless || false, args: ["--no-sandbox", "--disable-setuid-sandbox"], ignoreDefaultArgs: false }, 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
+            yield page.waitForNavigation({ waitUntil: "networkidle0" });
+            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;
+        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.");
+        }
+        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;
+        }
+        /** @type {import('puppeteer').Page} */
+        const page = (yield browser.pages()).length > 0 ? (yield browser.pages())[0] : yield browser.newPage();
+        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
+                yield clickSubmitButton(page);
+                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 (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
+                            yield clickSubmitButton(page);
+                            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();
+            }
+        }
+    });
+}

package/lib/utils/chatgpt.mjs

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

package/lib/{utils.cjs → utils/index.cjs}

@@ -1,4 +1,4 @@
-// src/utils.js
+// src/utils/index.cjs
 var fs = require("fs");
 var path = require("upath");
 var argv = require("minimist")(process.argv.slice(2));

package/lib/{utils.mjs → utils/index.mjs}

@@ -1,6 +1,6 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-APBWENF6.mjs";
-import "./chunk-AASHBCRW.mjs";
+} from "../chunk-V3N3JEUF.mjs";
+import "../chunk-QQ4A6DLD.mjs";
 export default require_utils();