@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/process/spawn/errors.js

@@ -1,118 +1,121 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-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);
-var errors_exports = {};
-__export(errors_exports, {
-  enhanceSpawnError: () => enhanceSpawnError,
-  isSpawnError: () => isSpawnError
-});
-module.exports = __toCommonJS(errors_exports);
-var import_stack = require("../../errors/stack");
-var import_predicates = require("../../objects/predicates");
-var import_error = require("../../primordials/error");
-var import_object = require("../../primordials/object");
-var import_reflect = require("../../primordials/reflect");
-var import_internal = require("./_internal");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../../primordials/error.js');
+const require_primordials_object = require('../../primordials/object.js');
+const require_primordials_reflect = require('../../primordials/reflect.js');
+const require_objects_predicates = require('../../objects/predicates.js');
+const require_process_spawn__internal = require('./_internal.js');
+let src_external_pony_cause = require("../../external/pony-cause");
+
+//#region src/process/spawn/errors.ts
+/**
+* @file Spawn error classification and enhancement. `isSpawnError` is a
+*   type-guard for shaping unknown errors that crossed an `await spawn(...)`.
+*   It checks for the `code` / `errno` / `syscall` properties that Node's
+*   child_process tags onto `ENOENT` / `EACCES` / process-exit failures.
+*   `enhanceSpawnError` rewrites the upstream `@npmcli/promise-spawn` "command
+*   failed" placeholder message into something the operator can actually act
+*   on: command + args (truncated at 100 chars), exit code or signal, and the
+*   first stderr line (truncated at 200 chars). The stack is computed lazily on
+*   first access via a per-error WeakMap so non-error paths don't pay the
+*   `stackWithCauses` cost.
+*/
+/**
+* Enhances spawn error with better context. Converts generic "command failed"
+* to detailed error with command, exit code, and stderr.
+*
+* @example
+*   ;```typescript
+*   try {
+*     await spawn('git', ['status'])
+*   } catch (e) {
+*     throw enhanceSpawnError(e)
+*   }
+*   ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function enhanceSpawnError(error) {
-  if (error === null || typeof error !== "object") {
-    return error;
-  }
-  if (!/* @__PURE__ */ isSpawnError(error)) {
-    return error;
-  }
-  const err = error;
-  const { args, cmd, code, signal, stderr } = err;
-  const stderrText = typeof stderr === "string" ? stderr : stderr?.toString() ?? "";
-  let enhancedMessage = `Command failed: ${cmd}`;
-  if (args && args.length > 0) {
-    const argsStr = args.join(" ");
-    if (argsStr.length < 100) {
-      enhancedMessage += ` ${argsStr}`;
-    } else {
-      enhancedMessage += ` ${argsStr.slice(0, 97)}...`;
-    }
-  }
-  if (signal) {
-    enhancedMessage += ` (terminated by ${signal})`;
-  } else if (code !== void 0) {
-    enhancedMessage += ` (exit code ${code})`;
-  }
-  const trimmedStderr = stderrText.trim();
-  if (trimmedStderr) {
-    const firstLine = trimmedStderr.split("\n")[0] ?? "";
-    if (firstLine.length < 200) {
-      enhancedMessage += `
-${firstLine}`;
-    } else {
-      enhancedMessage += `
-${firstLine.slice(0, 197)}...`;
-    }
-  }
-  const isSynthetic = err.message === "command failed";
-  if (isSynthetic) {
-    (0, import_object.ObjectDefineProperty)(err, "message", {
-      __proto__: null,
-      value: enhancedMessage,
-      writable: true,
-      enumerable: false,
-      configurable: true
-    });
-    return err;
-  }
-  const enhancedError = new import_error.ErrorCtor(enhancedMessage, {
-    cause: err
-  });
-  const descriptors = (0, import_object.ObjectGetOwnPropertyDescriptors)(err);
-  (0, import_reflect.ReflectDeleteProperty)(descriptors, "message");
-  (0, import_reflect.ReflectDeleteProperty)(descriptors, "stack");
-  (0, import_object.ObjectDefineProperties)(enhancedError, descriptors);
-  (0, import_object.ObjectDefineProperty)(enhancedError, "stack", {
-    __proto__: null,
-    configurable: true,
-    enumerable: false,
-    get() {
-      let stack = import_internal.stackCache.get(enhancedError);
-      if (stack === void 0) {
-        try {
-          stack = (0, import_stack.stackWithCauses)(err);
-        } catch {
-          stack = err.stack ?? new import_error.ErrorCtor().stack ?? "";
-        }
-        import_internal.stackCache.set(enhancedError, stack);
-      }
-      return stack;
-    }
-  });
-  return enhancedError;
+	if (error === null || typeof error !== "object") return error;
+	if (!/* @__PURE__ */ isSpawnError(error)) return error;
+	const err = error;
+	const { args, cmd, code, signal, stderr } = err;
+	const stderrText = typeof stderr === "string" ? stderr : stderr?.toString() ?? "";
+	let enhancedMessage = `Command failed: ${cmd}`;
+	if (args && args.length > 0) {
+		const argsStr = args.join(" ");
+		if (argsStr.length < 100) enhancedMessage += ` ${argsStr}`;
+		else enhancedMessage += ` ${argsStr.slice(0, 97)}...`;
+	}
+	/* c8 ignore start */
+	if (signal) enhancedMessage += ` (terminated by ${signal})`;
+	else if (code !== void 0) enhancedMessage += ` (exit code ${code})`;
+	const trimmedStderr = stderrText.trim();
+	if (trimmedStderr) {
+		const firstLine = trimmedStderr.split("\n")[0] ?? "";
+		if (firstLine.length < 200) enhancedMessage += `\n${firstLine}`;
+		else enhancedMessage += `\n${firstLine.slice(0, 197)}...`;
+	}
+	if (err.message === "command failed") {
+		require_primordials_object.ObjectDefineProperty(err, "message", {
+			__proto__: null,
+			value: enhancedMessage,
+			writable: true,
+			enumerable: false,
+			configurable: true
+		});
+		return err;
+	}
+	const enhancedError = new require_primordials_error.ErrorCtor(enhancedMessage, { cause: err });
+	const descriptors = require_primordials_object.ObjectGetOwnPropertyDescriptors(err);
+	require_primordials_reflect.ReflectDeleteProperty(descriptors, "message");
+	require_primordials_reflect.ReflectDeleteProperty(descriptors, "stack");
+	require_primordials_object.ObjectDefineProperties(enhancedError, descriptors);
+	require_primordials_object.ObjectDefineProperty(enhancedError, "stack", {
+		__proto__: null,
+		configurable: true,
+		enumerable: false,
+		get() {
+			let stack = require_process_spawn__internal.stackCache.get(enhancedError);
+			/* c8 ignore next - Lazy-init second-call branch on the per-error cache. */
+			if (stack === void 0) {
+				try {
+					stack = (0, src_external_pony_cause.stackWithCauses)(err);
+				} catch {
+					stack = err.stack ?? new require_primordials_error.ErrorCtor().stack ?? "";
+				}
+				/* c8 ignore stop */
+				require_process_spawn__internal.stackCache.set(enhancedError, stack);
+			}
+			return stack;
+		}
+	});
+	return enhancedError;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a value is a spawn error with expected error properties. Tests for
+* common error properties from child process failures.
+*
+* @example
+*   try {
+*     await spawn('nonexistent-command')
+*   } catch (e) {
+*     if (isSpawnError(e)) {
+*       console.error(`Spawn failed: ${e.code}`)
+*     }
+*   }
+*
+* @param {unknown} value - Value to check.
+*
+* @returns {boolean} `true` if the value has spawn error properties
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isSpawnError(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const err = value;
-  return (0, import_predicates.hasOwn)(err, "code") && typeof err["code"] !== "undefined" || (0, import_predicates.hasOwn)(err, "errno") && typeof err["errno"] !== "undefined" || (0, import_predicates.hasOwn)(err, "syscall") && typeof err["syscall"] === "string";
+	if (value === null || typeof value !== "object") return false;
+	const err = value;
+	return /* @__PURE__ */ require_objects_predicates.hasOwn(err, "code") && typeof err["code"] !== "undefined" || /* @__PURE__ */ require_objects_predicates.hasOwn(err, "errno") && typeof err["errno"] !== "undefined" || /* @__PURE__ */ require_objects_predicates.hasOwn(err, "syscall") && typeof err["syscall"] === "string";
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  enhanceSpawnError,
-  isSpawnError
-});
+
+//#endregion
+exports.enhanceSpawnError = enhanceSpawnError;
+exports.isSpawnError = isSpawnError;

package/dist/process/spawn/stdio.js

@@ -1,38 +1,54 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-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);
-var stdio_exports = {};
-__export(stdio_exports, {
-  isStdioType: () => isStdioType
-});
-module.exports = __toCommonJS(stdio_exports);
-var import_predicates = require("../../arrays/predicates");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_arrays_predicates = require('../../arrays/predicates.js');
+
+//#region src/process/spawn/stdio.ts
+/**
+* @file Stdio configuration helpers for `spawn` callers. `isStdioType` is
+*   dual-purpose:
+*
+*   - One arg: validate that a value is a known stdio mode (`'pipe'` / `'ignore'`
+*     / `'inherit'` / `'overlapped'`).
+*   - Two args: check whether the caller's stdio config matches a specific mode.
+*     Useful in spinner-pause logic — the spinner only stops when the child
+*     writes to a non-piped stream that would otherwise interleave with spinner
+*     redraws. Two-arg behavior special-cases `null` / `undefined` ↔ `'pipe'`
+*     because Node.js defaults unspecified entries to `'pipe'`. The
+*     three-element-array branch handles the common `[in, out, err]` tuple
+*     where all three streams use the same mode.
+*/
+/**
+* Check if stdio configuration matches a specific type. When called with one
+* argument, validates if it's a valid stdio type. When called with two
+* arguments, checks if the stdio config matches the specified type.
+*
+* @example
+*   // Check if valid stdio type
+*   isStdioType('pipe') // true
+*   isStdioType('invalid') // false
+*
+* @example
+*   // Check if stdio matches specific type
+*   isStdioType('pipe', 'pipe') // true
+*   isStdioType(['pipe', 'pipe', 'pipe'], 'pipe') // true
+*   isStdioType('ignore', 'pipe') // false
+*
+* @param {string | string[]} stdio - Stdio configuration to check.
+* @param {StdioType | undefined} type - Expected stdio type (optional)
+*
+* @returns {boolean} `true` if stdio matches the type or is valid
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isStdioType(stdio, type) {
-  if (arguments.length === 1) {
-    const validTypes = ["pipe", "ignore", "inherit", "overlapped"];
-    return typeof stdio === "string" && validTypes.includes(stdio);
-  }
-  return stdio === type || (stdio === null || stdio === void 0) && type === "pipe" || (0, import_predicates.isArray)(stdio) && stdio.length > 2 && stdio[0] === type && stdio[1] === type && stdio[2] === type;
+	if (arguments.length === 1) return typeof stdio === "string" && [
+		"pipe",
+		"ignore",
+		"inherit",
+		"overlapped"
+	].includes(stdio);
+	return stdio === type || (stdio === null || stdio === void 0) && type === "pipe" || require_arrays_predicates.isArray(stdio) && stdio.length > 2 && stdio[0] === type && stdio[1] === type && stdio[2] === type;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isStdioType
-});
+
+//#endregion
+exports.isStdioType = isStdioType;

package/dist/process/spawn/types.js

@@ -1,18 +1,2 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+/* Socket Lib - Built with rolldown */

package/dist/process/transient.js

@@ -1,68 +1,51 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-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);
-var transient_exports = {};
-__export(transient_exports, {
-  isTransientProcess: () => isTransientProcess
-});
-module.exports = __toCommonJS(transient_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_platform = require("../constants/platform");
-var import_normalize = require("../paths/normalize");
-function isTransientProcess(cwd = import_node_process.default.cwd()) {
-  const userAgent = import_node_process.default.env["npm_config_user_agent"];
-  if (userAgent?.includes("exec") || userAgent?.includes("npx") || // # socket-hook: allow npx
-  userAgent?.includes("dlx")) {
-    return true;
-  }
-  const normalizedCwd = (0, import_normalize.normalizePath)(cwd);
-  const npmCache = import_node_process.default.env["npm_config_cache"];
-  if (npmCache && normalizedCwd.includes((0, import_normalize.normalizePath)(npmCache))) {
-    return true;
-  }
-  const tempPatterns = [
-    // npm's npx cache directory
-    "_npx",
-    // pnpm dlx temporary store
-    ".pnpm-store",
-    // Common dlx directory prefix
-    "dlx-",
-    // Yarn Berry PnP virtual packages.
-    ".yarn/$$"
-  ];
-  if (import_platform.WIN32) {
-    tempPatterns.push("AppData/Local/Temp/xfs-");
-  }
-  return tempPatterns.some((pattern) => normalizedCwd.includes(pattern));
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_constants_platform = require('../constants/platform.js');
+const require_paths_normalize = require('../paths/normalize.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+
+//#region src/process/transient.ts
+/**
+* @file Temporary package executor detection utilities for Socket ecosystem.
+*   Identifies and handles temporary execution contexts such as npx, pnpm dlx,
+*   and yarn dlx.
+*/
+/**
+* Detects if the current process is running in a temporary package execution
+* context such as npm exec, npx, pnpm dlx, or yarn dlx.
+*
+* When package managers run commands via exec/npx/dlx, they execute in
+* temporary directories that are cleaned up after execution. Creating
+* persistent shadows or modifying PATH in these contexts can break subsequent
+* package manager commands.
+*
+* @example
+*   ;```typescript
+*   if (isTransientProcess()) {
+*     console.log('Running in a temporary executor context')
+*   }
+*   ```
+*/
+function isTransientProcess(cwd = node_process.default.cwd()) {
+	const userAgent = node_process.default.env["npm_config_user_agent"];
+	if (userAgent?.includes("exec") || userAgent?.includes("npx") || userAgent?.includes("dlx")) return true;
+	const normalizedCwd = /* @__PURE__ */ require_paths_normalize.normalizePath(cwd);
+	const npmCache = node_process.default.env["npm_config_cache"];
+	if (npmCache && normalizedCwd.includes(/* @__PURE__ */ require_paths_normalize.normalizePath(npmCache))) return true;
+	const tempPatterns = [
+		"_npx",
+		".pnpm-store",
+		"dlx-",
+		".yarn/$$"
+	];
+	/* c8 ignore start */
+	if (require_constants_platform.WIN32) tempPatterns.push("AppData/Local/Temp/xfs-");
+	/* c8 ignore stop */
+	return tempPatterns.some((pattern) => normalizedCwd.includes(pattern));
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isTransientProcess
-});
+
+//#endregion
+exports.isTransientProcess = isTransientProcess;

package/dist/promises/_internal.d.ts

@@ -5,8 +5,14 @@
  */
 export declare const abortSignal: AbortSignal;
 /**
- * Get the timers/promises module. Uses lazy loading to avoid Webpack bundling
- * issues.
+ * Get the timers/promises module. Lazy `require` (not a top-level import) to
+ * avoid Webpack bundling issues.
+ *
+ * Intentionally NOT memoized: Node's module cache already makes the repeat
+ * `require` effectively free, and caching the reference breaks fake timers
+ * (`vi.useFakeTimers()` swaps the clock after this module loads; a cached
+ * reference would hold the pre-fake real `setTimeout`, burning real wallclock
+ * on retry backoff and starving the test worker pool).
  *
  * @private
  *

package/dist/promises/_internal.js

@@ -1,41 +1,34 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-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);
-var internal_exports = {};
-__export(internal_exports, {
-  abortSignal: () => abortSignal,
-  getTimers: () => getTimers
-});
-module.exports = __toCommonJS(internal_exports);
-var import_abort = require("../process/abort");
-const abortSignal = (0, import_abort.getAbortSignal)();
-let _timers;
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_process_abort = require('../process/abort.js');
+
+//#region src/promises/_internal.ts
+/**
+* @file Private internals for `promises/*` modules — the lazy
+*   `node:timers/promises` accessor + the shared abort signal. Underscore
+*   prefix excludes from public exports.
+*/
+const abortSignal = require_process_abort.getAbortSignal();
+/**
+* Get the timers/promises module. Lazy `require` (not a top-level import) to
+* avoid Webpack bundling issues.
+*
+* Intentionally NOT memoized: Node's module cache already makes the repeat
+* `require` effectively free, and caching the reference breaks fake timers
+* (`vi.useFakeTimers()` swaps the clock after this module loads; a cached
+* reference would hold the pre-fake real `setTimeout`, burning real wallclock
+* on retry backoff and starving the test worker pool).
+*
+* @private
+*
+* @returns The Node.js timers/promises module
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getTimers() {
-  if (_timers === void 0) {
-    _timers = require("node:timers/promises");
-  }
-  return _timers;
+	return require("node:timers/promises");
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  abortSignal,
-  getTimers
-});
+
+//#endregion
+exports.abortSignal = abortSignal;
+exports.getTimers = getTimers;