@westbayberry/dg 1.0.52 → 1.0.56

package/dist/src/pypi/registry.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPyPIMetadata = fetchPyPIMetadata;
+exports.fetchPyPIDownloads = fetchPyPIDownloads;
+exports.prefetchPyPIDownloadCounts = prefetchPyPIDownloadCounts;
+exports.normalizePyPIName = normalizePyPIName;
+const logger_1 = require("../logger");
+const FETCH_TIMEOUT_MS = 30000;
+const downloadCache = new Map();
+const metadataCache = new Map();
+const DOWNLOAD_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const NULL_DOWNLOAD_CACHE_TTL_MS = 5 * 60 * 1000; // 5 min — retry sooner on failure
+const METADATA_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const MAX_CACHE_SIZE = 10000;
+// --- Fetch functions ---
+async function fetchPyPIMetadata(packageName) {
+    const normalizedName = normalizePyPIName(packageName);
+    // Check in-memory cache
+    const cached = metadataCache.get(normalizedName);
+    if (cached && Date.now() - cached.fetchedAt < METADATA_CACHE_TTL_MS) {
+        return cached.meta;
+    }
+    try {
+        const url = `https://pypi.org/pypi/${normalizedName}/json`;
+        const response = await fetch(url, {
+            headers: { "User-Agent": "dependency-guardian" },
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            evictAndSet(metadataCache, normalizedName, { meta: null, fetchedAt: Date.now() });
+            return null;
+        }
+        const raw = (await response.json());
+        const result = { raw, common: mapToCommon(raw) };
+        evictAndSet(metadataCache, normalizedName, { meta: result, fetchedAt: Date.now() });
+        return result;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger_1.logger.warning(`Failed to fetch PyPI metadata for ${packageName}: ${msg}`);
+        return null;
+    }
+}
+/**
+ * Fetch recent download counts from pypistats.org.
+ * Returns weekly downloads (last 7 days) or null on failure.
+ */
+async function fetchPyPIDownloads(packageName) {
+    const normalizedName = normalizePyPIName(packageName);
+    // Check in-memory cache — use shorter TTL for null entries so we retry sooner
+    const cached = downloadCache.get(normalizedName);
+    if (cached) {
+        const ttl = cached.count !== null ? DOWNLOAD_CACHE_TTL_MS : NULL_DOWNLOAD_CACHE_TTL_MS;
+        if (Date.now() - cached.fetchedAt < ttl) {
+            return cached.count;
+        }
+    }
+    const url = `https://pypistats.org/api/packages/${normalizedName}/recent`;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            const response = await fetch(url, {
+                headers: { "User-Agent": "dependency-guardian" },
+                signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+            });
+            if (response.status === 429) {
+                // Rate limited — exponential backoff
+                await new Promise((r) => setTimeout(r, 1000 * Math.pow(2, attempt)));
+                continue;
+            }
+            if (!response.ok) {
+                evictAndSet(downloadCache, normalizedName, { count: null, fetchedAt: Date.now() });
+                return null;
+            }
+            const data = (await response.json());
+            const count = data?.data?.last_week ?? null;
+            evictAndSet(downloadCache, normalizedName, { count, fetchedAt: Date.now() });
+            return count;
+        }
+        catch {
+            if (attempt < 2) {
+                await new Promise((r) => setTimeout(r, 1000 * (attempt + 1)));
+                continue;
+            }
+            evictAndSet(downloadCache, normalizedName, { count: null, fetchedAt: Date.now() });
+            return null;
+        }
+    }
+    evictAndSet(downloadCache, normalizedName, { count: null, fetchedAt: Date.now() });
+    return null;
+}
+/**
+ * Prefetch download counts for a batch of packages.
+ * pypistats.org doesn't have a bulk API, so we fetch individually
+ * with concurrency limiting to avoid rate limits.
+ */
+async function prefetchPyPIDownloadCounts(packageNames) {
+    const CONCURRENCY = 3; // pypistats rate limits aggressively
+    const uncached = packageNames.filter((name) => {
+        const normalizedName = normalizePyPIName(name);
+        const cached = downloadCache.get(normalizedName);
+        return !cached || Date.now() - cached.fetchedAt >= DOWNLOAD_CACHE_TTL_MS;
+    });
+    for (let i = 0; i < uncached.length; i += CONCURRENCY) {
+        const batch = uncached.slice(i, i + CONCURRENCY);
+        await Promise.all(batch.map((name) => fetchPyPIDownloads(name)));
+        // Small delay between batches to respect rate limits
+        if (i + CONCURRENCY < uncached.length) {
+            await new Promise((r) => setTimeout(r, 200));
+        }
+    }
+}
+// --- Helpers ---
+/**
+ * Evict expired entries and add new entry to cache.
+ * LRU-like: evicts oldest expired entries when at capacity.
+ */
+function evictAndSet(cache, key, value) {
+    if (cache.size >= MAX_CACHE_SIZE) {
+        const now = Date.now();
+        for (const [k, v] of cache) {
+            if (now - v.fetchedAt >= DOWNLOAD_CACHE_TTL_MS) {
+                cache.delete(k);
+            }
+            if (cache.size < MAX_CACHE_SIZE * 0.8)
+                break;
+        }
+        // If still full, delete oldest entries
+        if (cache.size >= MAX_CACHE_SIZE) {
+            const keysToDelete = [...cache.keys()].slice(0, Math.floor(MAX_CACHE_SIZE * 0.2));
+            for (const k of keysToDelete)
+                cache.delete(k);
+        }
+    }
+    cache.set(key, value);
+}
+/**
+ * Normalize PyPI package name per PEP 503:
+ * lowercase, replace [-_.] with hyphens, collapse runs.
+ */
+function normalizePyPIName(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+function extractRepoUrl(info) {
+    // Check project_urls first
+    if (info.project_urls) {
+        for (const [key, url] of Object.entries(info.project_urls)) {
+            const lowerKey = key.toLowerCase();
+            if (lowerKey.includes("source") ||
+                lowerKey.includes("repository") ||
+                lowerKey.includes("github") ||
+                lowerKey.includes("code")) {
+                return url;
+            }
+        }
+    }
+    // Fall back to home_page if it looks like a repo URL
+    if (info.home_page &&
+        (info.home_page.includes("github.com") ||
+            info.home_page.includes("gitlab.com") ||
+            info.home_page.includes("bitbucket.org"))) {
+        return info.home_page;
+    }
+    return undefined;
+}
+function extractMaintainers(info) {
+    const maintainers = [];
+    if (info.maintainer) {
+        maintainers.push({ name: info.maintainer, email: info.maintainer_email || undefined });
+    }
+    if (info.author && info.author !== info.maintainer) {
+        maintainers.push({ name: info.author, email: info.author_email || undefined });
+    }
+    return maintainers;
+}
+function pickBestDistUrl(files) {
+    // Prefer wheel over sdist
+    const wheel = files.find((f) => f.packagetype === "bdist_wheel");
+    if (wheel)
+        return wheel.url;
+    const sdist = files.find((f) => f.packagetype === "sdist");
+    if (sdist)
+        return sdist.url;
+    return files[0]?.url ?? null;
+}
+function mapToCommon(raw) {
+    const info = raw.info;
+    const versions = {};
+    const time = {};
+    let earliestTimestamp = null;
+    for (const [ver, files] of Object.entries(raw.releases)) {
+        if (files.length === 0)
+            continue;
+        const downloadUrl = pickBestDistUrl(files);
+        if (!downloadUrl)
+            continue;
+        const checksum = files[0]?.digests?.sha256 ?? undefined;
+        // Extract dependencies from requires_dist (only available on latest version)
+        const deps = {};
+        if (ver === info.version && info.requires_dist) {
+            for (const req of info.requires_dist) {
+                const match = req.match(/^([a-zA-Z0-9][-a-zA-Z0-9_.]*)/);
+                if (match) {
+                    deps[normalizePyPIName(match[1])] = req;
+                }
+            }
+        }
+        versions[ver] = {
+            downloadUrl,
+            checksum,
+            dependencies: Object.keys(deps).length > 0 ? deps : undefined,
+            repository: extractRepoUrl(info)
+                ? { type: "git", url: extractRepoUrl(info) }
+                : undefined,
+            maintainers: extractMaintainers(info),
+        };
+        // Build time map from upload timestamps
+        const uploadTime = files[0]?.upload_time_iso_8601;
+        if (uploadTime) {
+            time[ver] = uploadTime;
+            if (!earliestTimestamp || uploadTime < earliestTimestamp) {
+                earliestTimestamp = uploadTime;
+            }
+        }
+    }
+    if (earliestTimestamp) {
+        time.created = earliestTimestamp;
+    }
+    const keywords = info.keywords
+        ? info.keywords.split(/[,\s]+/).filter(Boolean)
+        : undefined;
+    // Extract license from metadata — try PEP 639 first, then legacy fields
+    let license;
+    if (info.license_expression && info.license_expression.trim().length > 0) {
+        // PEP 639 SPDX expression — most reliable when present (e.g. numpy, pandas)
+        license = info.license_expression.trim();
+    }
+    else if (info.license && info.license !== "UNKNOWN" && info.license.trim().length > 0) {
+        if (info.license.length > 200) {
+            // Long text is often full license body pasted verbatim — try classifiers first
+            const classifierLicense = classifierToSpdx(info.classifiers);
+            license = classifierLicense ?? "(long-text)";
+        }
+        else {
+            license = info.license.trim();
+        }
+    }
+    else {
+        license = classifierToSpdx(info.classifiers) ?? undefined;
+    }
+    return {
+        name: info.name,
+        versions,
+        time: Object.keys(time).length > 0 ? time : undefined,
+        maintainers: extractMaintainers(info),
+        description: info.summary || info.description || undefined,
+        keywords,
+        homepage: info.home_page || undefined,
+        repositoryUrl: extractRepoUrl(info),
+        license,
+    };
+}
+const CLASSIFIER_TO_SPDX = {
+    "License :: OSI Approved :: MIT License": "MIT",
+    "License :: OSI Approved :: Apache Software License": "Apache-2.0",
+    "License :: OSI Approved :: BSD License": "BSD-3-Clause",
+    "License :: OSI Approved :: ISC License (ISCL)": "ISC",
+    "License :: OSI Approved :: GNU General Public License v2 (GPLv2)": "GPL-2.0-only",
+    "License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)": "GPL-2.0-or-later",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)": "GPL-3.0-only",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)": "GPL-3.0-or-later",
+    "License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)": "LGPL-2.0-only",
+    "License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)": "LGPL-2.0-or-later",
+    "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)": "LGPL-3.0-only",
+    "License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)": "LGPL-3.0-or-later",
+    "License :: OSI Approved :: GNU Affero General Public License v3": "AGPL-3.0-only",
+    "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)": "AGPL-3.0-or-later",
+    "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)": "MPL-2.0",
+    "License :: OSI Approved :: Mozilla Public License 1.1 (MPL 1.1)": "MPL-1.1",
+    "License :: OSI Approved :: Eclipse Public License 1.0 (EPL-1.0)": "EPL-1.0",
+    "License :: OSI Approved :: Eclipse Public License 2.0 (EPL-2.0)": "EPL-2.0",
+    "License :: OSI Approved :: European Union Public Licence 1.2 (EUPL 1.2)": "EUPL-1.2",
+    "License :: OSI Approved :: The Unlicense (Unlicense)": "Unlicense",
+    "License :: OSI Approved :: Python Software Foundation License": "PSF-2.0",
+    "License :: OSI Approved :: Zope Public License": "ZPL-2.0",
+    "License :: OSI Approved :: Academic Free License (AFL)": "AFL-3.0",
+    "License :: OSI Approved :: Artistic License": "Artistic-2.0",
+    "License :: OSI Approved :: Boost Software License 1.0 (BSL-1.0)": "BSL-1.0",
+    "License :: OSI Approved :: zlib/libpng License": "Zlib",
+};
+function classifierToSpdx(classifiers) {
+    if (!classifiers)
+        return null;
+    for (const c of classifiers) {
+        const spdx = CLASSIFIER_TO_SPDX[c];
+        if (spdx)
+            return spdx;
+    }
+    return null;
+}

package/dist/src/pypi/tarball.js

@@ -0,0 +1,361 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadAndExtractPyPI = downloadAndExtractPyPI;
+exports.cleanupPyPI = cleanupPyPI;
+const logger_1 = require("../logger");
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const https = __importStar(require("https"));
+const tar = __importStar(require("tar"));
+const yauzl = __importStar(require("yauzl"));
+// Size caps — same env vars as npm so ops can tune both pipelines together.
+// Defaults sized to cover ML / native-binary packages like torch/tensorflow,
+// which routinely exceed 200 MB per wheel. Streaming download + per-entry
+// extraction means memory stays bounded regardless of these caps.
+const MAX_DOWNLOAD_BYTES = (() => {
+    const mb = parseInt(process.env.MAX_TARBALL_MB || "2000", 10);
+    return (Number.isFinite(mb) ? mb : 2000) * 1024 * 1024;
+})();
+const MAX_EXTRACTED_BYTES = (() => {
+    const mb = parseInt(process.env.MAX_EXTRACTED_MB || "4000", 10);
+    return (Number.isFinite(mb) ? mb : 4000) * 1024 * 1024;
+})();
+const MAX_EXTRACTED_FILES = parseInt(process.env.MAX_EXTRACTED_FILES || "25000", 10);
+const MAX_REDIRECTS = 5;
+const ALLOWED_HOSTS = new Set([
+    "files.pythonhosted.org",
+    "pypi.org",
+    "pypi.python.org",
+]);
+const BLOCKED_ENTRY_TYPES = new Set([
+    "SymbolicLink", "Link", "CharacterDevice", "BlockDevice", "FIFO",
+]);
+const downloadAgent = new https.Agent({
+    keepAlive: true,
+    maxSockets: 50,
+    maxFreeSockets: 10,
+});
+// Persistent tarball cache — set TARBALL_CACHE_PATH to enable
+const PYPI_CACHE_DIR = process.env.TARBALL_CACHE_PATH
+    ? path.join(process.env.TARBALL_CACHE_PATH, "pypi")
+    : "";
+function pypiCacheKey(packageName, version, url) {
+    const ext = url.endsWith(".whl") ? ".whl" : ".tar.gz";
+    return `${packageName.replace(/[/]/g, "__")}-${version}${ext}`;
+}
+function getCachedPyPI(packageName, version, url) {
+    if (!PYPI_CACHE_DIR)
+        return null;
+    const cached = path.join(PYPI_CACHE_DIR, pypiCacheKey(packageName, version, url));
+    try {
+        if (fs.existsSync(cached))
+            return cached;
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function savePyPIToCache(archivePath, packageName, version, url) {
+    if (!PYPI_CACHE_DIR)
+        return;
+    try {
+        fs.mkdirSync(PYPI_CACHE_DIR, { recursive: true });
+        const dest = path.join(PYPI_CACHE_DIR, pypiCacheKey(packageName, version, url));
+        fs.copyFileSync(archivePath, dest);
+    }
+    catch { /* best effort */ }
+}
+/** Defense-in-depth: verify resolved path stays within the extraction directory. */
+function isContainedPath(base, entryName) {
+    const resolved = path.resolve(path.join(base, entryName));
+    const resolvedBase = path.resolve(base) + path.sep;
+    return resolved === path.resolve(base) || resolved.startsWith(resolvedBase);
+}
+/**
+ * Download and extract a PyPI distribution (.tar.gz or .whl).
+ * .whl files are ZIP archives; .tar.gz are standard tarballs.
+ */
+async function downloadAndExtractPyPI(downloadUrl, packageName, version, expectedSha256) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dg-pypi-"));
+    const isWheel = downloadUrl.endsWith(".whl");
+    const ext = isWheel ? ".whl" : ".tar.gz";
+    const archivePath = path.join(tmpDir, `pkg${ext}`);
+    const extractDir = path.join(tmpDir, "extracted");
+    fs.mkdirSync(extractDir, { recursive: true });
+    try {
+        const cached = getCachedPyPI(packageName, version, downloadUrl);
+        if (cached) {
+            fs.copyFileSync(cached, archivePath);
+        }
+        else {
+            await downloadToFile(downloadUrl, archivePath);
+            savePyPIToCache(archivePath, packageName, version, downloadUrl);
+        }
+        if (expectedSha256) {
+            const hash = crypto.createHash("sha256");
+            const stream = fs.createReadStream(archivePath);
+            for await (const chunk of stream)
+                hash.update(chunk);
+            const actual = hash.digest("hex");
+            if (actual !== expectedSha256) {
+                logger_1.logger.warning(`Hash mismatch for PyPI ${packageName}@${version}: expected ${expectedSha256}, got ${actual}`);
+                cleanupPyPI(tmpDir);
+                return null;
+            }
+        }
+        if (isWheel) {
+            await extractWheel(archivePath, extractDir, packageName, version);
+        }
+        else {
+            await extractTarGz(archivePath, extractDir, packageName, version);
+        }
+        // Find the package root directory
+        const entries = fs.readdirSync(extractDir);
+        if (entries.length === 1) {
+            const singleDir = path.join(extractDir, entries[0]);
+            if (fs.statSync(singleDir).isDirectory()) {
+                return { packageDir: singleDir, rootTmpDir: tmpDir, archivePath };
+            }
+        }
+        return { packageDir: extractDir, rootTmpDir: tmpDir, archivePath };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger_1.logger.warning(`Failed to download/extract PyPI ${packageName}@${version}: ${msg}`);
+        cleanupPyPI(tmpDir);
+        return null;
+    }
+}
+async function extractTarGz(archivePath, extractDir, packageName, version) {
+    let extractedBytes = 0;
+    let extractedFiles = 0;
+    let extractionAborted = false;
+    await tar.extract({
+        file: archivePath,
+        cwd: extractDir,
+        filter: (entryPath, entry) => {
+            if (extractionAborted)
+                return false;
+            if ("type" in entry && BLOCKED_ENTRY_TYPES.has(entry.type)) {
+                logger_1.logger.warning(`Blocked ${entry.type} entry in ${packageName}@${version}: ${entryPath}`);
+                return false;
+            }
+            if (entryPath.startsWith("/") || entryPath.includes("..")) {
+                logger_1.logger.warning(`Blocked path traversal in PyPI ${packageName}@${version}: ${entryPath}`);
+                return false;
+            }
+            // Defense-in-depth: verify resolved path stays within extractDir
+            if (!isContainedPath(extractDir, entryPath)) {
+                logger_1.logger.warning(`Blocked path escape in PyPI ${packageName}@${version}: ${entryPath}`);
+                return false;
+            }
+            extractedBytes += entry.size;
+            if (extractedBytes > MAX_EXTRACTED_BYTES) {
+                extractionAborted = true;
+                logger_1.logger.warning(`Extracted content for PyPI ${packageName}@${version} exceeds 200MB — aborting`);
+                return false;
+            }
+            extractedFiles++;
+            if (extractedFiles > MAX_EXTRACTED_FILES) {
+                extractionAborted = true;
+                logger_1.logger.warning(`File count for PyPI ${packageName}@${version} exceeds ${MAX_EXTRACTED_FILES} — aborting`);
+                return false;
+            }
+            return true;
+        },
+    });
+    if (extractionAborted) {
+        throw new Error("Extraction aborted due to size/file limits");
+    }
+}
+/**
+ * Extract a .whl file (ZIP archive) using yauzl with per-entry validation.
+ * Blocks symlinks, path traversal, and enforces size/file-count limits
+ * during extraction (not post-extraction).
+ */
+async function extractWheel(archivePath, extractDir, packageName, version) {
+    return new Promise((resolve, reject) => {
+        yauzl.open(archivePath, { lazyEntries: true }, (err, zipfile) => {
+            if (err)
+                return reject(err);
+            let extractedBytes = 0;
+            let extractedFiles = 0;
+            zipfile.readEntry();
+            zipfile.on("entry", (entry) => {
+                // Block path traversal
+                if (entry.fileName.startsWith("/") || entry.fileName.includes("..")) {
+                    logger_1.logger.warning(`Blocked path traversal in PyPI ${packageName}@${version}: ${entry.fileName}`);
+                    zipfile.readEntry();
+                    return;
+                }
+                // Block symlinks (Unix external file attributes: 0xA000 = symlink)
+                const mode = (entry.externalFileAttributes >> 16) & 0xFFFF;
+                if ((mode & 0xF000) === 0xA000) {
+                    logger_1.logger.warning(`Blocked symlink in PyPI ${packageName}@${version}: ${entry.fileName}`);
+                    zipfile.readEntry();
+                    return;
+                }
+                // Defense-in-depth: verify resolved path stays within extractDir
+                if (!isContainedPath(extractDir, entry.fileName)) {
+                    logger_1.logger.warning(`Blocked path escape in PyPI ${packageName}@${version}: ${entry.fileName}`);
+                    zipfile.readEntry();
+                    return;
+                }
+                extractedFiles++;
+                if (extractedFiles > MAX_EXTRACTED_FILES) {
+                    zipfile.close();
+                    return reject(new Error(`File count for PyPI ${packageName}@${version} exceeds ${MAX_EXTRACTED_FILES}`));
+                }
+                // Directory entry — create and continue
+                if (entry.fileName.endsWith("/")) {
+                    fs.mkdirSync(path.join(extractDir, entry.fileName), { recursive: true });
+                    zipfile.readEntry();
+                    return;
+                }
+                // Extract file — track actual bytes written (not metadata) to prevent
+                // zip bombs with spoofed uncompressedSize headers.
+                zipfile.openReadStream(entry, (err, readStream) => {
+                    if (err)
+                        return reject(err);
+                    const outPath = path.join(extractDir, entry.fileName);
+                    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+                    const writeStream = fs.createWriteStream(outPath);
+                    readStream.on("data", (chunk) => {
+                        extractedBytes += chunk.length;
+                        if (extractedBytes > MAX_EXTRACTED_BYTES) {
+                            readStream.destroy();
+                            writeStream.destroy();
+                            zipfile.close();
+                            reject(new Error(`Extracted wheel for PyPI ${packageName}@${version} exceeds 200MB`));
+                        }
+                    });
+                    readStream.pipe(writeStream);
+                    writeStream.on("close", () => zipfile.readEntry());
+                    writeStream.on("error", reject);
+                });
+            });
+            zipfile.on("end", resolve);
+            zipfile.on("error", reject);
+        });
+    });
+}
+function validateDownloadUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`Invalid PyPI download URL: ${url}`);
+    }
+    if (parsed.protocol !== "https:") {
+        throw new Error(`PyPI download URL must use HTTPS: ${url}`);
+    }
+    if (!ALLOWED_HOSTS.has(parsed.hostname)) {
+        throw new Error(`PyPI download host not allowed: ${parsed.hostname}`);
+    }
+}
+function downloadToFile(url, destPath, redirectsRemaining = MAX_REDIRECTS) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateDownloadUrl(url);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
+        https
+            .get(url, { agent: downloadAgent }, (response) => {
+            if ((response.statusCode === 301 || response.statusCode === 302) &&
+                response.headers.location) {
+                if (redirectsRemaining <= 0) {
+                    reject(new Error("Too many redirects for PyPI download"));
+                    return;
+                }
+                response.resume();
+                downloadToFile(response.headers.location, destPath, redirectsRemaining - 1)
+                    .then(resolve)
+                    .catch(reject);
+                return;
+            }
+            if (response.statusCode !== 200) {
+                reject(new Error(`HTTP ${response.statusCode} for ${url}`));
+                return;
+            }
+            let bytesReceived = 0;
+            let aborted = false;
+            const file = fs.createWriteStream(destPath);
+            response.on("data", (chunk) => {
+                bytesReceived += chunk.length;
+                if (!aborted && bytesReceived > MAX_DOWNLOAD_BYTES) {
+                    aborted = true;
+                    response.destroy();
+                    file.destroy();
+                    try {
+                        fs.unlinkSync(destPath);
+                    }
+                    catch { }
+                    reject(new Error(`PyPI download exceeds ${MAX_DOWNLOAD_BYTES / 1024 / 1024}MB limit — aborting`));
+                }
+            });
+            response.pipe(file);
+            file.on("finish", () => {
+                if (!aborted) {
+                    file.close();
+                    resolve();
+                }
+            });
+            file.on("error", (err) => {
+                if (!aborted) {
+                    try {
+                        fs.unlinkSync(destPath);
+                    }
+                    catch { }
+                    reject(err);
+                }
+            });
+        })
+            .on("error", reject);
+    });
+}
+function cleanupPyPI(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // Non-fatal
+    }
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });