binary-collections 2.0.10 → 2.0.11

package/lib/utils/chatgpt.js

@@ -19,7 +19,29 @@ const puppeteer_extra_plugin_stealth_1 = __importDefault(require("puppeteer-extr
 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.
  *
@@ -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;
@@ -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 });
         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");
+        // 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;
         }
     });
 }
@@ -315,12 +439,15 @@ 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: [
+                "--start-maximized",
                 "--no-sandbox",
                 "--disable-setuid-sandbox",
                 "--disable-dev-shm-usage",
@@ -331,9 +458,9 @@ function createBrowser() {
                 "--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
+            ], 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));
@@ -342,7 +469,9 @@ function createBrowser() {
             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:");
@@ -375,8 +504,14 @@ function loginToChatGpt() {
         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" });
+            // 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 {
@@ -414,6 +549,7 @@ function runChatGpt() {
         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;
@@ -422,6 +558,21 @@ function runChatGpt() {
         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 });
@@ -435,8 +586,18 @@ function runChatGpt() {
             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 navigate = yield navigatePage(page, url);
@@ -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,7 +632,7 @@ 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
@@ -512,7 +676,10 @@ function runChatGpt() {
                             yield navigate.waitForDomIdle(2000, 15000);
                             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);

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-N436BNBK.mjs";
 import "../chunk-QQ4A6DLD.mjs";
 export {
   runChatGpt

package/lib/utils/findEnvFiles.cjs

@@ -0,0 +1,107 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/findEnvFiles.js
+var findEnvFiles_exports = {};
+__export(findEnvFiles_exports, {
+  findEnvFiles: () => findEnvFiles
+});
+module.exports = __toCommonJS(findEnvFiles_exports);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var glob = __toESM(require("glob"), 1);
+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 = import_node_path.default.normalize(file);
+    if (typeof filter === "function" && !filter(normalized)) {
+      return;
+    }
+    found.add(normalized);
+  }
+  let current = import_node_path.default.resolve(startDir);
+  while (true) {
+    const envPath = import_node_path.default.join(current, ".env");
+    if (import_node_fs.default.existsSync(envPath)) {
+      addFile(envPath);
+    }
+    const parent = import_node_path.default.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];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findEnvFiles
+});

package/lib/utils/findEnvFiles.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Find .env files.
+ *
+ * @param {string} startDir
+ * @param {(file:string)=>boolean} [filter]
+ * @returns {string[]}
+ */
+export function findEnvFiles(startDir?: string, filter?: (file: string) => boolean): string[];

package/lib/utils/findEnvFiles.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEnvFiles = findEnvFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const glob = __importStar(require("glob"));
+const 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/**"
+];
+/**
+ * Find .env files.
+ *
+ * @param {string} startDir
+ * @param {(file:string)=>boolean} [filter]
+ * @returns {string[]}
+ */
+function findEnvFiles(startDir = process.cwd(), filter) {
+    const found = new Set();
+    function addFile(file) {
+        const normalized = node_path_1.default.normalize(file);
+        if (typeof filter === "function" && !filter(normalized)) {
+            return;
+        }
+        found.add(normalized);
+    }
+    /* --------------------------------
+     * Parent directories
+     * -------------------------------- */
+    let current = node_path_1.default.resolve(startDir);
+    while (true) {
+        const envPath = node_path_1.default.join(current, ".env");
+        if (node_fs_1.default.existsSync(envPath)) {
+            addFile(envPath);
+        }
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    /* --------------------------------
+     * Subdirectories via glob
+     * -------------------------------- */
+    const files = glob.globSync("**/.env*", {
+        cwd: startDir,
+        absolute: true,
+        nodir: true,
+        ignore: DEFAULT_IGNORES
+    });
+    for (const file of files) {
+        addFile(file);
+    }
+    return [...found];
+}

package/lib/utils/findEnvFiles.mjs

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