@pipedog/core 0.0.0 → 0.1.0

package/dist/utils/security/redaction.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Masks credentials in text bound for logs and error reports.
+ *
+ * Error messages often quote whatever a failure carried: an SDK exception that
+ * prints the headers it sent, a URL signed for one download, a provider body
+ * echoing the key it rejected. `redactSecrets` masks the credential and keeps
+ * the rest, so a message still says what went wrong.
+ *
+ * It masks three things:
+ *
+ * - The value of any `name=value` or `name: value` pair, quoted or not,
+ *   whose name marks a credential (`api_key`, `Authorization`,
+ *   `X-Amz-Signature`, `apiKey`...). This covers query strings, printed
+ *   header dicts and plain prose alike.
+ * - A URL's password (`scheme://user:password@host`).
+ * - Tokens recognizable by their format alone: provider key prefixes, AWS
+ *   access key IDs and JWTs.
+ */
+export declare const REDACTED = "[REDACTED]";
+/**
+ * Mask the credentials in `text`, leaving the rest as written.
+ *
+ * @param text Text that may quote a credential, such as an error message.
+ * @returns The text with each credential replaced by `[REDACTED]`.
+ */
+export declare function redactSecrets(text: string): string;
+//# sourceMappingURL=redaction.d.ts.map

package/dist/utils/security/redaction.js

@@ -0,0 +1,123 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/security/redaction.py
+/**
+ * Masks credentials in text bound for logs and error reports.
+ *
+ * Error messages often quote whatever a failure carried: an SDK exception that
+ * prints the headers it sent, a URL signed for one download, a provider body
+ * echoing the key it rejected. `redactSecrets` masks the credential and keeps
+ * the rest, so a message still says what went wrong.
+ *
+ * It masks three things:
+ *
+ * - The value of any `name=value` or `name: value` pair, quoted or not,
+ *   whose name marks a credential (`api_key`, `Authorization`,
+ *   `X-Amz-Signature`, `apiKey`...). This covers query strings, printed
+ *   header dicts and plain prose alike.
+ * - A URL's password (`scheme://user:password@host`).
+ * - Tokens recognizable by their format alone: provider key prefixes, AWS
+ *   access key IDs and JWTs.
+ */
+export const REDACTED = "[REDACTED]";
+// A name marks a credential when one of its words is one of these, so
+// `x-api-key` and `X-Amz-Security-Token` do while `keyterms` and `max_tokens`
+// don't.
+const CREDENTIAL_WORDS = new Set([
+    "apikey",
+    "auth",
+    "authorization",
+    "cookie",
+    "credential",
+    "credentials",
+    "creds",
+    "jwt",
+    "key",
+    "passwd",
+    "password",
+    "pwd",
+    "secret",
+    "sig",
+    "signature",
+    "token",
+    // Google's resumable upload session ID, which authorizes the upload by itself.
+    "uploadid",
+]);
+// `name=value` or `name: value` (or `:=`, `=>`), the name optionally quoted as
+// in a printed dict, the value quoted or running to the next delimiter. A
+// quoted value cut short before its closing quote, as a truncated repr leaves
+// it, runs to the next delimiter instead. An auth scheme (`Bearer`, `Basic`...)
+// ahead of the value is kept. A value already redacted is matched whole, so
+// text redacted twice reads the same as text redacted once.
+const PAIR = new RegExp(String.raw `(?<name>(?<![\w.-])(?<nq>["']?)[A-Za-z][\w.-]*\k<nq>)` +
+    String.raw `(?<sep>\s*(?::=|=>|[:=])\s*)` +
+    String.raw `(?<scheme>(?:Bearer|Basic|Token|Api-Token|Key|Digest|AWS4-HMAC-SHA256)\s+)?` +
+    String.raw `(?:(?<vq>["'])(?<quoted>.*?)\k<vq>` +
+    String.raw `|(?<oq>["']?)(?<bare>(?:\[REDACTED\]|[^\s,;&"'}\])\[])+))`, "g");
+const URL_PASSWORD = /(?<prefix>\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:)[^\s/@]+(?=@)/gi;
+// Formats after gitleaks' rules for the same credentials
+// (github.com/gitleaks/gitleaks, config/gitleaks.toml), loosened where a
+// looser match costs nothing: a log line is masked, not scanned for findings.
+const KNOWN_TOKENS = new RegExp(String.raw `\b(?:` +
+    String.raw `sk-[A-Za-z0-9_-]{20,}` + // OpenAI, Anthropic
+    String.raw `|(?:A3T[A-Z0-9]|AKIA|ASIA|ABIA|ACCA)[A-Z0-9]{16}` + // AWS access key IDs
+    String.raw `|ABSK[A-Za-z0-9+/]{109,269}={0,2}` + // Amazon Bedrock API keys, long-lived
+    String.raw `|bedrock-api-key-[A-Za-z0-9+/=_-]+` + // Amazon Bedrock API keys, short-lived
+    String.raw `|AIza[0-9A-Za-z_-]{35}` + // Google API keys
+    String.raw `|gh[pousr]_[A-Za-z0-9]{36,}|github_pat_\w{82,}` + // GitHub
+    String.raw `|xox[abeoprs]-[A-Za-z0-9-]{10,}|xapp-\d-[A-Za-z0-9-]{10,}` + // Slack
+    // Slack webhooks, whose path is the secret
+    String.raw `|(?:(?<=hooks\.slack\.com/services/)|(?<=hooks\.slack\.com/workflows/)` +
+    String.raw `|(?<=hooks\.slack\.com/triggers/))[A-Za-z0-9+/]{20,}` +
+    String.raw `|(?:hf|api_org)_[A-Za-z]{34}` + // Hugging Face
+    String.raw `|pplx-[A-Za-z0-9]{48}` + // Perplexity
+    String.raw `|SK[0-9a-fA-F]{32}` + // Twilio API keys
+    String.raw `|eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]*` + // JWTs, signed or not
+    String.raw `)` +
+    // A PEM private key, through its END line or, cut short, the end of the text.
+    String.raw `|-----BEGIN[ A-Z0-9_-]{0,100}PRIVATE KEY(?: BLOCK)?-----` +
+    String.raw `(?:[\s\S]*?-----END[ A-Z0-9_-]{0,100}PRIVATE KEY(?: BLOCK)?-----|[\s\S]*)`, "g");
+function stripQuotes(name) {
+    return name.replace(/^["']+/, "").replace(/["']+$/, "");
+}
+function isCredentialName(name) {
+    const words = stripQuotes(name)
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase();
+    const parts = words.split(/[-_.]/).filter((p) => p);
+    return CREDENTIAL_WORDS.has(parts.join("")) || parts.some((p) => CREDENTIAL_WORDS.has(p));
+}
+function redactPairs(text) {
+    // String.prototype.replace collects every match before calling the
+    // replacer, so recursing with the same global regex is safe.
+    return text.replace(PAIR, (...args) => redactPair(args[args.length - 1]));
+}
+function redactPair(match) {
+    const quote = match.vq || "";
+    let value;
+    if (isCredentialName(match.name)) {
+        value = REDACTED;
+    }
+    else {
+        // The value may itself hold pairs, as `URL: https://...?token=...` does.
+        value = redactPairs(match.quoted || match.bare || "");
+    }
+    const opening = match.oq || "";
+    return `${match.name}${match.sep}${match.scheme || ""}${quote || opening}${value}${quote}`;
+}
+/**
+ * Mask the credentials in `text`, leaving the rest as written.
+ *
+ * @param text Text that may quote a credential, such as an error message.
+ * @returns The text with each credential replaced by `[REDACTED]`.
+ */
+export function redactSecrets(text) {
+    // Known formats go first: a PEM key spans lines, and masking its first line
+    // as a pair's value would leave the rest unrecognizable.
+    text = text.replace(KNOWN_TOKENS, REDACTED);
+    text = redactPairs(text);
+    return text.replace(URL_PASSWORD, `$<prefix>${REDACTED}`);
+}
+//# sourceMappingURL=redaction.js.map

package/dist/utils/security/ssrf.d.ts

@@ -0,0 +1,79 @@
+/** Who can safely reach a URL's host. */
+export declare const UrlReachability: {
+    /** Publicly routable — safe to hand to a third party to fetch itself. */
+    readonly PUBLIC: "public";
+    /**
+     * Within a trusted private network — safe for this server to fetch
+     * directly, but not to hand off to a third party that can't reach it.
+     */
+    readonly ALLOWED: "allowed";
+    /** Nobody should fetch it. */
+    readonly BLOCKED: "blocked";
+};
+export type UrlReachability = (typeof UrlReachability)[keyof typeof UrlReachability];
+/** A parsed IP address: its version and its value as a bigint. */
+export interface IPAddress {
+    version: 4 | 6;
+    value: bigint;
+}
+/**
+ * Parse an IPv4 or IPv6 address (Python's `ipaddress.ip_address`).
+ *
+ * @throws Error If `text` is not a valid address (upstream: ValueError).
+ */
+export declare function ipAddress(text: string): IPAddress;
+/** An IPv4 or IPv6 network in CIDR form (Python's `IPv4Network | IPv6Network`). */
+export declare class IPNetwork {
+    #private;
+    readonly version: 4 | 6;
+    readonly networkAddress: bigint;
+    readonly prefixlen: number;
+    /**
+     * @param cidr A network such as `"10.0.0.0/8"` or `"fd00::/8"`. A bare
+     *   address is a single-host network. Host bits must be zero, as Python's
+     *   strict default requires.
+     * @throws Error If `cidr` is not a valid network (upstream: ValueError).
+     */
+    constructor(cidr: string);
+    /** Whether `address` lies in this network (Python's `ip in network`). */
+    contains(address: IPAddress): boolean;
+    toString(): string;
+}
+/** Python's `ip_address(...).is_global`. */
+export declare function ipAddressIsGlobal(address: IPAddress): boolean;
+/** Resolve a hostname to its IP addresses (as `getaddrinfo` does). Throw if it fails. */
+export type HostResolver = (hostname: string) => Promise<string[]>;
+/** The default resolver: IP literals as-is, hostnames through `node:dns` if available. */
+export declare const defaultHostResolver: HostResolver;
+/** Install the resolver `classifyUrlReachability` uses. Pass `null` for the default. */
+export declare function setHostResolver(resolver: HostResolver | null): void;
+/**
+ * Return trusted networks from the `PIPECAT_ALLOWED_FILE_URL_NETWORKS` env var.
+ *
+ * Parses a comma-separated list of CIDR ranges (e.g.
+ * `10.0.0.0/8,192.168.0.0/16`). Returns an empty list (trust only the
+ * public internet) when the variable is unset or empty.
+ */
+export declare function defaultAllowedFileUrlNetworks(): string[];
+/**
+ * Classify who can safely reach `url`'s host: the public internet, this server, or no one.
+ *
+ * Resolution happens once, up front; it doesn't defend against a target
+ * that resolves differently between this check and the actual connection
+ * (DNS rebinding).
+ *
+ * @param url The URL to classify.
+ * @param allowedNetworks Private networks this server is trusted to reach
+ *   directly (e.g. where a deployment's own file servers live), beyond the
+ *   public internet.
+ * @returns `PUBLIC` if every resolved address is publicly routable — safe to
+ *   hand to a third party (e.g. an LLM provider) to fetch itself.
+ *   `ALLOWED` if not publicly routable, but every address falls within
+ *   `allowedNetworks` — safe for this server to fetch directly, but not to
+ *   hand off to a third party that can't reach it.
+ *   `BLOCKED` otherwise: loopback, link-local (including the cloud metadata
+ *   range `169.254.0.0/16`), private (RFC 1918), or unique-local (IPv6 ULA)
+ *   addresses outside `allowedNetworks`, or a host that fails to resolve.
+ */
+export declare function classifyUrlReachability(url: string, allowedNetworks?: readonly IPNetwork[]): Promise<UrlReachability>;
+//# sourceMappingURL=ssrf.d.ts.map

package/dist/utils/security/ssrf.js

@@ -0,0 +1,327 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/security/ssrf.py
+/**
+ * Guards against server-side request forgery via client-supplied URLs.
+ *
+ * Porting notes: Python's `ipaddress` module has no JavaScript counterpart, so
+ * this module carries the small part of it it needs (`IPNetwork`,
+ * `ipAddressIsGlobal`). Host resolution goes through a pluggable
+ * `HostResolver`; the default one uses `node:dns` through
+ * `process.getBuiltinModule` where the runtime provides it (Bun, Node, Deno),
+ * and otherwise only resolves IP literals, so a hostname that cannot be
+ * resolved is `BLOCKED`.
+ */
+import { abortable, rethrowIfCancelled } from "@pipedog/asyncio";
+/** Who can safely reach a URL's host. */
+export const UrlReachability = {
+    /** Publicly routable — safe to hand to a third party to fetch itself. */
+    PUBLIC: "public",
+    /**
+     * Within a trusted private network — safe for this server to fetch
+     * directly, but not to hand off to a third party that can't reach it.
+     */
+    ALLOWED: "allowed",
+    /** Nobody should fetch it. */
+    BLOCKED: "blocked",
+};
+function parseIPv4(text) {
+    const parts = text.split(".");
+    if (parts.length !== 4)
+        return null;
+    let value = 0n;
+    for (const part of parts) {
+        if (!/^\d{1,3}$/.test(part))
+            return null;
+        // Python rejects leading zeros (ambiguous octal).
+        if (part.length > 1 && part.startsWith("0"))
+            return null;
+        const n = Number(part);
+        if (n > 255)
+            return null;
+        value = (value << 8n) | BigInt(n);
+    }
+    return value;
+}
+function parseIPv6(text) {
+    // Drop a scope id ("fe80::1%eth0").
+    const address = text.split("%")[0] ?? "";
+    if (!address.includes(":"))
+        return null;
+    let head = address;
+    let tailV4 = null;
+    const lastColon = address.lastIndexOf(":");
+    const last = address.slice(lastColon + 1);
+    if (last.includes(".")) {
+        tailV4 = parseIPv4(last);
+        if (tailV4 === null)
+            return null;
+        head = `${address.slice(0, lastColon + 1)}0:0`;
+    }
+    const halves = head.split("::");
+    if (halves.length > 2)
+        return null;
+    const parseGroups = (s) => {
+        if (s === "")
+            return [];
+        const groups = [];
+        for (const g of s.split(":")) {
+            if (!/^[0-9a-fA-F]{1,4}$/.test(g))
+                return null;
+            groups.push(Number.parseInt(g, 16));
+        }
+        return groups;
+    };
+    const left = parseGroups(halves[0] ?? "");
+    const right = halves.length === 2 ? parseGroups(halves[1] ?? "") : [];
+    if (left === null || right === null)
+        return null;
+    let groups;
+    if (halves.length === 2) {
+        const missing = 8 - left.length - right.length;
+        if (missing < 1)
+            return null;
+        groups = [...left, ...new Array(missing).fill(0), ...right];
+    }
+    else {
+        groups = left;
+    }
+    if (groups.length !== 8)
+        return null;
+    let value = 0n;
+    for (const g of groups)
+        value = (value << 16n) | BigInt(g);
+    if (tailV4 !== null)
+        value = (value & ~0xffffffffn) | tailV4;
+    return value;
+}
+/**
+ * Parse an IPv4 or IPv6 address (Python's `ipaddress.ip_address`).
+ *
+ * @throws Error If `text` is not a valid address (upstream: ValueError).
+ */
+export function ipAddress(text) {
+    const v4 = parseIPv4(text);
+    if (v4 !== null)
+        return { version: 4, value: v4 };
+    const v6 = parseIPv6(text);
+    if (v6 !== null)
+        return { version: 6, value: v6 };
+    throw new Error(`'${text}' does not appear to be an IPv4 or IPv6 address`);
+}
+/** An IPv4 or IPv6 network in CIDR form (Python's `IPv4Network | IPv6Network`). */
+export class IPNetwork {
+    version;
+    networkAddress;
+    prefixlen;
+    #mask;
+    /**
+     * @param cidr A network such as `"10.0.0.0/8"` or `"fd00::/8"`. A bare
+     *   address is a single-host network. Host bits must be zero, as Python's
+     *   strict default requires.
+     * @throws Error If `cidr` is not a valid network (upstream: ValueError).
+     */
+    constructor(cidr) {
+        const [addressText, prefixText] = cidr.trim().split("/");
+        const address = ipAddress(addressText ?? "");
+        const bits = address.version === 4 ? 32 : 128;
+        const prefixlen = prefixText === undefined ? bits : Number(prefixText);
+        if (!Number.isInteger(prefixlen) || prefixlen < 0 || prefixlen > bits) {
+            throw new Error(`'${cidr}' does not appear to be an IPv4 or IPv6 network`);
+        }
+        const all = (1n << BigInt(bits)) - 1n;
+        const mask = (all << BigInt(bits - prefixlen)) & all;
+        if ((address.value & mask) !== address.value) {
+            throw new Error(`${cidr} has host bits set`);
+        }
+        this.version = address.version;
+        this.networkAddress = address.value;
+        this.prefixlen = prefixlen;
+        this.#mask = mask;
+    }
+    /** Whether `address` lies in this network (Python's `ip in network`). */
+    contains(address) {
+        return address.version === this.version && (address.value & this.#mask) === this.networkAddress;
+    }
+    toString() {
+        return `${formatAddress({ version: this.version, value: this.networkAddress })}/${this.prefixlen}`;
+    }
+}
+function formatAddress(address) {
+    if (address.version === 4) {
+        const v = address.value;
+        return [24n, 16n, 8n, 0n].map((s) => ((v >> s) & 0xffn).toString()).join(".");
+    }
+    const groups = [];
+    for (let s = 112n; s >= 0n; s -= 16n)
+        groups.push(((address.value >> s) & 0xffffn).toString(16));
+    return groups.join(":");
+}
+// The IANA special-purpose registries, as Python's `ipaddress` lists them.
+const IPV4_PRIVATE = [
+    "0.0.0.0/8",
+    "10.0.0.0/8",
+    "127.0.0.0/8",
+    "169.254.0.0/16",
+    "172.16.0.0/12",
+    "192.0.0.0/29",
+    "192.0.0.170/31",
+    "192.0.2.0/24",
+    "192.168.0.0/16",
+    "198.18.0.0/15",
+    "198.51.100.0/24",
+    "203.0.113.0/24",
+    "240.0.0.0/4",
+    "255.255.255.255/32",
+].map((n) => new IPNetwork(n));
+const IPV4_PRIVATE_EXCEPTIONS = ["192.0.0.9/32", "192.0.0.10/32"].map((n) => new IPNetwork(n));
+const IPV4_SHARED_ADDRESS_SPACE = new IPNetwork("100.64.0.0/10");
+const IPV6_PRIVATE = [
+    "::1/128",
+    "::/128",
+    "::ffff:0:0/96",
+    "64:ff9b:1::/48",
+    "100::/64",
+    "2001::/23",
+    "2001:db8::/32",
+    "2002::/16",
+    "3fff::/20",
+    "fc00::/7",
+    "fe80::/10",
+].map((n) => new IPNetwork(n));
+const IPV6_PRIVATE_EXCEPTIONS = [
+    "2001:1::1/128",
+    "2001:1::2/128",
+    "2001:3::/32",
+    "2001:4:112::/48",
+    "2001:20::/28",
+    "2001:30::/28",
+].map((n) => new IPNetwork(n));
+const IPV4_MAPPED = new IPNetwork("::ffff:0:0/96");
+/** Python's `ip_address(...).is_global`. */
+export function ipAddressIsGlobal(address) {
+    if (address.version === 4) {
+        const isPrivate = IPV4_PRIVATE.some((n) => n.contains(address)) &&
+            !IPV4_PRIVATE_EXCEPTIONS.some((n) => n.contains(address));
+        return !IPV4_SHARED_ADDRESS_SPACE.contains(address) && !isPrivate;
+    }
+    // An IPv4-mapped address is judged by the IPv4 address it carries.
+    if (IPV4_MAPPED.contains(address)) {
+        return ipAddressIsGlobal({ version: 4, value: address.value & 0xffffffffn });
+    }
+    const isPrivate = IPV6_PRIVATE.some((n) => n.contains(address)) &&
+        !IPV6_PRIVATE_EXCEPTIONS.some((n) => n.contains(address));
+    return !isPrivate;
+}
+function nodeDns() {
+    const proc = globalThis.process;
+    try {
+        return proc?.getBuiltinModule?.("node:dns")?.promises ?? null;
+    }
+    catch (e) {
+        rethrowIfCancelled(e);
+        return null;
+    }
+}
+/** The default resolver: IP literals as-is, hostnames through `node:dns` if available. */
+export const defaultHostResolver = async (hostname) => {
+    try {
+        ipAddress(hostname);
+        return [hostname];
+    }
+    catch (e) {
+        rethrowIfCancelled(e);
+    }
+    const dns = nodeDns();
+    if (!dns) {
+        throw new Error(`no DNS resolver available to resolve '${hostname}'`);
+    }
+    const infos = await abortable(dns.lookup(hostname, { all: true }));
+    return infos.map((info) => info.address);
+};
+let hostResolver = defaultHostResolver;
+/** Install the resolver `classifyUrlReachability` uses. Pass `null` for the default. */
+export function setHostResolver(resolver) {
+    hostResolver = resolver ?? defaultHostResolver;
+}
+function getenv(name) {
+    return globalThis.process?.env?.[name];
+}
+/**
+ * Return trusted networks from the `PIPECAT_ALLOWED_FILE_URL_NETWORKS` env var.
+ *
+ * Parses a comma-separated list of CIDR ranges (e.g.
+ * `10.0.0.0/8,192.168.0.0/16`). Returns an empty list (trust only the
+ * public internet) when the variable is unset or empty.
+ */
+export function defaultAllowedFileUrlNetworks() {
+    const val = getenv("PIPECAT_ALLOWED_FILE_URL_NETWORKS") ?? "";
+    return val
+        .split(",")
+        .map((n) => n.trim())
+        .filter((n) => n);
+}
+function urlHostname(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch (e) {
+        rethrowIfCancelled(e);
+        return null;
+    }
+    let hostname = parsed.hostname;
+    // `URL` keeps the brackets around IPv6 literals; `urlsplit` does not.
+    if (hostname.startsWith("[") && hostname.endsWith("]")) {
+        hostname = hostname.slice(1, -1);
+    }
+    return hostname ? hostname.toLowerCase() : null;
+}
+/**
+ * Classify who can safely reach `url`'s host: the public internet, this server, or no one.
+ *
+ * Resolution happens once, up front; it doesn't defend against a target
+ * that resolves differently between this check and the actual connection
+ * (DNS rebinding).
+ *
+ * @param url The URL to classify.
+ * @param allowedNetworks Private networks this server is trusted to reach
+ *   directly (e.g. where a deployment's own file servers live), beyond the
+ *   public internet.
+ * @returns `PUBLIC` if every resolved address is publicly routable — safe to
+ *   hand to a third party (e.g. an LLM provider) to fetch itself.
+ *   `ALLOWED` if not publicly routable, but every address falls within
+ *   `allowedNetworks` — safe for this server to fetch directly, but not to
+ *   hand off to a third party that can't reach it.
+ *   `BLOCKED` otherwise: loopback, link-local (including the cloud metadata
+ *   range `169.254.0.0/16`), private (RFC 1918), or unique-local (IPv6 ULA)
+ *   addresses outside `allowedNetworks`, or a host that fails to resolve.
+ */
+export async function classifyUrlReachability(url, allowedNetworks = []) {
+    const hostname = urlHostname(url);
+    if (!hostname) {
+        return UrlReachability.BLOCKED;
+    }
+    let addresses;
+    try {
+        addresses = await hostResolver(hostname);
+    }
+    catch (e) {
+        rethrowIfCancelled(e);
+        return UrlReachability.BLOCKED;
+    }
+    if (addresses.length === 0) {
+        return UrlReachability.BLOCKED;
+    }
+    const ips = addresses.map((a) => ipAddress(a));
+    if (ips.every((ip) => ipAddressIsGlobal(ip))) {
+        return UrlReachability.PUBLIC;
+    }
+    if (ips.every((ip) => ipAddressIsGlobal(ip) || allowedNetworks.some((network) => network.contains(ip)))) {
+        return UrlReachability.ALLOWED;
+    }
+    return UrlReachability.BLOCKED;
+}
+//# sourceMappingURL=ssrf.js.map

package/dist/utils/shared.d.ts

@@ -0,0 +1,35 @@
+type AsyncMethod<This, A extends unknown[], T> = (this: This, ...args: A) => Promise<T>;
+/**
+ * Run the decorated method for the first owner to acquire `name`.
+ *
+ * Owners that arrive while the first is still running wait for it to finish,
+ * so no caller continues against a half-built resource. Later owners return
+ * `null` without running the method again.
+ *
+ * A method that throws leaves the resource unbuilt, and every owner of it is
+ * told: the error is re-thrown to each one that arrives later, rather than the
+ * method being attempted again. So the owners of a resource share its verdict,
+ * and a pair of processors sharing a client either both come up or both fail.
+ *
+ * Note: the lock is not reentrant, so a method must not call another method
+ * that acquires the same resource.
+ *
+ * @param name The resource being acquired. Names are per instance, so paired
+ *   operations on the same object (e.g. `setup`/`cleanup` and `join`/`leave`)
+ *   count their owners separately.
+ */
+export declare function acquires(name: string): <This extends object, A extends unknown[], T>(func: AsyncMethod<This, A, T>, _context?: unknown) => AsyncMethod<This, A, T | null>;
+/**
+ * Run the decorated method for the last owner to release `name`.
+ *
+ * Every other owner returns `null`, as does a release that no acquire
+ * matched.
+ *
+ * Note: the lock is not reentrant, so a method must not call another method
+ * that releases the same resource.
+ *
+ * @param name The resource being released, matching the `acquires` name.
+ */
+export declare function releases(name: string): <This extends object, A extends unknown[], T>(func: AsyncMethod<This, A, T>, _context?: unknown) => AsyncMethod<This, A, T | null>;
+export {};
+//# sourceMappingURL=shared.d.ts.map