@poolzin/pool-bot 2026.3.4 → 2026.3.6

package/dist/infra/fs-safe.js

@@ -1,7 +1,14 @@
+import { randomUUID } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
-import { isNotFoundPathError, isPathInside, isSymlinkOpenError } from "./path-guards.js";
+import { pipeline } from "node:stream/promises";
+import { logWarn } from "../logger.js";
+import { sameFileIdentity } from "./file-identity.js";
+import { expandHomePrefix } from "./home-dir.js";
+import { assertNoPathAliasEscape } from "./path-alias-guards.js";
+import { hasNodeErrorCode, isNotFoundPathError, isPathInside, isSymlinkOpenError, } from "./path-guards.js";
 export class SafeOpenError extends Error {
     code;
     constructor(code, message, options) {
@@ -12,8 +19,37 @@ export class SafeOpenError extends Error {
 }
 const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in fsConstants;
 const OPEN_READ_FLAGS = fsConstants.O_RDONLY | (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0);
+const OPEN_WRITE_EXISTING_FLAGS = fsConstants.O_WRONLY | (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0);
+const OPEN_WRITE_CREATE_FLAGS = fsConstants.O_WRONLY |
+    fsConstants.O_CREAT |
+    fsConstants.O_EXCL |
+    (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0);
 const ensureTrailingSep = (value) => (value.endsWith(path.sep) ? value : value + path.sep);
-async function openVerifiedLocalFile(filePath) {
+async function expandRelativePathWithHome(relativePath) {
+    let home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    try {
+        home = await fs.realpath(home);
+    }
+    catch {
+        // If the home dir cannot be canonicalized, keep lexical expansion behavior.
+    }
+    return expandHomePrefix(relativePath, { home });
+}
+async function openVerifiedLocalFile(filePath, options) {
+    // Reject directories before opening so we never surface EISDIR to callers (e.g. tool
+    // results that get sent to messaging channels). See openclaw/openclaw#31186.
+    try {
+        const preStat = await fs.lstat(filePath);
+        if (preStat.isDirectory()) {
+            throw new SafeOpenError("not-file", "not a file");
+        }
+    }
+    catch (err) {
+        if (err instanceof SafeOpenError) {
+            throw err;
+        }
+        // ENOENT and other lstat errors: fall through and let fs.open handle.
+    }
     let handle;
     try {
         handle = await fs.open(filePath, OPEN_READ_FLAGS);
@@ -25,6 +61,10 @@ async function openVerifiedLocalFile(filePath) {
         if (isSymlinkOpenError(err)) {
             throw new SafeOpenError("symlink", "symlink open blocked", { cause: err });
         }
+        // Defensive: if open still throws EISDIR (e.g. race), sanitize so it never leaks.
+        if (hasNodeErrorCode(err, "EISDIR")) {
+            throw new SafeOpenError("not-file", "not a file");
+        }
         throw err;
     }
     try {
@@ -35,12 +75,18 @@ async function openVerifiedLocalFile(filePath) {
         if (!stat.isFile()) {
             throw new SafeOpenError("not-file", "not a file");
         }
-        if (stat.ino !== lstat.ino || stat.dev !== lstat.dev) {
+        if (options?.rejectHardlinks && stat.nlink > 1) {
+            throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
+        }
+        if (!sameFileIdentity(stat, lstat)) {
             throw new SafeOpenError("path-mismatch", "path changed during read");
         }
         const realPath = await fs.realpath(filePath);
         const realStat = await fs.stat(realPath);
-        if (stat.ino !== realStat.ino || stat.dev !== realStat.dev) {
+        if (options?.rejectHardlinks && realStat.nlink > 1) {
+            throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
+        }
+        if (!sameFileIdentity(stat, realStat)) {
             throw new SafeOpenError("path-mismatch", "path mismatch");
         }
         return { handle, realPath, stat };
@@ -56,7 +102,7 @@ async function openVerifiedLocalFile(filePath) {
         throw err;
     }
 }
-export async function openFileWithinRoot(params) {
+async function resolvePathWithinRoot(params) {
     let rootReal;
     try {
         rootReal = await fs.realpath(params.rootDir);
@@ -68,10 +114,15 @@ export async function openFileWithinRoot(params) {
         throw err;
     }
     const rootWithSep = ensureTrailingSep(rootReal);
-    const resolved = path.resolve(rootWithSep, params.relativePath);
+    const expanded = await expandRelativePathWithHome(params.relativePath);
+    const resolved = path.resolve(rootWithSep, expanded);
     if (!isPathInside(rootWithSep, resolved)) {
-        throw new SafeOpenError("invalid-path", "path escapes root");
+        throw new SafeOpenError("outside-workspace", "file is outside workspace root");
     }
+    return { rootReal, rootWithSep, resolved };
+}
+export async function openFileWithinRoot(params) {
+    const { rootWithSep, resolved } = await resolvePathWithinRoot(params);
     let opened;
     try {
         opened = await openVerifiedLocalFile(resolved);
@@ -87,22 +138,336 @@ export async function openFileWithinRoot(params) {
         }
         throw err;
     }
+    if (params.rejectHardlinks !== false && opened.stat.nlink > 1) {
+        await opened.handle.close().catch(() => { });
+        throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
+    }
     if (!isPathInside(rootWithSep, opened.realPath)) {
         await opened.handle.close().catch(() => { });
-        throw new SafeOpenError("invalid-path", "path escapes root");
+        throw new SafeOpenError("outside-workspace", "file is outside workspace root");
     }
     return opened;
 }
+export async function readFileWithinRoot(params) {
+    const opened = await openFileWithinRoot({
+        rootDir: params.rootDir,
+        relativePath: params.relativePath,
+        rejectHardlinks: params.rejectHardlinks,
+    });
+    try {
+        return await readOpenedFileSafely({ opened, maxBytes: params.maxBytes });
+    }
+    finally {
+        await opened.handle.close().catch(() => { });
+    }
+}
+export async function readPathWithinRoot(params) {
+    const rootDir = path.resolve(params.rootDir);
+    const candidatePath = path.isAbsolute(params.filePath)
+        ? path.resolve(params.filePath)
+        : path.resolve(rootDir, params.filePath);
+    const relativePath = path.relative(rootDir, candidatePath);
+    return await readFileWithinRoot({
+        rootDir,
+        relativePath,
+        rejectHardlinks: params.rejectHardlinks,
+        maxBytes: params.maxBytes,
+    });
+}
+export function createRootScopedReadFile(params) {
+    const rootDir = path.resolve(params.rootDir);
+    return async (filePath) => {
+        const safeRead = await readPathWithinRoot({
+            rootDir,
+            filePath,
+            rejectHardlinks: params.rejectHardlinks,
+            maxBytes: params.maxBytes,
+        });
+        return safeRead.buffer;
+    };
+}
 export async function readLocalFileSafely(params) {
     const opened = await openVerifiedLocalFile(params.filePath);
     try {
-        if (params.maxBytes !== undefined && opened.stat.size > params.maxBytes) {
-            throw new SafeOpenError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${opened.stat.size})`);
+        return await readOpenedFileSafely({ opened, maxBytes: params.maxBytes });
+    }
+    finally {
+        await opened.handle.close().catch(() => { });
+    }
+}
+async function readOpenedFileSafely(params) {
+    if (params.maxBytes !== undefined && params.opened.stat.size > params.maxBytes) {
+        throw new SafeOpenError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${params.opened.stat.size})`);
+    }
+    const buffer = await params.opened.handle.readFile();
+    return {
+        buffer,
+        realPath: params.opened.realPath,
+        stat: params.opened.stat,
+    };
+}
+function emitWriteBoundaryWarning(reason) {
+    logWarn(`security: fs-safe write boundary warning (${reason})`);
+}
+function buildAtomicWriteTempPath(targetPath) {
+    const dir = path.dirname(targetPath);
+    const base = path.basename(targetPath);
+    return path.join(dir, `.${base}.${process.pid}.${randomUUID()}.tmp`);
+}
+async function writeTempFileForAtomicReplace(params) {
+    const tempHandle = await fs.open(params.tempPath, OPEN_WRITE_CREATE_FLAGS, params.mode);
+    try {
+        if (typeof params.data === "string") {
+            await tempHandle.writeFile(params.data, params.encoding ?? "utf8");
+        }
+        else {
+            await tempHandle.writeFile(params.data);
+        }
+        return await tempHandle.stat();
+    }
+    finally {
+        await tempHandle.close().catch(() => { });
+    }
+}
+async function verifyAtomicWriteResult(params) {
+    const rootReal = await fs.realpath(params.rootDir);
+    const rootWithSep = ensureTrailingSep(rootReal);
+    const opened = await openVerifiedLocalFile(params.targetPath, { rejectHardlinks: true });
+    try {
+        if (!sameFileIdentity(opened.stat, params.expectedStat)) {
+            throw new SafeOpenError("path-mismatch", "path changed during write");
+        }
+        if (!isPathInside(rootWithSep, opened.realPath)) {
+            throw new SafeOpenError("outside-workspace", "file is outside workspace root");
         }
-        const buffer = await opened.handle.readFile();
-        return { buffer, realPath: opened.realPath, stat: opened.stat };
     }
     finally {
         await opened.handle.close().catch(() => { });
     }
 }
+export async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
+    try {
+        return await fs.realpath(ioPath);
+    }
+    catch (err) {
+        if (!isNotFoundPathError(err)) {
+            throw err;
+        }
+    }
+    const fdCandidates = process.platform === "linux"
+        ? [`/proc/self/fd/${handle.fd}`, `/dev/fd/${handle.fd}`]
+        : process.platform === "win32"
+            ? []
+            : [`/dev/fd/${handle.fd}`];
+    for (const fdPath of fdCandidates) {
+        try {
+            return await fs.realpath(fdPath);
+        }
+        catch {
+            // try next fd path
+        }
+    }
+    throw new SafeOpenError("path-mismatch", "unable to resolve opened file path");
+}
+export async function openWritableFileWithinRoot(params) {
+    const { rootReal, rootWithSep, resolved } = await resolvePathWithinRoot(params);
+    try {
+        await assertNoPathAliasEscape({
+            absolutePath: resolved,
+            rootPath: rootReal,
+            boundaryLabel: "root",
+        });
+    }
+    catch (err) {
+        throw new SafeOpenError("invalid-path", "path alias escape blocked", { cause: err });
+    }
+    if (params.mkdir !== false) {
+        await fs.mkdir(path.dirname(resolved), { recursive: true });
+    }
+    let ioPath = resolved;
+    try {
+        const resolvedRealPath = await fs.realpath(resolved);
+        if (!isPathInside(rootWithSep, resolvedRealPath)) {
+            throw new SafeOpenError("outside-workspace", "file is outside workspace root");
+        }
+        ioPath = resolvedRealPath;
+    }
+    catch (err) {
+        if (err instanceof SafeOpenError) {
+            throw err;
+        }
+        if (!isNotFoundPathError(err)) {
+            throw err;
+        }
+    }
+    const fileMode = params.mode ?? 0o600;
+    let handle;
+    let createdForWrite = false;
+    try {
+        try {
+            handle = await fs.open(ioPath, OPEN_WRITE_EXISTING_FLAGS, fileMode);
+        }
+        catch (err) {
+            if (!isNotFoundPathError(err)) {
+                throw err;
+            }
+            handle = await fs.open(ioPath, OPEN_WRITE_CREATE_FLAGS, fileMode);
+            createdForWrite = true;
+        }
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            throw new SafeOpenError("not-found", "file not found");
+        }
+        if (isSymlinkOpenError(err)) {
+            throw new SafeOpenError("invalid-path", "symlink open blocked", { cause: err });
+        }
+        throw err;
+    }
+    let openedRealPath = null;
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile()) {
+            throw new SafeOpenError("invalid-path", "path is not a regular file under root");
+        }
+        if (stat.nlink > 1) {
+            throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
+        }
+        try {
+            const lstat = await fs.lstat(ioPath);
+            if (lstat.isSymbolicLink() || !lstat.isFile()) {
+                throw new SafeOpenError("invalid-path", "path is not a regular file under root");
+            }
+            if (!sameFileIdentity(stat, lstat)) {
+                throw new SafeOpenError("path-mismatch", "path changed during write");
+            }
+        }
+        catch (err) {
+            if (!isNotFoundPathError(err)) {
+                throw err;
+            }
+        }
+        const realPath = await resolveOpenedFileRealPathForHandle(handle, ioPath);
+        openedRealPath = realPath;
+        const realStat = await fs.stat(realPath);
+        if (!sameFileIdentity(stat, realStat)) {
+            throw new SafeOpenError("path-mismatch", "path mismatch");
+        }
+        if (realStat.nlink > 1) {
+            throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
+        }
+        if (!isPathInside(rootWithSep, realPath)) {
+            throw new SafeOpenError("outside-workspace", "file is outside workspace root");
+        }
+        // Truncate only after boundary and identity checks complete. This avoids
+        // irreversible side effects if a symlink target changes before validation.
+        if (params.truncateExisting !== false && !createdForWrite) {
+            await handle.truncate(0);
+        }
+        return {
+            handle,
+            createdForWrite,
+            openedRealPath: realPath,
+            openedStat: stat,
+        };
+    }
+    catch (err) {
+        const cleanupCreatedPath = createdForWrite && err instanceof SafeOpenError;
+        const cleanupPath = openedRealPath ?? ioPath;
+        await handle.close().catch(() => { });
+        if (cleanupCreatedPath) {
+            await fs.rm(cleanupPath, { force: true }).catch(() => { });
+        }
+        throw err;
+    }
+}
+export async function writeFileWithinRoot(params) {
+    const target = await openWritableFileWithinRoot({
+        rootDir: params.rootDir,
+        relativePath: params.relativePath,
+        mkdir: params.mkdir,
+        truncateExisting: false,
+    });
+    const destinationPath = target.openedRealPath;
+    const targetMode = target.openedStat.mode & 0o777;
+    await target.handle.close().catch(() => { });
+    let tempPath = null;
+    try {
+        tempPath = buildAtomicWriteTempPath(destinationPath);
+        const writtenStat = await writeTempFileForAtomicReplace({
+            tempPath,
+            data: params.data,
+            encoding: params.encoding,
+            mode: targetMode || 0o600,
+        });
+        await fs.rename(tempPath, destinationPath);
+        tempPath = null;
+        try {
+            await verifyAtomicWriteResult({
+                rootDir: params.rootDir,
+                targetPath: destinationPath,
+                expectedStat: writtenStat,
+            });
+        }
+        catch (err) {
+            emitWriteBoundaryWarning(`post-write verification failed: ${String(err)}`);
+            throw err;
+        }
+    }
+    finally {
+        if (tempPath) {
+            await fs.rm(tempPath, { force: true }).catch(() => { });
+        }
+    }
+}
+export async function copyFileWithinRoot(params) {
+    const source = await openVerifiedLocalFile(params.sourcePath, {
+        rejectHardlinks: params.rejectSourceHardlinks,
+    });
+    if (params.maxBytes !== undefined && source.stat.size > params.maxBytes) {
+        await source.handle.close().catch(() => { });
+        throw new SafeOpenError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${source.stat.size})`);
+    }
+    let target = null;
+    let sourceClosedByStream = false;
+    let targetClosedByStream = false;
+    try {
+        target = await openWritableFileWithinRoot({
+            rootDir: params.rootDir,
+            relativePath: params.relativePath,
+            mkdir: params.mkdir,
+        });
+        const sourceStream = source.handle.createReadStream();
+        const targetStream = target.handle.createWriteStream();
+        sourceStream.once("close", () => {
+            sourceClosedByStream = true;
+        });
+        targetStream.once("close", () => {
+            targetClosedByStream = true;
+        });
+        await pipeline(sourceStream, targetStream);
+    }
+    catch (err) {
+        if (target?.createdForWrite) {
+            await fs.rm(target.openedRealPath, { force: true }).catch(() => { });
+        }
+        throw err;
+    }
+    finally {
+        if (!sourceClosedByStream) {
+            await source.handle.close().catch(() => { });
+        }
+        if (target && !targetClosedByStream) {
+            await target.handle.close().catch(() => { });
+        }
+    }
+}
+export async function writeFileFromPathWithinRoot(params) {
+    await copyFileWithinRoot({
+        sourcePath: params.sourcePath,
+        rootDir: params.rootDir,
+        relativePath: params.relativePath,
+        mkdir: params.mkdir,
+        rejectSourceHardlinks: true,
+    });
+}

package/dist/infra/hardlink-guards.js

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import { isNotFoundPathError } from "./path-guards.js";
+export async function assertNoHardlinkedFinalPath(params) {
+    if (params.allowFinalHardlinkForUnlink) {
+        return;
+    }
+    let stat;
+    try {
+        stat = await fs.stat(params.filePath);
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            return;
+        }
+        throw err;
+    }
+    if (!stat.isFile()) {
+        return;
+    }
+    if (stat.nlink > 1) {
+        throw new Error(`Hardlinked path is not allowed under ${params.boundaryLabel} (${shortPath(params.root)}): ${shortPath(params.filePath)}`);
+    }
+}
+function shortPath(value) {
+    if (value.startsWith(os.homedir())) {
+        return `~${value.slice(os.homedir().length)}`;
+    }
+    return value;
+}

package/dist/infra/json-utf8-bytes.js

@@ -0,0 +1,8 @@
+export function jsonUtf8Bytes(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf8");
+    }
+    catch {
+        return Buffer.byteLength(String(value), "utf8");
+    }
+}

package/dist/infra/net/fetch-guard.js

@@ -1,8 +1,47 @@
-import { closeDispatcher, createPinnedDispatcher, resolvePinnedHostname, resolvePinnedHostnameWithPolicy, } from "./ssrf.js";
+import { EnvHttpProxyAgent } from "undici";
+import { logWarn } from "../../logger.js";
+import { bindAbortRelay } from "../../utils/fetch-timeout.js";
+import { hasProxyEnvConfigured } from "./proxy-env.js";
+import { closeDispatcher, createPinnedDispatcher, resolvePinnedHostnameWithPolicy, SsrFBlockedError, } from "./ssrf.js";
+export const GUARDED_FETCH_MODE = {
+    STRICT: "strict",
+    TRUSTED_ENV_PROXY: "trusted_env_proxy",
+};
 const DEFAULT_MAX_REDIRECTS = 3;
+const CROSS_ORIGIN_REDIRECT_SENSITIVE_HEADERS = [
+    "authorization",
+    "proxy-authorization",
+    "cookie",
+    "cookie2",
+];
+export function withStrictGuardedFetchMode(params) {
+    return { ...params, mode: GUARDED_FETCH_MODE.STRICT };
+}
+export function withTrustedEnvProxyGuardedFetchMode(params) {
+    return { ...params, mode: GUARDED_FETCH_MODE.TRUSTED_ENV_PROXY };
+}
+function resolveGuardedFetchMode(params) {
+    if (params.mode) {
+        return params.mode;
+    }
+    if (params.proxy === "env" && params.dangerouslyAllowEnvProxyWithoutPinnedDns === true) {
+        return GUARDED_FETCH_MODE.TRUSTED_ENV_PROXY;
+    }
+    return GUARDED_FETCH_MODE.STRICT;
+}
 function isRedirectStatus(status) {
     return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
 }
+function stripSensitiveHeadersForCrossOriginRedirect(init) {
+    if (!init?.headers) {
+        return init;
+    }
+    const headers = new Headers(init.headers);
+    for (const header of CROSS_ORIGIN_REDIRECT_SENSITIVE_HEADERS) {
+        headers.delete(header);
+    }
+    return { ...init, headers };
+}
 function buildAbortSignal(params) {
     const { timeoutMs, signal } = params;
     if (!timeoutMs && !signal) {
@@ -12,8 +51,8 @@ function buildAbortSignal(params) {
         return { signal, cleanup: () => { } };
     }
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-    const onAbort = () => controller.abort();
+    const timeoutId = setTimeout(controller.abort.bind(controller), timeoutMs);
+    const onAbort = bindAbortRelay(controller);
     if (signal) {
         if (signal.aborted) {
             controller.abort();
@@ -38,6 +77,7 @@ export async function fetchWithSsrFGuard(params) {
     const maxRedirects = typeof params.maxRedirects === "number" && Number.isFinite(params.maxRedirects)
         ? Math.max(0, Math.floor(params.maxRedirects))
         : DEFAULT_MAX_REDIRECTS;
+    const mode = resolveGuardedFetchMode(params);
     const { signal, cleanup } = buildAbortSignal({
         timeoutMs: params.timeoutMs,
         signal: params.signal,
@@ -53,6 +93,7 @@ export async function fetchWithSsrFGuard(params) {
     };
     const visited = new Set();
     let currentUrl = params.url;
+    let currentInit = params.init ? { ...params.init } : undefined;
     let redirectCount = 0;
     while (true) {
         let parsedUrl;
@@ -69,18 +110,19 @@ export async function fetchWithSsrFGuard(params) {
         }
         let dispatcher = null;
         try {
-            const usePolicy = Boolean(params.policy?.allowPrivateNetwork || params.policy?.allowedHostnames?.length);
-            const pinned = usePolicy
-                ? await resolvePinnedHostnameWithPolicy(parsedUrl.hostname, {
-                    lookupFn: params.lookupFn,
-                    policy: params.policy,
-                })
-                : await resolvePinnedHostname(parsedUrl.hostname, params.lookupFn);
-            if (params.pinDns !== false) {
+            const pinned = await resolvePinnedHostnameWithPolicy(parsedUrl.hostname, {
+                lookupFn: params.lookupFn,
+                policy: params.policy,
+            });
+            const canUseTrustedEnvProxy = mode === GUARDED_FETCH_MODE.TRUSTED_ENV_PROXY && hasProxyEnvConfigured();
+            if (canUseTrustedEnvProxy) {
+                dispatcher = new EnvHttpProxyAgent();
+            }
+            else if (params.pinDns !== false) {
                 dispatcher = createPinnedDispatcher(pinned);
             }
             const init = {
-                ...(params.init ? { ...params.init } : {}),
+                ...(currentInit ? { ...currentInit } : {}),
                 redirect: "manual",
                 ...(dispatcher ? { dispatcher } : {}),
                 ...(signal ? { signal } : {}),
@@ -97,11 +139,15 @@ export async function fetchWithSsrFGuard(params) {
                     await release(dispatcher);
                     throw new Error(`Too many redirects (limit: ${maxRedirects})`);
                 }
-                const nextUrl = new URL(location, parsedUrl).toString();
+                const nextParsedUrl = new URL(location, parsedUrl);
+                const nextUrl = nextParsedUrl.toString();
                 if (visited.has(nextUrl)) {
                     await release(dispatcher);
                     throw new Error("Redirect loop detected");
                 }
+                if (nextParsedUrl.origin !== parsedUrl.origin) {
+                    currentInit = stripSensitiveHeadersForCrossOriginRedirect(currentInit);
+                }
                 visited.add(nextUrl);
                 void response.body?.cancel();
                 await closeDispatcher(dispatcher);
@@ -115,6 +161,10 @@ export async function fetchWithSsrFGuard(params) {
             };
         }
         catch (err) {
+            if (err instanceof SsrFBlockedError) {
+                const context = params.auditContext ?? "url-fetch";
+                logWarn(`security: blocked URL fetch (${context}) target=${parsedUrl.origin}${parsedUrl.pathname} reason=${err.message}`);
+            }
             await release(dispatcher);
             throw err;
         }

package/dist/infra/net/proxy-env.js

@@ -0,0 +1,17 @@
+export const PROXY_ENV_KEYS = [
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "all_proxy",
+];
+export function hasProxyEnvConfigured(env = process.env) {
+    for (const key of PROXY_ENV_KEYS) {
+        const value = env[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return true;
+        }
+    }
+    return false;
+}