@dbx-tools/appkit-web-search 0.6.71 → 0.6.73

package/README.md

@@ -205,14 +205,16 @@ URL's hostname, and a bare host also matches its subdomains; a path entry
 design: `web_search` citations are silently filtered to the permitted set (the
 model never surfaces a source it then can't fetch), while an explicit `web_fetch`
 of a disallowed URL is refused with an error (a visible, correctable mistake).
+`web_fetch` accepts only HTTPS targets that resolve to public addresses, and
+reapplies both checks before every redirect request.
 
 Which of the two modes is in force is named by `urlPolicy`, and the effective
 mode is in the boot log:
 
-| `urlPolicy`      | Effect                                            |
-| ---------------- | ------------------------------------------------- |
-| `"allowlist"`    | Only `allowedUrls` entries are reachable          |
-| `"unrestricted"` | Any URL is reachable; the open mode, stated aloud |
+| `urlPolicy`      | Effect                                   |
+| ---------------- | ---------------------------------------- |
+| `"allowlist"`    | Only `allowedUrls` entries are reachable |
+| `"unrestricted"` | Any public HTTPS URL is reachable        |
 
 Leave `urlPolicy` unset and it follows `allowedUrls`: `"allowlist"` when there
 are entries, `"unrestricted"` when there are none. Set it to say which one you

package/lib/src/_fetch-url.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Network policy for page fetches.
+ *
+ * Every request, including redirects, is HTTPS, matches the configured URL
+ * allow-list, and resolves only to public addresses. Resolution happens in the
+ * request hook immediately before I/O so a redirect cannot bypass the policy.
+ *
+ * @module
+ */
+import { type UrlAllowList } from "./allowlist.ts";
+/** DNS result shape used by Node and by deterministic tests. */
+export interface ResolvedAddress {
+    address: string;
+    family: number;
+}
+/** Injectable DNS resolver for fetch-policy tests. */
+export type ResolveAddresses = (hostname: string) => Promise<readonly ResolvedAddress[]>;
+/**
+ * Validate one concrete page-fetch target immediately before network I/O.
+ *
+ * Rejects embedded credentials, non-HTTPS URLs, disallowed hosts/paths, and
+ * hostnames whose DNS answers include any private, loopback, link-local, or
+ * reserved address.
+ */
+export declare function assertFetchUrlAllowed(value: string, allowList: UrlAllowList, resolve?: ResolveAddresses): Promise<void>;

package/lib/src/_fetch-url.js

@@ -0,0 +1,79 @@
+/**
+ * Network policy for page fetches.
+ *
+ * Every request, including redirects, is HTTPS, matches the configured URL
+ * allow-list, and resolves only to public addresses. Resolution happens in the
+ * request hook immediately before I/O so a redirect cannot bypass the policy.
+ *
+ * @module
+ */
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+import { ValidationError } from "@databricks/appkit";
+import { assertUrlAllowed } from "./allowlist.js";
+/** Resolve all addresses for a hostname without changing their family. */
+async function resolveAddresses(hostname) {
+    return lookup(hostname, { all: true, verbatim: true });
+}
+/** Whether an IPv4 address is private, local, reserved, or non-unicast. */
+function isBlockedIpv4(address) {
+    const [a = -1, b = -1, c = -1] = address.split(".").map(Number);
+    return (a === 0 ||
+        a === 10 ||
+        a === 127 ||
+        a >= 224 ||
+        (a === 100 && b >= 64 && b <= 127) ||
+        (a === 169 && b === 254) ||
+        (a === 172 && b >= 16 && b <= 31) ||
+        (a === 192 && b === 0 && c === 0) ||
+        (a === 192 && b === 0 && c === 2) ||
+        (a === 192 && b === 168) ||
+        (a === 198 && (b === 18 || b === 19)) ||
+        (a === 198 && b === 51 && c === 100) ||
+        (a === 203 && b === 0 && c === 113));
+}
+/** Whether an IPv6 address is private, local, reserved, or non-unicast. */
+function isBlockedIpv6(address) {
+    const normalized = address.toLowerCase();
+    return (normalized === "::" ||
+        normalized === "::1" ||
+        normalized.startsWith("::ffff:") ||
+        normalized.startsWith("100:") ||
+        normalized.startsWith("2001:db8:") ||
+        normalized.startsWith("fc") ||
+        normalized.startsWith("fd") ||
+        /^fe[89ab]/.test(normalized) ||
+        normalized.startsWith("ff"));
+}
+/** Whether an address is globally routable enough for an outbound page fetch. */
+function isPublicAddress(address) {
+    return address.family === 6 ? !isBlockedIpv6(address.address) : !isBlockedIpv4(address.address);
+}
+/**
+ * Validate one concrete page-fetch target immediately before network I/O.
+ *
+ * Rejects embedded credentials, non-HTTPS URLs, disallowed hosts/paths, and
+ * hostnames whose DNS answers include any private, loopback, link-local, or
+ * reserved address.
+ */
+export async function assertFetchUrlAllowed(value, allowList, resolve = resolveAddresses) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw ValidationError.invalidValue("url", value, "an absolute HTTPS URL");
+    }
+    if (url.protocol !== "https:" || url.username || url.password) {
+        throw ValidationError.invalidValue("url", value, "an absolute HTTPS URL without embedded credentials");
+    }
+    assertUrlAllowed(url.href, allowList);
+    const literalFamily = isIP(url.hostname);
+    const addresses = literalFamily
+        ? [{ address: url.hostname, family: literalFamily }]
+        : await resolve(url.hostname);
+    if (addresses.length === 0 || addresses.some((address) => !isPublicAddress(address))) {
+        throw ValidationError.invalidValue("url", value, "a URL that resolves only to public addresses");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_fetch-url.js","sourceRoot":"","sources":["../../src/_fetch-url.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Network policy for page fetches.\n *\n * Every request, including redirects, is HTTPS, matches the configured URL\n * allow-list, and resolves only to public addresses. Resolution happens in the\n * request hook immediately before I/O so a redirect cannot bypass the policy.\n *\n * @module\n */\n\nimport { lookup } from \"node:dns/promises\";\nimport { isIP } from \"node:net\";\nimport { ValidationError } from \"@databricks/appkit\";\n\nimport { assertUrlAllowed, type UrlAllowList } from \"./allowlist.ts\";\n\n/** DNS result shape used by Node and by deterministic tests. */\nexport interface ResolvedAddress {\n  address: string;\n  family: number;\n}\n\n/** Injectable DNS resolver for fetch-policy tests. */\nexport type ResolveAddresses = (hostname: string) => Promise<readonly ResolvedAddress[]>;\n\n/** Resolve all addresses for a hostname without changing their family. */\nasync function resolveAddresses(hostname: string): Promise<readonly ResolvedAddress[]> {\n  return lookup(hostname, { all: true, verbatim: true });\n}\n\n/** Whether an IPv4 address is private, local, reserved, or non-unicast. */\nfunction isBlockedIpv4(address: string): boolean {\n  const [a = -1, b = -1, c = -1] = address.split(\".\").map(Number);\n  return (\n    a === 0 ||\n    a === 10 ||\n    a === 127 ||\n    a >= 224 ||\n    (a === 100 && b >= 64 && b <= 127) ||\n    (a === 169 && b === 254) ||\n    (a === 172 && b >= 16 && b <= 31) ||\n    (a === 192 && b === 0 && c === 0) ||\n    (a === 192 && b === 0 && c === 2) ||\n    (a === 192 && b === 168) ||\n    (a === 198 && (b === 18 || b === 19)) ||\n    (a === 198 && b === 51 && c === 100) ||\n    (a === 203 && b === 0 && c === 113)\n  );\n}\n\n/** Whether an IPv6 address is private, local, reserved, or non-unicast. */\nfunction isBlockedIpv6(address: string): boolean {\n  const normalized = address.toLowerCase();\n  return (\n    normalized === \"::\" ||\n    normalized === \"::1\" ||\n    normalized.startsWith(\"::ffff:\") ||\n    normalized.startsWith(\"100:\") ||\n    normalized.startsWith(\"2001:db8:\") ||\n    normalized.startsWith(\"fc\") ||\n    normalized.startsWith(\"fd\") ||\n    /^fe[89ab]/.test(normalized) ||\n    normalized.startsWith(\"ff\")\n  );\n}\n\n/** Whether an address is globally routable enough for an outbound page fetch. */\nfunction isPublicAddress(address: ResolvedAddress): boolean {\n  return address.family === 6 ? !isBlockedIpv6(address.address) : !isBlockedIpv4(address.address);\n}\n\n/**\n * Validate one concrete page-fetch target immediately before network I/O.\n *\n * Rejects embedded credentials, non-HTTPS URLs, disallowed hosts/paths, and\n * hostnames whose DNS answers include any private, loopback, link-local, or\n * reserved address.\n */\nexport async function assertFetchUrlAllowed(\n  value: string,\n  allowList: UrlAllowList,\n  resolve: ResolveAddresses = resolveAddresses,\n): Promise<void> {\n  let url: URL;\n  try {\n    url = new URL(value);\n  } catch {\n    throw ValidationError.invalidValue(\"url\", value, \"an absolute HTTPS URL\");\n  }\n  if (url.protocol !== \"https:\" || url.username || url.password) {\n    throw ValidationError.invalidValue(\n      \"url\",\n      value,\n      \"an absolute HTTPS URL without embedded credentials\",\n    );\n  }\n  assertUrlAllowed(url.href, allowList);\n\n  const literalFamily = isIP(url.hostname);\n  const addresses = literalFamily\n    ? [{ address: url.hostname, family: literalFamily }]\n    : await resolve(url.hostname);\n  if (addresses.length === 0 || addresses.some((address) => !isPublicAddress(address))) {\n    throw ValidationError.invalidValue(\n      \"url\",\n      value,\n      \"a URL that resolves only to public addresses\",\n    );\n  }\n}\n"]}

package/lib/src/fetch.js

@@ -16,7 +16,7 @@
  */
 import { log } from "@dbx-tools/shared-core";
 import { gotScraping } from "got-scraping";
-import { assertUrlAllowed } from "./allowlist.js";
+import { assertFetchUrlAllowed } from "./_fetch-url.js";
 import { toCallSettings, webFetchExecuteDefaults } from "./defaults.js";
 import { decodeHtmlEntities, htmlToText } from "./html-text.js";
 import { executeRead } from "./runtime.js";
@@ -42,11 +42,16 @@ function truncate(text, max) {
  * `signal` cancels the in-flight fetch.
  */
 export async function runWebFetch(request, config, signal) {
-    assertUrlAllowed(request.url, config.allowList);
+    await assertFetchUrlAllowed(request.url, config.allowList);
     const cap = Math.min(request.maxLength ?? config.fetchMaxLength, config.fetchMaxLength);
     // The response is cached before the format reduction, so the same page read
     // as text and as html shares one network round trip.
-    const page = await executeRead("page-fetch", toCallSettings(webFetchExecuteDefaults, config.timeoutMs, ["web-search", "fetch", request.url]), async (executeSignal) => {
+    const page = await executeRead("page-fetch", toCallSettings(webFetchExecuteDefaults, config.timeoutMs, [
+        "web-search",
+        "fetch",
+        request.url,
+        ...config.allowList.patterns,
+    ]), async (executeSignal) => {
         const response = await gotScraping({
             url: request.url,
             // got's own timeout aborts the socket and reports which phase timed
@@ -54,6 +59,13 @@ export async function runWebFetch(request, config, signal) {
             timeout: { request: config.timeoutMs },
             throwHttpErrors: false,
             followRedirect: true,
+            hooks: {
+                beforeRequest: [
+                    async (options) => {
+                        await assertFetchUrlAllowed(String(options.url), config.allowList);
+                    },
+                ],
+            },
             ...(executeSignal ? { signal: executeSignal } : {}),
         });
         return {
@@ -63,6 +75,7 @@ export async function runWebFetch(request, config, signal) {
             body: typeof response.body === "string" ? response.body : String(response.body ?? ""),
         };
     }, signal);
+    await assertFetchUrlAllowed(page.url, config.allowList);
     const isHtml = !page.contentType || /html|xml/i.test(page.contentType);
     const rawContent = request.format === "html" || !isHtml ? page.body : htmlToText(page.body);
     const { content, truncated } = truncate(rawContent, cap);
@@ -83,4 +96,4 @@ export async function runWebFetch(request, config, signal) {
         truncated,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch.js","sourceRoot":"","sources":["../../src/fetch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Page fetching over {@link https://www.npmjs.com/package/got-scraping | got-scraping}\n * - a `got` wrapper that generates browser-like TLS + header fingerprints, so\n * fetches survive the bot walls a plain `fetch` trips. {@link runWebFetch}\n * enforces the URL allow-list (an explicit fetch of a disallowed URL is\n * refused, not silently emptied), fetches with the plugin's timeout, and\n * returns either the raw HTML or a readable plain-text reduction, capped at\n * the configured length.\n *\n * The HTML-to-text reduction is deliberately dependency-free (strip\n * script/style, unwrap tags, decode a handful of entities, collapse\n * whitespace): good enough to feed a model, and it keeps the add-on's\n * dependency surface to the two libraries the task called for.\n *\n * @module\n */\n\nimport { log } from \"@dbx-tools/shared-core\";\nimport { gotScraping } from \"got-scraping\";\nimport { assertUrlAllowed } from \"./allowlist.ts\";\nimport type { ResolvedWebSearchConfig } from \"./config.ts\";\nimport { toCallSettings, webFetchExecuteDefaults } from \"./defaults.ts\";\nimport { decodeHtmlEntities, htmlToText } from \"./html-text.ts\";\nimport { executeRead } from \"./runtime.ts\";\nimport type { WebFetchRequest, WebFetchResult } from \"./schema.ts\";\n\nconst logger = log.logger(\"web-search/fetch\");\n\n/** The slice of a got-scraping response this module reads. */\ninterface FetchedPage {\n  url: string;\n  statusCode: number;\n  contentType: string | undefined;\n  body: string;\n}\n\n/** Pull the <title> text out of an HTML document, when present. */\nfunction extractTitle(html: string): string | undefined {\n  const match = /<title[^>]*>([\\s\\S]*?)<\\/title>/i.exec(html);\n  const title = match?.[1] ? decodeHtmlEntities(match[1]).trim() : \"\";\n  return title.length > 0 ? title : undefined;\n}\n\n/** Truncate `text` to `max` chars, reporting whether it was cut. */\nfunction truncate(text: string, max: number): { content: string; truncated: boolean } {\n  if (text.length <= max) return { content: text, truncated: false };\n  return { content: text.slice(0, max), truncated: true };\n}\n\n/**\n * Fetch a single URL and return its content in the requested format.\n *\n * Throws when the URL is not permitted by the allow-list (the visible,\n * correctable failure the design calls for on the fetch path). The request's\n * `maxLength` narrows (never widens) the plugin's `fetchMaxLength` cap.\n * `signal` cancels the in-flight fetch.\n */\nexport async function runWebFetch(\n  request: WebFetchRequest,\n  config: ResolvedWebSearchConfig,\n  signal?: AbortSignal,\n): Promise<WebFetchResult> {\n  assertUrlAllowed(request.url, config.allowList);\n  const cap = Math.min(request.maxLength ?? config.fetchMaxLength, config.fetchMaxLength);\n\n  // The response is cached before the format reduction, so the same page read\n  // as text and as html shares one network round trip.\n  const page = await executeRead(\n    \"page-fetch\",\n    toCallSettings(webFetchExecuteDefaults, config.timeoutMs, [\"web-search\", \"fetch\", request.url]),\n    async (executeSignal): Promise<FetchedPage> => {\n      const response = await gotScraping({\n        url: request.url,\n        // got's own timeout aborts the socket and reports which phase timed\n        // out; the interceptor timeout bounds the whole attempt around it.\n        timeout: { request: config.timeoutMs },\n        throwHttpErrors: false,\n        followRedirect: true,\n        ...(executeSignal ? { signal: executeSignal } : {}),\n      });\n      return {\n        url: response.url ?? request.url,\n        statusCode: response.statusCode,\n        contentType: response.headers[\"content-type\"],\n        body: typeof response.body === \"string\" ? response.body : String(response.body ?? \"\"),\n      };\n    },\n    signal,\n  );\n\n  const isHtml = !page.contentType || /html|xml/i.test(page.contentType);\n  const rawContent = request.format === \"html\" || !isHtml ? page.body : htmlToText(page.body);\n  const { content, truncated } = truncate(rawContent, cap);\n  const title = isHtml ? extractTitle(page.body) : undefined;\n\n  logger.debug(\"fetched\", {\n    url: page.url,\n    status: page.statusCode,\n    bytes: page.body.length,\n    returned: content.length,\n    ...(truncated ? { truncated: true } : {}),\n  });\n\n  return {\n    url: page.url,\n    status: page.statusCode,\n    ...(page.contentType ? { contentType: page.contentType } : {}),\n    ...(title ? { title } : {}),\n    content,\n    truncated,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch.js","sourceRoot":"","sources":["../../src/fetch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Page fetching over {@link https://www.npmjs.com/package/got-scraping | got-scraping}\n * - a `got` wrapper that generates browser-like TLS + header fingerprints, so\n * fetches survive the bot walls a plain `fetch` trips. {@link runWebFetch}\n * enforces the URL allow-list (an explicit fetch of a disallowed URL is\n * refused, not silently emptied), fetches with the plugin's timeout, and\n * returns either the raw HTML or a readable plain-text reduction, capped at\n * the configured length.\n *\n * The HTML-to-text reduction is deliberately dependency-free (strip\n * script/style, unwrap tags, decode a handful of entities, collapse\n * whitespace): good enough to feed a model, and it keeps the add-on's\n * dependency surface to the two libraries the task called for.\n *\n * @module\n */\n\nimport { log } from \"@dbx-tools/shared-core\";\nimport { gotScraping } from \"got-scraping\";\nimport { assertFetchUrlAllowed } from \"./_fetch-url.ts\";\nimport type { ResolvedWebSearchConfig } from \"./config.ts\";\nimport { toCallSettings, webFetchExecuteDefaults } from \"./defaults.ts\";\nimport { decodeHtmlEntities, htmlToText } from \"./html-text.ts\";\nimport { executeRead } from \"./runtime.ts\";\nimport type { WebFetchRequest, WebFetchResult } from \"./schema.ts\";\n\nconst logger = log.logger(\"web-search/fetch\");\n\n/** The slice of a got-scraping response this module reads. */\ninterface FetchedPage {\n  url: string;\n  statusCode: number;\n  contentType: string | undefined;\n  body: string;\n}\n\n/** Pull the <title> text out of an HTML document, when present. */\nfunction extractTitle(html: string): string | undefined {\n  const match = /<title[^>]*>([\\s\\S]*?)<\\/title>/i.exec(html);\n  const title = match?.[1] ? decodeHtmlEntities(match[1]).trim() : \"\";\n  return title.length > 0 ? title : undefined;\n}\n\n/** Truncate `text` to `max` chars, reporting whether it was cut. */\nfunction truncate(text: string, max: number): { content: string; truncated: boolean } {\n  if (text.length <= max) return { content: text, truncated: false };\n  return { content: text.slice(0, max), truncated: true };\n}\n\n/**\n * Fetch a single URL and return its content in the requested format.\n *\n * Throws when the URL is not permitted by the allow-list (the visible,\n * correctable failure the design calls for on the fetch path). The request's\n * `maxLength` narrows (never widens) the plugin's `fetchMaxLength` cap.\n * `signal` cancels the in-flight fetch.\n */\nexport async function runWebFetch(\n  request: WebFetchRequest,\n  config: ResolvedWebSearchConfig,\n  signal?: AbortSignal,\n): Promise<WebFetchResult> {\n  await assertFetchUrlAllowed(request.url, config.allowList);\n  const cap = Math.min(request.maxLength ?? config.fetchMaxLength, config.fetchMaxLength);\n\n  // The response is cached before the format reduction, so the same page read\n  // as text and as html shares one network round trip.\n  const page = await executeRead(\n    \"page-fetch\",\n    toCallSettings(webFetchExecuteDefaults, config.timeoutMs, [\n      \"web-search\",\n      \"fetch\",\n      request.url,\n      ...config.allowList.patterns,\n    ]),\n    async (executeSignal): Promise<FetchedPage> => {\n      const response = await gotScraping({\n        url: request.url,\n        // got's own timeout aborts the socket and reports which phase timed\n        // out; the interceptor timeout bounds the whole attempt around it.\n        timeout: { request: config.timeoutMs },\n        throwHttpErrors: false,\n        followRedirect: true,\n        hooks: {\n          beforeRequest: [\n            async (options) => {\n              await assertFetchUrlAllowed(String(options.url), config.allowList);\n            },\n          ],\n        },\n        ...(executeSignal ? { signal: executeSignal } : {}),\n      });\n      return {\n        url: response.url ?? request.url,\n        statusCode: response.statusCode,\n        contentType: response.headers[\"content-type\"],\n        body: typeof response.body === \"string\" ? response.body : String(response.body ?? \"\"),\n      };\n    },\n    signal,\n  );\n  await assertFetchUrlAllowed(page.url, config.allowList);\n\n  const isHtml = !page.contentType || /html|xml/i.test(page.contentType);\n  const rawContent = request.format === \"html\" || !isHtml ? page.body : htmlToText(page.body);\n  const { content, truncated } = truncate(rawContent, cap);\n  const title = isHtml ? extractTitle(page.body) : undefined;\n\n  logger.debug(\"fetched\", {\n    url: page.url,\n    status: page.statusCode,\n    bytes: page.body.length,\n    returned: content.length,\n    ...(truncated ? { truncated: true } : {}),\n  });\n\n  return {\n    url: page.url,\n    status: page.statusCode,\n    ...(page.contentType ? { contentType: page.contentType } : {}),\n    ...(title ? { title } : {}),\n    content,\n    truncated,\n  };\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/allowlist.ts","../src/config.ts","../src/defaults.ts","../src/fetch.ts","../src/html-text.ts","../src/plugin.ts","../src/provider.ts","../src/runtime.ts","../src/schema.ts","../src/scrape.ts","../src/search.ts","../src/tool.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_fetch-url.ts","../src/allowlist.ts","../src/config.ts","../src/defaults.ts","../src/fetch.ts","../src/html-text.ts","../src/plugin.ts","../src/provider.ts","../src/runtime.ts","../src/schema.ts","../src/scrape.ts","../src/search.ts","../src/tool.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -26,10 +26,10 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/model": "0.6.71",
-    "@dbx-tools/path": "0.6.71",
-    "@dbx-tools/shared-core": "0.6.71",
-    "@dbx-tools/shared-model": "0.6.71",
+    "@dbx-tools/model": "0.6.73",
+    "@dbx-tools/path": "0.6.73",
+    "@dbx-tools/shared-core": "0.6.73",
+    "@dbx-tools/shared-model": "0.6.73",
     "@mastra/core": "^1.47.0",
     "got-scraping": "^4.2.1",
     "zod": "4.3.6"
@@ -48,7 +48,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.71",
+  "version": "0.6.73",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/_fetch-url.ts

@@ -0,0 +1,110 @@
+/**
+ * Network policy for page fetches.
+ *
+ * Every request, including redirects, is HTTPS, matches the configured URL
+ * allow-list, and resolves only to public addresses. Resolution happens in the
+ * request hook immediately before I/O so a redirect cannot bypass the policy.
+ *
+ * @module
+ */
+
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+import { ValidationError } from "@databricks/appkit";
+
+import { assertUrlAllowed, type UrlAllowList } from "./allowlist.ts";
+
+/** DNS result shape used by Node and by deterministic tests. */
+export interface ResolvedAddress {
+  address: string;
+  family: number;
+}
+
+/** Injectable DNS resolver for fetch-policy tests. */
+export type ResolveAddresses = (hostname: string) => Promise<readonly ResolvedAddress[]>;
+
+/** Resolve all addresses for a hostname without changing their family. */
+async function resolveAddresses(hostname: string): Promise<readonly ResolvedAddress[]> {
+  return lookup(hostname, { all: true, verbatim: true });
+}
+
+/** Whether an IPv4 address is private, local, reserved, or non-unicast. */
+function isBlockedIpv4(address: string): boolean {
+  const [a = -1, b = -1, c = -1] = address.split(".").map(Number);
+  return (
+    a === 0 ||
+    a === 10 ||
+    a === 127 ||
+    a >= 224 ||
+    (a === 100 && b >= 64 && b <= 127) ||
+    (a === 169 && b === 254) ||
+    (a === 172 && b >= 16 && b <= 31) ||
+    (a === 192 && b === 0 && c === 0) ||
+    (a === 192 && b === 0 && c === 2) ||
+    (a === 192 && b === 168) ||
+    (a === 198 && (b === 18 || b === 19)) ||
+    (a === 198 && b === 51 && c === 100) ||
+    (a === 203 && b === 0 && c === 113)
+  );
+}
+
+/** Whether an IPv6 address is private, local, reserved, or non-unicast. */
+function isBlockedIpv6(address: string): boolean {
+  const normalized = address.toLowerCase();
+  return (
+    normalized === "::" ||
+    normalized === "::1" ||
+    normalized.startsWith("::ffff:") ||
+    normalized.startsWith("100:") ||
+    normalized.startsWith("2001:db8:") ||
+    normalized.startsWith("fc") ||
+    normalized.startsWith("fd") ||
+    /^fe[89ab]/.test(normalized) ||
+    normalized.startsWith("ff")
+  );
+}
+
+/** Whether an address is globally routable enough for an outbound page fetch. */
+function isPublicAddress(address: ResolvedAddress): boolean {
+  return address.family === 6 ? !isBlockedIpv6(address.address) : !isBlockedIpv4(address.address);
+}
+
+/**
+ * Validate one concrete page-fetch target immediately before network I/O.
+ *
+ * Rejects embedded credentials, non-HTTPS URLs, disallowed hosts/paths, and
+ * hostnames whose DNS answers include any private, loopback, link-local, or
+ * reserved address.
+ */
+export async function assertFetchUrlAllowed(
+  value: string,
+  allowList: UrlAllowList,
+  resolve: ResolveAddresses = resolveAddresses,
+): Promise<void> {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw ValidationError.invalidValue("url", value, "an absolute HTTPS URL");
+  }
+  if (url.protocol !== "https:" || url.username || url.password) {
+    throw ValidationError.invalidValue(
+      "url",
+      value,
+      "an absolute HTTPS URL without embedded credentials",
+    );
+  }
+  assertUrlAllowed(url.href, allowList);
+
+  const literalFamily = isIP(url.hostname);
+  const addresses = literalFamily
+    ? [{ address: url.hostname, family: literalFamily }]
+    : await resolve(url.hostname);
+  if (addresses.length === 0 || addresses.some((address) => !isPublicAddress(address))) {
+    throw ValidationError.invalidValue(
+      "url",
+      value,
+      "a URL that resolves only to public addresses",
+    );
+  }
+}

package/src/fetch.ts

@@ -17,7 +17,7 @@
 
 import { log } from "@dbx-tools/shared-core";
 import { gotScraping } from "got-scraping";
-import { assertUrlAllowed } from "./allowlist.ts";
+import { assertFetchUrlAllowed } from "./_fetch-url.ts";
 import type { ResolvedWebSearchConfig } from "./config.ts";
 import { toCallSettings, webFetchExecuteDefaults } from "./defaults.ts";
 import { decodeHtmlEntities, htmlToText } from "./html-text.ts";
@@ -60,14 +60,19 @@ export async function runWebFetch(
   config: ResolvedWebSearchConfig,
   signal?: AbortSignal,
 ): Promise<WebFetchResult> {
-  assertUrlAllowed(request.url, config.allowList);
+  await assertFetchUrlAllowed(request.url, config.allowList);
   const cap = Math.min(request.maxLength ?? config.fetchMaxLength, config.fetchMaxLength);
 
   // The response is cached before the format reduction, so the same page read
   // as text and as html shares one network round trip.
   const page = await executeRead(
     "page-fetch",
-    toCallSettings(webFetchExecuteDefaults, config.timeoutMs, ["web-search", "fetch", request.url]),
+    toCallSettings(webFetchExecuteDefaults, config.timeoutMs, [
+      "web-search",
+      "fetch",
+      request.url,
+      ...config.allowList.patterns,
+    ]),
     async (executeSignal): Promise<FetchedPage> => {
       const response = await gotScraping({
         url: request.url,
@@ -76,6 +81,13 @@ export async function runWebFetch(
         timeout: { request: config.timeoutMs },
         throwHttpErrors: false,
         followRedirect: true,
+        hooks: {
+          beforeRequest: [
+            async (options) => {
+              await assertFetchUrlAllowed(String(options.url), config.allowList);
+            },
+          ],
+        },
         ...(executeSignal ? { signal: executeSignal } : {}),
       });
       return {
@@ -87,6 +99,7 @@ export async function runWebFetch(
     },
     signal,
   );
+  await assertFetchUrlAllowed(page.url, config.allowList);
 
   const isHtml = !page.contentType || /html|xml/i.test(page.contentType);
   const rawContent = request.format === "html" || !isHtml ? page.body : htmlToText(page.body);