@socketsecurity/lib 5.2.1 → 5.4.0

package/CHANGELOG.md

@@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.4.0](https://github.com/SocketDev/socket-lib/releases/tag/v5.4.0) - 2026-01-07
+
+### Added
+
+- **releases/github**: Extended release functions to accept glob patterns for asset discovery
+  - `getReleaseAssetUrl()` now accepts glob patterns: `'yoga-sync-*.mjs'`, `'models-*.tar.gz'`
+  - `downloadReleaseAsset()` now accepts glob patterns for automatic asset discovery
+  - `getLatestRelease()` now accepts asset patterns to find releases with matching assets
+  - Supports wildcards, brace expansion, RegExp patterns, and prefix/suffix objects
+  - Uses picomatch for robust glob pattern matching
+
+- **releases/socket-btm**: Extended `downloadSocketBtmRelease()` to accept glob patterns
+  - `asset` parameter now accepts wildcards: `'yoga-sync-*.mjs'`, `'models-*.tar.gz'`
+  - Automatically discovers and downloads latest matching asset
+  - Eliminates need for hardcoded asset names in build scripts
+
+## [5.3.0](https://github.com/SocketDev/socket-lib/releases/tag/v5.3.0) - 2026-01-07
+
+### Added
+
+- **releases/socket-btm**: Exported helper functions for external use
+  - `detectLibc()`: Detect musl vs glibc on Linux systems
+  - `getBinaryAssetName()`: Get GitHub asset name for platform/arch
+  - `getBinaryName()`: Get binary filename with platform-appropriate extension
+  - `getPlatformArch()`: Get platform-arch identifier for directory structure
+
+- **releases/github**: Exported `getAuthHeaders()` for GitHub API authentication
+  - Returns headers with `Accept`, `X-GitHub-Api-Version`, and optional `Authorization`
+  - Checks `GH_TOKEN` and `GITHUB_TOKEN` environment variables
+
 ## [5.2.1](https://github.com/SocketDev/socket-lib/releases/tag/v5.2.1) - 2026-01-06
 
 ### Fixed

package/dist/bin.d.ts

@@ -1,9 +1,3 @@
-// ============================================================================
-// Private Helper Functions
-// ============================================================================
-// ============================================================================
-// Types and Interfaces
-// ============================================================================
 /**
  * Options for the which function.
  */
@@ -21,9 +15,6 @@ export interface WhichOptions {
     /** Current working directory for resolving relative paths. */
     cwd?: string | undefined;
 }
-// ============================================================================
-// Public API (alphabetically sorted)
-// ============================================================================
 /**
  * Execute a binary with the given arguments.
  */

package/dist/bin.js

@@ -42,8 +42,6 @@ __export(bin_exports, {
   whichSync: () => whichSync
 });
 module.exports = __toCommonJS(bin_exports);
-var import_node_fs = __toESM(require("node:fs"));
-var import_node_path = __toESM(require("node:path"));
 var import_home = require("./env/home");
 var import_windows = require("./env/windows");
 var import_xdg = require("./env/xdg");
@@ -52,6 +50,22 @@ var import_which = __toESM(require("./external/which"));
 var import_fs = require("./fs");
 var import_normalize = require("./paths/normalize");
 var import_spawn = require("./spawn");
+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;
+}
 // @__NO_SIDE_EFFECTS__
 async function execBin(binPath, args, options) {
   const resolvedPath = (0, import_normalize.isPath)(binPath) ? /* @__PURE__ */ resolveRealBinSync(binPath) : await whichReal(binPath);
@@ -77,19 +91,21 @@ To resolve:
   });
 }
 function findRealBin(binName, commonPaths = []) {
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   for (const binPath2 of commonPaths) {
-    if (import_node_fs.default.existsSync(binPath2)) {
+    if (fs.existsSync(binPath2)) {
       return binPath2;
     }
   }
   const binPath = import_which.default.sync(binName, { nothrow: true });
   if (binPath) {
-    const binDir = import_node_path.default.dirname(binPath);
+    const binDir = path.dirname(binPath);
     if (isShadowBinPath(binDir)) {
       const allPaths = import_which.default.sync(binName, { all: true, nothrow: true }) || [];
       const pathsArray = Array.isArray(allPaths) ? allPaths : typeof allPaths === "string" ? [allPaths] : [];
       for (const altPath of pathsArray) {
-        const altDir = import_node_path.default.dirname(altPath);
+        const altDir = path.dirname(altPath);
         if (!isShadowBinPath(altDir)) {
           return altPath;
         }
@@ -100,49 +116,53 @@ function findRealBin(binName, commonPaths = []) {
   return void 0;
 }
 function findRealNpm() {
-  const nodeDir = import_node_path.default.dirname(process.execPath);
-  const npmInNodeDir = import_node_path.default.join(nodeDir, "npm");
-  if (import_node_fs.default.existsSync(npmInNodeDir)) {
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
+  const nodeDir = path.dirname(process.execPath);
+  const npmInNodeDir = path.join(nodeDir, "npm");
+  if (fs.existsSync(npmInNodeDir)) {
     return npmInNodeDir;
   }
   const commonPaths = ["/usr/local/bin/npm", "/usr/bin/npm"];
   const result = findRealBin("npm", commonPaths);
-  if (result && import_node_fs.default.existsSync(result)) {
+  if (result && fs.existsSync(result)) {
     return result;
   }
   const npmPath = whichRealSync("npm", { nothrow: true });
-  if (npmPath && typeof npmPath === "string" && import_node_fs.default.existsSync(npmPath)) {
+  if (npmPath && typeof npmPath === "string" && fs.existsSync(npmPath)) {
     return npmPath;
   }
   return "npm";
 }
 function findRealPnpm() {
+  const path = /* @__PURE__ */ getPath();
   const commonPaths = import_platform.WIN32 ? [
     // Windows common paths.
-    import_node_path.default.join((0, import_windows.getAppdata)(), "npm", "pnpm.cmd"),
-    import_node_path.default.join((0, import_windows.getAppdata)(), "npm", "pnpm"),
-    import_node_path.default.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm.cmd"),
-    import_node_path.default.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm"),
+    path.join((0, import_windows.getAppdata)(), "npm", "pnpm.cmd"),
+    path.join((0, import_windows.getAppdata)(), "npm", "pnpm"),
+    path.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm.cmd"),
+    path.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm"),
     "C:\\Program Files\\nodejs\\pnpm.cmd",
     "C:\\Program Files\\nodejs\\pnpm"
   ].filter(Boolean) : [
     // Unix common paths.
     "/usr/local/bin/pnpm",
     "/usr/bin/pnpm",
-    import_node_path.default.join(
+    path.join(
       (0, import_xdg.getXdgDataHome)() || `${(0, import_home.getHome)()}/.local/share`,
       "pnpm/pnpm"
     ),
-    import_node_path.default.join((0, import_home.getHome)(), ".pnpm/pnpm")
+    path.join((0, import_home.getHome)(), ".pnpm/pnpm")
   ].filter(Boolean);
   return findRealBin("pnpm", commonPaths) ?? "";
 }
 function findRealYarn() {
+  const path = /* @__PURE__ */ getPath();
   const commonPaths = [
     "/usr/local/bin/yarn",
     "/usr/bin/yarn",
-    import_node_path.default.join((0, import_home.getHome)(), ".yarn/bin/yarn"),
-    import_node_path.default.join(
+    path.join((0, import_home.getHome)(), ".yarn/bin/yarn"),
+    path.join(
       (0, import_home.getHome)(),
       ".config/yarn/global/node_modules/.bin/yarn"
     )
@@ -158,7 +178,9 @@ function isShadowBinPath(dirPath) {
 }
 // @__NO_SIDE_EFFECTS__
 function resolveRealBinSync(binPath) {
-  if (!import_node_path.default.isAbsolute(binPath)) {
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
+  if (!path.isAbsolute(binPath)) {
     try {
       const resolved = whichRealSync(binPath);
       if (resolved) {
@@ -171,17 +193,17 @@ function resolveRealBinSync(binPath) {
   if (binPath === ".") {
     return binPath;
   }
-  const ext = import_node_path.default.extname(binPath);
+  const ext = path.extname(binPath);
   const extLowered = ext.toLowerCase();
-  const basename = import_node_path.default.basename(binPath, ext);
+  const basename = path.basename(binPath, ext);
   const voltaIndex = basename === "node" ? -1 : /(?<=\/)\.volta\//i.exec(binPath)?.index ?? -1;
   if (voltaIndex !== -1) {
     const voltaPath = binPath.slice(0, voltaIndex);
-    const voltaToolsPath = import_node_path.default.join(voltaPath, "tools");
-    const voltaImagePath = import_node_path.default.join(voltaToolsPath, "image");
-    const voltaUserPath = import_node_path.default.join(voltaToolsPath, "user");
+    const voltaToolsPath = path.join(voltaPath, "tools");
+    const voltaImagePath = path.join(voltaToolsPath, "image");
+    const voltaUserPath = path.join(voltaToolsPath, "user");
     const voltaPlatform = (0, import_fs.readJsonSync)(
-      import_node_path.default.join(voltaUserPath, "platform.json"),
+      path.join(voltaUserPath, "platform.json"),
       { throws: false }
     );
     const voltaNodeVersion = voltaPlatform?.node?.runtime;
@@ -190,35 +212,35 @@ function resolveRealBinSync(binPath) {
     if (basename === "npm" || basename === "npx") {
       if (voltaNpmVersion) {
         const relCliPath = `bin/${basename}-cli.js`;
-        voltaBinPath = import_node_path.default.join(
+        voltaBinPath = path.join(
           voltaImagePath,
           `npm/${voltaNpmVersion}/${relCliPath}`
         );
-        if (voltaNodeVersion && !import_node_fs.default.existsSync(voltaBinPath)) {
-          voltaBinPath = import_node_path.default.join(
+        if (voltaNodeVersion && !fs.existsSync(voltaBinPath)) {
+          voltaBinPath = path.join(
             voltaImagePath,
             `node/${voltaNodeVersion}/lib/node_modules/npm/${relCliPath}`
           );
-          if (!import_node_fs.default.existsSync(voltaBinPath)) {
+          if (!fs.existsSync(voltaBinPath)) {
             voltaBinPath = "";
           }
         }
       }
     } else {
-      const voltaUserBinPath = import_node_path.default.join(voltaUserPath, "bin");
+      const voltaUserBinPath = path.join(voltaUserPath, "bin");
       const binInfo = (0, import_fs.readJsonSync)(
-        import_node_path.default.join(voltaUserBinPath, `${basename}.json`),
+        path.join(voltaUserBinPath, `${basename}.json`),
         { throws: false }
       );
       const binPackage = binInfo?.package;
       if (binPackage) {
-        voltaBinPath = import_node_path.default.join(
+        voltaBinPath = path.join(
           voltaImagePath,
           `packages/${binPackage}/bin/${basename}`
         );
-        if (!import_node_fs.default.existsSync(voltaBinPath)) {
+        if (!fs.existsSync(voltaBinPath)) {
           voltaBinPath = `${voltaBinPath}.cmd`;
-          if (!import_node_fs.default.existsSync(voltaBinPath)) {
+          if (!fs.existsSync(voltaBinPath)) {
             voltaBinPath = "";
           }
         }
@@ -226,7 +248,7 @@ function resolveRealBinSync(binPath) {
     }
     if (voltaBinPath) {
       try {
-        return (0, import_normalize.normalizePath)(import_node_fs.default.realpathSync.native(voltaBinPath));
+        return (0, import_normalize.normalizePath)(fs.realpathSync.native(voltaBinPath));
       } catch {
       }
       return voltaBinPath;
@@ -237,13 +259,13 @@ function resolveRealBinSync(binPath) {
     const isNpmOrNpx = basename === "npm" || basename === "npx";
     const isPnpmOrYarn = basename === "pnpm" || basename === "yarn";
     if (hasKnownExt && isNpmOrNpx) {
-      const quickPath = import_node_path.default.join(
-        import_node_path.default.dirname(binPath),
+      const quickPath = path.join(
+        path.dirname(binPath),
         `node_modules/npm/bin/${basename}-cli.js`
       );
-      if (import_node_fs.default.existsSync(quickPath)) {
+      if (fs.existsSync(quickPath)) {
         try {
-          return import_node_fs.default.realpathSync.native(quickPath);
+          return fs.realpathSync.native(quickPath);
         } catch {
         }
         return quickPath;
@@ -253,8 +275,8 @@ function resolveRealBinSync(binPath) {
     if (hasKnownExt && // Only parse shell scripts and batch files, not actual executables.
     // .exe files are already executables and don't need path resolution from wrapper scripts.
     extLowered !== ".exe" && // Check if file exists before attempting to read it to avoid ENOENT errors.
-    import_node_fs.default.existsSync(binPath)) {
-      const source = import_node_fs.default.readFileSync(binPath, "utf8");
+    fs.existsSync(binPath)) {
+      const source = fs.readFileSync(binPath, "utf8");
       if (isNpmOrNpx) {
         if (extLowered === ".cmd") {
           relPath = basename === "npm" ? /(?<="NPM_CLI_JS=%~dp0\\).*(?=")/.exec(source)?.[0] || "" : /(?<="NPX_CLI_JS=%~dp0\\).*(?=")/.exec(source)?.[0] || "";
@@ -301,7 +323,7 @@ function resolveRealBinSync(binPath) {
         relPath = /(?<="\$basedir\/).*(?=" $args\n)/.exec(source)?.[0] || "";
       }
       if (relPath) {
-        binPath = (0, import_normalize.normalizePath)(import_node_path.default.resolve(import_node_path.default.dirname(binPath), relPath));
+        binPath = (0, import_normalize.normalizePath)(path.resolve(path.dirname(binPath), relPath));
       }
     }
   } else {
@@ -313,10 +335,10 @@ function resolveRealBinSync(binPath) {
       if (binIndex !== -1) {
         const baseBinPath = binPath.slice(0, binIndex + "/.bin/pnpm".length);
         try {
-          const stats = import_node_fs.default.statSync(baseBinPath);
+          const stats = fs.statSync(baseBinPath);
           if (stats.isFile()) {
             binPath = (0, import_normalize.normalizePath)(baseBinPath);
-            hasNoExt = !import_node_path.default.extname(binPath);
+            hasNoExt = !path.extname(binPath);
           }
         } catch {
         }
@@ -324,8 +346,8 @@ function resolveRealBinSync(binPath) {
     }
     if (hasNoExt && (isPnpmOrYarn || isNpmOrNpx) && // For extensionless files (Unix shell scripts), verify existence before reading.
     // This prevents ENOENT errors when the bin path doesn't exist.
-    import_node_fs.default.existsSync(binPath)) {
-      const source = import_node_fs.default.readFileSync(binPath, "utf8");
+    fs.existsSync(binPath)) {
+      const source = fs.readFileSync(binPath, "utf8");
       let relPath = "";
       if (isPnpmOrYarn) {
         relPath = /(?<="\$basedir\/)\.tools\/[^"]+(?="\s+"\$@")/.exec(source)?.[0] || "";
@@ -347,12 +369,12 @@ function resolveRealBinSync(binPath) {
         relPath = basename === "npm" ? /(?<=NPM_CLI_JS="\$CLI_BASEDIR\/).*(?=")/.exec(source)?.[0] || "" : /(?<=NPX_CLI_JS="\$CLI_BASEDIR\/).*(?=")/.exec(source)?.[0] || "";
       }
       if (relPath) {
-        binPath = (0, import_normalize.normalizePath)(import_node_path.default.resolve(import_node_path.default.dirname(binPath), relPath));
+        binPath = (0, import_normalize.normalizePath)(path.resolve(path.dirname(binPath), relPath));
       }
     }
   }
   try {
-    const realPath = import_node_fs.default.realpathSync.native(binPath);
+    const realPath = fs.realpathSync.native(binPath);
     return (0, import_normalize.normalizePath)(realPath);
   } catch {
   }

package/dist/constants/agents.js

@@ -70,8 +70,8 @@ const NPM_BIN_PATH = /* @__PURE__ */ (() => {
 })();
 const NPM_REAL_EXEC_PATH = /* @__PURE__ */ (() => {
   try {
-    const { existsSync } = require("node:fs");
-    const path = require("node:path");
+    const { existsSync } = require("fs");
+    const path = require("path");
     const npmBin = import_which.default.sync("npm", { nothrow: true });
     if (!npmBin) {
       return void 0;

package/dist/constants/platform.d.ts

@@ -1,3 +1,24 @@
+/**
+ * CPU architecture type.
+ */
+export type Arch = NodeJS.Architecture;
+/**
+ * Linux libc variant.
+ */
+export type Libc = 'glibc' | 'musl';
+/**
+ * Operating system platform type.
+ */
+export type Platform = NodeJS.Platform;
+/**
+ * Get the current CPU architecture (memoized).
+ */
+export declare function getArch(): Arch;
+/**
+ * Get the current platform (memoized).
+ */
+export declare function getPlatform(): Platform;
+// Platform detection (memoized at module load).
 export declare const DARWIN: boolean;
 export declare const WIN32: boolean;
 // File permission modes.

package/dist/constants/platform.js

@@ -23,13 +23,35 @@ __export(platform_exports, {
   S_IXGRP: () => S_IXGRP,
   S_IXOTH: () => S_IXOTH,
   S_IXUSR: () => S_IXUSR,
-  WIN32: () => WIN32
+  WIN32: () => WIN32,
+  getArch: () => getArch,
+  getPlatform: () => getPlatform
 });
 module.exports = __toCommonJS(platform_exports);
-var import_os = require("os");
-const _platform = (0, import_os.platform)();
-const DARWIN = _platform === "darwin";
-const WIN32 = _platform === "win32";
+let _os;
+// @__NO_SIDE_EFFECTS__
+function getOs() {
+  if (_os === void 0) {
+    _os = require("os");
+  }
+  return _os;
+}
+let _arch;
+function getArch() {
+  if (_arch === void 0) {
+    _arch = (/* @__PURE__ */ getOs()).arch();
+  }
+  return _arch;
+}
+let _platform;
+function getPlatform() {
+  if (_platform === void 0) {
+    _platform = (/* @__PURE__ */ getOs()).platform();
+  }
+  return _platform;
+}
+const DARWIN = getPlatform() === "darwin";
+const WIN32 = getPlatform() === "win32";
 const S_IXUSR = 64;
 const S_IXGRP = 8;
 const S_IXOTH = 1;
@@ -39,5 +61,7 @@ const S_IXOTH = 1;
   S_IXGRP,
   S_IXOTH,
   S_IXUSR,
-  WIN32
+  WIN32,
+  getArch,
+  getPlatform
 });

package/dist/cover/code.js

@@ -22,15 +22,22 @@ __export(code_exports, {
   getCodeCoverage: () => getCodeCoverage
 });
 module.exports = __toCommonJS(code_exports);
-var import_fs = require("fs");
-var import_fs2 = require("../fs");
+var import_fs = require("../fs");
 var import_objects = require("../objects");
 var import_spawn = require("../spawn");
+let _fs;
 let _path;
 // @__NO_SIDE_EFFECTS__
+function getFs() {
+  if (_fs === void 0) {
+    _fs = require("fs");
+  }
+  return _fs;
+}
+// @__NO_SIDE_EFFECTS__
 function getPath() {
   if (_path === void 0) {
-    _path = require("node:path");
+    _path = require("path");
   }
   return _path;
 }
@@ -46,7 +53,8 @@ async function getCodeCoverage(options) {
   if (!coveragePath) {
     throw new Error("Coverage path is required");
   }
-  const coverageExists = await import_fs.promises.access(coveragePath).then(() => true).catch(() => false);
+  const fs = /* @__PURE__ */ getFs();
+  const coverageExists = await fs.promises.access(coveragePath).then(() => true).catch(() => false);
   if (!coverageExists) {
     if (generateIfMissing) {
       await (0, import_spawn.spawn)("vitest", ["run", "--coverage"], {
@@ -59,7 +67,7 @@ async function getCodeCoverage(options) {
       );
     }
   }
-  const coverageData = await (0, import_fs2.readJson)(coveragePath);
+  const coverageData = await (0, import_fs.readJson)(coveragePath);
   if (!(0, import_objects.isObjectObject)(coverageData)) {
     throw new Error(`Invalid coverage data format in "${coveragePath}"`);
   }

package/dist/debug.js

@@ -72,7 +72,7 @@ let _util;
 // @__NO_SIDE_EFFECTS__
 function getUtil() {
   if (_util === void 0) {
-    _util = require("node:util");
+    _util = require("util");
   }
   return _util;
 }

package/dist/dlx/binary.d.ts

@@ -1,5 +1,5 @@
-import type { SpawnExtra, SpawnOptions } from '../spawn';
 import { spawn } from '../spawn';
+import type { SpawnExtra, SpawnOptions } from '../spawn';
 export interface DlxBinaryOptions {
     /**
      * URL to download the binary from.