langflower 0.1.0 → 0.1.1

package/vendor/tools/dist/path-sandbox.js

@@ -1,96 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-const DEFAULT_DENY = [
-    '.git/',
-    'node_modules/',
-    '.langflower/secrets/',
-];
-const isUnderRoot = (absolute, root) => {
-    const relative = path.relative(path.resolve(root), absolute);
-    return (relative === '' ||
-        (!relative.startsWith('..') && !path.isAbsolute(relative)));
-};
-const matchesDeny = (posixRelative, denyPaths) => [...denyPaths, ...DEFAULT_DENY].find((pattern) => {
-    const normalized = pattern.replace(/\\/g, '/').replace(/^\//, '');
-    return (posixRelative === normalized.replace(/\/$/, '') ||
-        posixRelative.startsWith(normalized.endsWith('/') ? normalized : `${normalized}/`) ||
-        (normalized.endsWith('/') && posixRelative.startsWith(normalized)));
-});
-/**
- * Resolve which fence root contains `absolute` — project root first, then
- * allowlisted roots. Returns `null` when the path is outside every fence.
- */
-export const resolveFenceRoot = (projectRoot, absolute, allowedRoots = []) => {
-    const project = path.resolve(projectRoot);
-    if (isUnderRoot(absolute, project)) {
-        return project;
-    }
-    for (const entry of allowedRoots) {
-        const root = path.resolve(projectRoot, entry);
-        if (isUnderRoot(absolute, root)) {
-            return root;
-        }
-    }
-    return null;
-};
-/**
- * Path string suitable for later harness tool calls.
- * Project-scoped → relative; allowlisted outside → absolute (posix `/`).
- */
-export const toHarnessDisplayPath = (projectRoot, absolute, allowedRoots = []) => {
-    const fence = resolveFenceRoot(projectRoot, absolute, allowedRoots);
-    const project = path.resolve(projectRoot);
-    if (fence === project) {
-        return path.relative(project, absolute).split(path.sep).join('/');
-    }
-    return absolute.split(path.sep).join('/');
-};
-/**
- * Resolve `userPath` under the project root, or under an allowlisted extra
- * root when the path escapes the project (absolute vault paths, …).
- */
-const isPathFenceOptions = (value) => !Array.isArray(value);
-const asPathFenceOptions = (denyOrOptions) => isPathFenceOptions(denyOrOptions)
-    ? denyOrOptions
-    : { denyPaths: denyOrOptions };
-export const resolveProjectPath = (projectRoot, userPath, denyOrOptions = {}) => {
-    const options = asPathFenceOptions(denyOrOptions);
-    const denyPaths = options.denyPaths ?? DEFAULT_DENY;
-    const allowedRoots = options.allowedRoots ?? [];
-    const trimmed = userPath.trim();
-    if (trimmed.length === 0) {
-        throw new Error('Path is required.');
-    }
-    const project = path.resolve(projectRoot);
-    const candidate = path.isAbsolute(trimmed)
-        ? path.resolve(trimmed)
-        : path.resolve(project, trimmed);
-    const fence = resolveFenceRoot(project, candidate, allowedRoots);
-    if (fence === null) {
-        throw new Error(`Path escapes project root: «${userPath}». Stay under the project directory, or add the vault to harness.allowedRoots.`);
-    }
-    const posixRelative = path
-        .relative(fence, candidate)
-        .split(path.sep)
-        .join('/');
-    const denied = matchesDeny(posixRelative, denyPaths);
-    if (denied !== undefined) {
-        throw new Error(`Path is denied by sandbox policy: «${userPath}» (matched «${denied}»).`);
-    }
-    return candidate;
-};
-const listSiblingHints = async (absolutePath, limit = 8) => {
-    const parent = path.dirname(absolutePath);
-    try {
-        const entries = await fs.readdir(parent);
-        return entries.slice(0, limit);
-    }
-    catch {
-        return [];
-    }
-};
-export const formatNotFound = async (absolutePath, userPath) => {
-    const siblings = await listSiblingHints(absolutePath);
-    const hint = siblings.length > 0 ? ` Nearby names: ${siblings.join(', ')}.` : '';
-    return `File not found: «${userPath}».${hint}`;
-};

package/vendor/tools/dist/permission.d.ts

@@ -1,75 +0,0 @@
-/**
- * OpenCode-style permission resolver for harness tools.
- *
- * Policy comes from `langflower.jsonc` `permission` (project floor) plus
- * per-node `toolPermissions` (clamped to floor). This is the runtime security
- * boundary.
- */
-export type PermissionDecision = 'allow' | 'ask' | 'deny';
-/** Per-tool rules: pattern → decision, or a single decision for `*`. */
-export type PermissionToolConfig = PermissionDecision | Readonly<Record<string, PermissionDecision>>;
-/** Top-level `permission` block keyed by tool id (`read`, `bash`, …). */
-export type PermissionConfig = Readonly<Record<string, PermissionToolConfig>>;
-export type PermissionAskRequest = {
-    readonly toolId: string;
-    readonly detail: string;
-    readonly summary: string;
-};
-/** Defaults when `permission` is missing or incomplete — allow-all. */
-export declare const DEFAULT_PERMISSION_CONFIG: PermissionConfig;
-/**
- * Match OpenCode-style patterns:
- * - `*` — anything
- * - path globs with `**` / `*` (e.g. all markdown under a tree, `docs/**`)
- * - command prefixes with trailing `*` (`git diff*`, `rm *`)
- */
-export declare const matchPermissionPattern: (pattern: string, detail: string) => boolean;
-/**
- * Resolve allow|ask|deny for one tool call.
- * Among matching patterns, longest pattern wins; ties prefer deny > ask > allow.
- */
-export declare const resolvePermission: (config: PermissionConfig | undefined, toolId: string, detail: string) => PermissionDecision;
-/** Extract the path/command string used for pattern matching. */
-export declare const permissionDetailForCall: (toolId: string, args: Readonly<Record<string, unknown>>) => string;
-/**
- * Permission detail for an MCP invoke — remote tool name plus a stable args
- * digest so grants/patterns are not collapsed to a single `'mcp'` key.
- */
-export declare const permissionDetailForMcpCall: (remoteName: string, args: Readonly<Record<string, unknown>>) => string;
-export declare const permissionAskSummary: (toolId: string, detail: string) => string;
-export declare const grantKeyForCall: (toolId: string, detail: string) => string;
-/**
- * Shallow per-tool merge: later layers replace whole tool configs.
- * Used for project config ← node toolPermissions overlays.
- */
-export declare const mergePermissionConfigs: (...layers: readonly (PermissionConfig | undefined)[]) => PermissionConfig;
-export declare const permissionDecisionRank: (decision: PermissionDecision) => number;
-/** Stricter of two decisions (`deny` > `ask` > `allow`). */
-export declare const stricterPermission: (left: PermissionDecision, right: PermissionDecision) => PermissionDecision;
-/**
- * Coarse floor decision for Inspector radios.
- * Shorthand / `*` rule; if only patterns: any allow → allow ceiling, else any
- * ask → ask, else deny.
- */
-export declare const toolFloorDecision: (config: PermissionConfig | undefined, toolId: string) => PermissionDecision;
-/** Clamp a node choice so it cannot loosen past the project floor. */
-export declare const clampToolPermission: (floor: PermissionDecision, node: PermissionDecision) => PermissionDecision;
-/**
- * Radios valid under floor (node may only tighten).
- * Floor deny → empty (row should be hidden).
- */
-export declare const validNodePermissionOptions: (floor: PermissionDecision) => readonly PermissionDecision[];
-/**
- * True when every rule for `toolId` is `deny` (no allow/ask path).
- * Unknown tool ids (no default and no project entry) are **not** always-deny
- * — wired/domain tools are outside the harness permission map.
- */
-export declare const isToolAlwaysDenied: (config: PermissionConfig | undefined, toolId: string) => boolean;
-/**
- * Overlay coarse node toolPermissions onto project config, clamping each
- * node decision to the project floor.
- */
-export declare const mergeProjectAndNodePermissions: (projectPermission: PermissionConfig | undefined, nodeToolPermissions: Readonly<Record<string, PermissionDecision>> | undefined) => PermissionConfig;
-/** Hint appended to permission-deny tool results (author vs runtime gate). */
-export declare const PERMISSION_DENY_HINT = "Tighten or loosen via Inspector tool permissions (within project floor) or edit permission.<tool> in .langflower/langflower.jsonc.";
-export declare const formatPermissionDeniedText: (toolId: string, detail: string) => string;

package/vendor/tools/dist/permission.js

@@ -1,264 +0,0 @@
-/**
- * OpenCode-style permission resolver for harness tools.
- *
- * Policy comes from `langflower.jsonc` `permission` (project floor) plus
- * per-node `toolPermissions` (clamped to floor). This is the runtime security
- * boundary.
- */
-/** Defaults when `permission` is missing or incomplete — allow-all. */
-export const DEFAULT_PERMISSION_CONFIG = {
-    read: { '*': 'allow' },
-    glob: { '*': 'allow' },
-    grep: { '*': 'allow' },
-    edit: { '*': 'allow' },
-    write: { '*': 'allow' },
-    create: { '*': 'allow' },
-    delete: { '*': 'allow' },
-    bash: { '*': 'allow' },
-};
-const DECISION_RANK = {
-    deny: 3,
-    ask: 2,
-    allow: 1,
-};
-const isDecision = (value) => value === 'allow' || value === 'ask' || value === 'deny';
-const escapeRegExp = (text) => text.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-/**
- * Match OpenCode-style patterns:
- * - `*` — anything
- * - path globs with `**` / `*` (e.g. all markdown under a tree, `docs/**`)
- * - command prefixes with trailing `*` (`git diff*`, `rm *`)
- */
-export const matchPermissionPattern = (pattern, detail) => {
-    const normalizedPattern = pattern.trim();
-    const normalizedDetail = detail;
-    if (normalizedPattern.length === 0) {
-        return false;
-    }
-    if (normalizedPattern === '*') {
-        return true;
-    }
-    const pathStyle = normalizedPattern.includes('/') || normalizedPattern.includes('**');
-    if (pathStyle) {
-        const posixDetail = normalizedDetail.replace(/\\/g, '/');
-        let regexSource = '';
-        for (let i = 0; i < normalizedPattern.length; i += 1) {
-            if (normalizedPattern.startsWith('**/', i)) {
-                regexSource += '(?:.*/)?';
-                i += 2;
-                continue;
-            }
-            if (normalizedPattern.startsWith('**', i)) {
-                regexSource += '.*';
-                i += 1;
-                continue;
-            }
-            const ch = normalizedPattern[i] ?? '';
-            if (ch === '*') {
-                regexSource += '[^/]*';
-                continue;
-            }
-            regexSource += escapeRegExp(ch);
-        }
-        return new RegExp(`^${regexSource}$`).test(posixDetail);
-    }
-    let regexSource = '';
-    for (const ch of normalizedPattern) {
-        if (ch === '*') {
-            regexSource += '[\\s\\S]*';
-            continue;
-        }
-        regexSource += escapeRegExp(ch);
-    }
-    return new RegExp(`^${regexSource}$`).test(normalizedDetail);
-};
-const rulesForTool = (config, toolId) => {
-    const raw = config[toolId] ?? DEFAULT_PERMISSION_CONFIG[toolId];
-    if (raw === undefined) {
-        return { '*': 'deny' };
-    }
-    if (isDecision(raw)) {
-        return { '*': raw };
-    }
-    const entries = Object.entries(raw).filter((entry) => isDecision(entry[1]));
-    if (entries.length === 0) {
-        return { '*': 'deny' };
-    }
-    return Object.fromEntries(entries);
-};
-/**
- * Resolve allow|ask|deny for one tool call.
- * Among matching patterns, longest pattern wins; ties prefer deny > ask > allow.
- */
-export const resolvePermission = (config, toolId, detail) => {
-    const merged = {
-        ...DEFAULT_PERMISSION_CONFIG,
-        ...(config ?? {}),
-    };
-    const rules = rulesForTool(merged, toolId);
-    const matches = Object.entries(rules).filter(([pattern]) => matchPermissionPattern(pattern, detail));
-    if (matches.length === 0) {
-        return 'deny';
-    }
-    matches.sort((a, b) => {
-        const lengthDelta = b[0].length - a[0].length;
-        if (lengthDelta !== 0) {
-            return lengthDelta;
-        }
-        return DECISION_RANK[b[1]] - DECISION_RANK[a[1]];
-    });
-    return matches[0]?.[1] ?? 'deny';
-};
-/** Extract the path/command string used for pattern matching. */
-export const permissionDetailForCall = (toolId, args) => {
-    if (toolId === 'bash') {
-        return typeof args.command === 'string' ? args.command : '';
-    }
-    if (typeof args.path === 'string' && args.path.length > 0) {
-        return args.path.replace(/\\/g, '/');
-    }
-    if (typeof args.file === 'string' && args.file.length > 0) {
-        return args.file.replace(/\\/g, '/');
-    }
-    if (typeof args.url === 'string' && args.url.length > 0) {
-        return args.url;
-    }
-    if (typeof args.key === 'string' && args.key.length > 0) {
-        return args.key;
-    }
-    if (typeof args.collectionId === 'string' && args.collectionId.length > 0) {
-        return args.collectionId;
-    }
-    return '*';
-};
-const MCP_DETAIL_ARGS_CAP = 180;
-/**
- * Permission detail for an MCP invoke — remote tool name plus a stable args
- * digest so grants/patterns are not collapsed to a single `'mcp'` key.
- */
-export const permissionDetailForMcpCall = (remoteName, args) => {
-    const name = remoteName.trim().length > 0 ? remoteName.trim() : 'mcp';
-    const fromArgs = permissionDetailForCall('_', args);
-    if (fromArgs !== '*') {
-        return `${name}:${fromArgs}`;
-    }
-    const keys = Object.keys(args).sort();
-    if (keys.length === 0) {
-        return name;
-    }
-    try {
-        const digest = JSON.stringify(args, keys);
-        if (digest.length <= MCP_DETAIL_ARGS_CAP) {
-            return `${name}:${digest}`;
-        }
-        return `${name}:${digest.slice(0, MCP_DETAIL_ARGS_CAP)}…`;
-    }
-    catch {
-        return name;
-    }
-};
-export const permissionAskSummary = (toolId, detail) => {
-    if (toolId === 'bash') {
-        return `Allow bash: ${detail.length > 0 ? detail : '(empty command)'}?`;
-    }
-    return `Allow ${toolId}: ${detail.length > 0 ? detail : '(no path)'}?`;
-};
-export const grantKeyForCall = (toolId, detail) => `${toolId}\0${detail}`;
-/**
- * Shallow per-tool merge: later layers replace whole tool configs.
- * Used for project config ← node toolPermissions overlays.
- */
-export const mergePermissionConfigs = (...layers) => layers.reduce((acc, layer) => (layer === undefined ? acc : { ...acc, ...layer }), {});
-export const permissionDecisionRank = (decision) => DECISION_RANK[decision];
-/** Stricter of two decisions (`deny` > `ask` > `allow`). */
-export const stricterPermission = (left, right) => DECISION_RANK[left] >= DECISION_RANK[right] ? left : right;
-/**
- * Coarse floor decision for Inspector radios.
- * Shorthand / `*` rule; if only patterns: any allow → allow ceiling, else any
- * ask → ask, else deny.
- */
-export const toolFloorDecision = (config, toolId) => {
-    const merged = {
-        ...DEFAULT_PERMISSION_CONFIG,
-        ...(config ?? {}),
-    };
-    if (merged[toolId] === undefined &&
-        DEFAULT_PERMISSION_CONFIG[toolId] === undefined) {
-        return 'allow';
-    }
-    const rules = rulesForTool(merged, toolId);
-    const star = rules['*'];
-    if (star !== undefined && Object.keys(rules).length === 1) {
-        return star;
-    }
-    const decisions = Object.values(rules);
-    if (decisions.some((decision) => decision === 'allow')) {
-        return 'allow';
-    }
-    if (decisions.some((decision) => decision === 'ask')) {
-        return 'ask';
-    }
-    return 'deny';
-};
-/** Clamp a node choice so it cannot loosen past the project floor. */
-export const clampToolPermission = (floor, node) => stricterPermission(floor, node);
-/**
- * Radios valid under floor (node may only tighten).
- * Floor deny → empty (row should be hidden).
- */
-export const validNodePermissionOptions = (floor) => {
-    if (floor === 'deny') {
-        return [];
-    }
-    if (floor === 'ask') {
-        return ['deny', 'ask'];
-    }
-    return ['deny', 'ask', 'allow'];
-};
-/**
- * True when every rule for `toolId` is `deny` (no allow/ask path).
- * Unknown tool ids (no default and no project entry) are **not** always-deny
- * — wired/domain tools are outside the harness permission map.
- */
-export const isToolAlwaysDenied = (config, toolId) => {
-    const merged = {
-        ...DEFAULT_PERMISSION_CONFIG,
-        ...(config ?? {}),
-    };
-    if (merged[toolId] === undefined &&
-        DEFAULT_PERMISSION_CONFIG[toolId] === undefined) {
-        return false;
-    }
-    const rules = rulesForTool(merged, toolId);
-    const decisions = Object.values(rules);
-    return (decisions.length > 0 &&
-        decisions.every((decision) => decision === 'deny'));
-};
-/**
- * Overlay coarse node toolPermissions onto project config, clamping each
- * node decision to the project floor.
- */
-export const mergeProjectAndNodePermissions = (projectPermission, nodeToolPermissions) => {
-    const project = {
-        ...DEFAULT_PERMISSION_CONFIG,
-        ...(projectPermission ?? {}),
-    };
-    if (nodeToolPermissions === undefined) {
-        return projectPermission ?? {};
-    }
-    const nodeEntries = [];
-    for (const [toolId, decision] of Object.entries(nodeToolPermissions)) {
-        if (!isDecision(decision)) {
-            continue;
-        }
-        const floor = toolFloorDecision(project, toolId);
-        nodeEntries.push([toolId, clampToolPermission(floor, decision)]);
-    }
-    return mergePermissionConfigs(projectPermission, Object.fromEntries(nodeEntries));
-};
-/** Hint appended to permission-deny tool results (author vs runtime gate). */
-export const PERMISSION_DENY_HINT = 'Tighten or loosen via Inspector tool permissions (within project floor) or edit permission.<tool> in .langflower/langflower.jsonc.';
-export const formatPermissionDeniedText = (toolId, detail) => {
-    const target = detail.length > 0 ? `${toolId} (${detail})` : toolId;
-    return `Permission denied for ${target}. Effective policy is deny (project floor and/or node toolPermissions). ${PERMISSION_DENY_HINT}`;
-};

package/vendor/tools/dist/post-process.d.ts

@@ -1,9 +0,0 @@
-export type PostProcessOptions = {
-    readonly timeoutMs?: number;
-    readonly maxOutputChars?: number;
-};
-/**
- * Run agent-supplied `(res: string) => string` source in an isolated VM.
- * Fail closed: throw on timeout, non-function, non-string, or oversized output.
- */
-export declare const runReadClassPostProcess: (source: string, input: string, options?: PostProcessOptions) => string;

package/vendor/tools/dist/post-process.js

@@ -1,36 +0,0 @@
-import vm from 'node:vm';
-const DEFAULT_TIMEOUT_MS = 50;
-const DEFAULT_MAX_OUTPUT_CHARS = 200_000;
-/**
- * Run agent-supplied `(res: string) => string` source in an isolated VM.
- * Fail closed: throw on timeout, non-function, non-string, or oversized output.
- */
-export const runReadClassPostProcess = (source, input, options = {}) => {
-    const trimmed = source.trim();
-    if (trimmed.length === 0) {
-        throw new Error('postProcess source is empty.');
-    }
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const maxOutputChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
-    const sandbox = {
-        __input: input,
-        __result: undefined,
-    };
-    try {
-        vm.runInNewContext(`__result = (${trimmed})(__input)`, sandbox, {
-            timeout: timeoutMs,
-            displayErrors: true,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`postProcess failed: ${message}`);
-    }
-    if (typeof sandbox.__result !== 'string') {
-        throw new Error(`postProcess must return a string (got ${typeof sandbox.__result}).`);
-    }
-    if (sandbox.__result.length > maxOutputChars) {
-        throw new Error(`postProcess output exceeds ${maxOutputChars} characters.`);
-    }
-    return sandbox.__result;
-};

package/vendor/tools/dist/ssrf-guard.d.ts

@@ -1,22 +0,0 @@
-/** True when the address is loopback, private, link-local, or metadata. */
-export declare const isBlockedIpAddress: (address: string) => boolean;
-export type AssertUrlSafeOptions = {
-    readonly allowedHosts?: readonly string[];
-    /** When true, skip DNS resolution (hostname-only checks). */
-    readonly skipDns?: boolean;
-};
-/**
- * Validated URL plus addresses that passed the SSRF check.
- * Callers should pin the TCP connect to {@link pinnedAddresses} so DNS cannot
- * rebind between check and fetch.
- */
-export type SafeFetchTarget = {
-    readonly url: URL;
-    /** Public addresses validated at check time; empty when `skipDns`. */
-    readonly pinnedAddresses: readonly string[];
-};
-/**
- * Reject non-http(s) URLs, blocked hostnames, and (by default) private IPs
- * after DNS resolution. Optional `allowedHosts` is an exact hostname allowlist.
- */
-export declare const assertUrlSafeForFetch: (rawUrl: string, options?: AssertUrlSafeOptions) => Promise<SafeFetchTarget>;

package/vendor/tools/dist/ssrf-guard.js

@@ -1,119 +0,0 @@
-import dns from 'node:dns/promises';
-import net from 'node:net';
-const BLOCKED_HOSTNAMES = new Set([
-    'localhost',
-    'localhost.localdomain',
-    'metadata.google.internal',
-]);
-const isIpv4Private = (ip) => {
-    const parts = ip.split('.').map((part) => Number(part));
-    if (parts.length !== 4 ||
-        parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
-        return false;
-    }
-    const a = parts[0] ?? 0;
-    const b = parts[1] ?? 0;
-    if (a === 10) {
-        return true;
-    }
-    if (a === 127) {
-        return true;
-    }
-    if (a === 0) {
-        return true;
-    }
-    if (a === 169 && b === 254) {
-        return true;
-    }
-    if (a === 172 && b >= 16 && b <= 31) {
-        return true;
-    }
-    if (a === 192 && b === 168) {
-        return true;
-    }
-    if (a === 100 && b >= 64 && b <= 127) {
-        return true;
-    }
-    return false;
-};
-const isIpv6Private = (ip) => {
-    const normalized = ip.toLowerCase();
-    if (normalized === '::1' || normalized === '::') {
-        return true;
-    }
-    if (normalized.startsWith('fc') || normalized.startsWith('fd')) {
-        return true;
-    }
-    if (normalized.startsWith('fe80:')) {
-        return true;
-    }
-    // IPv4-mapped IPv6 (:ffff:x.x.x.x)
-    const mapped = normalized.match(/^:ffff:(\d+\.\d+\.\d+\.\d+)$/i);
-    if (mapped?.[1] !== undefined) {
-        return isIpv4Private(mapped[1]);
-    }
-    return false;
-};
-/** True when the address is loopback, private, link-local, or metadata. */
-export const isBlockedIpAddress = (address) => {
-    const family = net.isIP(address);
-    if (family === 4) {
-        return isIpv4Private(address);
-    }
-    if (family === 6) {
-        return isIpv6Private(address);
-    }
-    return true;
-};
-/**
- * Reject non-http(s) URLs, blocked hostnames, and (by default) private IPs
- * after DNS resolution. Optional `allowedHosts` is an exact hostname allowlist.
- */
-export const assertUrlSafeForFetch = async (rawUrl, options = {}) => {
-    let parsed;
-    try {
-        parsed = new URL(rawUrl);
-    }
-    catch {
-        throw new Error(`Invalid URL: ${rawUrl}`);
-    }
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        throw new Error(`Blocked URL protocol «${parsed.protocol}» (only http/https).`);
-    }
-    const hostname = parsed.hostname.toLowerCase();
-    if (hostname.length === 0) {
-        throw new Error('URL hostname is empty.');
-    }
-    if (BLOCKED_HOSTNAMES.has(hostname) ||
-        hostname.endsWith('.localhost') ||
-        hostname.endsWith('.local')) {
-        throw new Error(`Blocked hostname «${hostname}».`);
-    }
-    const allowed = options.allowedHosts?.map((host) => host.toLowerCase());
-    if (allowed !== undefined && allowed.length > 0) {
-        if (!allowed.includes(hostname)) {
-            throw new Error(`Hostname «${hostname}» is not in harness.allowedHosts.`);
-        }
-    }
-    if (net.isIP(hostname) !== 0) {
-        if (isBlockedIpAddress(hostname)) {
-            throw new Error(`Blocked IP address «${hostname}».`);
-        }
-        return { url: parsed, pinnedAddresses: [hostname] };
-    }
-    if (options.skipDns === true) {
-        return { url: parsed, pinnedAddresses: [] };
-    }
-    const records = await dns.lookup(hostname, { all: true, verbatim: true });
-    if (records.length === 0) {
-        throw new Error(`DNS lookup failed for «${hostname}».`);
-    }
-    const blocked = records.find((record) => isBlockedIpAddress(record.address));
-    if (blocked !== undefined) {
-        throw new Error(`Blocked: «${hostname}» resolves to private/link-local address ${blocked.address}.`);
-    }
-    return {
-        url: parsed,
-        pinnedAddresses: records.map((record) => record.address),
-    };
-};