@socketsecurity/lib 0.0.0 → 1.0.1

package/dist/dlx-binary.js

@@ -0,0 +1,261 @@
+/* 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)
+    __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 dlx_binary_exports = {};
+__export(dlx_binary_exports, {
+  cleanDlxCache: () => cleanDlxCache,
+  dlxBinary: () => dlxBinary,
+  getDlxCachePath: () => getDlxCachePath,
+  listDlxCache: () => listDlxCache
+});
+module.exports = __toCommonJS(dlx_binary_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_platform = require("#constants/platform");
+var import_fs = require("./fs");
+var import_http_request = require("./http-request");
+var import_objects = require("./objects");
+var import_path = require("./path");
+var import_paths = require("./paths");
+var import_spawn = require("./spawn");
+function generateCacheKey(url) {
+  return (0, import_node_crypto.createHash)("sha256").update(url).digest("hex");
+}
+function getMetadataPath(cacheEntryPath) {
+  return import_node_path.default.join(cacheEntryPath, ".dlx-metadata.json");
+}
+async function isCacheValid(cacheEntryPath, cacheTtl) {
+  try {
+    const metaPath = getMetadataPath(cacheEntryPath);
+    if (!(0, import_node_fs.existsSync)(metaPath)) {
+      return false;
+    }
+    const metadata = await (0, import_fs.readJson)(metaPath, { throws: false });
+    if (!(0, import_objects.isObjectObject)(metadata)) {
+      return false;
+    }
+    const now = Date.now();
+    const age = now - (metadata["timestamp"] || 0);
+    return age < cacheTtl;
+  } catch {
+    return false;
+  }
+}
+async function downloadBinary(url, destPath, checksum) {
+  const response = await (0, import_http_request.httpRequest)(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download binary: ${response.status} ${response.statusText}`
+    );
+  }
+  const tempPath = `${destPath}.download`;
+  const hasher = (0, import_node_crypto.createHash)("sha256");
+  try {
+    await import_node_fs.promises.mkdir(import_node_path.default.dirname(destPath), { recursive: true });
+    const buffer = response.body;
+    hasher.update(buffer);
+    const actualChecksum = hasher.digest("hex");
+    if (checksum && actualChecksum !== checksum) {
+      throw new Error(
+        `Checksum mismatch: expected ${checksum}, got ${actualChecksum}`
+      );
+    }
+    await import_node_fs.promises.writeFile(tempPath, buffer);
+    if (!import_platform.WIN32) {
+      await import_node_fs.promises.chmod(tempPath, 493);
+    }
+    await import_node_fs.promises.rename(tempPath, destPath);
+    return actualChecksum;
+  } catch (e) {
+    try {
+      await (0, import_fs.safeDelete)(tempPath);
+    } catch {
+    }
+    throw e;
+  }
+}
+async function writeMetadata(cacheEntryPath, url, checksum) {
+  const metaPath = getMetadataPath(cacheEntryPath);
+  const metadata = {
+    arch: import_node_os.default.arch(),
+    checksum,
+    platform: import_node_os.default.platform(),
+    timestamp: Date.now(),
+    url,
+    version: "1.0.0"
+  };
+  await import_node_fs.promises.writeFile(metaPath, JSON.stringify(metadata, null, 2));
+}
+async function cleanDlxCache(maxAge = (
+  /*@__INLINE__*/
+  require("./constants/time").DLX_BINARY_CACHE_TTL
+)) {
+  const cacheDir = getDlxCachePath();
+  if (!(0, import_node_fs.existsSync)(cacheDir)) {
+    return 0;
+  }
+  let cleaned = 0;
+  const now = Date.now();
+  const entries = await import_node_fs.promises.readdir(cacheDir);
+  for (const entry of entries) {
+    const entryPath = import_node_path.default.join(cacheDir, entry);
+    const metaPath = getMetadataPath(entryPath);
+    try {
+      if (!await (0, import_fs.isDir)(entryPath)) {
+        continue;
+      }
+      const metadata = await (0, import_fs.readJson)(metaPath, { throws: false });
+      if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+        continue;
+      }
+      const age = now - (metadata["timestamp"] || 0);
+      if (age > maxAge) {
+        await (0, import_fs.safeDelete)(entryPath, { force: true, recursive: true });
+        cleaned += 1;
+      }
+    } catch {
+      try {
+        const contents = await import_node_fs.promises.readdir(entryPath);
+        if (!contents.length) {
+          await (0, import_fs.safeDelete)(entryPath);
+          cleaned += 1;
+        }
+      } catch {
+      }
+    }
+  }
+  return cleaned;
+}
+async function dlxBinary(args, options, spawnExtra) {
+  const {
+    cacheTtl = (
+      /*@__INLINE__*/
+      require("./constants/time").DLX_BINARY_CACHE_TTL
+    ),
+    checksum,
+    force = false,
+    name,
+    spawnOptions,
+    url
+  } = { __proto__: null, ...options };
+  const cacheDir = getDlxCachePath();
+  const cacheKey = generateCacheKey(url);
+  const cacheEntryDir = import_node_path.default.join(cacheDir, cacheKey);
+  const binaryName = name || `binary-${process.platform}-${import_node_os.default.arch()}`;
+  const binaryPath = (0, import_path.normalizePath)(import_node_path.default.join(cacheEntryDir, binaryName));
+  let downloaded = false;
+  let computedChecksum = checksum;
+  if (!force && (0, import_node_fs.existsSync)(cacheEntryDir) && await isCacheValid(cacheEntryDir, cacheTtl)) {
+    try {
+      const metaPath = getMetadataPath(cacheEntryDir);
+      const metadata = await (0, import_fs.readJson)(metaPath, { throws: false });
+      if (metadata && typeof metadata === "object" && !Array.isArray(metadata) && typeof metadata["checksum"] === "string") {
+        computedChecksum = metadata["checksum"];
+      } else {
+        downloaded = true;
+      }
+    } catch {
+      downloaded = true;
+    }
+  } else {
+    downloaded = true;
+  }
+  if (downloaded) {
+    await import_node_fs.promises.mkdir(cacheEntryDir, { recursive: true });
+    computedChecksum = await downloadBinary(url, binaryPath, checksum);
+    await writeMetadata(cacheEntryDir, url, computedChecksum || "");
+  }
+  const needsShell = import_platform.WIN32 && /\.(?:bat|cmd|ps1)$/i.test(binaryPath);
+  const finalSpawnOptions = needsShell ? {
+    ...spawnOptions,
+    env: {
+      ...spawnOptions?.env,
+      PATH: `${cacheEntryDir}${import_node_path.default.delimiter}${process.env["PATH"] || ""}`
+    },
+    shell: true
+  } : spawnOptions;
+  const spawnPromise = (0, import_spawn.spawn)(binaryPath, args, finalSpawnOptions, spawnExtra);
+  return {
+    binaryPath,
+    downloaded,
+    spawnPromise
+  };
+}
+function getDlxCachePath() {
+  return (0, import_path.normalizePath)(import_node_path.default.join((0, import_paths.getSocketHomePath)(), "cache", "dlx"));
+}
+async function listDlxCache() {
+  const cacheDir = getDlxCachePath();
+  if (!(0, import_node_fs.existsSync)(cacheDir)) {
+    return [];
+  }
+  const results = [];
+  const now = Date.now();
+  const entries = await import_node_fs.promises.readdir(cacheDir);
+  for (const entry of entries) {
+    const entryPath = import_node_path.default.join(cacheDir, entry);
+    try {
+      if (!await (0, import_fs.isDir)(entryPath)) {
+        continue;
+      }
+      const metaPath = getMetadataPath(entryPath);
+      const metadata = await (0, import_fs.readJson)(metaPath, { throws: false });
+      if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+        continue;
+      }
+      const files = await import_node_fs.promises.readdir(entryPath);
+      const binaryFile = files.find((f) => !f.startsWith("."));
+      if (binaryFile) {
+        const binaryPath = import_node_path.default.join(entryPath, binaryFile);
+        const binaryStats = await import_node_fs.promises.stat(binaryPath);
+        const metaObj = metadata;
+        results.push({
+          age: now - (metaObj["timestamp"] || 0),
+          arch: metaObj["arch"] || "unknown",
+          checksum: metaObj["checksum"] || "",
+          name: binaryFile,
+          platform: metaObj["platform"] || "unknown",
+          size: binaryStats.size,
+          url: metaObj["url"] || ""
+        });
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanDlxCache,
+  dlxBinary,
+  getDlxCachePath,
+  listDlxCache
+});
+//# sourceMappingURL=dlx-binary.js.map

package/dist/dlx-binary.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/dlx-binary.ts"],
+  "sourcesContent": ["/** @fileoverview DLX binary execution utilities for Socket ecosystem. */\n\nimport { createHash } from 'node:crypto'\nimport { existsSync, promises as fs } from 'node:fs'\nimport os from 'node:os'\nimport path from 'node:path'\n\nimport { WIN32 } from '#constants/platform'\n\nimport { isDir, readJson, safeDelete } from './fs'\nimport { httpRequest } from './http-request'\nimport { isObjectObject } from './objects'\nimport { normalizePath } from './path'\nimport { getSocketHomePath } from './paths'\nimport type { SpawnExtra, SpawnOptions } from './spawn'\nimport { spawn } from './spawn'\n\nexport interface DlxBinaryOptions {\n  /** URL to download the binary from. */\n  url: string\n  /** Optional name for the cached binary (defaults to URL hash). */\n  name?: string | undefined\n  /** Expected checksum (sha256) for verification. */\n  checksum?: string | undefined\n  /** Cache TTL in milliseconds (default: 7 days). */\n  cacheTtl?: number | undefined\n  /** Force re-download even if cached. */\n  force?: boolean | undefined\n  /** Additional spawn options. */\n  spawnOptions?: SpawnOptions | undefined\n}\n\nexport interface DlxBinaryResult {\n  /** Path to the cached binary. */\n  binaryPath: string\n  /** Whether the binary was newly downloaded. */\n  downloaded: boolean\n  /** The spawn promise for the running process. */\n  spawnPromise: ReturnType<typeof spawn>\n}\n\n/**\n * Generate a cache directory name from URL, similar to pnpm/npx.\n * Uses SHA256 hash to create content-addressed storage.\n */\nfunction generateCacheKey(url: string): string {\n  return createHash('sha256').update(url).digest('hex')\n}\n\n/**\n * Get metadata file path for a cached binary.\n */\nfunction getMetadataPath(cacheEntryPath: string): string {\n  return path.join(cacheEntryPath, '.dlx-metadata.json')\n}\n\n/**\n * Check if a cached binary is still valid.\n */\nasync function isCacheValid(\n  cacheEntryPath: string,\n  cacheTtl: number,\n): Promise<boolean> {\n  try {\n    const metaPath = getMetadataPath(cacheEntryPath)\n    if (!existsSync(metaPath)) {\n      return false\n    }\n\n    const metadata = await readJson(metaPath, { throws: false })\n    if (!isObjectObject(metadata)) {\n      return false\n    }\n    const now = Date.now()\n    const age =\n      now -\n      (((metadata as Record<string, unknown>)['timestamp'] as number) || 0)\n\n    return age < cacheTtl\n  } catch {\n    return false\n  }\n}\n\n/**\n * Download a file from a URL with integrity checking.\n */\nasync function downloadBinary(\n  url: string,\n  destPath: string,\n  checksum?: string | undefined,\n): Promise<string> {\n  const response = await httpRequest(url)\n  if (!response.ok) {\n    throw new Error(\n      `Failed to download binary: ${response.status} ${response.statusText}`,\n    )\n  }\n\n  // Create a temporary file first.\n  const tempPath = `${destPath}.download`\n  const hasher = createHash('sha256')\n\n  try {\n    // Ensure directory exists.\n    await fs.mkdir(path.dirname(destPath), { recursive: true })\n\n    // Get the response as a buffer and compute hash.\n    const buffer = response.body\n\n    // Compute hash.\n    hasher.update(buffer)\n    const actualChecksum = hasher.digest('hex')\n\n    // Verify checksum if provided.\n    if (checksum && actualChecksum !== checksum) {\n      throw new Error(\n        `Checksum mismatch: expected ${checksum}, got ${actualChecksum}`,\n      )\n    }\n\n    // Write to temp file.\n    await fs.writeFile(tempPath, buffer)\n\n    // Make executable on POSIX systems.\n    if (!WIN32) {\n      await fs.chmod(tempPath, 0o755)\n    }\n\n    // Move temp file to final location.\n    await fs.rename(tempPath, destPath)\n\n    return actualChecksum\n  } catch (e) {\n    // Clean up temp file on error.\n    try {\n      await safeDelete(tempPath)\n    } catch {\n      // Ignore cleanup errors.\n    }\n    throw e\n  }\n}\n\n/**\n * Write metadata for a cached binary.\n */\nasync function writeMetadata(\n  cacheEntryPath: string,\n  url: string,\n  checksum: string,\n): Promise<void> {\n  const metaPath = getMetadataPath(cacheEntryPath)\n  const metadata = {\n    arch: os.arch(),\n    checksum,\n    platform: os.platform(),\n    timestamp: Date.now(),\n    url,\n    version: '1.0.0',\n  }\n  await fs.writeFile(metaPath, JSON.stringify(metadata, null, 2))\n}\n\n/**\n * Clean expired entries from the DLX cache.\n */\nexport async function cleanDlxCache(\n  maxAge: number = /*@__INLINE__*/ require('../constants/time').DLX_BINARY_CACHE_TTL,\n): Promise<number> {\n  const cacheDir = getDlxCachePath()\n\n  if (!existsSync(cacheDir)) {\n    return 0\n  }\n\n  let cleaned = 0\n  const now = Date.now()\n  const entries = await fs.readdir(cacheDir)\n\n  for (const entry of entries) {\n    const entryPath = path.join(cacheDir, entry)\n    const metaPath = getMetadataPath(entryPath)\n\n    try {\n      // eslint-disable-next-line no-await-in-loop\n      if (!(await isDir(entryPath))) {\n        continue\n      }\n\n      // eslint-disable-next-line no-await-in-loop\n      const metadata = await readJson(metaPath, { throws: false })\n      if (\n        !metadata ||\n        typeof metadata !== 'object' ||\n        Array.isArray(metadata)\n      ) {\n        continue\n      }\n      const age =\n        now -\n        (((metadata as Record<string, unknown>)['timestamp'] as number) || 0)\n\n      if (age > maxAge) {\n        // Remove entire cache entry directory.\n        // eslint-disable-next-line no-await-in-loop\n        await safeDelete(entryPath, { force: true, recursive: true })\n        cleaned += 1\n      }\n    } catch {\n      // If we can't read metadata, check if directory is empty or corrupted.\n      try {\n        // eslint-disable-next-line no-await-in-loop\n        const contents = await fs.readdir(entryPath)\n        if (!contents.length) {\n          // Remove empty directory.\n          // eslint-disable-next-line no-await-in-loop\n          await safeDelete(entryPath)\n          cleaned += 1\n        }\n      } catch {}\n    }\n  }\n\n  return cleaned\n}\n\n/**\n * Download and execute a binary from a URL with caching.\n */\nexport async function dlxBinary(\n  args: readonly string[] | string[],\n  options?: DlxBinaryOptions | undefined,\n  spawnExtra?: SpawnExtra | undefined,\n): Promise<DlxBinaryResult> {\n  const {\n    cacheTtl = /*@__INLINE__*/ require('../constants/time').DLX_BINARY_CACHE_TTL,\n    checksum,\n    force = false,\n    name,\n    spawnOptions,\n    url,\n  } = { __proto__: null, ...options } as DlxBinaryOptions\n\n  // Generate cache paths similar to pnpm/npx structure.\n  const cacheDir = getDlxCachePath()\n  const cacheKey = generateCacheKey(url)\n  const cacheEntryDir = path.join(cacheDir, cacheKey)\n  const binaryName = name || `binary-${process.platform}-${os.arch()}`\n  const binaryPath = normalizePath(path.join(cacheEntryDir, binaryName))\n\n  let downloaded = false\n  let computedChecksum = checksum\n\n  // Check if we need to download.\n  if (\n    !force &&\n    existsSync(cacheEntryDir) &&\n    (await isCacheValid(cacheEntryDir, cacheTtl))\n  ) {\n    // Binary is cached and valid, read the checksum from metadata.\n    try {\n      const metaPath = getMetadataPath(cacheEntryDir)\n      const metadata = await readJson(metaPath, { throws: false })\n      if (\n        metadata &&\n        typeof metadata === 'object' &&\n        !Array.isArray(metadata) &&\n        typeof (metadata as Record<string, unknown>)['checksum'] === 'string'\n      ) {\n        computedChecksum = (metadata as Record<string, unknown>)[\n          'checksum'\n        ] as string\n      } else {\n        // If metadata is invalid, re-download.\n        downloaded = true\n      }\n    } catch {\n      // If we can't read metadata, re-download.\n      downloaded = true\n    }\n  } else {\n    downloaded = true\n  }\n\n  if (downloaded) {\n    // Ensure cache directory exists.\n    await fs.mkdir(cacheEntryDir, { recursive: true })\n\n    // Download the binary.\n    computedChecksum = await downloadBinary(url, binaryPath, checksum)\n    await writeMetadata(cacheEntryDir, url, computedChecksum || '')\n  }\n\n  // Execute the binary.\n  // On Windows, script files (.bat, .cmd, .ps1) require shell: true because\n  // they are not executable on their own and must be run through cmd.exe.\n  // Note: .exe files are actual binaries and don't need shell mode.\n  const needsShell = WIN32 && /\\.(?:bat|cmd|ps1)$/i.test(binaryPath)\n  // Windows cmd.exe PATH resolution behavior:\n  // When shell: true on Windows with .cmd/.bat/.ps1 files, spawn will automatically\n  // strip the full path down to just the basename without extension (e.g.,\n  // C:\\cache\\test.cmd becomes just \"test\"). Windows cmd.exe then searches for \"test\"\n  // in directories listed in PATH, trying each extension from PATHEXT environment\n  // variable (.COM, .EXE, .BAT, .CMD, etc.) until it finds a match.\n  //\n  // Since our binaries are downloaded to a custom cache directory that's not in PATH\n  // (unlike system package managers like npm/pnpm/yarn which are already in PATH),\n  // we must prepend the cache directory to PATH so cmd.exe can locate the binary.\n  //\n  // This approach is consistent with how other tools handle Windows command execution:\n  // - npm's promise-spawn: uses which.sync() to find commands in PATH\n  // - cross-spawn: spawns cmd.exe with escaped arguments\n  // - Node.js spawn with shell: true: delegates to cmd.exe which uses PATH\n  const finalSpawnOptions = needsShell\n    ? {\n        ...spawnOptions,\n        env: {\n          ...spawnOptions?.env,\n          PATH: `${cacheEntryDir}${path.delimiter}${process.env['PATH'] || ''}`,\n        },\n        shell: true,\n      }\n    : spawnOptions\n  const spawnPromise = spawn(binaryPath, args, finalSpawnOptions, spawnExtra)\n\n  return {\n    binaryPath,\n    downloaded,\n    spawnPromise,\n  }\n}\n\n/**\n * Get the DLX binary cache directory path.\n * Returns normalized path for cross-platform compatibility.\n */\nexport function getDlxCachePath(): string {\n  return normalizePath(path.join(getSocketHomePath(), 'cache', 'dlx'))\n}\n\n/**\n * Get information about cached binaries.\n */\nexport async function listDlxCache(): Promise<\n  Array<{\n    age: number\n    arch: string\n    checksum: string\n    name: string\n    platform: string\n    size: number\n    url: string\n  }>\n> {\n  const cacheDir = getDlxCachePath()\n\n  if (!existsSync(cacheDir)) {\n    return []\n  }\n\n  const results = []\n  const now = Date.now()\n  const entries = await fs.readdir(cacheDir)\n\n  for (const entry of entries) {\n    const entryPath = path.join(cacheDir, entry)\n    try {\n      // eslint-disable-next-line no-await-in-loop\n      if (!(await isDir(entryPath))) {\n        continue\n      }\n\n      const metaPath = getMetadataPath(entryPath)\n      // eslint-disable-next-line no-await-in-loop\n      const metadata = await readJson(metaPath, { throws: false })\n      if (\n        !metadata ||\n        typeof metadata !== 'object' ||\n        Array.isArray(metadata)\n      ) {\n        continue\n      }\n\n      // Find the binary file in the directory.\n      // eslint-disable-next-line no-await-in-loop\n      const files = await fs.readdir(entryPath)\n      const binaryFile = files.find(f => !f.startsWith('.'))\n\n      if (binaryFile) {\n        const binaryPath = path.join(entryPath, binaryFile)\n        // eslint-disable-next-line no-await-in-loop\n        const binaryStats = await fs.stat(binaryPath)\n\n        const metaObj = metadata as Record<string, unknown>\n        results.push({\n          age: now - ((metaObj['timestamp'] as number) || 0),\n          arch: (metaObj['arch'] as string) || 'unknown',\n          checksum: (metaObj['checksum'] as string) || '',\n          name: binaryFile,\n          platform: (metaObj['platform'] as string) || 'unknown',\n          size: binaryStats.size,\n          url: (metaObj['url'] as string) || '',\n        })\n      }\n    } catch {}\n  }\n\n  return results\n}\n"],
+  "mappings": "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",
+  "names": ["path", "fs", "os"]
+}

package/dist/dlx.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Clear all DLX package installations.
+ */
+export declare function clearDlx(): Promise<void>;
+/**
+ * Clear all DLX package installations synchronously.
+ */
+export declare function clearDlxSync(): void;
+/**
+ * Check if the DLX directory exists.
+ */
+export declare function dlxDirExists(): boolean;
+/**
+ * Check if the DLX directory exists asynchronously.
+ */
+export declare function dlxDirExistsAsync(): Promise<boolean>;
+/**
+ * Ensure the DLX directory exists, creating it if necessary.
+ */
+export declare function ensureDlxDir(): Promise<void>;
+/**
+ * Ensure the DLX directory exists synchronously, creating it if necessary.
+ */
+export declare function ensureDlxDirSync(): void;
+/**
+ * Get the installed package directory within DLX node_modules.
+ */
+export declare function getDlxInstalledPackageDir(packageName: string): string;
+/**
+ * Get the DLX installation directory for a specific package.
+ */
+export declare function getDlxPackageDir(packageName: string): string;
+/**
+ * Get the package.json path for a DLX installed package.
+ */
+export declare function getDlxPackageJsonPath(packageName: string): string;
+/**
+ * Get the node_modules directory for a DLX package installation.
+ */
+export declare function getDlxPackageNodeModulesDir(packageName: string): string;
+/**
+ * Check if a package is installed in DLX.
+ */
+export declare function isDlxPackageInstalled(packageName: string): boolean;
+/**
+ * Check if a package is installed in DLX asynchronously.
+ */
+export declare function isDlxPackageInstalledAsync(packageName: string): Promise<boolean>;
+/**
+ * List all packages installed in DLX.
+ */
+export declare function listDlxPackages(): string[];
+/**
+ * List all packages installed in DLX asynchronously.
+ */
+export declare function listDlxPackagesAsync(): Promise<string[]>;
+/**
+ * Remove a DLX package installation.
+ */
+export declare function removeDlxPackage(packageName: string): Promise<void>;
+/**
+ * Remove a DLX package installation synchronously.
+ */
+export declare function removeDlxPackageSync(packageName: string): void;

package/dist/dlx.js

@@ -0,0 +1,168 @@
+/* Socket Lib - Built with esbuild */
+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 dlx_exports = {};
+__export(dlx_exports, {
+  clearDlx: () => clearDlx,
+  clearDlxSync: () => clearDlxSync,
+  dlxDirExists: () => dlxDirExists,
+  dlxDirExistsAsync: () => dlxDirExistsAsync,
+  ensureDlxDir: () => ensureDlxDir,
+  ensureDlxDirSync: () => ensureDlxDirSync,
+  getDlxInstalledPackageDir: () => getDlxInstalledPackageDir,
+  getDlxPackageDir: () => getDlxPackageDir,
+  getDlxPackageJsonPath: () => getDlxPackageJsonPath,
+  getDlxPackageNodeModulesDir: () => getDlxPackageNodeModulesDir,
+  isDlxPackageInstalled: () => isDlxPackageInstalled,
+  isDlxPackageInstalledAsync: () => isDlxPackageInstalledAsync,
+  listDlxPackages: () => listDlxPackages,
+  listDlxPackagesAsync: () => listDlxPackagesAsync,
+  removeDlxPackage: () => removeDlxPackage,
+  removeDlxPackageSync: () => removeDlxPackageSync
+});
+module.exports = __toCommonJS(dlx_exports);
+var import_node_fs = require("node:fs");
+var import_fs = require("./fs");
+var import_path = require("./path");
+var import_paths = require("./paths");
+var import_promises = require("./promises");
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("node:path");
+  }
+  return _path;
+}
+async function clearDlx() {
+  const packages = await listDlxPackagesAsync();
+  await (0, import_promises.pEach)(packages, (pkg) => removeDlxPackage(pkg));
+}
+function clearDlxSync() {
+  const packages = listDlxPackages();
+  for (const pkg of packages) {
+    removeDlxPackageSync(pkg);
+  }
+}
+function dlxDirExists() {
+  return (0, import_node_fs.existsSync)((0, import_paths.getSocketDlxDir)());
+}
+async function dlxDirExistsAsync() {
+  try {
+    await import_node_fs.promises.access((0, import_paths.getSocketDlxDir)());
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDlxDir() {
+  await import_node_fs.promises.mkdir((0, import_paths.getSocketDlxDir)(), { recursive: true });
+}
+function ensureDlxDirSync() {
+  const { mkdirSync } = require("node:fs");
+  mkdirSync((0, import_paths.getSocketDlxDir)(), { recursive: true });
+}
+function getDlxInstalledPackageDir(packageName) {
+  const path = /* @__PURE__ */ getPath();
+  return (0, import_path.normalizePath)(
+    path.join(getDlxPackageNodeModulesDir(packageName), packageName)
+  );
+}
+function getDlxPackageDir(packageName) {
+  const path = /* @__PURE__ */ getPath();
+  return (0, import_path.normalizePath)(path.join((0, import_paths.getSocketDlxDir)(), packageName));
+}
+function getDlxPackageJsonPath(packageName) {
+  const path = /* @__PURE__ */ getPath();
+  return (0, import_path.normalizePath)(
+    path.join(getDlxInstalledPackageDir(packageName), "package.json")
+  );
+}
+function getDlxPackageNodeModulesDir(packageName) {
+  const path = /* @__PURE__ */ getPath();
+  return (0, import_path.normalizePath)(path.join(getDlxPackageDir(packageName), "node_modules"));
+}
+function isDlxPackageInstalled(packageName) {
+  return (0, import_node_fs.existsSync)(getDlxInstalledPackageDir(packageName));
+}
+async function isDlxPackageInstalledAsync(packageName) {
+  try {
+    await import_node_fs.promises.access(getDlxInstalledPackageDir(packageName));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listDlxPackages() {
+  try {
+    return (0, import_fs.readDirNamesSync)((0, import_paths.getSocketDlxDir)(), { sort: true });
+  } catch {
+    return [];
+  }
+}
+async function listDlxPackagesAsync() {
+  try {
+    const entries = await import_node_fs.promises.readdir((0, import_paths.getSocketDlxDir)(), {
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+async function removeDlxPackage(packageName) {
+  const packageDir = getDlxPackageDir(packageName);
+  try {
+    await (0, import_fs.safeDelete)(packageDir, { recursive: true, force: true });
+  } catch (e) {
+    throw new Error(`Failed to remove DLX package "${packageName}"`, {
+      cause: e
+    });
+  }
+}
+function removeDlxPackageSync(packageName) {
+  const { rmSync } = require("node:fs");
+  const packageDir = getDlxPackageDir(packageName);
+  try {
+    rmSync(packageDir, { recursive: true, force: true });
+  } catch (e) {
+    throw new Error(`Failed to remove DLX package "${packageName}"`, {
+      cause: e
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearDlx,
+  clearDlxSync,
+  dlxDirExists,
+  dlxDirExistsAsync,
+  ensureDlxDir,
+  ensureDlxDirSync,
+  getDlxInstalledPackageDir,
+  getDlxPackageDir,
+  getDlxPackageJsonPath,
+  getDlxPackageNodeModulesDir,
+  isDlxPackageInstalled,
+  isDlxPackageInstalledAsync,
+  listDlxPackages,
+  listDlxPackagesAsync,
+  removeDlxPackage,
+  removeDlxPackageSync
+});
+//# sourceMappingURL=dlx.js.map

package/dist/dlx.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/dlx.ts"],
+  "sourcesContent": ["/** @fileoverview DLX (execute package) utilities for Socket ecosystem shared installations. */\n\nimport { existsSync, promises as fs } from 'node:fs'\n\nimport { readDirNamesSync, safeDelete } from './fs'\nimport { normalizePath } from './path'\nimport { getSocketDlxDir } from './paths'\nimport { pEach } from './promises'\n\nlet _path: typeof import('path') | undefined\n/**\n * Lazily load the path module to avoid Webpack errors.\n * @private\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getPath() {\n  if (_path === undefined) {\n    // Use non-'node:' prefixed require to avoid Webpack errors.\n\n    _path = /*@__PURE__*/ require('node:path')\n  }\n  // biome-ignore lint/style/noNonNullAssertion: Initialized above.\n  return _path!\n}\n\n/**\n * Clear all DLX package installations.\n */\nexport async function clearDlx(): Promise<void> {\n  const packages = await listDlxPackagesAsync()\n  await pEach(packages, pkg => removeDlxPackage(pkg))\n}\n\n/**\n * Clear all DLX package installations synchronously.\n */\nexport function clearDlxSync(): void {\n  const packages = listDlxPackages()\n  for (const pkg of packages) {\n    removeDlxPackageSync(pkg)\n  }\n}\n\n/**\n * Check if the DLX directory exists.\n */\nexport function dlxDirExists(): boolean {\n  return existsSync(getSocketDlxDir())\n}\n\n/**\n * Check if the DLX directory exists asynchronously.\n */\nexport async function dlxDirExistsAsync(): Promise<boolean> {\n  try {\n    await fs.access(getSocketDlxDir())\n    return true\n  } catch {\n    return false\n  }\n}\n\n/**\n * Ensure the DLX directory exists, creating it if necessary.\n */\nexport async function ensureDlxDir(): Promise<void> {\n  await fs.mkdir(getSocketDlxDir(), { recursive: true })\n}\n\n/**\n * Ensure the DLX directory exists synchronously, creating it if necessary.\n */\nexport function ensureDlxDirSync(): void {\n  const { mkdirSync } = require('node:fs')\n  mkdirSync(getSocketDlxDir(), { recursive: true })\n}\n\n/**\n * Get the installed package directory within DLX node_modules.\n */\nexport function getDlxInstalledPackageDir(packageName: string): string {\n  const path = getPath()\n  return normalizePath(\n    path.join(getDlxPackageNodeModulesDir(packageName), packageName),\n  )\n}\n\n/**\n * Get the DLX installation directory for a specific package.\n */\nexport function getDlxPackageDir(packageName: string): string {\n  const path = getPath()\n  return normalizePath(path.join(getSocketDlxDir(), packageName))\n}\n\n/**\n * Get the package.json path for a DLX installed package.\n */\nexport function getDlxPackageJsonPath(packageName: string): string {\n  const path = getPath()\n  return normalizePath(\n    path.join(getDlxInstalledPackageDir(packageName), 'package.json'),\n  )\n}\n\n/**\n * Get the node_modules directory for a DLX package installation.\n */\nexport function getDlxPackageNodeModulesDir(packageName: string): string {\n  const path = getPath()\n  return normalizePath(path.join(getDlxPackageDir(packageName), 'node_modules'))\n}\n\n/**\n * Check if a package is installed in DLX.\n */\nexport function isDlxPackageInstalled(packageName: string): boolean {\n  return existsSync(getDlxInstalledPackageDir(packageName))\n}\n\n/**\n * Check if a package is installed in DLX asynchronously.\n */\nexport async function isDlxPackageInstalledAsync(\n  packageName: string,\n): Promise<boolean> {\n  try {\n    await fs.access(getDlxInstalledPackageDir(packageName))\n    return true\n  } catch {\n    return false\n  }\n}\n\n/**\n * List all packages installed in DLX.\n */\nexport function listDlxPackages(): string[] {\n  try {\n    return readDirNamesSync(getSocketDlxDir(), { sort: true })\n  } catch {\n    return []\n  }\n}\n\n/**\n * List all packages installed in DLX asynchronously.\n */\nexport async function listDlxPackagesAsync(): Promise<string[]> {\n  try {\n    const entries = await fs.readdir(getSocketDlxDir(), {\n      withFileTypes: true,\n    })\n    return entries\n      .filter(e => e.isDirectory())\n      .map(e => e.name)\n      .sort()\n  } catch {\n    return []\n  }\n}\n\n/**\n * Remove a DLX package installation.\n */\nexport async function removeDlxPackage(packageName: string): Promise<void> {\n  const packageDir = getDlxPackageDir(packageName)\n  try {\n    await safeDelete(packageDir, { recursive: true, force: true })\n  } catch (e) {\n    throw new Error(`Failed to remove DLX package \"${packageName}\"`, {\n      cause: e,\n    })\n  }\n}\n\n/**\n * Remove a DLX package installation synchronously.\n */\nexport function removeDlxPackageSync(packageName: string): void {\n  const { rmSync } = require('node:fs')\n  const packageDir = getDlxPackageDir(packageName)\n  try {\n    rmSync(packageDir, { recursive: true, force: true })\n  } catch (e) {\n    throw new Error(`Failed to remove DLX package \"${packageName}\"`, {\n      cause: e,\n    })\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["fs"]
+}

package/dist/download-lock.d.ts

@@ -0,0 +1,48 @@
+import type { HttpDownloadOptions, HttpDownloadResult } from './http-request';
+export interface DownloadLockInfo {
+    pid: number;
+    startTime: number;
+    url: string;
+}
+export interface DownloadWithLockOptions extends HttpDownloadOptions {
+    /**
+     * Maximum time to wait for lock acquisition in milliseconds.
+     * @default 60000 (1 minute)
+     */
+    lockTimeout?: number | undefined;
+    /**
+     * Directory where lock files are stored.
+     * @default '<destPath>.locks'
+     */
+    locksDir?: string | undefined;
+    /**
+     * Interval for checking stale locks in milliseconds.
+     * @default 1000 (1 second)
+     */
+    pollInterval?: number | undefined;
+    /**
+     * Maximum age of a lock before it's considered stale in milliseconds.
+     * @default 300000 (5 minutes)
+     */
+    staleTimeout?: number | undefined;
+}
+/**
+ * Download a file with locking to prevent concurrent downloads of the same resource.
+ * If another process is already downloading to the same destination, this will wait
+ * for the download to complete (up to lockTimeout) before proceeding.
+ *
+ * @throws {Error} When download fails or lock cannot be acquired.
+ *
+ * @example
+ * ```typescript
+ * const result = await downloadWithLock(
+ *   'https://example.com/file.tar.gz',
+ *   '/tmp/downloads/file.tar.gz',
+ *   {
+ *     retries: 3,
+ *     lockTimeout: 60000, // Wait up to 1 minute for other downloads
+ *   }
+ * )
+ * ```
+ */
+export declare function downloadWithLock(url: string, destPath: string, options?: DownloadWithLockOptions | undefined): Promise<HttpDownloadResult>;