@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/abort.d.ts

@@ -1,27 +0,0 @@
-/**
- * @fileoverview Abort signal utilities.
- */
-/**
- * Create a composite AbortSignal from multiple signals.
- *
- * @example
- * ```typescript
- * const ac1 = new AbortController()
- * const ac2 = new AbortController()
- * const signal = createCompositeAbortSignal(ac1.signal, ac2.signal)
- * ```
- */
-export declare function createCompositeAbortSignal(...signals: Array<AbortSignal | null | undefined>): AbortSignal;
-/**
- * Create an AbortSignal that triggers after a timeout.
- *
- * @throws {TypeError} If `ms` is not a number, is NaN, is not finite, or is not
- *   positive.
- *
- * @example
- * ```typescript
- * const signal = createTimeoutSignal(5000) // aborts after 5 seconds
- * fetch('https://example.com', { signal })
- * ```
- */
-export declare function createTimeoutSignal(ms: number): AbortSignal;

package/dist/agent.d.ts

@@ -1,196 +0,0 @@
-/**
- * @fileoverview Package manager agent for executing npm, pnpm, and yarn commands.
- * Provides cross-platform utilities with optimized flags and security defaults.
- *
- * SECURITY: Array-Based Arguments Prevent Command Injection
- *
- * All functions in this module (execNpm, execPnpm, execYarn) use array-based
- * arguments when calling spawn(). This is the PRIMARY DEFENSE against command
- * injection attacks.
- *
- * When arguments are passed as an array:
- *   spawn(cmd, ['install', packageName, '--flag'], options)
- *
- * Node.js handles escaping automatically. Each argument is passed directly to
- * the OS without shell interpretation. Shell metacharacters like ; | & $ ( )
- * are treated as LITERAL STRINGS, not as commands.
- *
- * Example: If packageName = "lodash; rm -rf /", the package manager will try to
- * install a package literally named "lodash; rm -rf /" (which doesn't exist),
- * rather than executing the malicious command.
- *
- * This approach is secure even when shell: true is used on Windows for .cmd
- * file resolution, because Node.js properly escapes each array element.
- */
-import type { SpawnOptions } from './spawn';
-export interface PnpmOptions extends SpawnOptions {
-    allowLockfileUpdate?: boolean;
-}
-export interface ExecScriptOptions extends SpawnOptions {
-    prepost?: boolean | undefined;
-}
-/**
- * Execute npm commands with optimized flags and settings.
- *
- * SECURITY: Uses array-based arguments to prevent command injection. All elements
- * in the args array are properly escaped by Node.js when passed to spawn().
- *
- * @example
- * ```typescript
- * await execNpm(['install', '--save', 'lodash'])
- * await execNpm(['run', 'build'], { cwd: '/tmp/project' })
- * ```
- */
-export declare function execNpm(args: string[], options?: SpawnOptions | undefined): import("./spawn").PromiseSpawnResult;
-/**
- * Execute pnpm commands with optimized flags and settings.
- *
- * SECURITY: Uses array-based arguments to prevent command injection. All elements
- * in the args array are properly escaped by Node.js when passed to execBin().
- *
- * @example
- * ```typescript
- * await execPnpm(['install'])
- * await execPnpm(['add', 'lodash'], { allowLockfileUpdate: true })
- * ```
- */
-export declare function execPnpm(args: string[], options?: PnpmOptions | undefined): Promise<{
-    cmd: string;
-    args: string[] | readonly string[];
-    code: number;
-    signal: NodeJS.Signals | null;
-    stdout: string | Buffer;
-    stderr: string | Buffer;
-}>;
-/**
- * Execute a package.json script using the detected package manager.
- * Picks pnpm, npm, or yarn by walking up to the nearest lockfile; falls back
- * to running `node --run` or `npm run` directly when no lockfile is found.
- * Honors `shell: true` by passing through to `spawn()` unchanged.
- *
- * @param scriptName - The package.json script to run
- * @param args - Either the script arguments or an options object
- * @param options - Spawn options plus `prepost` to force npm-style pre/post scripts
- * @returns The spawned `ChildProcess`-like promise from the underlying runner.
- */
-export declare function execScript(scriptName: string, args?: string[] | readonly string[] | ExecScriptOptions | undefined, options?: ExecScriptOptions | undefined): Promise<{
-    cmd: string;
-    args: string[] | readonly string[];
-    code: number;
-    signal: NodeJS.Signals | null;
-    stdout: string | Buffer;
-    stderr: string | Buffer;
-}>;
-/**
- * Execute yarn commands with optimized flags and settings.
- *
- * SECURITY: Uses array-based arguments to prevent command injection. All elements
- * in the args array are properly escaped by Node.js when passed to execBin().
- *
- * @example
- * ```typescript
- * await execYarn(['install'])
- * await execYarn(['add', 'lodash'], { cwd: '/tmp/project' })
- * ```
- */
-export declare function execYarn(args: string[], options?: import('./spawn').SpawnOptions): Promise<{
-    cmd: string;
-    args: string[] | readonly string[];
-    code: number;
-    signal: NodeJS.Signals | null;
-    stdout: string | Buffer;
-    stderr: string | Buffer;
-}>;
-/**
- * Check if a command argument is an npm audit flag.
- *
- * @example
- * ```typescript
- * isNpmAuditFlag('--no-audit')  // true
- * isNpmAuditFlag('--audit')     // true
- * isNpmAuditFlag('--save')      // false
- * ```
- */
-export declare function isNpmAuditFlag(cmdArg: string): boolean;
-/**
- * Check if a command argument is an npm fund flag.
- *
- * @example
- * ```typescript
- * isNpmFundFlag('--no-fund')  // true
- * isNpmFundFlag('--fund')     // true
- * isNpmFundFlag('--save')     // false
- * ```
- */
-export declare function isNpmFundFlag(cmdArg: string): boolean;
-/**
- * Check if a command argument is an npm loglevel flag.
- *
- * @example
- * ```typescript
- * isNpmLoglevelFlag('--loglevel')  // true
- * isNpmLoglevelFlag('--silent')    // true
- * isNpmLoglevelFlag('-s')          // true
- * isNpmLoglevelFlag('--save')      // false
- * ```
- */
-export declare function isNpmLoglevelFlag(cmdArg: string): boolean;
-/**
- * Check if a command argument is an npm node-options flag.
- *
- * @example
- * ```typescript
- * isNpmNodeOptionsFlag('--node-options')                            // true
- * isNpmNodeOptionsFlag('--node-options=--max-old-space-size=4096')  // true
- * isNpmNodeOptionsFlag('--save')                                   // false
- * ```
- */
-export declare function isNpmNodeOptionsFlag(cmdArg: string): boolean;
-/**
- * Check if a command argument is an npm progress flag.
- *
- * @example
- * ```typescript
- * isNpmProgressFlag('--no-progress')  // true
- * isNpmProgressFlag('--progress')     // true
- * isNpmProgressFlag('--save')         // false
- * ```
- */
-export declare function isNpmProgressFlag(cmdArg: string): boolean;
-/**
- * Check if a command argument is a pnpm frozen-lockfile flag.
- *
- * @example
- * ```typescript
- * isPnpmFrozenLockfileFlag('--frozen-lockfile')     // true
- * isPnpmFrozenLockfileFlag('--no-frozen-lockfile')  // true
- * isPnpmFrozenLockfileFlag('--save')                // false
- * ```
- */
-export declare function isPnpmFrozenLockfileFlag(cmdArg: string): boolean;
-/**
- * Check if a command argument is a pnpm ignore-scripts flag.
- *
- * @example
- * ```typescript
- * isPnpmIgnoreScriptsFlag('--ignore-scripts')     // true
- * isPnpmIgnoreScriptsFlag('--no-ignore-scripts')  // true
- * isPnpmIgnoreScriptsFlag('--save')               // false
- * ```
- */
-export declare function isPnpmIgnoreScriptsFlag(cmdArg: string): boolean;
-/**
- * Check if a command argument is a pnpm install command.
- *
- * @example
- * ```typescript
- * isPnpmInstallCommand('install')  // true
- * isPnpmInstallCommand('i')        // true
- * isPnpmInstallCommand('run')      // false
- * ```
- */
-export declare function isPnpmInstallCommand(cmdArg: string): boolean;
-/**
- * Alias for isNpmLoglevelFlag — pnpm uses the same `--loglevel` surface.
- */
-export declare const isPnpmLoglevelFlag: typeof isNpmLoglevelFlag;

package/dist/agent.js

@@ -1,287 +0,0 @@
-"use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-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 agent_exports = {};
-__export(agent_exports, {
-  execNpm: () => execNpm,
-  execPnpm: () => execPnpm,
-  execScript: () => execScript,
-  execYarn: () => execYarn,
-  isNpmAuditFlag: () => isNpmAuditFlag,
-  isNpmFundFlag: () => isNpmFundFlag,
-  isNpmLoglevelFlag: () => isNpmLoglevelFlag,
-  isNpmNodeOptionsFlag: () => isNpmNodeOptionsFlag,
-  isNpmProgressFlag: () => isNpmProgressFlag,
-  isPnpmFrozenLockfileFlag: () => isPnpmFrozenLockfileFlag,
-  isPnpmIgnoreScriptsFlag: () => isPnpmIgnoreScriptsFlag,
-  isPnpmInstallCommand: () => isPnpmInstallCommand,
-  isPnpmLoglevelFlag: () => isPnpmLoglevelFlag
-});
-module.exports = __toCommonJS(agent_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_bin = require("./bin");
-var import_agents = require("./constants/agents");
-var import_node = require("./constants/node");
-var import_platform = require("./constants/platform");
-var import_debug = require("./debug");
-var import_ci = require("./env/ci");
-var import_fs = require("./fs");
-var import_objects = require("./objects");
-var import_spawn = require("./spawn");
-var import_primordials = require("./primordials");
-const pnpmIgnoreScriptsFlags = new import_primordials.SetCtor([
-  "--ignore-scripts",
-  "--no-ignore-scripts"
-]);
-const pnpmFrozenLockfileFlags = new import_primordials.SetCtor([
-  "--frozen-lockfile",
-  "--no-frozen-lockfile"
-]);
-const pnpmInstallCommands = new import_primordials.SetCtor(["install", "i"]);
-const pnpmInstallLikeCommands = new import_primordials.SetCtor([
-  "install",
-  "i",
-  "add",
-  "update",
-  "up",
-  "remove",
-  "rm",
-  "link",
-  "ln",
-  "unlink",
-  "import",
-  "rebuild",
-  "rb"
-]);
-const yarnInstallLikeCommands = new import_primordials.SetCtor([
-  "install",
-  "add",
-  "upgrade",
-  "remove",
-  "link",
-  "unlink",
-  "import"
-]);
-function execNpm(args, options) {
-  const useDebug = (0, import_debug.isDebug)();
-  const terminatorPos = (0, import_primordials.ArrayPrototypeIndexOf)(args, "--");
-  const npmArgs = (terminatorPos === -1 ? args : (0, import_primordials.ArrayPrototypeSlice)(args, 0, terminatorPos)).filter(
-    (a) => !/* @__PURE__ */ isNpmAuditFlag(a) && !/* @__PURE__ */ isNpmFundFlag(a) && !/* @__PURE__ */ isNpmProgressFlag(a)
-  );
-  const otherArgs = terminatorPos === -1 ? [] : (0, import_primordials.ArrayPrototypeSlice)(args, terminatorPos);
-  const logLevelArgs = (
-    // The default value of loglevel is "notice". We default to "warn" which is
-    // one level quieter.
-    useDebug || npmArgs.some(isNpmLoglevelFlag) ? [] : ["--loglevel", "warn"]
-  );
-  const npmBin = import_agents.NPM_BIN_PATH;
-  return (0, import_spawn.spawn)(
-    npmBin,
-    [
-      // Even though '--loglevel=error' is passed npm will still run through
-      // code paths for 'audit' and 'fund' unless '--no-audit' and '--no-fund'
-      // flags are passed.
-      "--no-audit",
-      "--no-fund",
-      // Add `--no-progress` and `--silent` flags to fix input being swallowed
-      // by the spinner when running the command with recent versions of npm.
-      "--no-progress",
-      // Add '--loglevel=error' if a loglevel flag is not provided and the
-      // SOCKET_DEBUG environment variable is not truthy.
-      ...logLevelArgs,
-      ...npmArgs,
-      ...otherArgs
-    ],
-    {
-      __proto__: null,
-      // On Windows, npm is a .cmd file that requires shell to execute.
-      shell: import_platform.WIN32,
-      ...options
-    }
-  );
-}
-function execPnpm(args, options) {
-  const { allowLockfileUpdate, ...extBinOpts } = {
-    __proto__: null,
-    ...options
-  };
-  const useDebug = (0, import_debug.isDebug)();
-  const terminatorPos = (0, import_primordials.ArrayPrototypeIndexOf)(args, "--");
-  const pnpmArgs = (terminatorPos === -1 ? args : (0, import_primordials.ArrayPrototypeSlice)(args, 0, terminatorPos)).filter((a) => !/* @__PURE__ */ isNpmProgressFlag(a));
-  const otherArgs = terminatorPos === -1 ? [] : (0, import_primordials.ArrayPrototypeSlice)(args, terminatorPos);
-  const firstArg = pnpmArgs[0];
-  const supportsIgnoreScripts = firstArg ? pnpmInstallLikeCommands.has(firstArg) : false;
-  const logLevelArgs = useDebug || pnpmArgs.some(isPnpmLoglevelFlag) ? [] : ["--loglevel", "warn"];
-  const hasIgnoreScriptsFlag = pnpmArgs.some(isPnpmIgnoreScriptsFlag);
-  const ignoreScriptsArgs = !supportsIgnoreScripts || hasIgnoreScriptsFlag ? [] : ["--ignore-scripts"];
-  const frozenLockfileArgs = [];
-  if ((0, import_ci.getCI)() && allowLockfileUpdate && firstArg && /* @__PURE__ */ isPnpmInstallCommand(firstArg) && !pnpmArgs.some(isPnpmFrozenLockfileFlag)) {
-    frozenLockfileArgs.push("--no-frozen-lockfile");
-  }
-  return (0, import_bin.execBin)(
-    "pnpm",
-    [
-      // Add '--loglevel=warn' if a loglevel flag is not provided and debug is off.
-      ...logLevelArgs,
-      // Add '--ignore-scripts' by default for security (only for installation commands).
-      ...ignoreScriptsArgs,
-      // Add '--no-frozen-lockfile' in CI when lockfile updates are needed.
-      ...frozenLockfileArgs,
-      ...pnpmArgs,
-      ...otherArgs
-    ],
-    extBinOpts
-  );
-}
-function execScript(scriptName, args, options) {
-  let resolvedOptions;
-  let resolvedArgs;
-  if (!(0, import_primordials.ArrayIsArray)(args) && args !== null && typeof args === "object") {
-    resolvedOptions = args;
-    resolvedArgs = [];
-  } else {
-    resolvedOptions = options;
-    resolvedArgs = args || [];
-  }
-  const { prepost, ...spawnOptions } = {
-    __proto__: null,
-    ...resolvedOptions
-  };
-  if (spawnOptions.shell === true) {
-    return (0, import_spawn.spawn)(scriptName, resolvedArgs, spawnOptions);
-  }
-  const useNodeRun = !prepost && (0, import_node.supportsNodeRun)();
-  const cwd = (0, import_objects.getOwn)(spawnOptions, "cwd") ?? import_node_process.default.cwd();
-  const pnpmLockPath = (0, import_fs.findUpSync)(import_agents.PNPM_LOCK_YAML, { cwd });
-  if (pnpmLockPath) {
-    return execPnpm(["run", scriptName, ...resolvedArgs], spawnOptions);
-  }
-  const packageLockPath = (0, import_fs.findUpSync)(import_agents.PACKAGE_LOCK_JSON, { cwd });
-  if (packageLockPath) {
-    return execNpm(["run", scriptName, ...resolvedArgs], spawnOptions);
-  }
-  const yarnLockPath = (0, import_fs.findUpSync)(import_agents.YARN_LOCK, { cwd });
-  if (yarnLockPath) {
-    return execYarn(["run", scriptName, ...resolvedArgs], spawnOptions);
-  }
-  return (0, import_spawn.spawn)(
-    (0, import_node.getExecPath)(),
-    [
-      ...(0, import_node.getNodeNoWarningsFlags)(),
-      ...useNodeRun ? ["--run"] : [import_agents.NPM_REAL_EXEC_PATH, "run"],
-      scriptName,
-      ...resolvedArgs
-    ],
-    {
-      ...spawnOptions
-    }
-  );
-}
-function execYarn(args, options) {
-  const useDebug = (0, import_debug.isDebug)();
-  const terminatorPos = (0, import_primordials.ArrayPrototypeIndexOf)(args, "--");
-  const yarnArgs = (terminatorPos === -1 ? args : (0, import_primordials.ArrayPrototypeSlice)(args, 0, terminatorPos)).filter((a) => !/* @__PURE__ */ isNpmProgressFlag(a));
-  const otherArgs = terminatorPos === -1 ? [] : (0, import_primordials.ArrayPrototypeSlice)(args, terminatorPos);
-  const firstArg = yarnArgs[0];
-  const supportsIgnoreScripts = firstArg ? yarnInstallLikeCommands.has(firstArg) : false;
-  const logLevelArgs = useDebug || yarnArgs.some(isNpmLoglevelFlag) ? [] : ["--silent"];
-  const hasIgnoreScriptsFlag = yarnArgs.some(isPnpmIgnoreScriptsFlag);
-  const ignoreScriptsArgs = !supportsIgnoreScripts || hasIgnoreScriptsFlag ? [] : ["--ignore-scripts"];
-  return (0, import_bin.execBin)(
-    "yarn",
-    [
-      // Add '--silent' if a loglevel flag is not provided and debug is off.
-      ...logLevelArgs,
-      // Add '--ignore-scripts' by default for security (only for installation commands).
-      ...ignoreScriptsArgs,
-      ...yarnArgs,
-      ...otherArgs
-    ],
-    {
-      __proto__: null,
-      ...options
-    }
-  );
-}
-// @__NO_SIDE_EFFECTS__
-function isNpmAuditFlag(cmdArg) {
-  return /^--(no-)?audit(=.*)?$/.test(cmdArg);
-}
-// @__NO_SIDE_EFFECTS__
-function isNpmFundFlag(cmdArg) {
-  return /^--(no-)?fund(=.*)?$/.test(cmdArg);
-}
-// @__NO_SIDE_EFFECTS__
-function isNpmLoglevelFlag(cmdArg) {
-  if (/^--loglevel(=.*)?$/.test(cmdArg)) {
-    return true;
-  }
-  if (/^--(silent|verbose|info|warn|error|quiet)$/.test(cmdArg)) {
-    return true;
-  }
-  return /^-(s|q|d|dd|ddd|v)$/.test(cmdArg);
-}
-// @__NO_SIDE_EFFECTS__
-function isNpmNodeOptionsFlag(cmdArg) {
-  return /^--node-options(=.*)?$/.test(cmdArg);
-}
-// @__NO_SIDE_EFFECTS__
-function isNpmProgressFlag(cmdArg) {
-  return /^--(no-)?progress(=.*)?$/.test(cmdArg);
-}
-// @__NO_SIDE_EFFECTS__
-function isPnpmFrozenLockfileFlag(cmdArg) {
-  return pnpmFrozenLockfileFlags.has(cmdArg);
-}
-// @__NO_SIDE_EFFECTS__
-function isPnpmIgnoreScriptsFlag(cmdArg) {
-  return pnpmIgnoreScriptsFlags.has(cmdArg);
-}
-// @__NO_SIDE_EFFECTS__
-function isPnpmInstallCommand(cmdArg) {
-  return pnpmInstallCommands.has(cmdArg);
-}
-const isPnpmLoglevelFlag = isNpmLoglevelFlag;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  execNpm,
-  execPnpm,
-  execScript,
-  execYarn,
-  isNpmAuditFlag,
-  isNpmFundFlag,
-  isNpmLoglevelFlag,
-  isNpmNodeOptionsFlag,
-  isNpmProgressFlag,
-  isPnpmFrozenLockfileFlag,
-  isPnpmIgnoreScriptsFlag,
-  isPnpmInstallCommand,
-  isPnpmLoglevelFlag
-});

package/dist/ansi.d.ts

@@ -1,39 +0,0 @@
-/**
- * @fileoverview ANSI escape code utilities.
- * Provides constants and helpers for terminal formatting.
- */
-export declare const ANSI_BOLD = "\u001B[1m";
-export declare const ANSI_DIM = "\u001B[2m";
-export declare const ANSI_ITALIC = "\u001B[3m";
-export declare const ANSI_RESET = "\u001B[0m";
-export declare const ANSI_STRIKETHROUGH = "\u001B[9m";
-export declare const ANSI_UNDERLINE = "\u001B[4m";
-/**
- * Create a regular expression for matching ANSI escape codes.
- *
- * Inlined ansi-regex:
- * https://socket.dev/npm/package/ansi-regexp/overview/6.2.2
- * MIT License
- * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
- *
- * @example
- * ```typescript
- * const regex = ansiRegex()
- * '\u001b[31mHello\u001b[0m'.match(regex)  // ['\u001b[31m', '\u001b[0m']
- * ansiRegex({ onlyFirst: true })           // matches only the first code
- * ```
- */
-export declare function ansiRegex(options?: {
-    onlyFirst?: boolean;
-}): RegExp;
-/**
- * Strip ANSI escape codes from text.
- * Uses the inlined ansi-regex for matching.
- *
- * @example
- * ```typescript
- * stripAnsi('\u001b[31mError\u001b[0m')  // 'Error'
- * stripAnsi('\u001b[1mBold\u001b[0m')    // 'Bold'
- * ```
- */
-export declare function stripAnsi(text: string): string;

package/dist/archives.d.ts

@@ -1,95 +0,0 @@
-/**
- * @fileoverview Generic archive extraction utilities.
- * Supports zip, tar, tar.gz, and tgz formats.
- */
-/**
- * Archive format type.
- */
-export type ArchiveFormat = 'tar' | 'tar.gz' | 'tgz' | 'zip';
-/**
- * Options for archive extraction.
- */
-export interface ExtractOptions {
-    /** Suppress log messages */
-    quiet?: boolean | undefined;
-    /** Strip leading path components (like tar --strip-components) */
-    strip?: number | undefined;
-    /** Maximum number of entries to extract (default: 100,000) */
-    maxEntries?: number | undefined;
-    /** Maximum size of a single extracted file in bytes (default: 100MB) */
-    maxFileSize?: number | undefined;
-    /** Maximum total extracted size in bytes (default: 1GB) */
-    maxTotalSize?: number | undefined;
-}
-/**
- * Detect archive format from file path.
- *
- * @param filePath - Path to archive file
- * @returns Archive format or null if unknown
- *
- * @example
- * ```typescript
- * detectArchiveFormat('package.tar.gz')  // 'tar.gz'
- * detectArchiveFormat('archive.zip')     // 'zip'
- * detectArchiveFormat('data.csv')        // null
- * ```
- */
-export declare function detectArchiveFormat(filePath: string): ArchiveFormat | null;
-/**
- * Extract an archive to a directory.
- * Automatically detects format from file extension.
- *
- * @param archivePath - Path to archive file
- * @param outputDir - Directory to extract to
- * @param options - Extraction options
- * @throws Error if archive format is not supported
- *
- * @example
- * ```typescript
- * await extractArchive('/tmp/package.tar.gz', '/tmp/output')
- * await extractArchive('/tmp/release.zip', '/tmp/output', { strip: 1 })
- * ```
- */
-export declare function extractArchive(archivePath: string, outputDir: string, options?: ExtractOptions): Promise<void>;
-/**
- * Extract a tar archive to a directory.
- *
- * @param archivePath - Path to tar file
- * @param outputDir - Directory to extract to
- * @param options - Extraction options
- *
- * @example
- * ```typescript
- * await extractTar('/tmp/archive.tar', '/tmp/output')
- * await extractTar('/tmp/archive.tar', '/tmp/output', { strip: 1 })
- * ```
- */
-export declare function extractTar(archivePath: string, outputDir: string, options?: ExtractOptions): Promise<void>;
-/**
- * Extract a gzipped tar archive to a directory.
- *
- * @param archivePath - Path to tar.gz or tgz file
- * @param outputDir - Directory to extract to
- * @param options - Extraction options
- *
- * @example
- * ```typescript
- * await extractTarGz('/tmp/archive.tar.gz', '/tmp/output')
- * await extractTarGz('/tmp/archive.tgz', '/tmp/output', { strip: 1 })
- * ```
- */
-export declare function extractTarGz(archivePath: string, outputDir: string, options?: ExtractOptions): Promise<void>;
-/**
- * Extract a zip archive to a directory.
- *
- * @param archivePath - Path to zip file
- * @param outputDir - Directory to extract to
- * @param options - Extraction options
- *
- * @example
- * ```typescript
- * await extractZip('/tmp/archive.zip', '/tmp/output')
- * await extractZip('/tmp/archive.zip', '/tmp/output', { strip: 1 })
- * ```
- */
-export declare function extractZip(archivePath: string, outputDir: string, options?: ExtractOptions): Promise<void>;