@socketsecurity/lib 6.0.3 → 6.0.5

package/dist/dlx/detect.js

@@ -1,180 +1,266 @@
 "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 detect_exports = {};
-__export(detect_exports, {
-  detectDlxExecutableType: () => detectDlxExecutableType,
-  detectExecutableType: () => detectExecutableType,
-  detectLocalExecutableType: () => detectLocalExecutableType,
-  findPackageJson: () => findPackageJson,
-  isJsFilePath: () => isJsFilePath,
-  isNativeBinary: () => isNativeBinary,
-  isNodePackage: () => isNodePackage,
-  packageJsonPathCacheSet: () => packageJsonPathCacheSet,
-  readPackageJson: () => readPackageJson
-});
-module.exports = __toCommonJS(detect_exports);
-var import_paths = require("./paths");
-var import_find_up = require("../fs/find-up");
-var import_socket = require("../paths/socket");
-var import_date = require("../primordials/date");
-var import_json = require("../primordials/json");
-var import_map_set = require("../primordials/map-set");
-var import_fs = require("../node/fs");
-var import_path = require("../node/path");
-const NODE_JS_EXTENSIONS = new import_map_set.SetCtor([".js", ".mjs", ".cjs"]);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_map_set = require('../primordials/map-set.js');
+const require_node_fs = require('../node/fs.js');
+const require_node_path = require('../node/path.js');
+const require_primordials_date = require('../primordials/date.js');
+const require_primordials_json = require('../primordials/json.js');
+const require_paths_socket = require('../paths/socket.js');
+const require_dlx_paths = require('./paths.js');
+const require_fs_find_up = require('../fs/find-up.js');
+
+//#region src/dlx/detect.ts
+/**
+* @file Executable type detection for DLX and local filesystem paths. Provides
+*   utilities to detect whether a path is a Node.js package or native binary
+*   executable. Supports both DLX cache paths and local filesystem paths. Key
+*   Functions:
+*
+*   - detectExecutableType: Generic entry point for any path
+*   - detectDlxExecutableType: DLX cache specific detection
+*   - detectLocalExecutableType: Local filesystem specific detection Detection
+*     Strategies:
+*   - DLX cache: Check for node_modules/ directory
+*   - Local paths: Check for package.json with bin field, then file extension
+*/
+/**
+* Node.js script file extensions.
+*/
+const NODE_JS_EXTENSIONS = new require_primordials_map_set.SetCtor([
+	".js",
+	".mjs",
+	".cjs"
+]);
 const PACKAGE_JSON_PATH_CACHE_MAX_SIZE = 200;
 const PACKAGE_JSON_NEGATIVE_TTL_MS = 1e4;
-const packageJsonPathCache = new import_map_set.MapCtor();
+const packageJsonPathCache = new require_primordials_map_set.MapCtor();
 function packageJsonPathCacheSet(key, value) {
-  if (packageJsonPathCache.has(key)) {
-    packageJsonPathCache.delete(key);
-  } else if (packageJsonPathCache.size >= PACKAGE_JSON_PATH_CACHE_MAX_SIZE) {
-    const oldest = packageJsonPathCache.keys().next().value;
-    if (oldest !== void 0) {
-      packageJsonPathCache.delete(oldest);
-    }
-  }
-  packageJsonPathCache.set(key, { path: value, at: Date.now() });
+	if (packageJsonPathCache.has(key)) packageJsonPathCache.delete(key);
+	else if (packageJsonPathCache.size >= PACKAGE_JSON_PATH_CACHE_MAX_SIZE) {
+		const oldest = packageJsonPathCache.keys().next().value;
+		if (oldest !== void 0) packageJsonPathCache.delete(oldest);
+	}
+	packageJsonPathCache.set(key, {
+		path: value,
+		at: Date.now()
+	});
 }
-const packageJsonContentCache = new import_map_set.MapCtor();
+const packageJsonContentCache = new require_primordials_map_set.MapCtor();
+/**
+* Find package.json in the directory containing the file or parent directories.
+* Results are cached to avoid repeated directory traversal.
+*
+* @private
+*
+* @param filePath - Path to search from.
+*
+* @returns Path to package.json if found, undefined otherwise
+*/
 function findPackageJson(filePath) {
-  const fs = (0, import_fs.getNodeFs)();
-  const path = (0, import_path.getNodePath)();
-  const startDir = path.dirname(path.resolve(filePath));
-  const cached = packageJsonPathCache.get(startDir);
-  if (cached !== void 0) {
-    if (cached.path === void 0) {
-      if ((0, import_date.DateNow)() - cached.at < PACKAGE_JSON_NEGATIVE_TTL_MS) {
-        return void 0;
-      }
-      packageJsonPathCache.delete(startDir);
-    } else if (fs.existsSync(cached.path)) {
-      packageJsonPathCacheSet(startDir, cached.path);
-      return cached.path;
-    } else {
-      packageJsonPathCache.delete(startDir);
-    }
-  }
-  const packageJsonPath = (0, import_find_up.findUpSync)("package.json", { cwd: startDir });
-  packageJsonPathCacheSet(startDir, packageJsonPath);
-  return packageJsonPath;
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const nodePath = /* @__PURE__ */ require_node_path.getNodePath();
+	const startDir = nodePath.dirname(nodePath.resolve(filePath));
+	const cached = packageJsonPathCache.get(startDir);
+	if (cached !== void 0) if (cached.path === void 0) {
+		if (require_primordials_date.DateNow() - cached.at < PACKAGE_JSON_NEGATIVE_TTL_MS) return;
+		packageJsonPathCache.delete(startDir);
+	} else if (fs.existsSync(cached.path)) {
+		packageJsonPathCacheSet(startDir, cached.path);
+		return cached.path;
+	} else packageJsonPathCache.delete(startDir);
+	const packageJsonPath = /* @__PURE__ */ require_fs_find_up.findUpSync("package.json", { cwd: startDir });
+	packageJsonPathCacheSet(startDir, packageJsonPath);
+	return packageJsonPath;
 }
+/**
+* Read and parse package.json with caching. Results are cached to avoid
+* repeated file reads.
+*
+* @private
+*
+* @param packageJsonPath - Path to package.json.
+*
+* @returns Parsed package.json or null if invalid
+*/
 function readPackageJson(packageJsonPath) {
-  const fs = (0, import_fs.getNodeFs)();
-  let mtimeMs = 0;
-  try {
-    mtimeMs = fs.statSync(packageJsonPath).mtimeMs;
-  } catch {
-    packageJsonContentCache.delete(packageJsonPath);
-    return void 0;
-  }
-  const cached = packageJsonContentCache.get(packageJsonPath);
-  if (cached !== void 0 && cached.mtimeMs === mtimeMs) {
-    return cached.content;
-  }
-  try {
-    const content = (0, import_json.JSONParse)(fs.readFileSync(packageJsonPath, "utf8"));
-    packageJsonContentCache.set(packageJsonPath, { mtimeMs, content });
-    return content;
-  } catch {
-    packageJsonContentCache.set(packageJsonPath, {
-      mtimeMs,
-      content: void 0
-    });
-    return void 0;
-  }
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	let mtimeMs = 0;
+	try {
+		mtimeMs = fs.statSync(packageJsonPath).mtimeMs;
+	} catch {
+		packageJsonContentCache.delete(packageJsonPath);
+		return;
+	}
+	const cached = packageJsonContentCache.get(packageJsonPath);
+	if (cached !== void 0 && cached.mtimeMs === mtimeMs) return cached.content;
+	try {
+		const content = require_primordials_json.JSONParse(fs.readFileSync(packageJsonPath, "utf8"));
+		packageJsonContentCache.set(packageJsonPath, {
+			mtimeMs,
+			content
+		});
+		return content;
+	} catch {
+		packageJsonContentCache.set(packageJsonPath, {
+			mtimeMs,
+			content: void 0
+		});
+		return;
+	}
 }
+/**
+* Detect executable type for paths in DLX cache. Uses filesystem structure
+* (node_modules/ presence).
+*
+* @example
+*   ;```typescript
+*   const result = detectDlxExecutableType('/tmp/.socket/_dlx/a1b2c3d4/tool')
+*   console.log(result.type) // 'package' or 'binary'
+*   ```
+*
+* @param filePath - Path within DLX cache (~/.socket/_dlx/)
+*
+* @returns Detection result
+*/
 function detectDlxExecutableType(filePath) {
-  const fs = (0, import_fs.getNodeFs)();
-  const path = (0, import_path.getNodePath)();
-  const dlxDir = (0, import_socket.getSocketDlxDir)();
-  const absolutePath = path.resolve(filePath);
-  const relativePath = path.relative(dlxDir, absolutePath);
-  const cacheKey = relativePath.split(path.sep)[0] ?? "";
-  const cacheDir = path.join(dlxDir, cacheKey);
-  if (fs.existsSync(path.join(cacheDir, "node_modules"))) {
-    return {
-      type: "package",
-      method: "dlx-cache",
-      inDlxCache: true
-    };
-  }
-  return {
-    type: "binary",
-    method: "dlx-cache",
-    inDlxCache: true
-  };
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const dlxDir = require_paths_socket.getSocketDlxDir();
+	const absolutePath = path.resolve(filePath);
+	const cacheKey = path.relative(dlxDir, absolutePath).split(path.sep)[0] ?? "";
+	const cacheDir = path.join(dlxDir, cacheKey);
+	if (fs.existsSync(path.join(cacheDir, "node_modules"))) return {
+		type: "package",
+		method: "dlx-cache",
+		inDlxCache: true
+	};
+	return {
+		type: "binary",
+		method: "dlx-cache",
+		inDlxCache: true
+	};
 }
+/**
+* Detect if a path is a Node.js package or native binary executable. Works for
+* both DLX cache paths and local filesystem paths.
+*
+* Detection strategy: 1. If in DLX cache: Use detectDlxExecutableType() 2.
+* Otherwise: Use detectLocalExecutableType()
+*
+* @example
+*   ;```typescript
+*   const result = detectExecutableType('/path/to/tool')
+*   if (result.type === 'package') {
+*     spawnNode([filePath, ...args])
+*   } else {
+*     spawn(filePath, args)
+*   }
+*   ```
+*
+* @param filePath - Path to executable (DLX cache or local filesystem)
+*
+* @returns Detection result with type, method, and metadata
+*/
 function detectExecutableType(filePath) {
-  if ((0, import_paths.isInSocketDlx)(filePath)) {
-    return detectDlxExecutableType(filePath);
-  }
-  return detectLocalExecutableType(filePath);
+	if (require_dlx_paths.isInSocketDlx(filePath)) return detectDlxExecutableType(filePath);
+	return detectLocalExecutableType(filePath);
 }
+/**
+* Detect executable type for local filesystem paths. Uses package.json and file
+* extension checks.
+*
+* @example
+*   ;```typescript
+*   const result = detectLocalExecutableType('/usr/local/bin/tool')
+*   if (result.type === 'package') {
+*     console.log('Node.js package at:', result.packageJsonPath)
+*   }
+*   ```
+*
+* @param filePath - Local filesystem path (not in DLX cache)
+*
+* @returns Detection result
+*/
 function detectLocalExecutableType(filePath) {
-  const packageJsonPath = findPackageJson(filePath);
-  if (packageJsonPath !== void 0) {
-    const packageJson = readPackageJson(packageJsonPath);
-    if (packageJson?.["bin"]) {
-      return {
-        type: "package",
-        method: "package-json",
-        packageJsonPath,
-        inDlxCache: false
-      };
-    }
-  }
-  if (isJsFilePath(filePath)) {
-    return {
-      inDlxCache: false,
-      method: "file-extension",
-      type: "package"
-    };
-  }
-  return {
-    type: "binary",
-    method: "file-extension",
-    inDlxCache: false
-  };
+	const packageJsonPath = findPackageJson(filePath);
+	if (packageJsonPath !== void 0) {
+		if (readPackageJson(packageJsonPath)?.["bin"]) return {
+			type: "package",
+			method: "package-json",
+			packageJsonPath,
+			inDlxCache: false
+		};
+	}
+	if (isJsFilePath(filePath)) return {
+		inDlxCache: false,
+		method: "file-extension",
+		type: "package"
+	};
+	return {
+		type: "binary",
+		method: "file-extension",
+		inDlxCache: false
+	};
 }
+/**
+* Check if a file path indicates a Node.js script.
+*
+* @example
+*   ;```typescript
+*   isJsFilePath('index.js') // true
+*   isJsFilePath('lib.mjs') // true
+*   isJsFilePath('tool.exe') // false
+*   ```
+*
+* @param filePath - Path to check.
+*
+* @returns True if file has .js, .mjs, or .cjs extension
+*/
 function isJsFilePath(filePath) {
-  const path = (0, import_path.getNodePath)();
-  const ext = path.extname(filePath).toLowerCase();
-  return NODE_JS_EXTENSIONS.has(ext);
+	const ext = (/* @__PURE__ */ require_node_path.getNodePath()).extname(filePath).toLowerCase();
+	return NODE_JS_EXTENSIONS.has(ext);
 }
+/**
+* Simplified helper: Is this a native binary executable?
+*
+* @example
+*   ;```typescript
+*   isNativeBinary('/usr/local/bin/tool') // true
+*   isNativeBinary('/tmp/project/index.js') // false
+*   ```
+*
+* @param filePath - Path to check.
+*
+* @returns True if detected as native binary (not Node.js package)
+*/
 function isNativeBinary(filePath) {
-  return detectExecutableType(filePath).type === "binary";
+	return detectExecutableType(filePath).type === "binary";
 }
+/**
+* Simplified helper: Is this a Node.js package?
+*
+* @example
+*   ;```typescript
+*   isNodePackage('/tmp/project/index.js') // true
+*   isNodePackage('/usr/local/bin/tool') // false
+*   ```
+*
+* @param filePath - Path to check.
+*
+* @returns True if detected as Node.js package
+*/
 function isNodePackage(filePath) {
-  return detectExecutableType(filePath).type === "package";
+	return detectExecutableType(filePath).type === "package";
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  detectDlxExecutableType,
-  detectExecutableType,
-  detectLocalExecutableType,
-  findPackageJson,
-  isJsFilePath,
-  isNativeBinary,
-  isNodePackage,
-  packageJsonPathCacheSet,
-  readPackageJson
-});
+
+//#endregion
+exports.detectDlxExecutableType = detectDlxExecutableType;
+exports.detectExecutableType = detectExecutableType;
+exports.detectLocalExecutableType = detectLocalExecutableType;
+exports.findPackageJson = findPackageJson;
+exports.isJsFilePath = isJsFilePath;
+exports.isNativeBinary = isNativeBinary;
+exports.isNodePackage = isNodePackage;
+exports.packageJsonPathCacheSet = packageJsonPathCacheSet;
+exports.readPackageJson = readPackageJson;

package/dist/dlx/dir.js

@@ -1,62 +1,78 @@
 "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 dir_exports = {};
-__export(dir_exports, {
-  clearDlx: () => clearDlx,
-  clearDlxSync: () => clearDlxSync,
-  dlxDirExists: () => dlxDirExists,
-  ensureDlxDir: () => ensureDlxDir,
-  ensureDlxDirSync: () => ensureDlxDirSync
-});
-module.exports = __toCommonJS(dir_exports);
-var import_safe = require("../fs/safe");
-var import_socket = require("../paths/socket");
-var import_iterate = require("../promises/iterate");
-var import_fs = require("../node/fs");
-var import_packages = require("./packages");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_fs = require('../node/fs.js');
+const require_paths_socket = require('../paths/socket.js');
+const require_fs_safe = require('../fs/safe.js');
+const require_promises_iterate = require('../promises/iterate.js');
+const require_dlx_packages = require('./packages.js');
+
+//#region src/dlx/dir.ts
+/**
+* @file Directory management utilities for DLX installations.
+*/
+/**
+* Clear all DLX package installations.
+*
+* @example
+*   ;```typescript
+*   await clearDlx()
+*   ```
+*/
 async function clearDlx() {
-  const packages = await (0, import_packages.listDlxPackagesAsync)();
-  await (0, import_iterate.pEach)(packages, (pkg) => (0, import_packages.removeDlxPackage)(pkg));
+	await /* @__PURE__ */ require_promises_iterate.pEach(await require_dlx_packages.listDlxPackagesAsync(), (pkg) => require_dlx_packages.removeDlxPackage(pkg));
 }
+/**
+* Clear all DLX package installations synchronously.
+*
+* @example
+*   ;```typescript
+*   clearDlxSync()
+*   ```
+*/
 function clearDlxSync() {
-  const packages = (0, import_packages.listDlxPackages)();
-  for (const pkg of packages) {
-    (0, import_packages.removeDlxPackageSync)(pkg);
-  }
+	const packages = require_dlx_packages.listDlxPackages();
+	for (const pkg of packages) require_dlx_packages.removeDlxPackageSync(pkg);
 }
+/**
+* Check if the DLX directory exists.
+*
+* @example
+*   ;```typescript
+*   if (dlxDirExists()) {
+*     console.log('DLX directory is present')
+*   }
+*   ```
+*/
 function dlxDirExists() {
-  const fs = (0, import_fs.getNodeFs)();
-  return fs.existsSync((0, import_socket.getSocketDlxDir)());
+	return (/* @__PURE__ */ require_node_fs.getNodeFs()).existsSync(require_paths_socket.getSocketDlxDir());
 }
+/**
+* Ensure the DLX directory exists, creating it if necessary.
+*
+* @example
+*   ;```typescript
+*   await ensureDlxDir()
+*   ```
+*/
 async function ensureDlxDir() {
-  await (0, import_safe.safeMkdir)((0, import_socket.getSocketDlxDir)());
+	await require_fs_safe.safeMkdir(require_paths_socket.getSocketDlxDir());
 }
+/**
+* Ensure the DLX directory exists synchronously, creating it if necessary.
+*
+* @example
+*   ;```typescript
+*   ensureDlxDirSync()
+*   ```
+*/
 function ensureDlxDirSync() {
-  (0, import_safe.safeMkdirSync)((0, import_socket.getSocketDlxDir)());
+	require_fs_safe.safeMkdirSync(require_paths_socket.getSocketDlxDir());
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  clearDlx,
-  clearDlxSync,
-  dlxDirExists,
-  ensureDlxDir,
-  ensureDlxDirSync
-});
+
+//#endregion
+exports.clearDlx = clearDlx;
+exports.clearDlxSync = clearDlxSync;
+exports.dlxDirExists = dlxDirExists;
+exports.ensureDlxDir = ensureDlxDir;
+exports.ensureDlxDirSync = ensureDlxDirSync;