@socketsecurity/lib 5.2.1 → 5.4.0

package/dist/packages/isolation.js

@@ -32,14 +32,28 @@ __export(isolation_exports, {
   isolatePackage: () => isolatePackage
 });
 module.exports = __toCommonJS(isolation_exports);
-var import_fs = require("fs");
 var import_platform = require("../constants/platform");
-var import_node_path = __toESM(require("node:path"));
 var import_npm_package_arg = __toESM(require("../external/npm-package-arg"));
 var import_spawn = require("../spawn");
 var import_normalize = require("../paths/normalize");
 var import_operations = require("./operations");
 var import_socket = require("../paths/socket");
+let _fs;
+// @__NO_SIDE_EFFECTS__
+function getFs() {
+  if (_fs === void 0) {
+    _fs = require("fs");
+  }
+  return _fs;
+}
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("path");
+  }
+  return _path;
+}
 const FS_CP_OPTIONS = {
   dereference: true,
   errorOnExist: false,
@@ -49,14 +63,19 @@ const FS_CP_OPTIONS = {
   ...import_platform.WIN32 ? { maxRetries: 3, retryDelay: 100 } : {}
 };
 async function resolveRealPath(pathStr) {
-  return await import_fs.promises.realpath(pathStr).catch(() => import_node_path.default.resolve(pathStr));
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
+  return await fs.promises.realpath(pathStr).catch(() => path.resolve(pathStr));
 }
 async function mergePackageJson(pkgJsonPath, originalPkgJson) {
-  const pkgJson = JSON.parse(await import_fs.promises.readFile(pkgJsonPath, "utf8"));
+  const fs = /* @__PURE__ */ getFs();
+  const pkgJson = JSON.parse(await fs.promises.readFile(pkgJsonPath, "utf8"));
   const mergedPkgJson = originalPkgJson ? { ...originalPkgJson, ...pkgJson } : pkgJson;
   return mergedPkgJson;
 }
 async function isolatePackage(packageSpec, options) {
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   const opts = { __proto__: null, ...options };
   const { imports, install, onPackageJson, sourcePath: optSourcePath } = opts;
   let sourcePath = optSourcePath;
@@ -65,8 +84,8 @@ async function isolatePackage(packageSpec, options) {
   if ((0, import_normalize.isPath)(packageSpec)) {
     const trimmedPath = (0, import_normalize.trimLeadingDotSlash)(packageSpec);
     const pathToResolve = (0, import_normalize.isAbsolute)(trimmedPath) ? trimmedPath : packageSpec;
-    sourcePath = import_node_path.default.resolve(pathToResolve);
-    if (!(0, import_fs.existsSync)(sourcePath)) {
+    sourcePath = path.resolve(pathToResolve);
+    if (!fs.existsSync(sourcePath)) {
       throw new Error(`Source path does not exist: ${sourcePath}`);
     }
     const pkgJson = await (0, import_operations.readPackageJson)(sourcePath, { normalize: true });
@@ -79,7 +98,7 @@ async function isolatePackage(packageSpec, options) {
     packageName = parsed.name;
     if (parsed.type === "directory" || parsed.type === "file") {
       sourcePath = parsed.fetchSpec;
-      if (!sourcePath || !(0, import_fs.existsSync)(sourcePath)) {
+      if (!sourcePath || !fs.existsSync(sourcePath)) {
         throw new Error(`Source path does not exist: ${sourcePath}`);
       }
       if (!packageName) {
@@ -97,16 +116,16 @@ async function isolatePackage(packageSpec, options) {
     throw new Error(`Could not determine package name from: ${packageSpec}`);
   }
   const sanitizedName = packageName.replace(/[@/]/g, "-");
-  const tempDir = await import_fs.promises.mkdtemp(
-    import_node_path.default.join((0, import_socket.getOsTmpDir)(), `socket-test-${sanitizedName}-`)
+  const tempDir = await fs.promises.mkdtemp(
+    path.join((0, import_socket.getOsTmpDir)(), `socket-test-${sanitizedName}-`)
   );
-  const packageTempDir = import_node_path.default.join(tempDir, sanitizedName);
-  await import_fs.promises.mkdir(packageTempDir, { recursive: true });
+  const packageTempDir = path.join(tempDir, sanitizedName);
+  await fs.promises.mkdir(packageTempDir, { recursive: true });
   let installedPath;
   let originalPackageJson;
   if (spec) {
-    await import_fs.promises.writeFile(
-      import_node_path.default.join(packageTempDir, "package.json"),
+    await fs.promises.writeFile(
+      path.join(packageTempDir, "package.json"),
       JSON.stringify(
         {
           name: "test-temp",
@@ -127,7 +146,7 @@ async function isolatePackage(packageSpec, options) {
         stdio: "pipe"
       });
     }
-    installedPath = import_node_path.default.join(packageTempDir, "node_modules", packageName);
+    installedPath = path.join(packageTempDir, "node_modules", packageName);
     originalPackageJson = await (0, import_operations.readPackageJson)(installedPath, {
       normalize: true
     });
@@ -135,30 +154,33 @@ async function isolatePackage(packageSpec, options) {
       const realInstalledPath = await resolveRealPath(installedPath);
       const realSourcePath = await resolveRealPath(sourcePath);
       if (realSourcePath !== realInstalledPath) {
-        await import_fs.promises.cp(sourcePath, installedPath, FS_CP_OPTIONS);
+        await fs.promises.cp(sourcePath, installedPath, FS_CP_OPTIONS);
       }
     }
   } else {
     if (!sourcePath) {
       throw new Error("sourcePath is required when no version spec provided");
     }
-    const scopedPath = packageName.startsWith("@") ? import_node_path.default.join(
+    const scopedPath = packageName.startsWith("@") ? path.join(
       packageTempDir,
       "node_modules",
       packageName.split("/")[0] ?? ""
-    ) : import_node_path.default.join(packageTempDir, "node_modules");
-    await import_fs.promises.mkdir(scopedPath, { recursive: true });
-    installedPath = import_node_path.default.join(packageTempDir, "node_modules", packageName);
-    await import_fs.promises.cp(sourcePath, installedPath, FS_CP_OPTIONS);
+    ) : path.join(packageTempDir, "node_modules");
+    await fs.promises.mkdir(scopedPath, { recursive: true });
+    installedPath = path.join(packageTempDir, "node_modules", packageName);
+    await fs.promises.cp(sourcePath, installedPath, FS_CP_OPTIONS);
   }
   if (onPackageJson || originalPackageJson) {
-    const pkgJsonPath = import_node_path.default.join(installedPath, "package.json");
+    const pkgJsonPath = path.join(installedPath, "package.json");
     const mergedPkgJson = await mergePackageJson(
       pkgJsonPath,
       originalPackageJson
     );
     const finalPkgJson = onPackageJson ? await onPackageJson(mergedPkgJson) : mergedPkgJson;
-    await import_fs.promises.writeFile(pkgJsonPath, JSON.stringify(finalPkgJson, null, 2));
+    await fs.promises.writeFile(
+      pkgJsonPath,
+      JSON.stringify(finalPkgJson, null, 2)
+    );
   }
   if (install) {
     await install(installedPath);
@@ -172,7 +194,7 @@ async function isolatePackage(packageSpec, options) {
   const exports2 = imports ? { __proto__: null } : void 0;
   if (imports) {
     for (const { 0: key, 1: specifier } of Object.entries(imports)) {
-      const fullPath = import_node_path.default.join(installedPath, specifier);
+      const fullPath = path.join(installedPath, specifier);
       exports2[key] = require(fullPath);
     }
   }

package/dist/packages/licenses.js

@@ -41,12 +41,19 @@ __export(licenses_exports, {
 module.exports = __toCommonJS(licenses_exports);
 var import_core = require("../constants/core");
 var import_licenses = require("../constants/licenses");
-var import_node_path = __toESM(require("node:path"));
 var import_spdx_correct = __toESM(require("../external/spdx-correct"));
 var import_spdx_expression_parse = __toESM(require("../external/spdx-expression-parse"));
 var import_objects = require("../objects");
 var import_normalize = require("../paths/normalize");
 const copyLeftLicenses = (0, import_licenses.getCopyLeftLicenses)();
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("path");
+  }
+  return _path;
+}
 const BINARY_OPERATION_NODE_TYPE = "BinaryOperation";
 const LICENSE_NODE_TYPE = "License";
 const fileReferenceRegExp = /^SEE LICEN[CS]E IN (.+)$/;
@@ -133,10 +140,11 @@ function resolvePackageLicenses(licenseFieldValue, where) {
   }
   const match = fileReferenceRegExp.exec(licenseFieldValue);
   if (match) {
+    const path = /* @__PURE__ */ getPath();
     return [
       {
         license: licenseFieldValue,
-        inFile: (0, import_normalize.normalizePath)(import_node_path.default.relative(where, match[1] || ""))
+        inFile: (0, import_normalize.normalizePath)(path.relative(where, match[1] || ""))
       }
     ];
   }

package/dist/paths/normalize.js

@@ -54,7 +54,7 @@ let _buffer;
 // @__NO_SIDE_EFFECTS__
 function getBuffer() {
   if (_buffer === void 0) {
-    _buffer = require("node:buffer");
+    _buffer = require("buffer");
   }
   return _buffer;
 }
@@ -62,7 +62,7 @@ let _url;
 // @__NO_SIDE_EFFECTS__
 function getUrl() {
   if (_url === void 0) {
-    _url = require("node:url");
+    _url = require("url");
   }
   return _url;
 }
@@ -351,7 +351,7 @@ function resolve(...segments) {
     resolvedAbsolute = /* @__PURE__ */ isAbsolute(segment);
   }
   if (!resolvedAbsolute) {
-    const cwd = /* @__PURE__ */ require("node:process").cwd();
+    const cwd = /* @__PURE__ */ require("process").cwd();
     resolvedPath = cwd + (resolvedPath.length === 0 ? "" : `/${resolvedPath}`);
   }
   return /* @__PURE__ */ normalizePath(resolvedPath);

package/dist/paths/packages.js

@@ -28,7 +28,7 @@ let _path;
 // @__NO_SIDE_EFFECTS__
 function getPath() {
   if (_path === void 0) {
-    _path = require("node:path");
+    _path = require("path");
   }
   return _path;
 }

package/dist/paths/socket.d.ts

@@ -81,7 +81,7 @@ export declare function getSocketRegistryGithubCacheDir(): string;
  * Priority order:
  *   1. HOME environment variable (Unix)
  *   2. USERPROFILE environment variable (Windows)
- *   3. os.homedir()
- *   4. Fallback: os.tmpdir() (rarely used, for restricted environments)
+ *   3. getOs().homedir()
+ *   4. Fallback: getOs().tmpdir() (rarely used, for restricted environments)
  */
 export declare function getUserHomeDir(): string;

package/dist/paths/socket.js

@@ -1,10 +1,8 @@
 "use strict";
 /* Socket Lib - Built with esbuild */
-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)
@@ -18,14 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 socket_exports = {};
 __export(socket_exports, {
@@ -44,8 +34,6 @@ __export(socket_exports, {
   getUserHomeDir: () => getUserHomeDir
 });
 module.exports = __toCommonJS(socket_exports);
-var os = __toESM(require("os"));
-var path = __toESM(require("path"));
 var import_github = require("../constants/github");
 var import_socket = require("../constants/socket");
 var import_home = require("../env/home");
@@ -54,11 +42,27 @@ var import_windows = require("../env/windows");
 var import_dirnames = require("./dirnames");
 var import_normalize = require("./normalize");
 var import_rewire = require("./rewire");
+let _os;
+// @__NO_SIDE_EFFECTS__
+function getOs() {
+  if (_os === void 0) {
+    _os = require("os");
+  }
+  return _os;
+}
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("path");
+  }
+  return _path;
+}
 function getOsHomeDir() {
-  return (0, import_rewire.getPathValue)("homedir", () => os.homedir());
+  return (0, import_rewire.getPathValue)("homedir", () => (/* @__PURE__ */ getOs()).homedir());
 }
 function getOsTmpDir() {
-  return (0, import_rewire.getPathValue)("tmpdir", () => os.tmpdir());
+  return (0, import_rewire.getPathValue)("tmpdir", () => (/* @__PURE__ */ getOs()).tmpdir());
 }
 function getSocketHomePath() {
   return getSocketUserDir();
@@ -69,12 +73,12 @@ function getSocketUserDir() {
     if (socketHome) {
       return (0, import_normalize.normalizePath)(socketHome);
     }
-    return (0, import_normalize.normalizePath)(path.join(getUserHomeDir(), import_dirnames.DOT_SOCKET_DIR));
+    return (0, import_normalize.normalizePath)((/* @__PURE__ */ getPath()).join(getUserHomeDir(), import_dirnames.DOT_SOCKET_DIR));
   });
 }
 function getSocketAppDir(appName) {
   return (0, import_normalize.normalizePath)(
-    path.join(getSocketUserDir(), `${import_socket.SOCKET_APP_PREFIX}${appName}`)
+    (/* @__PURE__ */ getPath()).join(getSocketUserDir(), `${import_socket.SOCKET_APP_PREFIX}${appName}`)
   );
 }
 function getSocketCacacheDir() {
@@ -83,7 +87,7 @@ function getSocketCacacheDir() {
       return (0, import_normalize.normalizePath)((0, import_socket2.getSocketCacacheDir)());
     }
     return (0, import_normalize.normalizePath)(
-      path.join(getSocketUserDir(), `${import_socket.SOCKET_APP_PREFIX}cacache`)
+      (/* @__PURE__ */ getPath()).join(getSocketUserDir(), `${import_socket.SOCKET_APP_PREFIX}cacache`)
     );
   });
 }
@@ -93,7 +97,7 @@ function getSocketDlxDir() {
       return (0, import_normalize.normalizePath)((0, import_socket2.getSocketDlxDirEnv)());
     }
     return (0, import_normalize.normalizePath)(
-      path.join(
+      (/* @__PURE__ */ getPath()).join(
         getSocketUserDir(),
         `${import_socket.SOCKET_APP_PREFIX}${import_socket.SOCKET_DLX_APP_NAME}`
       )
@@ -101,10 +105,12 @@ function getSocketDlxDir() {
   });
 }
 function getSocketAppCacheDir(appName) {
-  return (0, import_normalize.normalizePath)(path.join(getSocketAppDir(appName), import_dirnames.CACHE_DIR));
+  return (0, import_normalize.normalizePath)((/* @__PURE__ */ getPath()).join(getSocketAppDir(appName), import_dirnames.CACHE_DIR));
 }
 function getSocketAppCacheTtlDir(appName) {
-  return (0, import_normalize.normalizePath)(path.join(getSocketAppCacheDir(appName), import_dirnames.CACHE_TTL_DIR));
+  return (0, import_normalize.normalizePath)(
+    (/* @__PURE__ */ getPath()).join(getSocketAppCacheDir(appName), import_dirnames.CACHE_TTL_DIR)
+  );
 }
 function getSocketCliDir() {
   return getSocketAppDir(import_socket.SOCKET_CLI_APP_NAME);
@@ -114,7 +120,7 @@ function getSocketRegistryDir() {
 }
 function getSocketRegistryGithubCacheDir() {
   return (0, import_normalize.normalizePath)(
-    path.join(
+    (/* @__PURE__ */ getPath()).join(
       getSocketAppCacheTtlDir(import_socket.SOCKET_REGISTRY_APP_NAME),
       import_github.CACHE_GITHUB_DIR
     )

package/dist/process-lock.js

@@ -22,11 +22,20 @@ __export(process_lock_exports, {
   processLock: () => processLock
 });
 module.exports = __toCommonJS(process_lock_exports);
-var import_fs = require("fs");
-var import_fs2 = require("./fs");
+var import_fs = require("./fs");
 var import_logger = require("./logger");
 var import_promises = require("./promises");
 var import_signal_exit = require("./signal-exit");
+let _fs;
+// @__NO_SIDE_EFFECTS__
+function getFs() {
+  if (_fs === void 0) {
+    _fs = require("fs");
+  }
+  return _fs;
+}
+const fs = /* @__PURE__ */ getFs();
+const { existsSync, mkdirSync, statSync, utimesSync } = fs;
 const logger = (0, import_logger.getDefaultLogger)();
 class ProcessLockManager {
   activeLocks = /* @__PURE__ */ new Set();
@@ -47,8 +56,8 @@ class ProcessLockManager {
       this.touchTimers.clear();
       for (const lockPath of this.activeLocks) {
         try {
-          if ((0, import_fs.existsSync)(lockPath)) {
-            (0, import_fs2.safeDeleteSync)(lockPath, { recursive: true });
+          if (existsSync(lockPath)) {
+            (0, import_fs.safeDeleteSync)(lockPath, { recursive: true });
           }
         } catch {
         }
@@ -64,9 +73,9 @@ class ProcessLockManager {
    */
   touchLock(lockPath) {
     try {
-      if ((0, import_fs.existsSync)(lockPath)) {
+      if (existsSync(lockPath)) {
         const now = /* @__PURE__ */ new Date();
-        (0, import_fs.utimesSync)(lockPath, now, now);
+        utimesSync(lockPath, now, now);
       }
     } catch (error) {
       logger.warn(
@@ -114,10 +123,10 @@ class ProcessLockManager {
    */
   isStale(lockPath, staleMs) {
     try {
-      if (!(0, import_fs.existsSync)(lockPath)) {
+      if (!existsSync(lockPath)) {
         return false;
       }
-      const stats = (0, import_fs.statSync)(lockPath);
+      const stats = statSync(lockPath);
       const ageSeconds = Math.floor((Date.now() - stats.mtime.getTime()) / 1e3);
       const staleSeconds = Math.floor(staleMs / 1e3);
       return ageSeconds > staleSeconds;
@@ -160,17 +169,17 @@ class ProcessLockManager {
     return await (0, import_promises.pRetry)(
       async () => {
         try {
-          if ((0, import_fs.existsSync)(lockPath) && this.isStale(lockPath, staleMs)) {
+          if (existsSync(lockPath) && this.isStale(lockPath, staleMs)) {
             logger.log(`Removing stale lock: ${lockPath}`);
             try {
-              (0, import_fs2.safeDeleteSync)(lockPath, { recursive: true });
+              (0, import_fs.safeDeleteSync)(lockPath, { recursive: true });
             } catch {
             }
           }
-          if ((0, import_fs.existsSync)(lockPath)) {
+          if (existsSync(lockPath)) {
             throw new Error(`Lock already exists: ${lockPath}`);
           }
-          (0, import_fs.mkdirSync)(lockPath, { recursive: true });
+          mkdirSync(lockPath, { recursive: true });
           this.activeLocks.add(lockPath);
           this.startTouchTimer(lockPath, touchIntervalMs);
           return () => this.release(lockPath);
@@ -246,8 +255,8 @@ To resolve:
   release(lockPath) {
     this.stopTouchTimer(lockPath);
     try {
-      if ((0, import_fs.existsSync)(lockPath)) {
-        (0, import_fs2.safeDeleteSync)(lockPath, { recursive: true });
+      if (existsSync(lockPath)) {
+        (0, import_fs.safeDeleteSync)(lockPath, { recursive: true });
       }
       this.activeLocks.delete(lockPath);
     } catch (error) {

package/dist/promises.js

@@ -37,7 +37,7 @@ let _timers;
 // @__NO_SIDE_EFFECTS__
 function getTimers() {
   if (_timers === void 0) {
-    _timers = require("node:timers/promises");
+    _timers = require("timers/promises");
   }
   return _timers;
 }