@abot-ai/runtime 1.2.0 → 1.3.1

package/plugins/web/source/public-http.ts

@@ -1,150 +1,25 @@
-import { createAggregateGate } from "./aggregate-gate.js";
-import { remainingTime } from "./deadline.js";
-import { WebPluginError, isWebPluginError } from "./errors.js";
-import { WEB_LIMITS } from "./limits.js";
-import {
-  parsePublicHttpUrl,
-  resolvePublicTarget,
-  type HostResolver,
-} from "./network-policy.js";
-import {
-  requestPinnedHop,
-  type HopRequester,
-  type HopResponse,
-} from "./request-hop.js";
-
-export { requestPinnedHop };
-export type { HopRequester };
-
-export type PublicHttpResponse = HopResponse &
-  Readonly<{
-    requestedUrl: string;
-    finalUrl: string;
-  }>;
-
-export type PublicHttpRequest = Readonly<{
-  url: string;
-  headers?: Readonly<Record<string, string>>;
-  maxBytes?: number;
-  maxRedirects?: number;
-  followRedirects?: boolean;
-  timeoutMs?: number;
-  abortSignal?: AbortSignal;
-}>;
-
-export type PublicHttpClient = Readonly<{
-  get(request: PublicHttpRequest): Promise<PublicHttpResponse>;
-}>;
-
-const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
-
-function canFollowHttpRedirect(
-  request: PublicHttpRequest,
-  status: number,
-): boolean {
-  if (request.followRedirects === false) return false;
-  return REDIRECT_STATUSES.has(status);
-}
-
-function redirectLocation(response: HopResponse): string | undefined {
-  const raw = response.headers.location;
-  return Array.isArray(raw) ? raw[0] : raw;
-}
-
-function validateBounds(request: PublicHttpRequest): Readonly<{
-  maxBytes: number;
-  maxRedirects: number;
-  timeoutMs: number;
-}> {
-  const maxBytes = request.maxBytes ?? WEB_LIMITS.responseBytes;
-  const maxRedirects = request.maxRedirects ?? WEB_LIMITS.redirects;
-  const timeoutMs = request.timeoutMs ?? WEB_LIMITS.requestTimeoutMs;
-  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) {
-    throw new RangeError("maxBytes must be a positive safe integer");
-  }
-  if (!Number.isSafeInteger(maxRedirects) || maxRedirects < 0) {
-    throw new RangeError("maxRedirects must be a non-negative safe integer");
-  }
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
-    throw new RangeError("timeoutMs must be a positive safe integer");
-  }
-  return Object.freeze({ maxBytes, maxRedirects, timeoutMs });
-}
+import { createPublicHttpClient as createSharedClient } from "../../../src/shared/public-http/public-http.js";
+import { rethrowWebPluginError } from "./errors.js";
+import type { PublicHttpClient } from "../../../src/shared/public-http/public-http.js";
+
+export type {
+  PublicHttpClient,
+  PublicHttpRequest,
+  PublicHttpResponse,
+  HopRequester,
+} from "../../../src/shared/public-http/public-http.js";
+export { requestPinnedHop } from "./request-hop.js";
 
 export function createPublicHttpClient(
-  dependencies: Readonly<{
-    resolveHost?: HostResolver;
-    requestHop?: HopRequester;
-  }> = {},
+  dependencies: Parameters<typeof createSharedClient>[0] = {},
 ): PublicHttpClient {
-  const resolveHost = dependencies.resolveHost;
-  const requestHop = dependencies.requestHop ?? requestPinnedHop;
-  const gate = createAggregateGate(
-    WEB_LIMITS.httpConcurrency,
-    WEB_LIMITS.httpQueueLimit,
-  );
+  const client = createSharedClient(dependencies);
   return Object.freeze({
     async get(request) {
-      const requested = parsePublicHttpUrl(request.url);
-      const bounds = validateBounds(request);
-      const deadline = Date.now() + bounds.timeoutMs;
-      let current = requested;
-      for (let redirectCount = 0; ; redirectCount += 1) {
-        const address = await gate.run(
-          () => resolvePublicTarget(current, resolveHost),
-          deadline,
-          request.abortSignal,
-        );
-        const response = await gate.run(
-          () =>
-            requestHop({
-              url: current,
-              address,
-              headers: Object.freeze({
-                Accept:
-                  "text/html,application/xhtml+xml,text/plain,application/json;q=0.9,application/xml;q=0.8,text/xml;q=0.8",
-                "Accept-Encoding": "identity",
-                "User-Agent": "abot-runtime-web/1.0",
-                ...(request.headers ?? {}),
-              }),
-              maxBytes: bounds.maxBytes,
-              timeoutMs: remainingTime(deadline),
-              ...(request.abortSignal
-                ? { abortSignal: request.abortSignal }
-                : {}),
-            }),
-          deadline,
-          request.abortSignal,
-        );
-        if (!canFollowHttpRedirect(request, response.status)) {
-          return Object.freeze({
-            requestedUrl: requested.toString(),
-            finalUrl: current.toString(),
-            ...response,
-          });
-        }
-        const location = redirectLocation(response);
-        if (!location) {
-          throw new WebPluginError(
-            "web_redirect_invalid",
-            "The upstream redirect did not provide a valid destination.",
-          );
-        }
-        if (redirectCount >= bounds.maxRedirects) {
-          throw new WebPluginError(
-            "web_redirect_limit_exceeded",
-            "The web request exceeded the redirect limit.",
-          );
-        }
-        try {
-          current = parsePublicHttpUrl(new URL(location, current).toString());
-        } catch (error) {
-          if (isWebPluginError(error)) throw error;
-          throw new WebPluginError(
-            "web_redirect_invalid",
-            "The upstream redirect did not provide a valid destination.",
-          );
-        }
+      try {
+        return await client.get(request);
+      } catch (error) {
+        return rethrowWebPluginError(error);
       }
     },
   });

package/plugins/web/source/request-hop.ts

@@ -1,196 +1,16 @@
-import type { LookupFunction } from "node:net";
-import {
-  request as requestHttp,
-  type IncomingHttpHeaders,
-  type IncomingMessage,
-  type RequestOptions,
-} from "node:http";
-import { request as requestHttps } from "node:https";
+import { requestPinnedHop as requestSharedHop } from "../../../src/shared/public-http/request-hop.js";
+import type { HopRequester } from "../../../src/shared/public-http/request-hop.js";
+import { rethrowWebPluginError } from "./errors.js";
 
-import { WebPluginError, isWebPluginError } from "./errors.js";
-import { WEB_LIMITS } from "./limits.js";
-import type { PublicAddress } from "./network-policy.js";
-
-export type HopResponse = Readonly<{
-  status: number;
-  headers: IncomingHttpHeaders;
-  body: Uint8Array;
-  bytesRead: number;
-  partialContent: boolean;
-}>;
-
-export type HopRequester = (params: {
-  url: URL;
-  address: PublicAddress;
-  headers: Readonly<Record<string, string>>;
-  maxBytes: number;
-  timeoutMs: number;
-  abortSignal?: AbortSignal;
-}) => Promise<HopResponse>;
-
-function buildPinnedLookup(address: PublicAddress): LookupFunction {
-  return (_hostname, options, callback) => {
-    if (options.all) {
-      callback(null, [address]);
-      return;
-    }
-    callback(null, address.address, address.family);
-  };
-}
-
-function contentLength(headers: IncomingHttpHeaders): number | undefined {
-  const raw = headers["content-length"];
-  const value = Array.isArray(raw) ? raw[0] : raw;
-  if (typeof value !== "string" || !/^\d+$/u.test(value)) return undefined;
-  const parsed = Number(value);
-  return Number.isSafeInteger(parsed) ? parsed : undefined;
-}
-
-function readBoundedBody(
-  response: IncomingMessage,
-  maxBytes: number,
-): Promise<Readonly<{ body: Uint8Array; partialContent: boolean }>> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    let bytesRead = 0;
-    let settled = false;
-    const finish = (partialContent: boolean) => {
-      if (settled) return;
-      settled = true;
-      resolve(
-        Object.freeze({
-          body: Buffer.concat(chunks, bytesRead),
-          partialContent,
-        }),
-      );
-    };
-    response.on("data", (rawChunk: Buffer | string) => {
-      if (settled) return;
-      const chunk = Buffer.isBuffer(rawChunk)
-        ? rawChunk
-        : Buffer.from(rawChunk);
-      const remaining = maxBytes - bytesRead;
-      if (chunk.byteLength > remaining) {
-        if (remaining > 0) {
-          chunks.push(chunk.subarray(0, remaining));
-          bytesRead += remaining;
-        }
-        finish(true);
-        response.destroy();
-        return;
-      }
-      chunks.push(chunk);
-      bytesRead += chunk.byteLength;
-    });
-    response.once("end", () => finish(false));
-    response.once("error", (error) => {
-      if (settled) return;
-      settled = true;
-      reject(error);
-    });
-    response.once("aborted", () => {
-      if (settled) return;
-      settled = true;
-      reject(
-        new WebPluginError(
-          "web_response_invalid",
-          "The upstream response ended before completion.",
-        ),
-      );
-    });
-  });
-}
+export type {
+  HopRequester,
+  HopResponse,
+} from "../../../src/shared/public-http/request-hop.js";
 
 export const requestPinnedHop: HopRequester = async (params) => {
-  if (params.abortSignal?.aborted) {
-    throw new WebPluginError(
-      "web_request_aborted",
-      "The web request was aborted.",
-    );
+  try {
+    return await requestSharedHop(params);
+  } catch (error) {
+    return rethrowWebPluginError(error);
   }
-  return await new Promise<HopResponse>((resolve, reject) => {
-    let settled = false;
-    let timedOut = false;
-    const requestOptions: RequestOptions = {
-      protocol: params.url.protocol,
-      hostname: params.url.hostname.replace(/^\[|\]$/gu, ""),
-      port: params.url.port || undefined,
-      path: `${params.url.pathname}${params.url.search}`,
-      method: "GET",
-      headers: params.headers,
-      lookup: buildPinnedLookup(params.address),
-      agent: false,
-      maxHeaderSize: WEB_LIMITS.responseHeaderBytes,
-    };
-    const requestFunction =
-      params.url.protocol === "https:" ? requestHttps : requestHttp;
-    const request = requestFunction(requestOptions, async (response) => {
-      try {
-        const declaredLength = contentLength(response.headers);
-        const body = await readBoundedBody(response, params.maxBytes);
-        if (settled) return;
-        settled = true;
-        resolve(
-          Object.freeze({
-            status: response.statusCode ?? 0,
-            headers: response.headers,
-            body: body.body,
-            bytesRead: body.body.byteLength,
-            partialContent:
-              body.partialContent ||
-              (declaredLength !== undefined &&
-                declaredLength > params.maxBytes),
-          }),
-        );
-      } catch (error) {
-        if (settled) return;
-        settled = true;
-        reject(error);
-      }
-    });
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      request.destroy(
-        new WebPluginError(
-          "web_request_timed_out",
-          "The upstream web request timed out.",
-        ),
-      );
-    }, params.timeoutMs);
-    timeout.unref?.();
-    const onAbort = () =>
-      request.destroy(
-        new WebPluginError(
-          "web_request_aborted",
-          "The web request was aborted.",
-        ),
-      );
-    params.abortSignal?.addEventListener("abort", onAbort, { once: true });
-    request.once("error", (error) => {
-      if (settled) return;
-      settled = true;
-      if (isWebPluginError(error)) {
-        reject(error);
-      } else if (timedOut) {
-        reject(
-          new WebPluginError(
-            "web_request_timed_out",
-            "The upstream web request timed out.",
-          ),
-        );
-      } else {
-        reject(
-          new WebPluginError(
-            "web_response_invalid",
-            "The upstream web request failed.",
-          ),
-        );
-      }
-    });
-    request.once("close", () => {
-      clearTimeout(timeout);
-      params.abortSignal?.removeEventListener("abort", onAbort);
-    });
-    request.end();
-  });
 };