@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/dlx/package.js

@@ -30,126 +30,40 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var package_exports = {};
 __export(package_exports, {
+  binaryPathCacheSet: () => import_internal.binaryPathCacheSet,
+  checkFirewallPurls: () => import_firewall2.checkFirewallPurls,
   dlxPackage: () => dlxPackage,
   downloadPackage: () => downloadPackage,
   ensurePackageInstalled: () => ensurePackageInstalled,
   executePackage: () => executePackage,
-  findBinaryPath: () => findBinaryPath,
-  makePackageBinsExecutable: () => makePackageBinsExecutable,
-  npmPurl: () => npmPurl,
-  parsePackageSpec: () => parsePackageSpec,
-  resolveBinaryPath: () => resolveBinaryPath
+  findBinaryPath: () => import_binary_resolution2.findBinaryPath,
+  makePackageBinsExecutable: () => import_binary_resolution2.makePackageBinsExecutable,
+  npmPurl: () => import_firewall2.npmPurl,
+  parsePackageSpec: () => import_spec2.parsePackageSpec,
+  resolveBinaryPath: () => import_binary_resolution2.resolveBinaryPath
 });
 module.exports = __toCommonJS(package_exports);
 var import_platform = require("../constants/platform");
-var import_socket = require("../constants/socket");
-var import_errors = require("../errors");
+var import_predicates = require("../errors/predicates");
 var import_arborist = __toESM(require("../external/@npmcli/arborist"));
-var import_libnpmexec = __toESM(require("../external/libnpmexec"));
-var import_npm_package_arg = __toESM(require("../external/npm-package-arg"));
-var import_fs = require("../fs");
-var import_http_request = require("../http-request");
+var import_safe = require("../fs/safe");
 var import_normalize = require("../paths/normalize");
-var import_socket2 = require("../paths/socket");
-var import_process_lock = require("../process-lock");
-var import_spawn = require("../spawn");
+var import_socket = require("../paths/socket");
+var import_lock_instance = require("../process/lock-instance");
+var import_spawn = require("../spawn/spawn");
 var import_cache = require("./cache");
-var import_primordials = require("../primordials");
-let _fs;
-let _path;
+var import_fs = require("../node/fs");
+var import_path = require("../node/path");
+var import_binary_resolution = require("./binary-resolution");
+var import_firewall = require("./firewall");
+var import_spec = require("./spec");
+var import_error = require("../primordials/error");
+var import_regexp = require("../primordials/regexp");
+var import_internal = require("./_internal");
+var import_binary_resolution2 = require("./binary-resolution");
+var import_firewall2 = require("./firewall");
+var import_spec2 = require("./spec");
 const rangeOperatorsRegExp = /[~^><=xX* ]|\|\|/;
-const FIREWALL_API_URL = "https://firewall-api.socket.dev/purl";
-const FIREWALL_TIMEOUT = 1e4;
-const FIREWALL_BLOCK_SEVERITIES = new import_primordials.SetCtor([
-  "critical",
-  "high"
-]);
-const BINARY_PATH_CACHE_MAX_SIZE = 200;
-const binaryPathCache = new import_primordials.MapCtor();
-function binaryPathCacheSet(key, value) {
-  if (binaryPathCache.has(key)) {
-    binaryPathCache.delete(key);
-  } else if (binaryPathCache.size >= BINARY_PATH_CACHE_MAX_SIZE) {
-    const oldest = binaryPathCache.keys().next().value;
-    if (oldest !== void 0) {
-      binaryPathCache.delete(oldest);
-    }
-  }
-  binaryPathCache.set(key, value);
-}
-async function checkFirewallPurls(arb, requestedPackage) {
-  const idealTree = arb.idealTree;
-  if (!idealTree) {
-    return;
-  }
-  const purls = [];
-  for (const node of idealTree.inventory.values()) {
-    if (node.isProjectRoot) {
-      continue;
-    }
-    const { name, version } = node.package;
-    if (!name || !version) {
-      continue;
-    }
-    purls.push({ purl: npmPurl(name, version), name, version });
-  }
-  if (purls.length === 0) {
-    return;
-  }
-  const blocked = [];
-  await (0, import_primordials.PromiseAllSettled)(
-    purls.map(async ({ name, purl, version }) => {
-      try {
-        const data = await (0, import_http_request.httpJson)(
-          `${FIREWALL_API_URL}/${encodeURIComponent(purl)}`,
-          {
-            headers: { "User-Agent": import_socket.SOCKET_LIB_USER_AGENT },
-            timeout: FIREWALL_TIMEOUT,
-            retries: 1,
-            retryDelay: 500
-          }
-        );
-        const blocking = (data.alerts ?? []).filter(
-          (a) => a.severity && FIREWALL_BLOCK_SEVERITIES.has(a.severity)
-        );
-        if (blocking.length > 0) {
-          blocked.push({
-            name,
-            version,
-            alerts: blocking.map(
-              (a) => `${a.severity}: ${a.type ?? a.key ?? "unknown"}`
-            )
-          });
-        }
-      } catch {
-      }
-    })
-  );
-  if (blocked.length > 0) {
-    const details = blocked.map((b) => `  ${b.name}@${b.version}: ${b.alerts.join(", ")}`).join("\n");
-    throw new import_primordials.ErrorCtor(
-      `Socket Firewall blocked installation of "${requestedPackage}".
-The following dependencies have security alerts:
-${details}
-
-Visit https://socket.dev for more information.`
-    );
-  }
-}
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
 async function dlxPackage(args, options, spawnExtra) {
   const downloadResult = await downloadPackage(options);
   const spawnPromise = executePackage(
@@ -176,8 +90,8 @@ async function downloadPackage(options) {
     __proto__: null,
     ...options
   };
-  const { name: packageName, version: packageVersion } = parsePackageSpec(packageSpec);
-  const isVersionRange = packageVersion !== void 0 && (0, import_primordials.RegExpPrototypeTest)(rangeOperatorsRegExp, packageVersion);
+  const { name: packageName, version: packageVersion } = (0, import_spec.parsePackageSpec)(packageSpec);
+  const isVersionRange = packageVersion !== void 0 && (0, import_regexp.RegExpPrototypeTest)(rangeOperatorsRegExp, packageVersion);
   const force = userForce !== void 0 ? userForce : yes === true ? true : isVersionRange;
   const fullPackageSpec = packageVersion ? `${packageName}@${packageVersion}` : packageName;
   const { installed, packageDir } = await ensurePackageInstalled(
@@ -186,8 +100,8 @@ async function downloadPackage(options) {
     force,
     { hash, installRoot, lockfile }
   );
-  const binaryPath = findBinaryPath(packageDir, packageName, binaryName);
-  makePackageBinsExecutable(packageDir, packageName);
+  const binaryPath = (0, import_binary_resolution.findBinaryPath)(packageDir, packageName, binaryName);
+  (0, import_binary_resolution.makePackageBinsExecutable)(packageDir, packageName);
   return {
     binaryPath,
     installed,
@@ -195,38 +109,38 @@ async function downloadPackage(options) {
   };
 }
 async function ensurePackageInstalled(packageName, packageSpec, force, install) {
-  const fs = /* @__PURE__ */ getFs();
-  const path = /* @__PURE__ */ getPath();
+  const fs = (0, import_fs.getNodeFs)();
+  const path = (0, import_path.getNodePath)();
   const packageDir = (0, import_normalize.normalizePath)(
-    install?.installRoot ?? path.join((0, import_socket2.getSocketDlxDir)(), (0, import_cache.generateCacheKey)(packageSpec))
+    install?.installRoot ?? path.join((0, import_socket.getSocketDlxDir)(), (0, import_cache.generateCacheKey)(packageSpec))
   );
   const installedDir = (0, import_normalize.normalizePath)(
     path.join(packageDir, "node_modules", packageName)
   );
   try {
-    await (0, import_fs.safeMkdir)(packageDir);
+    await (0, import_safe.safeMkdir)(packageDir);
   } catch (e) {
     const code = e.code;
     if (code === "EACCES" || code === "EPERM") {
-      throw new import_primordials.ErrorCtor(
+      throw new import_error.ErrorCtor(
         `Permission denied creating package directory: ${packageDir}
 Please check directory permissions or run with appropriate access.`,
         { cause: e }
       );
     }
     if (code === "EROFS") {
-      throw new import_primordials.ErrorCtor(
+      throw new import_error.ErrorCtor(
         `Cannot create package directory on read-only filesystem: ${packageDir}
 Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`,
         { cause: e }
       );
     }
-    throw new import_primordials.ErrorCtor(`Failed to create package directory: ${packageDir}`, {
+    throw new import_error.ErrorCtor(`Failed to create package directory: ${packageDir}`, {
       cause: e
     });
   }
   const lockPath = path.join(packageDir, "concurrency.lock");
-  return await import_process_lock.processLock.withLock(
+  return await import_lock_instance.processLock.withLock(
     lockPath,
     async () => {
       if (!force && fs.existsSync(installedDir)) {
@@ -262,7 +176,8 @@ Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`
         const arb = new import_arborist.default({
           path: packageDir,
           // Use Socket's shared cacache directory (~/.socket/_cacache).
-          cache: (0, import_socket2.getSocketCacacheDir)(),
+          /* c8 ignore stop */
+          cache: (0, import_socket.getSocketCacacheDir)(),
           // Skip devDependencies (production-only like npx).
           omit: ["dev"],
           // Security: Skip install/preinstall/postinstall scripts to prevent arbitrary code execution.
@@ -277,15 +192,15 @@ Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`
           silent: true
         });
         await arb.buildIdealTree({ add: [packageSpec] });
-        await checkFirewallPurls(arb, packageName);
+        await (0, import_firewall.checkFirewallPurls)(arb, packageName);
         await arb.reify({ save: true });
       } catch (e) {
-        if ((0, import_errors.isError)(e) && e.message.startsWith("Socket Firewall blocked")) {
+        if ((0, import_predicates.isError)(e) && e.message.startsWith("Socket Firewall blocked")) {
           throw e;
         }
         const code = e?.code;
         if (code === "E404" || code === "ETARGET") {
-          throw new Error(
+          throw new import_error.ErrorCtor(
             `Package not found: ${packageSpec}
 Verify the package exists on npm registry and check the version.
 Visit https://www.npmjs.com/package/${packageName} to see available versions.`,
@@ -293,13 +208,13 @@ Visit https://www.npmjs.com/package/${packageName} to see available versions.`,
           );
         }
         if (code === "ENOTFOUND" || code === "ETIMEDOUT" || code === "EAI_AGAIN") {
-          throw new Error(
+          throw new import_error.ErrorCtor(
             `Network error installing ${packageSpec}
 Check your internet connection and try again.`,
             { cause: e }
           );
         }
-        throw new Error(
+        throw new import_error.ErrorCtor(
           `Failed to install package: ${packageSpec}
 Destination: ${installedDir}
 Check npm registry connectivity or package name.`,
@@ -323,147 +238,10 @@ function executePackage(binaryPath, args, spawnOptions, spawnExtra) {
   } : spawnOptions;
   return (0, import_spawn.spawn)(binaryPath, args, finalOptions, spawnExtra);
 }
-function findBinaryPath(packageDir, packageName, binaryName) {
-  const path = /* @__PURE__ */ getPath();
-  const installedDir = (0, import_normalize.normalizePath)(
-    path.join(packageDir, "node_modules", packageName)
-  );
-  const pkgJsonPath = path.join(installedDir, "package.json");
-  const pkgJson = (0, import_fs.readJsonSync)(pkgJsonPath);
-  const bin = pkgJson["bin"];
-  let binName;
-  let binPath;
-  if (typeof bin === "string") {
-    binPath = bin;
-  } else if (typeof bin === "object" && bin !== null) {
-    const binObj = bin;
-    const binKeys = (0, import_primordials.ObjectKeys)(binObj);
-    if (binKeys.length === 1) {
-      binName = binKeys[0];
-      binPath = binObj[binName];
-    } else {
-      try {
-        const { getBinFromManifest } = import_libnpmexec.default;
-        binName = getBinFromManifest({
-          name: packageName,
-          bin: binObj,
-          _id: `${packageName}@${pkgJson.version || "unknown"}`
-        });
-        binPath = binObj[binName];
-      } catch {
-        const lastSegment = packageName.split("/").pop() ?? packageName;
-        const candidates = [
-          binaryName,
-          lastSegment,
-          packageName.replace(/^@[^/]+\//, "")
-        ].filter(Boolean);
-        for (const candidate of candidates) {
-          if (candidate && binObj[candidate]) {
-            binName = candidate;
-            binPath = binObj[candidate];
-            break;
-          }
-        }
-        if (!binPath && binKeys.length > 0) {
-          binName = binKeys[0];
-          binPath = binObj[binName];
-        }
-      }
-    }
-  }
-  if (!binPath) {
-    throw new import_primordials.ErrorCtor(`No binary found for package "${packageName}"`);
-  }
-  const rawPath = (0, import_normalize.normalizePath)(path.join(installedDir, binPath));
-  return resolveBinaryPath(rawPath);
-}
-function makePackageBinsExecutable(packageDir, packageName) {
-  if (import_platform.WIN32) {
-    return;
-  }
-  const fs = /* @__PURE__ */ getFs();
-  const path = /* @__PURE__ */ getPath();
-  const installedDir = (0, import_normalize.normalizePath)(
-    path.join(packageDir, "node_modules", packageName)
-  );
-  const pkgJsonPath = path.join(installedDir, "package.json");
-  try {
-    const pkgJson = (0, import_fs.readJsonSync)(pkgJsonPath);
-    const bin = pkgJson["bin"];
-    if (!bin) {
-      return;
-    }
-    const binPaths = [];
-    if (typeof bin === "string") {
-      binPaths.push(bin);
-    } else if (typeof bin === "object" && bin !== null) {
-      const binObj = bin;
-      binPaths.push(...(0, import_primordials.ObjectValues)(binObj));
-    }
-    for (const binPath of binPaths) {
-      const fullPath = (0, import_normalize.normalizePath)(path.join(installedDir, binPath));
-      if (fs.existsSync(fullPath)) {
-        try {
-          fs.chmodSync(fullPath, 493);
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-}
-function npmPurl(name, version) {
-  const encoded = (0, import_primordials.StringPrototypeStartsWith)(name, "@") ? `%40${(0, import_primordials.StringPrototypeSlice)(name, 1)}` : name;
-  const encodedVersion = (0, import_primordials.StringPrototypeReplace)(version, /\+/g, "%2B");
-  return `pkg:npm/${encoded}@${encodedVersion}`;
-}
-function parsePackageSpec(spec) {
-  try {
-    const parsed = (0, import_npm_package_arg.default)(spec);
-    const version = parsed.type === "tag" ? parsed.fetchSpec : parsed.type === "version" || parsed.type === "range" ? parsed.fetchSpec : void 0;
-    return {
-      name: parsed.name || spec,
-      version
-    };
-  } catch {
-    const atIndex = (0, import_primordials.StringPrototypeLastIndexOf)(spec, "@");
-    if (atIndex === -1 || atIndex === 0) {
-      return { name: spec, version: void 0 };
-    }
-    const sliced = (0, import_primordials.StringPrototypeSlice)(spec, atIndex + 1);
-    return {
-      name: (0, import_primordials.StringPrototypeSlice)(spec, 0, atIndex),
-      // A trailing `@` (e.g. `'pkg@'`) yields an empty slice — normalize
-      // to undefined so downstream "no version" checks behave.
-      version: sliced || void 0
-    };
-  }
-}
-function resolveBinaryPath(basePath) {
-  if (!import_platform.WIN32) {
-    return basePath;
-  }
-  const fs = /* @__PURE__ */ getFs();
-  const cached = binaryPathCache.get(basePath);
-  if (cached) {
-    if (fs.existsSync(cached)) {
-      binaryPathCacheSet(basePath, cached);
-      return cached;
-    }
-    binaryPathCache.delete(basePath);
-  }
-  const extensions = [".cmd", ".bat", ".ps1", ".exe", ""];
-  for (const ext of extensions) {
-    const testPath = basePath + ext;
-    if (fs.existsSync(testPath)) {
-      binaryPathCacheSet(basePath, testPath);
-      return testPath;
-    }
-  }
-  return basePath;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  binaryPathCacheSet,
+  checkFirewallPurls,
   dlxPackage,
   downloadPackage,
   ensurePackageInstalled,

package/dist/dlx/packages.d.ts

@@ -1,50 +1,52 @@
-/** @fileoverview Package management utilities for DLX installations. */
+/**
+ * @file Package management utilities for DLX installations.
+ */
 /**
  * Check if a package is installed in DLX.
  *
  * @example
- * ```typescript
- * if (isDlxPackageInstalled('prettier')) {
- *   console.log('prettier is installed')
- * }
- * ```
+ *   ;```typescript
+ *   if (isDlxPackageInstalled('prettier')) {
+ *     console.log('prettier is installed')
+ *   }
+ *   ```
  */
 export declare function isDlxPackageInstalled(packageName: string): boolean;
 /**
  * List all packages installed in DLX.
  *
  * @example
- * ```typescript
- * const packages = listDlxPackages()
- * console.log('Installed:', packages.join(', '))
- * ```
+ *   ;```typescript
+ *   const packages = listDlxPackages()
+ *   console.log('Installed:', packages.join(', '))
+ *   ```
  */
 export declare function listDlxPackages(): string[];
 /**
  * List all packages installed in DLX asynchronously.
  *
  * @example
- * ```typescript
- * const packages = await listDlxPackagesAsync()
- * console.log('Installed:', packages.join(', '))
- * ```
+ *   ;```typescript
+ *   const packages = await listDlxPackagesAsync()
+ *   console.log('Installed:', packages.join(', '))
+ *   ```
  */
 export declare function listDlxPackagesAsync(): Promise<string[]>;
 /**
  * Remove a DLX package installation.
  *
  * @example
- * ```typescript
- * await removeDlxPackage('prettier')
- * ```
+ *   ;```typescript
+ *   await removeDlxPackage('prettier')
+ *   ```
  */
 export declare function removeDlxPackage(packageName: string): Promise<void>;
 /**
  * Remove a DLX package installation synchronously.
  *
  * @example
- * ```typescript
- * removeDlxPackageSync('prettier')
- * ```
+ *   ;```typescript
+ *   removeDlxPackageSync('prettier')
+ *   ```
  */
 export declare function removeDlxPackageSync(packageName: string): void;

package/dist/dlx/packages.js

@@ -27,36 +27,31 @@ __export(packages_exports, {
   removeDlxPackageSync: () => removeDlxPackageSync
 });
 module.exports = __toCommonJS(packages_exports);
-var import_fs = require("../fs");
+var import_read_dir = require("../fs/read-dir");
+var import_safe = require("../fs/safe");
 var import_socket = require("../paths/socket");
 var import_paths = require("./paths");
-var import_primordials = require("../primordials");
-let _fs;
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
+var import_array = require("../primordials/array");
+var import_error = require("../primordials/error");
+var import_fs = require("../node/fs");
 function isDlxPackageInstalled(packageName) {
-  const fs = /* @__PURE__ */ getFs();
+  const fs = (0, import_fs.getNodeFs)();
   return fs.existsSync((0, import_paths.getDlxInstalledPackageDir)(packageName));
 }
 function listDlxPackages() {
   try {
-    return (0, import_fs.readDirNamesSync)((0, import_socket.getSocketDlxDir)(), { sort: true });
+    return (0, import_read_dir.readDirNamesSync)((0, import_socket.getSocketDlxDir)(), { sort: true });
   } catch {
     return [];
   }
 }
 async function listDlxPackagesAsync() {
-  const fs = /* @__PURE__ */ getFs();
+  const fs = (0, import_fs.getNodeFs)();
   try {
     const entries = await fs.promises.readdir((0, import_socket.getSocketDlxDir)(), {
       withFileTypes: true
     });
-    return (0, import_primordials.ArrayPrototypeFilter)(entries, (e) => e.isDirectory()).map((e) => e.name).sort();
+    return (0, import_array.ArrayPrototypeFilter)(entries, (e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
   }
@@ -64,9 +59,9 @@ async function listDlxPackagesAsync() {
 async function removeDlxPackage(packageName) {
   const packageDir = (0, import_paths.getDlxPackageDir)(packageName);
   try {
-    await (0, import_fs.safeDelete)(packageDir, { recursive: true, force: true });
+    await (0, import_safe.safeDelete)(packageDir, { recursive: true, force: true });
   } catch (e) {
-    throw new import_primordials.ErrorCtor(`Failed to remove DLX package "${packageName}"`, {
+    throw new import_error.ErrorCtor(`Failed to remove DLX package "${packageName}"`, {
       cause: e
     });
   }
@@ -74,11 +69,11 @@ async function removeDlxPackage(packageName) {
 function removeDlxPackageSync(packageName) {
   const packageDir = (0, import_paths.getDlxPackageDir)(packageName);
   try {
-    (0, import_fs.safeDeleteSync)(packageDir, { recursive: true, force: true });
+    (0, import_safe.safeDeleteSync)(packageDir, { recursive: true, force: true });
   } catch (e) {
     const code = e.code;
     if (code === "EACCES" || code === "EPERM") {
-      throw new import_primordials.ErrorCtor(
+      throw new import_error.ErrorCtor(
         `Permission denied removing DLX package "${packageName}"
 Directory: ${packageDir}
 To resolve:
@@ -90,14 +85,14 @@ To resolve:
       );
     }
     if (code === "EROFS") {
-      throw new import_primordials.ErrorCtor(
+      throw new import_error.ErrorCtor(
         `Cannot remove DLX package "${packageName}" from read-only filesystem
 Directory: ${packageDir}
 The filesystem is mounted read-only.`,
         { cause: e }
       );
     }
-    throw new import_primordials.ErrorCtor(
+    throw new import_error.ErrorCtor(
       `Failed to remove DLX package "${packageName}"
 Directory: ${packageDir}
 Check permissions and ensure no programs are using this directory.`,

package/dist/dlx/paths.d.ts

@@ -1,52 +1,55 @@
-/** @fileoverview Path utilities for DLX package installations. */
+/**
+ * @file Path utilities for DLX package installations.
+ */
 /**
  * Get the installed package directory within DLX node_modules.
  *
  * @example
- * ```typescript
- * const dir = getDlxInstalledPackageDir('prettier')
- * ```
+ *   ;```typescript
+ *   const dir = getDlxInstalledPackageDir('prettier')
+ *   ```
  */
 export declare function getDlxInstalledPackageDir(packageName: string): string;
 /**
  * Get the DLX installation directory for a specific package.
  *
  * @example
- * ```typescript
- * const dir = getDlxPackageDir('a1b2c3d4')
- * ```
+ *   ;```typescript
+ *   const dir = getDlxPackageDir('a1b2c3d4')
+ *   ```
  */
 export declare function getDlxPackageDir(packageName: string): string;
 /**
  * Get the package.json path for a DLX installed package.
  *
  * @example
- * ```typescript
- * const jsonPath = getDlxPackageJsonPath('prettier')
- * ```
+ *   ;```typescript
+ *   const jsonPath = getDlxPackageJsonPath('prettier')
+ *   ```
  */
 export declare function getDlxPackageJsonPath(packageName: string): string;
 /**
  * Get the node_modules directory for a DLX package installation.
  *
  * @example
- * ```typescript
- * const nmDir = getDlxPackageNodeModulesDir('a1b2c3d4')
- * ```
+ *   ;```typescript
+ *   const nmDir = getDlxPackageNodeModulesDir('a1b2c3d4')
+ *   ```
  */
 export declare function getDlxPackageNodeModulesDir(packageName: string): string;
 /**
- * Check if a file path is within the Socket DLX directory.
- * This is useful for determining if a binary or file is managed by Socket's DLX system.
- *
- * @param filePath - Absolute or relative path to check
- * @returns true if the path is within ~/.socket/_dlx/, false otherwise
+ * Check if a file path is within the Socket DLX directory. This is useful for
+ * determining if a binary or file is managed by Socket's DLX system.
  *
  * @example
- * ```typescript
- * isInSocketDlx('/home/<user>/.socket/_dlx/abc123/bin/socket') // true
- * isInSocketDlx('/usr/local/bin/socket') // false
- * isInSocketDlx(process.argv[0]) // Check if current binary is in DLX
- * ```
+ *   ;```typescript
+ *   isInSocketDlx('/home/<user>/.socket/_dlx/abc123/bin/socket') // true
+ *   isInSocketDlx('/usr/local/bin/socket') // false
+ *   isInSocketDlx(process.argv[0]) // Check if current binary is in DLX
+ *   ```
+ *
+ * @param filePath - Absolute or relative path to check.
+ *
+ * @returns True if the path is within ~/.socket/_dlx/, false otherwise
  */
 export declare function isInSocketDlx(filePath: string): boolean;