@socketsecurity/lib 0.0.0 → 1.0.0

package/dist/github.d.ts

@@ -0,0 +1,121 @@
+import type { SpawnOptions } from './spawn';
+export interface GitHubFetchOptions {
+    token?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}
+export interface GitHubRateLimitError extends Error {
+    status: number;
+    resetTime?: Date | undefined;
+}
+/**
+ * Get GitHub token from environment variables.
+ */
+export declare function getGitHubToken(): string | undefined;
+/**
+ * Fetch data from GitHub API with rate limit handling.
+ */
+export declare function fetchGitHub<T = unknown>(url: string, options?: GitHubFetchOptions | undefined): Promise<T>;
+export interface GitHubRef {
+    object: {
+        sha: string;
+        type: string;
+        url: string;
+    };
+    ref: string;
+    url: string;
+}
+export interface GitHubTag {
+    message: string;
+    object: {
+        sha: string;
+        type: string;
+        url: string;
+    };
+    sha: string;
+    tag: string;
+    tagger?: {
+        date: string;
+        email: string;
+        name: string;
+    };
+    url: string;
+}
+export interface GitHubCommit {
+    sha: string;
+    url: string;
+    commit: {
+        message: string;
+        author: {
+            date: string;
+            email: string;
+            name: string;
+        };
+    };
+}
+export interface ResolveRefOptions {
+    token?: string | undefined;
+}
+/**
+ * Resolve a git ref (tag, branch, or commit SHA) to its full commit SHA.
+ * Results are cached in-memory and on disk (with TTL) to minimize API calls.
+ */
+export declare function resolveRefToSha(owner: string, repo: string, ref: string, options?: ResolveRefOptions | undefined): Promise<string>;
+/**
+ * Clear the ref resolution cache (in-memory only).
+ */
+export declare function clearRefCache(): Promise<void>;
+/**
+ * Get GitHub token from git config if not in environment.
+ * Falls back to checking git config for github.token.
+ */
+export declare function getGitHubTokenFromGitConfig(options?: SpawnOptions): Promise<string | undefined>;
+/**
+ * Get GitHub token from all available sources.
+ * Checks environment variables first, then git config.
+ */
+export declare function getGitHubTokenWithFallback(): Promise<string | undefined>;
+// GHSA (GitHub Security Advisory) types and utilities.
+export interface GhsaDetails {
+    ghsaId: string;
+    summary: string;
+    details: string;
+    severity: string;
+    aliases: string[];
+    publishedAt: string;
+    updatedAt: string;
+    withdrawnAt: string | null;
+    references: Array<{
+        url: string;
+    }>;
+    vulnerabilities: Array<{
+        package: {
+            ecosystem: string;
+            name: string;
+        };
+        vulnerableVersionRange: string;
+        firstPatchedVersion: {
+            identifier: string;
+        } | null;
+    }>;
+    cvss: {
+        score: number;
+        vectorString: string;
+    } | null;
+    cwes: Array<{
+        cweId: string;
+        name: string;
+        description: string;
+    }>;
+}
+/**
+ * Generate GitHub Security Advisory URL from GHSA ID.
+ */
+export declare function getGhsaUrl(ghsaId: string): string;
+/**
+ * Fetch GitHub Security Advisory details.
+ */
+export declare function fetchGhsaDetails(ghsaId: string, options?: GitHubFetchOptions): Promise<GhsaDetails>;
+/**
+ * Cached fetch for GHSA details.
+ */
+export declare function cacheFetchGhsa(ghsaId: string, options?: GitHubFetchOptions): Promise<GhsaDetails>;

package/dist/github.js

@@ -0,0 +1,203 @@
+/* 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 github_exports = {};
+__export(github_exports, {
+  cacheFetchGhsa: () => cacheFetchGhsa,
+  clearRefCache: () => clearRefCache,
+  fetchGhsaDetails: () => fetchGhsaDetails,
+  fetchGitHub: () => fetchGitHub,
+  getGhsaUrl: () => getGhsaUrl,
+  getGitHubToken: () => getGitHubToken,
+  getGitHubTokenFromGitConfig: () => getGitHubTokenFromGitConfig,
+  getGitHubTokenWithFallback: () => getGitHubTokenWithFallback,
+  resolveRefToSha: () => resolveRefToSha
+});
+module.exports = __toCommonJS(github_exports);
+var import_cache_with_ttl = require("./cache-with-ttl");
+var import_http_request = require("./http-request");
+var import_spawn = require("./spawn");
+const GITHUB_API_BASE_URL = "https://api.github.com";
+const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
+let _githubCache;
+function getGithubCache() {
+  if (_githubCache === void 0) {
+    _githubCache = (0, import_cache_with_ttl.createTtlCache)({
+      memoize: true,
+      prefix: "github-refs",
+      ttl: DEFAULT_CACHE_TTL_MS
+    });
+  }
+  return _githubCache;
+}
+function getGitHubToken() {
+  const { env } = process;
+  return env["GITHUB_TOKEN"] || env["GH_TOKEN"] || env["SOCKET_CLI_GITHUB_TOKEN"] || void 0;
+}
+async function fetchGitHub(url, options) {
+  const opts = { __proto__: null, ...options };
+  const token = opts.token || getGitHubToken();
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "socket-registry-github-client",
+    ...opts.headers
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const response = await (0, import_http_request.httpRequest)(url, { headers });
+  if (!response.ok) {
+    if (response.status === 403) {
+      const rateLimit = response.headers["x-ratelimit-remaining"];
+      const rateLimitStr = typeof rateLimit === "string" ? rateLimit : rateLimit?.[0];
+      if (rateLimitStr === "0") {
+        const resetTime = response.headers["x-ratelimit-reset"];
+        const resetTimeStr = typeof resetTime === "string" ? resetTime : resetTime?.[0];
+        const resetDate = resetTimeStr ? new Date(Number(resetTimeStr) * 1e3) : void 0;
+        const error = new Error(
+          `GitHub API rate limit exceeded${resetDate ? `. Resets at ${resetDate.toLocaleString()}` : ""}. Use GITHUB_TOKEN environment variable to increase rate limit.`
+        );
+        error.status = 403;
+        error.resetTime = resetDate;
+        throw error;
+      }
+    }
+    throw new Error(
+      `GitHub API error ${response.status}: ${response.statusText}`
+    );
+  }
+  return JSON.parse(response.body.toString("utf8"));
+}
+async function resolveRefToSha(owner, repo, ref, options) {
+  const opts = {
+    __proto__: null,
+    ...options
+  };
+  const cacheKey = `${owner}/${repo}@${ref}`;
+  if (process.env["DISABLE_GITHUB_CACHE"]) {
+    return await fetchRefSha(owner, repo, ref, opts);
+  }
+  const cache = getGithubCache();
+  return await cache.getOrFetch(cacheKey, async () => {
+    return await fetchRefSha(owner, repo, ref, opts);
+  });
+}
+async function fetchRefSha(owner, repo, ref, options) {
+  const fetchOptions = {
+    token: options.token
+  };
+  try {
+    const tagUrl = `${GITHUB_API_BASE_URL}/repos/${owner}/${repo}/git/refs/tags/${ref}`;
+    const tagData = await fetchGitHub(tagUrl, fetchOptions);
+    if (tagData.object.type === "tag") {
+      const tagObject = await fetchGitHub(
+        tagData.object.url,
+        fetchOptions
+      );
+      return tagObject.object.sha;
+    }
+    return tagData.object.sha;
+  } catch {
+    try {
+      const branchUrl = `${GITHUB_API_BASE_URL}/repos/${owner}/${repo}/git/refs/heads/${ref}`;
+      const branchData = await fetchGitHub(branchUrl, fetchOptions);
+      return branchData.object.sha;
+    } catch {
+      try {
+        const commitUrl = `${GITHUB_API_BASE_URL}/repos/${owner}/${repo}/commits/${ref}`;
+        const commitData = await fetchGitHub(
+          commitUrl,
+          fetchOptions
+        );
+        return commitData.sha;
+      } catch (e) {
+        throw new Error(
+          `failed to resolve ref "${ref}" for ${owner}/${repo}: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+  }
+}
+async function clearRefCache() {
+  if (_githubCache) {
+    await _githubCache.clear({ memoOnly: true });
+  }
+}
+async function getGitHubTokenFromGitConfig(options) {
+  try {
+    const result = await (0, import_spawn.spawn)("git", ["config", "github.token"], {
+      ...options,
+      stdio: "pipe"
+    });
+    if (result.code === 0 && result.stdout) {
+      return result.stdout.toString().trim();
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function getGitHubTokenWithFallback() {
+  return getGitHubToken() || await getGitHubTokenFromGitConfig();
+}
+function getGhsaUrl(ghsaId) {
+  return `https://github.com/advisories/${ghsaId}`;
+}
+async function fetchGhsaDetails(ghsaId, options) {
+  const url = `https://api.github.com/advisories/${ghsaId}`;
+  const data = await fetchGitHub(url, options);
+  return {
+    ghsaId: data.ghsa_id,
+    summary: data.summary,
+    details: data.details,
+    severity: data.severity,
+    aliases: data.aliases || [],
+    publishedAt: data.published_at,
+    updatedAt: data.updated_at,
+    withdrawnAt: data.withdrawn_at,
+    references: data.references || [],
+    vulnerabilities: data.vulnerabilities || [],
+    cvss: data.cvss,
+    cwes: data.cwes || []
+  };
+}
+async function cacheFetchGhsa(ghsaId, options) {
+  const cache = getGithubCache();
+  const key = `ghsa:${ghsaId}`;
+  if (!process.env["DISABLE_GITHUB_CACHE"]) {
+    const cached = await cache.get(key);
+    if (cached) {
+      return JSON.parse(cached);
+    }
+  }
+  const data = await fetchGhsaDetails(ghsaId, options);
+  await cache.set(key, JSON.stringify(data));
+  return data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheFetchGhsa,
+  clearRefCache,
+  fetchGhsaDetails,
+  fetchGitHub,
+  getGhsaUrl,
+  getGitHubToken,
+  getGitHubTokenFromGitConfig,
+  getGitHubTokenWithFallback,
+  resolveRefToSha
+});
+//# sourceMappingURL=github.js.map

package/dist/github.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/github.ts"],
+  "sourcesContent": ["/**\n * @fileoverview GitHub utilities for Socket projects.\n * Provides GitHub API integration for repository operations.\n *\n * Authentication:\n * - getGitHubToken: Retrieve GitHub token from environment variables\n * - fetchGitHub: Authenticated GitHub API requests with rate limit handling\n *\n * Ref Resolution:\n * - resolveRefToSha: Convert tags/branches to commit SHAs (with memoization and persistent cache)\n * - clearRefCache: Clear the in-memory memoization cache\n *\n * Caching:\n * - Uses cacache for persistent storage with in-memory memoization\n * - Two-tier caching: in-memory (Map) for hot data, persistent (cacache) for durability\n * - Default TTL: 5 minutes\n * - Disable with DISABLE_GITHUB_CACHE env var\n *\n * Rate Limiting:\n * - Automatic rate limit detection and error messages\n * - Cache to minimize API calls\n */\n\nimport type { TtlCache } from './cache-with-ttl'\nimport { createTtlCache } from './cache-with-ttl'\nimport { httpRequest } from './http-request'\nimport type { SpawnOptions } from './spawn'\nimport { spawn } from './spawn'\n\n// GitHub API base URL constant (inlined for coverage mode compatibility).\nconst GITHUB_API_BASE_URL = 'https://api.github.com'\n\n// 5 minutes.\nconst DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000\n\n// Create TTL cache instance for GitHub ref resolution.\n// Uses cacache for persistent storage with in-memory memoization.\nlet _githubCache: TtlCache | undefined\n\n/**\n * Get or create the GitHub cache instance.\n */\nfunction getGithubCache(): TtlCache {\n  if (_githubCache === undefined) {\n    _githubCache = createTtlCache({\n      memoize: true,\n      prefix: 'github-refs',\n      ttl: DEFAULT_CACHE_TTL_MS,\n    })\n  }\n  return _githubCache\n}\n\nexport interface GitHubFetchOptions {\n  token?: string | undefined\n  headers?: Record<string, string> | undefined\n}\n\nexport interface GitHubRateLimitError extends Error {\n  status: number\n  resetTime?: Date | undefined\n}\n\n/**\n * Get GitHub token from environment variables.\n */\nexport function getGitHubToken(): string | undefined {\n  const { env } = process\n  return (\n    env['GITHUB_TOKEN'] ||\n    env['GH_TOKEN'] ||\n    env['SOCKET_CLI_GITHUB_TOKEN'] ||\n    undefined\n  )\n}\n\n/**\n * Fetch data from GitHub API with rate limit handling.\n */\nexport async function fetchGitHub<T = unknown>(\n  url: string,\n  options?: GitHubFetchOptions | undefined,\n): Promise<T> {\n  const opts = { __proto__: null, ...options } as GitHubFetchOptions\n  const token = opts.token || getGitHubToken()\n\n  const headers: Record<string, string> = {\n    Accept: 'application/vnd.github.v3+json',\n    'User-Agent': 'socket-registry-github-client',\n    ...opts.headers,\n  }\n\n  if (token) {\n    headers['Authorization'] = `Bearer ${token}`\n  }\n\n  const response = await httpRequest(url, { headers })\n\n  if (!response.ok) {\n    if (response.status === 403) {\n      const rateLimit = response.headers['x-ratelimit-remaining']\n      const rateLimitStr =\n        typeof rateLimit === 'string' ? rateLimit : rateLimit?.[0]\n      if (rateLimitStr === '0') {\n        const resetTime = response.headers['x-ratelimit-reset']\n        const resetTimeStr =\n          typeof resetTime === 'string' ? resetTime : resetTime?.[0]\n        const resetDate = resetTimeStr\n          ? new Date(Number(resetTimeStr) * 1000)\n          : undefined\n        const error = new Error(\n          `GitHub API rate limit exceeded${resetDate ? `. Resets at ${resetDate.toLocaleString()}` : ''}. Use GITHUB_TOKEN environment variable to increase rate limit.`,\n        ) as GitHubRateLimitError\n        error.status = 403\n        error.resetTime = resetDate\n        throw error\n      }\n    }\n    throw new Error(\n      `GitHub API error ${response.status}: ${response.statusText}`,\n    )\n  }\n\n  return JSON.parse(response.body.toString('utf8')) as T\n}\n\nexport interface GitHubRef {\n  object: {\n    sha: string\n    type: string\n    url: string\n  }\n  ref: string\n  url: string\n}\n\nexport interface GitHubTag {\n  message: string\n  object: {\n    sha: string\n    type: string\n    url: string\n  }\n  sha: string\n  tag: string\n  tagger?: {\n    date: string\n    email: string\n    name: string\n  }\n  url: string\n}\n\nexport interface GitHubCommit {\n  sha: string\n  url: string\n  commit: {\n    message: string\n    author: {\n      date: string\n      email: string\n      name: string\n    }\n  }\n}\n\nexport interface ResolveRefOptions {\n  token?: string | undefined\n}\n\n/**\n * Resolve a git ref (tag, branch, or commit SHA) to its full commit SHA.\n * Results are cached in-memory and on disk (with TTL) to minimize API calls.\n */\nexport async function resolveRefToSha(\n  owner: string,\n  repo: string,\n  ref: string,\n  options?: ResolveRefOptions | undefined,\n): Promise<string> {\n  const opts = {\n    __proto__: null,\n    ...options,\n  } as ResolveRefOptions\n\n  const cacheKey = `${owner}/${repo}@${ref}`\n\n  // Optionally disable cache.\n  if (process.env['DISABLE_GITHUB_CACHE']) {\n    return await fetchRefSha(owner, repo, ref, opts)\n  }\n\n  // Use TTL cache for persistent storage and in-memory memoization.\n  const cache = getGithubCache()\n  return await cache.getOrFetch(cacheKey, async () => {\n    return await fetchRefSha(owner, repo, ref, opts)\n  })\n}\n\n/**\n * Fetch the SHA for a git ref from GitHub API.\n */\nasync function fetchRefSha(\n  owner: string,\n  repo: string,\n  ref: string,\n  options: ResolveRefOptions,\n): Promise<string> {\n  const fetchOptions: GitHubFetchOptions = {\n    token: options.token,\n  }\n\n  try {\n    // Try as a tag first.\n    const tagUrl = `${GITHUB_API_BASE_URL}/repos/${owner}/${repo}/git/refs/tags/${ref}`\n    const tagData = await fetchGitHub<GitHubRef>(tagUrl, fetchOptions)\n\n    // Tag might point to a tag object or directly to a commit.\n    if (tagData.object.type === 'tag') {\n      // Dereference the tag object to get the commit.\n      const tagObject = await fetchGitHub<GitHubTag>(\n        tagData.object.url,\n        fetchOptions,\n      )\n      return tagObject.object.sha\n    }\n    return tagData.object.sha\n  } catch {\n    // Not a tag, try as a branch.\n    try {\n      const branchUrl = `${GITHUB_API_BASE_URL}/repos/${owner}/${repo}/git/refs/heads/${ref}`\n      const branchData = await fetchGitHub<GitHubRef>(branchUrl, fetchOptions)\n      return branchData.object.sha\n    } catch {\n      // Try without refs/ prefix (for commit SHAs or other refs).\n      try {\n        const commitUrl = `${GITHUB_API_BASE_URL}/repos/${owner}/${repo}/commits/${ref}`\n        const commitData = await fetchGitHub<GitHubCommit>(\n          commitUrl,\n          fetchOptions,\n        )\n        return commitData.sha\n      } catch (e) {\n        throw new Error(\n          `failed to resolve ref \"${ref}\" for ${owner}/${repo}: ${e instanceof Error ? e.message : String(e)}`,\n        )\n      }\n    }\n  }\n}\n\n/**\n * Clear the ref resolution cache (in-memory only).\n */\nexport async function clearRefCache(): Promise<void> {\n  if (_githubCache) {\n    await _githubCache.clear({ memoOnly: true })\n  }\n}\n\n/**\n * Get GitHub token from git config if not in environment.\n * Falls back to checking git config for github.token.\n */\nexport async function getGitHubTokenFromGitConfig(\n  options?: SpawnOptions,\n): Promise<string | undefined> {\n  try {\n    const result = await spawn('git', ['config', 'github.token'], {\n      ...options,\n      stdio: 'pipe',\n    })\n    if (result.code === 0 && result.stdout) {\n      return result.stdout.toString().trim()\n    }\n  } catch {\n    // Ignore errors - git config may not have token.\n  }\n  return undefined\n}\n\n/**\n * Get GitHub token from all available sources.\n * Checks environment variables first, then git config.\n */\nexport async function getGitHubTokenWithFallback(): Promise<\n  string | undefined\n> {\n  return getGitHubToken() || (await getGitHubTokenFromGitConfig())\n}\n\n// GHSA (GitHub Security Advisory) types and utilities.\nexport interface GhsaDetails {\n  ghsaId: string\n  summary: string\n  details: string\n  severity: string\n  aliases: string[]\n  publishedAt: string\n  updatedAt: string\n  withdrawnAt: string | null\n  references: Array<{ url: string }>\n  vulnerabilities: Array<{\n    package: {\n      ecosystem: string\n      name: string\n    }\n    vulnerableVersionRange: string\n    firstPatchedVersion: { identifier: string } | null\n  }>\n  cvss: {\n    score: number\n    vectorString: string\n  } | null\n  cwes: Array<{\n    cweId: string\n    name: string\n    description: string\n  }>\n}\n\n/**\n * Generate GitHub Security Advisory URL from GHSA ID.\n */\nexport function getGhsaUrl(ghsaId: string): string {\n  return `https://github.com/advisories/${ghsaId}`\n}\n\n/**\n * Fetch GitHub Security Advisory details.\n */\nexport async function fetchGhsaDetails(\n  ghsaId: string,\n  options?: GitHubFetchOptions,\n): Promise<GhsaDetails> {\n  const url = `https://api.github.com/advisories/${ghsaId}`\n  const data = await fetchGitHub<{\n    aliases?: string[]\n    cvss: unknown\n    cwes?: Array<{ cweId: string; name: string; description: string }>\n    details: string\n    ghsa_id: string\n    published_at: string\n    references?: Array<{ url: string }>\n    severity: string\n    summary: string\n    updated_at: string\n    vulnerabilities?: Array<{\n      package: { ecosystem: string; name: string }\n      vulnerableVersionRange: string\n      firstPatchedVersion: { identifier: string } | null\n    }>\n    withdrawn_at: string\n  }>(url, options)\n\n  return {\n    ghsaId: data.ghsa_id,\n    summary: data.summary,\n    details: data.details,\n    severity: data.severity,\n    aliases: data.aliases || [],\n    publishedAt: data.published_at,\n    updatedAt: data.updated_at,\n    withdrawnAt: data.withdrawn_at,\n    references: data.references || [],\n    vulnerabilities: data.vulnerabilities || [],\n    cvss: data.cvss as { score: number; vectorString: string } | null,\n    cwes: data.cwes || [],\n  }\n}\n\n/**\n * Cached fetch for GHSA details.\n */\nexport async function cacheFetchGhsa(\n  ghsaId: string,\n  options?: GitHubFetchOptions,\n): Promise<GhsaDetails> {\n  const cache = getGithubCache()\n  const key = `ghsa:${ghsaId}`\n\n  // Check cache first.\n  if (!process.env['DISABLE_GITHUB_CACHE']) {\n    const cached = await cache.get(key)\n    if (cached) {\n      return JSON.parse(cached as string) as GhsaDetails\n    }\n  }\n\n  // Fetch and cache.\n  const data = await fetchGhsaDetails(ghsaId, options)\n  await cache.set(key, JSON.stringify(data))\n  return data\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/globs.d.ts

@@ -0,0 +1,46 @@
+// Type definitions
+type Pattern = string;
+interface FastGlobOptions {
+    absolute?: boolean;
+    baseNameMatch?: boolean;
+    braceExpansion?: boolean;
+    caseSensitiveMatch?: boolean;
+    concurrency?: number;
+    cwd?: string;
+    deep?: number;
+    dot?: boolean;
+    extglob?: boolean;
+    followSymbolicLinks?: boolean;
+    fs?: unknown;
+    globstar?: boolean;
+    ignore?: string[];
+    ignoreFiles?: string[];
+    markDirectories?: boolean;
+    objectMode?: boolean;
+    onlyDirectories?: boolean;
+    onlyFiles?: boolean;
+    stats?: boolean;
+    suppressErrors?: boolean;
+    throwErrorOnBrokenSymbolicLink?: boolean;
+    unique?: boolean;
+}
+export interface GlobOptions extends FastGlobOptions {
+    ignoreOriginals?: boolean;
+    recursive?: boolean;
+}
+export type { Pattern, FastGlobOptions };
+export declare const defaultIgnore: readonly string[];
+/**
+ * Create a stream of license file paths matching glob patterns.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function globStreamLicenses(dirname: string, options?: GlobOptions): NodeJS.ReadableStream;
+/**
+ * Get a cached glob matcher function.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function getGlobMatcher(glob: Pattern | Pattern[], options?: {
+    dot?: boolean;
+    nocase?: boolean;
+    ignore?: string[];
+}): (path: string) => boolean;

package/dist/globs.js

@@ -0,0 +1,154 @@
+/* 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 globs_exports = {};
+__export(globs_exports, {
+  defaultIgnore: () => defaultIgnore,
+  getGlobMatcher: () => getGlobMatcher,
+  globStreamLicenses: () => globStreamLicenses
+});
+module.exports = __toCommonJS(globs_exports);
+var import_objects = require("./objects");
+const defaultIgnore = (0, import_objects.objectFreeze)([
+  // Most of these ignored files can be included specifically if included in the
+  // files globs. Exceptions to this are:
+  // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
+  // These can NOT be included.
+  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L280
+  "**/.git",
+  "**/.npmrc",
+  // '**/bun.lockb?',
+  "**/node_modules",
+  // '**/package-lock.json',
+  // '**/pnpm-lock.ya?ml',
+  // '**/yarn.lock',
+  // Include npm-packlist defaults:
+  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L15-L38
+  "**/.DS_Store",
+  "**/.gitignore",
+  "**/.hg",
+  "**/.lock-wscript",
+  "**/.npmignore",
+  "**/.svn",
+  "**/.wafpickle-*",
+  "**/.*.swp",
+  "**/._*/**",
+  "**/archived-packages/**",
+  "**/build/config.gypi",
+  "**/CVS",
+  "**/npm-debug.log",
+  "**/*.orig",
+  // Inline generic socket-registry .gitignore entries.
+  "**/.env",
+  "**/.eslintcache",
+  "**/.nvm",
+  "**/.tap",
+  "**/.vscode",
+  "**/*.tsbuildinfo",
+  "**/Thumbs.db",
+  // Inline additional ignores.
+  "**/bower_components"
+]);
+let _picomatch;
+// @__NO_SIDE_EFFECTS__
+function getPicomatch() {
+  if (_picomatch === void 0) {
+    _picomatch = require("../external/picomatch");
+  }
+  return _picomatch;
+}
+let _fastGlob;
+// @__NO_SIDE_EFFECTS__
+function getFastGlob() {
+  if (_fastGlob === void 0) {
+    const globExport = require("../external/fast-glob");
+    _fastGlob = globExport.default || globExport;
+  }
+  return _fastGlob;
+}
+// @__NO_SIDE_EFFECTS__
+function globStreamLicenses(dirname, options) {
+  const {
+    ignore: ignoreOpt,
+    ignoreOriginals,
+    recursive,
+    ...globOptions
+  } = { __proto__: null, ...options };
+  const ignore = [
+    ...Array.isArray(ignoreOpt) ? ignoreOpt : defaultIgnore,
+    "**/*.{cjs,cts,js,json,mjs,mts,ts}"
+  ];
+  if (ignoreOriginals) {
+    ignore.push(
+      /*@__INLINE__*/
+      require("../constants/paths").LICENSE_ORIGINAL_GLOB_RECURSIVE
+    );
+  }
+  const fastGlob = /* @__PURE__ */ getFastGlob();
+  return fastGlob.globStream(
+    [
+      recursive ? (
+        /*@__INLINE__*/
+        require("../constants/paths").LICENSE_GLOB_RECURSIVE
+      ) : (
+        /*@__INLINE__*/
+        require("../constants/paths").LICENSE_GLOB
+      )
+    ],
+    {
+      __proto__: null,
+      absolute: true,
+      caseSensitiveMatch: false,
+      cwd: dirname,
+      ...globOptions,
+      ...ignore ? { ignore } : {}
+    }
+  );
+}
+const matcherCache = /* @__PURE__ */ new Map();
+// @__NO_SIDE_EFFECTS__
+function getGlobMatcher(glob, options) {
+  const patterns = Array.isArray(glob) ? glob : [glob];
+  const key = JSON.stringify({ patterns, options });
+  let matcher = matcherCache.get(key);
+  if (matcher) {
+    return matcher;
+  }
+  const positivePatterns = patterns.filter((p) => !p.startsWith("!"));
+  const negativePatterns = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+  const picomatch = /* @__PURE__ */ getPicomatch();
+  const matchOptions = {
+    dot: true,
+    nocase: true,
+    ...options,
+    ...negativePatterns.length > 0 ? { ignore: negativePatterns } : {}
+  };
+  matcher = picomatch(
+    positivePatterns.length > 0 ? positivePatterns : patterns,
+    matchOptions
+  );
+  matcherCache.set(key, matcher);
+  return matcher;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultIgnore,
+  getGlobMatcher,
+  globStreamLicenses
+});
+//# sourceMappingURL=globs.js.map

package/dist/globs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/globs.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Glob pattern matching utilities with default ignore patterns.\n * Provides file filtering and glob matcher functions for npm-like behavior.\n */\n\n// IMPORTANT: Do not use destructuring here - use direct assignment instead.\nimport { objectFreeze as ObjectFreeze } from './objects'\n\n// Type definitions\ntype Pattern = string\n\ninterface FastGlobOptions {\n  absolute?: boolean\n  baseNameMatch?: boolean\n  braceExpansion?: boolean\n  caseSensitiveMatch?: boolean\n  concurrency?: number\n  cwd?: string\n  deep?: number\n  dot?: boolean\n  extglob?: boolean\n  followSymbolicLinks?: boolean\n  fs?: unknown\n  globstar?: boolean\n  ignore?: string[]\n  ignoreFiles?: string[]\n  markDirectories?: boolean\n  objectMode?: boolean\n  onlyDirectories?: boolean\n  onlyFiles?: boolean\n  stats?: boolean\n  suppressErrors?: boolean\n  throwErrorOnBrokenSymbolicLink?: boolean\n  unique?: boolean\n}\n\nexport interface GlobOptions extends FastGlobOptions {\n  ignoreOriginals?: boolean\n  recursive?: boolean\n}\n\nexport type { Pattern, FastGlobOptions }\n\nexport const defaultIgnore = ObjectFreeze([\n  // Most of these ignored files can be included specifically if included in the\n  // files globs. Exceptions to this are:\n  // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files\n  // These can NOT be included.\n  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L280\n  '**/.git',\n  '**/.npmrc',\n  // '**/bun.lockb?',\n  '**/node_modules',\n  // '**/package-lock.json',\n  // '**/pnpm-lock.ya?ml',\n  // '**/yarn.lock',\n  // Include npm-packlist defaults:\n  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L15-L38\n  '**/.DS_Store',\n  '**/.gitignore',\n  '**/.hg',\n  '**/.lock-wscript',\n  '**/.npmignore',\n  '**/.svn',\n  '**/.wafpickle-*',\n  '**/.*.swp',\n  '**/._*/**',\n  '**/archived-packages/**',\n  '**/build/config.gypi',\n  '**/CVS',\n  '**/npm-debug.log',\n  '**/*.orig',\n  // Inline generic socket-registry .gitignore entries.\n  '**/.env',\n  '**/.eslintcache',\n  '**/.nvm',\n  '**/.tap',\n  '**/.vscode',\n  '**/*.tsbuildinfo',\n  '**/Thumbs.db',\n  // Inline additional ignores.\n  '**/bower_components',\n])\n\nlet _picomatch: typeof import('picomatch') | undefined\n/**\n * Lazily load the picomatch module.\n * @private\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getPicomatch() {\n  if (_picomatch === undefined) {\n    // The 'picomatch' package is browser safe.\n    _picomatch = /*@__PURE__*/ require('../external/picomatch')\n  }\n  return _picomatch as typeof import('picomatch')\n}\n\nlet _fastGlob: typeof import('fast-glob') | undefined\n/**\n * Lazily load the fast-glob module.\n * @private\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getFastGlob() {\n  if (_fastGlob === undefined) {\n    const globExport = /*@__PURE__*/ require('../external/fast-glob')\n    _fastGlob = globExport.default || globExport\n  }\n  return _fastGlob as typeof import('fast-glob')\n}\n\n/**\n * Create a stream of license file paths matching glob patterns.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function globStreamLicenses(\n  dirname: string,\n  options?: GlobOptions,\n): NodeJS.ReadableStream {\n  const {\n    ignore: ignoreOpt,\n    ignoreOriginals,\n    recursive,\n    ...globOptions\n  } = { __proto__: null, ...options } as GlobOptions\n  const ignore = [\n    ...(Array.isArray(ignoreOpt) ? ignoreOpt : defaultIgnore),\n    '**/*.{cjs,cts,js,json,mjs,mts,ts}',\n  ]\n  if (ignoreOriginals) {\n    ignore.push(\n      /*@__INLINE__*/ require('../constants/paths')\n        .LICENSE_ORIGINAL_GLOB_RECURSIVE,\n    )\n  }\n  const fastGlob = getFastGlob()\n  return fastGlob.globStream(\n    [\n      recursive\n        ? /*@__INLINE__*/ require('../constants/paths').LICENSE_GLOB_RECURSIVE\n        : /*@__INLINE__*/ require('../constants/paths').LICENSE_GLOB,\n    ],\n    {\n      __proto__: null,\n      absolute: true,\n      caseSensitiveMatch: false,\n      cwd: dirname,\n      ...globOptions,\n      ...(ignore ? { ignore } : {}),\n    } as import('fast-glob').Options,\n  )\n}\n\nconst matcherCache = new Map()\n/**\n * Get a cached glob matcher function.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function getGlobMatcher(\n  glob: Pattern | Pattern[],\n  options?: { dot?: boolean; nocase?: boolean; ignore?: string[] },\n): (path: string) => boolean {\n  const patterns = Array.isArray(glob) ? glob : [glob]\n  const key = JSON.stringify({ patterns, options })\n  let matcher = matcherCache.get(key)\n  if (matcher) {\n    return matcher\n  }\n\n  // Separate positive and negative patterns.\n  const positivePatterns = patterns.filter(p => !p.startsWith('!'))\n  const negativePatterns = patterns\n    .filter(p => p.startsWith('!'))\n    .map(p => p.slice(1))\n\n  const picomatch = getPicomatch()\n\n  // Use ignore option for negation patterns.\n  const matchOptions = {\n    dot: true,\n    nocase: true,\n    ...options,\n    ...(negativePatterns.length > 0 ? { ignore: negativePatterns } : {}),\n  }\n\n  matcher = picomatch(\n    positivePatterns.length > 0 ? positivePatterns : patterns,\n    matchOptions,\n  )\n\n  matcherCache.set(key, matcher)\n  return matcher\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA6C;AAqCtC,MAAM,oBAAgB,eAAAA,cAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMxC;AAAA,EACA;AAAA;AAAA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AACF,CAAC;AAED,IAAI;AAAA;AAMJ,SAAS,eAAe;AACtB,MAAI,eAAe,QAAW;AAE5B,iBAA2B,QAAQ,uBAAuB;AAAA,EAC5D;AACA,SAAO;AACT;AAEA,IAAI;AAAA;AAMJ,SAAS,cAAc;AACrB,MAAI,cAAc,QAAW;AAC3B,UAAM,aAA2B,QAAQ,uBAAuB;AAChE,gBAAY,WAAW,WAAW;AAAA,EACpC;AACA,SAAO;AACT;AAAA;AAMO,SAAS,mBACd,SACA,SACuB;AACvB,QAAM;AAAA,IACJ,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL,IAAI,EAAE,WAAW,MAAM,GAAG,QAAQ;AAClC,QAAM,SAAS;AAAA,IACb,GAAI,MAAM,QAAQ,SAAS,IAAI,YAAY;AAAA,IAC3C;AAAA,EACF;AACA,MAAI,iBAAiB;AACnB,WAAO;AAAA;AAAA,MACW,QAAQ,oBAAoB,EACzC;AAAA,IACL;AAAA,EACF;AACA,QAAM,WAAW,4BAAY;AAC7B,SAAO,SAAS;AAAA,IACd;AAAA,MACE;AAAA;AAAA,QACoB,QAAQ,oBAAoB,EAAE;AAAA;AAAA;AAAA,QAC9B,QAAQ,oBAAoB,EAAE;AAAA;AAAA,IACpD;AAAA,IACA;AAAA,MACE,WAAW;AAAA,MACX,UAAU;AAAA,MACV,oBAAoB;AAAA,MACpB,KAAK;AAAA,MACL,GAAG;AAAA,MACH,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;AAAA,IAC7B;AAAA,EACF;AACF;AAEA,MAAM,eAAe,oBAAI,IAAI;AAAA;AAKtB,SAAS,eACd,MACA,SAC2B;AAC3B,QAAM,WAAW,MAAM,QAAQ,IAAI,IAAI,OAAO,CAAC,IAAI;AACnD,QAAM,MAAM,KAAK,UAAU,EAAE,UAAU,QAAQ,CAAC;AAChD,MAAI,UAAU,aAAa,IAAI,GAAG;AAClC,MAAI,SAAS;AACX,WAAO;AAAA,EACT;AAGA,QAAM,mBAAmB,SAAS,OAAO,OAAK,CAAC,EAAE,WAAW,GAAG,CAAC;AAChE,QAAM,mBAAmB,SACtB,OAAO,OAAK,EAAE,WAAW,GAAG,CAAC,EAC7B,IAAI,OAAK,EAAE,MAAM,CAAC,CAAC;AAEtB,QAAM,YAAY,6BAAa;AAG/B,QAAM,eAAe;AAAA,IACnB,KAAK;AAAA,IACL,QAAQ;AAAA,IACR,GAAG;AAAA,IACH,GAAI,iBAAiB,SAAS,IAAI,EAAE,QAAQ,iBAAiB,IAAI,CAAC;AAAA,EACpE;AAEA,YAAU;AAAA,IACR,iBAAiB,SAAS,IAAI,mBAAmB;AAAA,IACjD;AAAA,EACF;AAEA,eAAa,IAAI,KAAK,OAAO;AAC7B,SAAO;AACT;",
+  "names": ["ObjectFreeze"]
+}

package/dist/http-request.d.ts

@@ -0,0 +1,53 @@
+export interface HttpRequestOptions {
+    body?: Buffer | string | undefined;
+    followRedirects?: boolean | undefined;
+    headers?: Record<string, string> | undefined;
+    maxRedirects?: number | undefined;
+    method?: string | undefined;
+    retries?: number | undefined;
+    retryDelay?: number | undefined;
+    timeout?: number | undefined;
+}
+export interface HttpResponse {
+    arrayBuffer(): ArrayBuffer;
+    body: Buffer;
+    headers: Record<string, string | string[] | undefined>;
+    json<T = unknown>(): T;
+    ok: boolean;
+    status: number;
+    statusText: string;
+    text(): string;
+}
+export interface HttpDownloadOptions {
+    headers?: Record<string, string> | undefined;
+    onProgress?: ((downloaded: number, total: number) => void) | undefined;
+    retries?: number | undefined;
+    retryDelay?: number | undefined;
+    timeout?: number | undefined;
+}
+export interface HttpDownloadResult {
+    path: string;
+    size: number;
+}
+/**
+ * Make an HTTP/HTTPS request with retry logic and redirect support.
+ * Provides a fetch-like API using Node.js native http/https modules.
+ * @throws {Error} When all retries are exhausted or non-retryable error occurs.
+ */
+export declare function httpRequest(url: string, options?: HttpRequestOptions | undefined): Promise<HttpResponse>;
+/**
+ * Download a file from a URL to a local path with retry logic and progress callbacks.
+ * Uses streaming to avoid loading entire file in memory.
+ * @throws {Error} When all retries are exhausted or download fails.
+ */
+export declare function httpDownload(url: string, destPath: string, options?: HttpDownloadOptions | undefined): Promise<HttpDownloadResult>;
+/**
+ * Perform a GET request and parse JSON response.
+ * @throws {Error} When request fails or JSON parsing fails.
+ */
+export declare function httpGetJson<T = unknown>(url: string, options?: HttpRequestOptions | undefined): Promise<T>;
+/**
+ * Perform a GET request and return text response.
+ * @throws {Error} When request fails.
+ */
+export declare function httpGetText(url: string, options?: HttpRequestOptions | undefined): Promise<string>;