binary-collections 2.0.10 → 2.0.12

package/lib/utils/findEnvFiles.d.cts

@@ -0,0 +1,19 @@
+export const DEFAULT_IGNORES: string[];
+/**
+ * Find all `.env*` files from the current directory tree
+ * and parent directories.
+ *
+ * @param {string} [startDir=process.cwd()] Starting directory.
+ * @param {(file: string) => boolean} [filter] Optional filter callback.
+ * @returns {string[]} Normalized absolute file paths.
+ */
+export function findEnvFiles(startDir?: string, filter?: (file: string) => boolean): string[];
+/**
+ * Find the first `.env*` file containing a token variable.
+ *
+ * @param {string} [startDir=process.cwd()] Starting directory.
+ * @param {string} [tokenName="GITHUB_TOKEN"] Environment variable name.
+ * @returns {string | undefined} Matching file path.
+ */
+export function findEnvWithToken(startDir?: string, tokenName?: string): string | undefined;
+export { findEnvFiles as default };

package/lib/utils/findEnvFiles.mjs

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

package/lib/utils/findWorkspaceRoot.cjs

@@ -0,0 +1,70 @@
+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/findWorkspaceRoot.js
+var findWorkspaceRoot_exports = {};
+__export(findWorkspaceRoot_exports, {
+  findWorkspaceRoot: () => findYarnWorkspaceRootFS,
+  findWorkspaceRootYC: () => findWorkspaceRootYC,
+  findYarnWorkspaceRootFS: () => findYarnWorkspaceRootFS
+});
+module.exports = __toCommonJS(findWorkspaceRoot_exports);
+var import_core = require("@yarnpkg/core");
+var import_upath = __toESM(require("upath"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+async function findWorkspaceRootYC(cwd = process.cwd()) {
+  const configuration = await import_core.Configuration.find(cwd, null);
+  const { project } = await import_core.Project.find(configuration, cwd);
+  return project.cwd;
+}
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+  let current = import_upath.default.resolve(cwd);
+  while (true) {
+    const pkgPath = import_upath.default.join(current, "package.json");
+    if (import_fs_extra.default.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(import_fs_extra.default.readFileSync(pkgPath, "utf8"));
+        if (pkg.workspaces || import_fs_extra.default.existsSync(import_upath.default.join(current, "yarn.lock")) || import_fs_extra.default.existsSync(import_upath.default.join(current, ".yarn"))) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = import_upath.default.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findWorkspaceRoot,
+  findWorkspaceRootYC,
+  findYarnWorkspaceRootFS
+});

package/lib/utils/findWorkspaceRoot.d.ts

@@ -0,0 +1,9 @@
+export function findWorkspaceRootYC(cwd?: string): Promise<import("@yarnpkg/fslib").PortablePath>;
+/**
+ * Find Yarn workspace root directory.
+ *
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+export function findYarnWorkspaceRootFS(cwd?: string): string | null;
+export { findYarnWorkspaceRootFS as findWorkspaceRoot };

package/lib/utils/findWorkspaceRoot.js

@@ -0,0 +1,57 @@
+"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.findWorkspaceRootYC = findWorkspaceRootYC;
+exports.findYarnWorkspaceRootFS = findYarnWorkspaceRootFS;
+exports.findWorkspaceRoot = findYarnWorkspaceRootFS;
+const core_1 = require("@yarnpkg/core");
+const upath_1 = __importDefault(require("upath"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function findWorkspaceRootYC() {
+    return __awaiter(this, arguments, void 0, function* (cwd = process.cwd()) {
+        const configuration = yield core_1.Configuration.find(cwd, null);
+        const { project } = yield core_1.Project.find(configuration, cwd);
+        return project.cwd;
+    });
+}
+/**
+ * Find Yarn workspace root directory.
+ *
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+    let current = upath_1.default.resolve(cwd);
+    while (true) {
+        const pkgPath = upath_1.default.join(current, 'package.json');
+        if (fs_extra_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs_extra_1.default.readFileSync(pkgPath, 'utf8'));
+                if (pkg.workspaces ||
+                    fs_extra_1.default.existsSync(upath_1.default.join(current, 'yarn.lock')) ||
+                    fs_extra_1.default.existsSync(upath_1.default.join(current, '.yarn'))) {
+                    return current;
+                }
+            }
+            catch (_a) {
+                // ignore invalid package.json
+            }
+        }
+        const parent = upath_1.default.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}

package/lib/utils/findWorkspaceRoot.mjs

@@ -0,0 +1,40 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/utils/findWorkspaceRoot.js
+init_esm_shims();
+import { Configuration, Project } from "@yarnpkg/core";
+import path from "upath";
+import fs from "fs-extra";
+async function findWorkspaceRootYC(cwd = process.cwd()) {
+  const configuration = await Configuration.find(cwd, null);
+  const { project } = await Project.find(configuration, cwd);
+  return project.cwd;
+}
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+  let current = path.resolve(cwd);
+  while (true) {
+    const pkgPath = path.join(current, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (pkg.workspaces || fs.existsSync(path.join(current, "yarn.lock")) || fs.existsSync(path.join(current, ".yarn"))) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+export {
+  findYarnWorkspaceRootFS as findWorkspaceRoot,
+  findWorkspaceRootYC,
+  findYarnWorkspaceRootFS
+};

package/lib/utils/index.cjs

@@ -50,31 +50,78 @@ function getArgs() {
 }
 module.exports.getArgs = getArgs;
 function del(fullPath) {
-  if (fs.statSync(fullPath).isDirectory()) {
-    const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-    for (let i = 0; i < subdir.length; i++) {
-      del(subdir[i]);
+  try {
+    if (!fs.existsSync(fullPath)) return;
+    const stat = fs.lstatSync(fullPath);
+    if (stat.isSymbolicLink()) {
+      try {
+        fs.unlinkSync(fullPath);
+        console.log("deleted symlink", fullPath);
+      } catch (e) {
+        console.log("failed delete symlink", fullPath, e && e.message);
+      }
+      return;
+    }
+    if (stat.isDirectory()) {
+      const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+      for (let i = 0; i < subdir.length; i++) {
+        del(subdir[i]);
+      }
+      try {
+        fs.rmdirSync(fullPath);
+        console.log("deleted", fullPath);
+      } catch (_e) {
+        try {
+          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          console.log("deleted", fullPath);
+        } catch (ee) {
+          console.log("failed delete", fullPath, ee && ee.message);
+        }
+      }
+      return;
     }
-  } else {
     try {
-      fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+      fs.unlinkSync(fullPath);
       console.log("deleted", fullPath);
-    } catch (_) {
-      console.log("failed delete", fullPath);
+    } catch (_e) {
+      try {
+        fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+        console.log("deleted", fullPath);
+      } catch (ee) {
+        console.log("failed delete", fullPath, ee && ee.message);
+      }
     }
+  } catch (err) {
+    console.log("failed delete", fullPath, err && err.message);
   }
 }
 module.exports.del = del;
 function delStream(globStream) {
   globStream.stream().on("data", (result) => {
     const fullPath = path.resolve(process.cwd(), result);
-    if (fs.statSync(fullPath).isDirectory()) {
-      const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-      for (let i = 0; i < subdir.length; i++) {
-        del(subdir[i]);
+    try {
+      if (fs.existsSync(fullPath)) {
+        const stat = fs.lstatSync(fullPath);
+        if (stat.isSymbolicLink()) {
+          try {
+            fs.unlinkSync(fullPath);
+            console.log("deleted symlink", fullPath);
+          } catch (e) {
+            console.log("failed delete symlink", fullPath, e && e.message);
+          }
+          return;
+        }
+        if (stat.isDirectory()) {
+          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del(subdir[i]);
+          }
+        }
       }
+      del(fullPath);
+    } catch (err) {
+      console.log("failed processing", fullPath, err && err.message);
     }
-    del(fullPath);
   });
 }
 module.exports.delStream = delStream;

package/lib/utils/index.mjs

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

package/lib/utils/isGithubTokenValid.cjs

@@ -0,0 +1,64 @@
+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/isGithubTokenValid.js
+var isGithubTokenValid_exports = {};
+__export(isGithubTokenValid_exports, {
+  isGitHubTokenValid: () => isGitHubTokenValid
+});
+module.exports = __toCommonJS(isGithubTokenValid_exports);
+var import_node_https = __toESM(require("https"), 1);
+async function isGitHubTokenValid(token) {
+  if (!token || typeof token !== "string") {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const req = import_node_https.default.request(
+      {
+        hostname: "api.github.com",
+        path: "/user",
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "github-token-validator",
+          Accept: "application/vnd.github+json"
+        }
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+        res.resume();
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.end();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isGitHubTokenValid
+});

package/lib/utils/isGithubTokenValid.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check whether a GitHub token is valid.
+ *
+ * @param {string} token GitHub personal access token
+ * @returns {Promise<boolean>}
+ */
+export function isGitHubTokenValid(token: string): Promise<boolean>;

package/lib/utils/isGithubTokenValid.js

@@ -0,0 +1,48 @@
+"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.isGitHubTokenValid = isGitHubTokenValid;
+const node_https_1 = __importDefault(require("node:https"));
+/**
+ * Check whether a GitHub token is valid.
+ *
+ * @param {string} token GitHub personal access token
+ * @returns {Promise<boolean>}
+ */
+function isGitHubTokenValid(token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!token || typeof token !== 'string') {
+            return false;
+        }
+        return new Promise((resolve) => {
+            const req = node_https_1.default.request({
+                hostname: 'api.github.com',
+                path: '/user',
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'User-Agent': 'github-token-validator',
+                    Accept: 'application/vnd.github+json'
+                }
+            }, (res) => {
+                // 200 = valid token
+                resolve(res.statusCode === 200);
+                // consume response to avoid memory leak
+                res.resume();
+            });
+            req.on('error', () => resolve(false));
+            req.end();
+        });
+    });
+}

package/lib/utils/isGithubTokenValid.mjs

@@ -0,0 +1,36 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/utils/isGithubTokenValid.js
+init_esm_shims();
+import https from "https";
+async function isGitHubTokenValid(token) {
+  if (!token || typeof token !== "string") {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const req = https.request(
+      {
+        hostname: "api.github.com",
+        path: "/user",
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "github-token-validator",
+          Accept: "application/vnd.github+json"
+        }
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+        res.resume();
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.end();
+  });
+}
+export {
+  isGitHubTokenValid
+};

package/lib/{ps/index.d.cjs → utils/isWindows.cjs}

@@ -2,6 +2,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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))
@@ -12,6 +16,16 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/ps/index.d.ts
-var index_d_exports = {};
-module.exports = __toCommonJS(index_d_exports);
+// src/utils/isWindows.js
+var isWindows_exports = {};
+__export(isWindows_exports, {
+  isWindows: () => isWindows
+});
+module.exports = __toCommonJS(isWindows_exports);
+function isWindows() {
+  return process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE || "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isWindows
+});

package/lib/utils/isWindows.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Determines if the current platform is Windows
+ * @returns {boolean} true if running on Windows, false otherwise
+ */
+export function isWindows(): boolean;

package/lib/utils/isWindows.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWindows = isWindows;
+/**
+ * Determines if the current platform is Windows
+ * @returns {boolean} true if running on Windows, false otherwise
+ */
+function isWindows() {
+    return process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE || '');
+}

package/lib/utils/isWindows.mjs

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

package/lib/utils/runBash.cjs

@@ -0,0 +1,53 @@
+// src/utils/runBash.cjs
+var { spawn } = require("child_process");
+var fs = require("fs");
+var path = require("path");
+function runBash(file, options = {}) {
+  return new Promise((resolve, reject) => {
+    const env = { ...process.env, ...options.env || {} };
+    if (options.env) delete options.env;
+    const isWindows = process.platform === "win32";
+    if (isWindows) {
+      const candidates = [
+        "C:\\Program Files\\Git\\bin",
+        "C:\\Program Files\\Git\\usr\\bin",
+        "C:\\laragon\\bin\\git\\bin",
+        path.join(process.cwd(), "node_modules", ".bin"),
+        path.join(process.cwd(), "vendor", "bin"),
+        path.join(process.cwd(), "bin"),
+        path.join(process.cwd(), "venv", "Scripts"),
+        path.join(process.cwd(), ".venv", "Scripts")
+      ].filter((dir) => fs.existsSync(dir));
+      if (candidates.length > 0) {
+        env.PATH = `${candidates.join(";")};${env.PATH}`;
+      } else {
+        return reject(
+          new Error("No suitable bash found on Windows. Please install Git Bash or WSL and ensure it's in your PATH.")
+        );
+      }
+    }
+    const proc = spawn("bash", [file], {
+      shell: true,
+      env,
+      ...options
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      const result = { code, stdout, stderr };
+      if (code === 0) return resolve(result);
+      return reject(result);
+    });
+  });
+}
+module.exports = { runBash };
+module.exports.default = runBash;

package/lib/utils/runBash.d.cts

@@ -0,0 +1,12 @@
+export default runBash;
+/**
+ * Run a bash script using spawn
+ * @param {string} file - path to bash file
+ * @param {import("child_process").SpawnOptions} options
+ * @returns {Promise<{code: number, stdout: string, stderr: string}>}
+ */
+export function runBash(file: string, options?: import("child_process").SpawnOptions): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;

package/lib/utils/runBash.mjs

@@ -0,0 +1,66 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/utils/runBash.cjs
+var require_runBash = __commonJS({
+  "src/utils/runBash.cjs"(exports, module) {
+    init_esm_shims();
+    var { spawn } = __require("child_process");
+    var fs = __require("fs");
+    var path = __require("path");
+    function runBash(file, options = {}) {
+      return new Promise((resolve, reject) => {
+        const env = { ...process.env, ...options.env || {} };
+        if (options.env) delete options.env;
+        const isWindows = process.platform === "win32";
+        if (isWindows) {
+          const candidates = [
+            "C:\\Program Files\\Git\\bin",
+            "C:\\Program Files\\Git\\usr\\bin",
+            "C:\\laragon\\bin\\git\\bin",
+            path.join(process.cwd(), "node_modules", ".bin"),
+            path.join(process.cwd(), "vendor", "bin"),
+            path.join(process.cwd(), "bin"),
+            path.join(process.cwd(), "venv", "Scripts"),
+            path.join(process.cwd(), ".venv", "Scripts")
+          ].filter((dir) => fs.existsSync(dir));
+          if (candidates.length > 0) {
+            env.PATH = `${candidates.join(";")};${env.PATH}`;
+          } else {
+            return reject(
+              new Error("No suitable bash found on Windows. Please install Git Bash or WSL and ensure it's in your PATH.")
+            );
+          }
+        }
+        const proc = spawn("bash", [file], {
+          shell: true,
+          env,
+          ...options
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+        proc.on("error", (err) => {
+          reject(err);
+        });
+        proc.on("close", (code) => {
+          const result = { code, stdout, stderr };
+          if (code === 0) return resolve(result);
+          return reject(result);
+        });
+      });
+    }
+    module.exports = { runBash };
+    module.exports.default = runBash;
+  }
+});
+export default require_runBash();