binary-collections 2.0.10 → 2.0.12

package/lib/kill-night-crows.mjs

@@ -0,0 +1,65 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/kill-night-crows.mjs
+init_esm_shims();
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var scriptCandidates = [
+  path.resolve(__dirname, "../bin/kill-night-crows.ps1"),
+  path.resolve(__dirname, "../binaries/kill-night-crows.ps1")
+];
+var scriptPath = scriptCandidates.find((candidate) => fs.existsSync(candidate));
+var scriptChecks = scriptCandidates.map((candidate) => ({
+  path: candidate,
+  exists: fs.existsSync(candidate)
+}));
+var args = process.argv.slice(2);
+var isHelp = args.includes("--help") || args.includes("-h");
+if (isHelp) {
+  console.log(`
+kill-night-crows
+
+Usage:
+  node src/kill-night-crows.mjs [options]
+
+Options:
+  --help, -h    Show this help message
+
+Description:
+  Runs kill-night-crows.ps1 to watch Night Crows processes
+  and kill the launcher tree when the shipping process is not responding.
+  Resolution priority: ../bin first, then ../binaries.
+
+Script check:
+${scriptChecks.map((check) => `  ${check.exists ? "found" : "missing"} - ${check.path}`).join("\n")}
+`);
+  process.exit(0);
+}
+if (!scriptPath) {
+  console.error(
+    `PowerShell script not found in any of these paths:
+${scriptCandidates.map((p) => ` - ${p}`).join("\n")}`
+  );
+  process.exit(1);
+}
+if (process.platform !== "win32") {
+  console.error("kill-night-crows is supported only on Windows.");
+  process.exit(1);
+}
+var result = spawnSync("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", scriptPath, ...args], {
+  stdio: "inherit"
+});
+if (typeof result.status === "number") {
+  process.exit(result.status);
+}
+if (result.error) {
+  console.error(result.error.message);
+}
+process.exit(1);

package/lib/node-cache-cleaner/npm.cjs

@@ -0,0 +1,65 @@
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node-cache-cleaner/npm.ts
+var npm_exports = {};
+__export(npm_exports, {
+  cleanNpmCache: () => cleanNpmCache,
+  npmVersion: () => npmVersion
+});
+module.exports = __toCommonJS(npm_exports);
+var import_cross_spawn = require("cross-spawn");
+function npmVersion() {
+  return new Promise((resolve, reject) => {
+    const process = (0, import_cross_spawn.spawn)("npm", ["--version"], {
+      stdio: "pipe",
+      shell: true
+    });
+    let version = "";
+    process.stdout.on("data", (data) => {
+      version += data.toString();
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(version.trim());
+      } else {
+        reject(new Error(`NPM version check failed with exit code ${code}`));
+      }
+    });
+  });
+}
+function cleanNpmCache() {
+  return new Promise((resolve, reject) => {
+    const process = (0, import_cross_spawn.spawn)("npm", ["cache", "clean", "--force"], {
+      stdio: "inherit",
+      shell: true
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        reject(new Error(`NPM cache clean failed with exit code ${code}`));
+      }
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanNpmCache,
+  npmVersion
+});

package/lib/node-cache-cleaner/npm.d.ts

@@ -0,0 +1,2 @@
+export declare function npmVersion(): Promise<string>;
+export declare function cleanNpmCache(): Promise<unknown>;

package/lib/node-cache-cleaner/npm.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.npmVersion = npmVersion;
+exports.cleanNpmCache = cleanNpmCache;
+const cross_spawn_1 = require("cross-spawn");
+function npmVersion() {
+    return new Promise((resolve, reject) => {
+        const process = (0, cross_spawn_1.spawn)('npm', ['--version'], {
+            stdio: 'pipe',
+            shell: true
+        });
+        let version = '';
+        process.stdout.on('data', (data) => {
+            version += data.toString();
+        });
+        process.on('close', (code) => {
+            if (code === 0) {
+                resolve(version.trim());
+            }
+            else {
+                reject(new Error(`NPM version check failed with exit code ${code}`));
+            }
+        });
+    });
+}
+function cleanNpmCache() {
+    return new Promise((resolve, reject) => {
+        const process = (0, cross_spawn_1.spawn)('npm', ['cache', 'clean', '--force'], {
+            stdio: 'inherit',
+            shell: true
+        });
+        process.on('close', (code) => {
+            if (code === 0) {
+                resolve(true);
+            }
+            else {
+                reject(new Error(`NPM cache clean failed with exit code ${code}`));
+            }
+        });
+    });
+}

package/lib/node-cache-cleaner/npm.mjs

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

package/lib/node-cache-cleaner/npx.cjs

@@ -0,0 +1,89 @@
+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/node-cache-cleaner/npx.ts
+var npx_exports = {};
+__export(npx_exports, {
+  cleanNpxCache: () => cleanNpxCache
+});
+module.exports = __toCommonJS(npx_exports);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_upath = __toESM(require("upath"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_cross_spawn = require("cross-spawn");
+function getNpmCacheDir() {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    const child = (0, import_cross_spawn.spawn)("npm", ["config", "get", "cache"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true
+    });
+    let output = "";
+    let error = "";
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (data) => {
+      output += data.toString();
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (data) => {
+      error += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(output.trim());
+      } else {
+        reject(new Error(`Failed to get npm cache directory (code ${code}): ${error}`));
+      }
+    });
+  });
+}
+async function removeDir(target) {
+  try {
+    const exists = await import_fs_extra.default.pathExists(target);
+    if (exists) {
+      console.log(`Removing: ${target}`);
+      await import_fs_extra.default.remove(target);
+    } else {
+      console.log(`Not found: ${target}`);
+    }
+  } catch (err) {
+    console.error(`Failed to remove ${target}:`, err);
+  }
+}
+async function cleanNpxCache() {
+  const cacheDir = await getNpmCacheDir();
+  console.log("Detected npm cache:", cacheDir);
+  console.log("\nCleaning npm/npx cache...\n");
+  const npxCache = import_upath.default.join(cacheDir, "_npx");
+  const npmCache = import_upath.default.join(cacheDir, "_cacache");
+  const altNpxLinux = import_upath.default.join(import_os.default.homedir(), ".cache", "npx");
+  await Promise.all([removeDir(npxCache), removeDir(npmCache), removeDir(altNpxLinux)]);
+  console.log("\nDone \u2714\uFE0F");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanNpxCache
+});

package/lib/node-cache-cleaner/npx.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Main cleaner
+ */
+export declare function cleanNpxCache(): Promise<void>;

package/lib/node-cache-cleaner/npx.js

@@ -0,0 +1,82 @@
+"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.cleanNpxCache = cleanNpxCache;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const upath_1 = __importDefault(require("upath"));
+const os_1 = __importDefault(require("os"));
+const cross_spawn_1 = require("cross-spawn");
+/**
+ * Get npm cache directory using `npm config get cache`
+ */
+function getNpmCacheDir() {
+    return new Promise((resolve, reject) => {
+        var _a, _b;
+        const child = (0, cross_spawn_1.spawn)('npm', ['config', 'get', 'cache'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: true
+        });
+        let output = '';
+        let error = '';
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+            output += data.toString();
+        });
+        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+            error += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve(output.trim());
+            }
+            else {
+                reject(new Error(`Failed to get npm cache directory (code ${code}): ${error}`));
+            }
+        });
+    });
+}
+/**
+ * Remove directory safely
+ */
+function removeDir(target) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const exists = yield fs_extra_1.default.pathExists(target);
+            if (exists) {
+                console.log(`Removing: ${target}`);
+                yield fs_extra_1.default.remove(target);
+            }
+            else {
+                console.log(`Not found: ${target}`);
+            }
+        }
+        catch (err) {
+            console.error(`Failed to remove ${target}:`, err);
+        }
+    });
+}
+/**
+ * Main cleaner
+ */
+function cleanNpxCache() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cacheDir = yield getNpmCacheDir();
+        console.log('Detected npm cache:', cacheDir);
+        console.log('\nCleaning npm/npx cache...\n');
+        const npxCache = upath_1.default.join(cacheDir, '_npx');
+        const npmCache = upath_1.default.join(cacheDir, '_cacache');
+        const altNpxLinux = upath_1.default.join(os_1.default.homedir(), '.cache', 'npx');
+        yield Promise.all([removeDir(npxCache), removeDir(npmCache), removeDir(altNpxLinux)]);
+        console.log('\nDone ✔️');
+    });
+}

package/lib/{ps/index.d.mjs → node-cache-cleaner/npx.mjs}

@@ -1,7 +1,8 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
-  init_esm_shims
-} from "../chunk-QQ4A6DLD.mjs";
-
-// src/ps/index.d.ts
-init_esm_shims();
+  cleanNpxCache
+} from "../chunk-OXV52GD5.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  cleanNpxCache
+};

package/lib/node-cache-cleaner/yarn.cjs

@@ -0,0 +1,73 @@
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node-cache-cleaner/yarn.ts
+var yarn_exports = {};
+__export(yarn_exports, {
+  cleanYarnCache: () => cleanYarnCache,
+  yarnVersion: () => yarnVersion
+});
+module.exports = __toCommonJS(yarn_exports);
+var import_cross_spawn = require("cross-spawn");
+function yarnVersion() {
+  return new Promise((resolve, reject) => {
+    const process = (0, import_cross_spawn.spawn)("yarn", ["--version"], {
+      stdio: "pipe",
+      shell: true
+    });
+    let version = "";
+    process.stdout.on("data", (data) => {
+      version += data.toString();
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(version.trim());
+      } else {
+        reject(new Error(`Yarn version check failed with exit code ${code}`));
+      }
+    });
+  });
+}
+async function cleanYarnCache() {
+  let version = "";
+  try {
+    version = await yarnVersion();
+  } catch {
+  }
+  const major = parseInt(version.split(".")[0], 10);
+  const isClassic = major === 1 || version === "";
+  const args = isClassic ? ["cache", "clean"] : ["cache", "clean", "--all"];
+  return new Promise((resolve, reject) => {
+    const process = (0, import_cross_spawn.spawn)("yarn", args, {
+      stdio: "inherit",
+      shell: true
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        reject(new Error(`Yarn cache clean failed with exit code ${code}`));
+      }
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanYarnCache,
+  yarnVersion
+});

package/lib/node-cache-cleaner/yarn.d.ts

@@ -0,0 +1,2 @@
+export declare function yarnVersion(): Promise<string>;
+export declare function cleanYarnCache(): Promise<unknown>;

package/lib/node-cache-cleaner/yarn.js

@@ -0,0 +1,62 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yarnVersion = yarnVersion;
+exports.cleanYarnCache = cleanYarnCache;
+const cross_spawn_1 = require("cross-spawn");
+function yarnVersion() {
+    return new Promise((resolve, reject) => {
+        const process = (0, cross_spawn_1.spawn)('yarn', ['--version'], {
+            stdio: 'pipe',
+            shell: true
+        });
+        let version = '';
+        process.stdout.on('data', (data) => {
+            version += data.toString();
+        });
+        process.on('close', (code) => {
+            if (code === 0) {
+                resolve(version.trim());
+            }
+            else {
+                reject(new Error(`Yarn version check failed with exit code ${code}`));
+            }
+        });
+    });
+}
+function cleanYarnCache() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let version = '';
+        try {
+            version = yield yarnVersion();
+        }
+        catch (_a) {
+            // if version check fails, just try the generic command
+        }
+        const major = parseInt(version.split('.')[0], 10);
+        const isClassic = major === 1 || version === '';
+        const args = isClassic ? ['cache', 'clean'] : ['cache', 'clean', '--all'];
+        return new Promise((resolve, reject) => {
+            const process = (0, cross_spawn_1.spawn)('yarn', args, {
+                stdio: 'inherit',
+                shell: true
+            });
+            process.on('close', (code) => {
+                if (code === 0) {
+                    resolve(true);
+                }
+                else {
+                    reject(new Error(`Yarn cache clean failed with exit code ${code}`));
+                }
+            });
+        });
+    });
+}

package/lib/node-cache-cleaner/yarn.mjs

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