@jini-ai/platform 0.5.6 → 0.5.8

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @jini-ai/platform
 
+## 0.5.8 — 2026-10-15
+
+- SECURITY: the guarded HTTP client forwards only `accept`, `accept-language` and `user-agent` on a cross-origin redirect (4de69b67). It used to strip only Authorization/Cookie, so custom credential headers (`x-api-key`, `X-Shopify-Access-Token`, …) followed a redirect to another origin. Same-origin hops keep all headers.
+- `./web` page fetch applies `maxChars` to the readable text, not the raw HTML (0625844e): raw HTML uses the fixed 1,000,000-char parser ceiling, and the result says `truncated: true` when cut. A page with a large script/style head no longer returns almost no text.
+
+## 0.5.7 — 2026-10-14
+
+- The asset cache's optional `undici` load moves behind `asset-cache.adapter.ts` (64eafe35); injected dispatchers, DNS validation and the MODULE_NOT_FOUND message are unchanged. No API change.
+
 ## 0.5.6 — 2026-10-13
 
 - `undici` and `hast-util-from-parse5`, `hast-util-to-mdast`, `mdast-util-to-markdown`, `mdast-util-gfm-table` (with `parse5`) are now optional peers instead of dependencies. Only `./web` needs the HTML/Markdown set; only the default `createAssetCacheDispatcher` needs undici, loaded lazily (a missing peer throws `AssetCacheError` 500; a host-supplied dispatcher needs none). Hosts using those must list the packages themselves.

package/dist/asset-cache.adapter.d.ts

@@ -0,0 +1,9 @@
+import type { LookupFunction } from 'node:net';
+import type { Agent } from 'undici';
+/** Load the optional vendor only for a default dispatcher; the cache owns lookup validation.
+ * @throws When the optional peer cannot be loaded or its Agent cannot be constructed.
+ */
+export declare function createUndiciAssetCacheDispatcher({ lookup }: {
+    lookup: LookupFunction;
+}, _options?: Record<string, never>): Agent;
+//# sourceMappingURL=asset-cache.adapter.d.ts.map

package/dist/asset-cache.adapter.js

@@ -0,0 +1,10 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+/** Load the optional vendor only for a default dispatcher; the cache owns lookup validation.
+ * @throws When the optional peer cannot be loaded or its Agent cannot be constructed.
+ */
+export function createUndiciAssetCacheDispatcher({ lookup }, _options = {}) {
+    const { Agent } = require('undici');
+    return new Agent({ connect: { lookup } });
+}
+//# sourceMappingURL=asset-cache.adapter.js.map

package/dist/asset-cache.js

@@ -23,10 +23,9 @@ import { createHash } from 'node:crypto';
 import { lookup as dnsLookupCb } from 'node:dns';
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { isIP } from 'node:net';
-import { createRequire } from 'node:module';
 import path from 'node:path';
+import { createUndiciAssetCacheDispatcher } from './asset-cache.adapter.js';
 import { isPrivateAddress } from './net/address.js';
-const require = createRequire(import.meta.url);
 /** Media extensions we are willing to cache + proxy. Anything else (HTML,
  *  CSS, JS, fonts) is intentionally left alone so this surface never becomes a
  *  general-purpose open proxy. */
@@ -133,9 +132,8 @@ export function createValidatingLookup(lookupImpl = dnsLookupCb) {
  */
 export function createAssetCacheDispatcher(_required, { lookupImpl } = {}) {
     // Keep the factory synchronous while root imports and host-supplied dispatchers need no undici.
-    let undici;
     try {
-        undici = require('undici');
+        return createUndiciAssetCacheDispatcher({ lookup: createValidatingLookup(lookupImpl) });
     }
     catch (error) {
         if (error instanceof Error && error.code === 'MODULE_NOT_FOUND'
@@ -144,7 +142,6 @@ export function createAssetCacheDispatcher(_required, { lookupImpl } = {}) {
         }
         throw error;
     }
-    return new undici.Agent({ connect: { lookup: createValidatingLookup(lookupImpl) } });
 }
 /** Build a disk-backed cache for external sandboxed-content media. Concurrent
  *  requests for the same URL share one in-flight fetch; completed fetches

package/dist/http/guarded/client.js

@@ -38,7 +38,7 @@ export function classifyAddress({ ip }) {
     // it is not globally routable and belongs with RFC 1918 private ranges for egress decisions.
     return "private";
 }
-const SENSITIVE_HEADERS = new Set(["authorization", "cookie"]);
+const CROSS_ORIGIN_HEADERS = new Set(["accept", "accept-language", "user-agent"]);
 // HTTP header names are case-insensitive; preserve the caller's explicit User-Agent in any casing.
 function hasUserAgentHeader(headers) {
     return Object.keys(headers).some((key) => key.toLowerCase() === "user-agent");
@@ -105,10 +105,10 @@ async function resolvePinnedPeer(url, policy, dns) {
         tlsServerName: isIP(hostname) === 0 ? url.hostname : undefined,
     };
 }
-function withStrippedSensitiveHeaders(headers) {
+function withCrossOriginHeaders(headers) {
     const next = {};
     for (const [key, value] of Object.entries(headers)) {
-        if (SENSITIVE_HEADERS.has(key.toLowerCase()))
+        if (!CROSS_ORIGIN_HEADERS.has(key.toLowerCase()))
             continue;
         next[key] = value;
     }
@@ -179,8 +179,9 @@ async function sendWithPolicy(transport, policy, request, redirectsFollowed, dns
         return cappedResponse;
     const nextUrl = new URL(location, url);
     // Cross-origin hops must not inherit authorization or cookies entrusted to the original origin.
+    // Custom headers can carry credentials too; forward only the explicit noncredential allowlist.
     const nextHeaders = isCrossOrigin(url, nextUrl)
-        ? withStrippedSensitiveHeaders(request.headers)
+        ? withCrossOriginHeaders(request.headers)
         : request.headers;
     return sendWithPolicy(transport, policy, { ...request, url: nextUrl.toString(), headers: nextHeaders }, redirectsFollowed + 1, dns, redirect);
 }

package/dist/web/web-page.js

@@ -245,8 +245,8 @@ function project({ input, ports, url, response }) {
     const body = decodeBody(response, contentType, isHtml);
     if (body.includes("\u0000"))
         throw new ToolInputError({ message: "web_fetch_page: the response is binary, not a text page." });
-    // Four input characters per output character limits synchronous parsing for small requests too.
-    const bounded = isHtml ? boundHtml({ html: body }, { maxChars: Math.max(4096, input.maxChars * 4) }) : { html: body, truncated: false };
+    // A fixed ceiling limits synchronous parsing without letting a large head consume the output budget.
+    const bounded = isHtml ? boundHtml({ html: body }) : { html: body, truncated: false };
     const facts = isHtml ? readHtmlDocument({ html: bounded.html, pageUrl: finalUrl }) : /xml/.test(mediaType) ? sitemapFacts(body, finalUrl) : EMPTY_FACTS;
     const rendered = render(input.format, input.format === "raw" ? body : bounded.html, isHtml, finalUrl, ports);
     const content = clip(rendered, input.maxChars);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/platform",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Generic OS/platform primitives: process exec and lifecycle, filesystem containment, HTTP readiness polling, toolchain discovery, blob storage, AWS signing, and an SSRF-safe asset cache.",
   "license": "Apache-2.0",
   "repository": {