manifest 7.0.0 → 7.2.0

package/dist/chunk-GC5H22R2.js

@@ -0,0 +1,495 @@
+import {
+  HealApi,
+  REQUEST_LIMIT,
+  TRANSPORT_ERROR,
+  captureRequest,
+  captureResponse,
+  isObject,
+  mergeBody,
+  parseRequestBody,
+  safeHeaders,
+  safeUrl,
+  serializeRequestBody,
+  trackedUrl,
+  travelingBody,
+  warn
+} from "./chunk-NHEF7GUP.js";
+
+// src/http.ts
+import http from "http";
+import https from "https";
+import { syncBuiltinESMExports } from "module";
+import { Readable } from "stream";
+import { createBrotliDecompress, createUnzip } from "zlib";
+
+// src/runtime.ts
+import { randomUUID } from "crypto";
+
+// src/tracking.ts
+var MAX_BUFFER = 5e3;
+var MAX_BATCH = 500;
+var CallBuffer = class {
+  constructor(send, options = {}) {
+    this.send = send;
+    this.flushAt = options.flushAt ?? 500;
+    this.minGapMs = options.minGapMs ?? 1e3;
+    this.timer = setInterval(() => void this.kick(), options.intervalMs ?? 5e3);
+    this.timer.unref();
+  }
+  send;
+  queue = [];
+  inFlight = null;
+  lastSentAt = -Infinity;
+  /** Past this instant, nothing is retried or waited for, and a send in flight is aborted. */
+  deadline = Infinity;
+  controller = new AbortController();
+  timer;
+  flushAt;
+  minGapMs;
+  record(call) {
+    if (this.queue.length >= MAX_BUFFER) return;
+    this.queue.push(call);
+    if (this.queue.length >= this.flushAt) void this.kick();
+  }
+  size() {
+    return this.queue.length;
+  }
+  /** Resolves when the send in flight, if any, has settled. */
+  async idle() {
+    await this.inFlight;
+  }
+  /**
+   * Send everything buffered now, one batch at a time through the same
+   * in-flight guard as the timer. With `deadlineMs` (the exit path), it gives
+   * up at the deadline: the send in flight is aborted, nothing is retried, and
+   * what is left is dropped, so a script never hangs on an unreachable server.
+   */
+  async flush(deadlineMs = Infinity) {
+    this.deadline = performance.now() + deadlineMs;
+    const abortAt = Number.isFinite(deadlineMs) ? setTimeout(() => this.controller.abort(), deadlineMs) : null;
+    try {
+      while ((this.queue.length > 0 || this.inFlight) && performance.now() < this.deadline) {
+        await (this.inFlight ?? this.start());
+      }
+    } finally {
+      if (abortAt) clearTimeout(abortAt);
+      if (this.controller.signal.aborted) this.controller = new AbortController();
+      this.deadline = Infinity;
+    }
+  }
+  stop() {
+    clearInterval(this.timer);
+  }
+  kick() {
+    if (this.inFlight || this.queue.length === 0) return;
+    if (performance.now() - this.lastSentAt < this.minGapMs) return;
+    void this.start();
+  }
+  start() {
+    this.inFlight = this.sendOne().finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  async sendOne() {
+    const batch = this.queue.splice(0, MAX_BATCH);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (attempt > 0 && performance.now() >= this.deadline) return;
+      await this.waitForGap();
+      this.lastSentAt = performance.now();
+      try {
+        await this.send(batch, this.controller.signal);
+        return;
+      } catch {
+      }
+      if (this.controller.signal.aborted) {
+        this.controller = new AbortController();
+        return;
+      }
+    }
+  }
+  // Referenced on purpose: this wait only happens while a send or an exit
+  // flush is under way, and an unref'd wait would let the process exit with
+  // the batch unsent. It never outlasts the flush deadline.
+  async waitForGap() {
+    const wait = Math.min(this.lastSentAt + this.minGapMs, this.deadline) - performance.now();
+    if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
+  }
+};
+
+// src/runtime.ts
+var forbidden = /* @__PURE__ */ new Set([401, 402, 403, 429]);
+var bodyless = ["GET", "HEAD", "DELETE", "OPTIONS"];
+var neverBodied = (method) => method === "GET" || method === "HEAD";
+var eligible = (status) => status >= 400 && status < 500 && !forbidden.has(status);
+var Runtime = class {
+  constructor(options, original, api) {
+    this.options = options;
+    this.original = original;
+    this.api = api ?? new HealApi(original, options.key, options.url);
+    this.tracker = new CallBuffer((batch, signal) => this.api.sendRequests(batch, signal));
+  }
+  options;
+  original;
+  api;
+  /** Calls that did not go to `/v1/heal`, any status, on their way to `/v1/requests`. */
+  tracker;
+  /**
+   * Record a call that is not being healed. An in-memory append: never awaited,
+   * never throws, reads nothing of the response.
+   */
+  track(method, url, statusCode, startedAt, responseTimeMs) {
+    try {
+      const reported = trackedUrl(url());
+      const verb = method.toUpperCase();
+      if (!reported || reported.length > 4096 || !verb || verb.length > 16 || statusCode < 100 || statusCode > 599) return;
+      this.tracker.record({
+        traceId: randomUUID(),
+        method: verb,
+        url: reported,
+        statusCode,
+        responseTimeMs: Math.round(responseTimeMs),
+        occurredAt: new Date(startedAt).toISOString()
+      });
+    } catch {
+    }
+  }
+  fetch = async (input, init) => {
+    const request = new Request(input, init);
+    const extras = { ...init };
+    delete extras.body;
+    delete extras.headers;
+    const bodyPromise = captureRequest(request).catch(() => ({ body: null, complete: false }));
+    const startedAt = Date.now();
+    const started = performance.now();
+    const response = await this.original(request, extras);
+    const responseTimeMs = performance.now() - started;
+    if (!eligible(response.status) || response.redirected || !this.api.canHeal()) {
+      this.track(request.method, () => request.url, response.status, startedAt, responseTimeMs);
+      return response;
+    }
+    return this.handleResponse(request, response, await bodyPromise, responseTimeMs, extras);
+  };
+  async handleResponse(request, response, body, responseTimeMs, extras = {}) {
+    if (!eligible(response.status) || response.redirected || !this.api.enabled()) return response;
+    return this.repair(request, extras, response, body, responseTimeMs);
+  }
+  async repair(request, extras, original, body, responseTimeMs) {
+    let response = original;
+    let result = null;
+    const started = performance.now();
+    let replayStatusCode = null;
+    let replayAttempted = false;
+    try {
+      const captured = await captureResponse(response);
+      response = captured.response;
+      const payload = {
+        traceId: randomUUID(),
+        request: { method: request.method, url: safeUrl(request.url), headers: safeHeaders(request.headers), body: travelingBody(body.body) },
+        response: { statusCode: response.status, body: captured.body, truncated: captured.truncated },
+        responseTimeMs: Math.round(responseTimeMs)
+      };
+      request.signal.throwIfAborted();
+      result = await this.api.heal(payload, request.signal);
+      request.signal.throwIfAborted();
+      const retry = body.complete && captured.complete ? buildRetry(request, body.body, result) : null;
+      if (!retry) {
+        this.api.report(result?.healAttemptId, { failure: { kind: "not_attempted", message: "replay_not_attempted" } });
+        return response;
+      }
+      replayAttempted = true;
+      let retried;
+      try {
+        retried = await this.original(retry, extras);
+      } catch {
+        this.api.report(result?.healAttemptId, { failure: { kind: "transport_error", message: TRANSPORT_ERROR } });
+        request.signal.throwIfAborted();
+        return response;
+      }
+      replayStatusCode = retried.status;
+      if (retried.status >= 400) {
+        const capturedRetry = await captureResponse(retried);
+        retried = capturedRetry.response;
+        this.api.report(result?.healAttemptId, { response: { statusCode: retried.status, body: capturedRetry.body, truncated: capturedRetry.truncated } });
+      } else {
+        this.api.report(result?.healAttemptId, { response: { statusCode: retried.status } });
+      }
+      void response.body?.cancel().catch(() => {
+      });
+      return retried;
+    } catch {
+      request.signal.throwIfAborted();
+      this.api.report(result?.healAttemptId, { failure: { kind: "not_attempted", message: "replay_not_attempted" } });
+      return response;
+    } finally {
+      if (this.options.onHeal) {
+        try {
+          void Promise.resolve(this.options.onHeal({
+            url: safeUrl(request.url),
+            statusCode: original.status,
+            healStatus: replayAttempted && replayStatusCode === null ? "replay_failed" : result?.status ?? "heal_unreachable",
+            replayStatusCode,
+            healMs: Math.round(performance.now() - started),
+            operations: result?.operations
+          })).catch(() => warn("onHeal callback failed"));
+        } catch {
+          warn("onHeal callback failed");
+        }
+      }
+    }
+  }
+};
+function buildRetry(request, originalBody, result) {
+  if (!result || !["patched", "unverified"].includes(result.status) || !isObject(result.healedRequest)) return null;
+  const healed = result.healedRequest;
+  if (!["url", "headers", "body"].some((key) => Object.hasOwn(healed, key))) return null;
+  try {
+    const url = new URL(healed.url ?? request.url);
+    if (url.origin !== new URL(request.url).origin || url.username || url.password) return null;
+    const headers = new Headers(request.headers);
+    const contentType = headers.get("content-type");
+    headers.delete("content-length");
+    if (healed.headers !== void 0 && !isObject(healed.headers)) return null;
+    for (const [name, value] of Object.entries(healed.headers ?? {})) {
+      if (value === null) headers.delete(name);
+      else if (typeof value === "string") headers.set(name, value);
+      else return null;
+    }
+    const body = Object.hasOwn(healed, "body") ? mergeBody(originalBody, healed.body) : originalBody;
+    if (body === null && !bodyless.includes(request.method)) return null;
+    return new Request(url, {
+      method: request.method,
+      headers,
+      body: body === null || neverBodied(request.method) ? void 0 : serializeRequestBody(body, contentType),
+      signal: request.signal,
+      redirect: request.redirect,
+      credentials: request.credentials,
+      cache: request.cache,
+      integrity: request.integrity,
+      keepalive: request.keepalive,
+      mode: request.mode,
+      referrer: request.referrer,
+      referrerPolicy: request.referrerPolicy
+    });
+  } catch {
+    return null;
+  }
+}
+
+// src/http.ts
+function installHttp(runtime) {
+  const httpRequest = wrapRequest(http.request, "http:", runtime);
+  const httpsRequest = wrapRequest(https.request, "https:", runtime);
+  http.request = httpRequest;
+  https.request = httpsRequest;
+  http.get = wrapGet(httpRequest);
+  https.get = wrapGet(httpsRequest);
+  syncBuiltinESMExports();
+}
+function wrapGet(request) {
+  return ((...args) => {
+    const result = request(...args);
+    result.end();
+    return result;
+  });
+}
+function wrapRequest(original, protocol, runtime) {
+  return ((...received) => {
+    const args = [...received];
+    const callback = typeof args.at(-1) === "function" ? args.pop() : void 0;
+    const startedAt = Date.now();
+    const started = performance.now();
+    const request = original(...args);
+    const capture = captureBody(request);
+    const signal = cancellation(request, requestSignal(args));
+    const emit = request.emit.bind(request);
+    request.emit = ((event, ...values) => {
+      if (event !== "response") return emit(event, ...values);
+      const response = values[0];
+      if (!eligible(response.statusCode ?? 0) || !runtime.api.canHeal()) {
+        runtime.track(
+          request.method,
+          () => requestUrl(request, protocol).toString(),
+          response.statusCode ?? 0,
+          startedAt,
+          performance.now() - started
+        );
+        return emit(event, ...values);
+      }
+      void handleResponse(runtime, request, response, protocol, capture.body(), signal, started).then((healed) => emit("response", healed)).catch((error) => {
+        response.destroy();
+        if (!request.destroyed) request.destroy(error instanceof Error ? error : void 0);
+      });
+      return true;
+    });
+    if (callback) request.once("response", callback);
+    return request;
+  });
+}
+async function handleResponse(runtime, clientRequest, incoming, protocol, body, signal, started) {
+  const request = webRequest(clientRequest, protocol, body, signal);
+  const response = webResponse(incoming, request.url);
+  const healed = await runtime.handleResponse(request, response, body, performance.now() - started);
+  return incomingResponse(healed, clientRequest);
+}
+function requestUrl(request, protocol) {
+  const authority = String(request.getHeader("host") ?? request.host);
+  return new URL(request.path, `${protocol}//${authority}`);
+}
+function webRequest(request, protocol, captured, signal) {
+  const headers = new Headers();
+  for (const name of request.getHeaderNames()) {
+    const value = request.getHeader(name);
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (item !== void 0) headers.append(name, String(item));
+    }
+  }
+  const url = requestUrl(request, protocol);
+  const method = request.method;
+  return new Request(url, {
+    method,
+    headers,
+    signal,
+    body: ["GET", "HEAD"].includes(method) || !captured.complete || captured.body === null ? void 0 : serializeRequestBody(captured.body, headers.get("content-type"))
+  });
+}
+function webResponse(response, url) {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(response.headers)) {
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (item !== void 0) headers.append(name, String(item));
+    }
+  }
+  const encoding = headers.get("content-encoding")?.toLowerCase();
+  let body = response;
+  if (encoding === "gzip" || encoding === "x-gzip" || encoding === "deflate") {
+    body = response.pipe(createUnzip());
+    headers.delete("content-encoding");
+    headers.delete("content-length");
+  } else if (encoding === "br") {
+    body = response.pipe(createBrotliDecompress());
+    headers.delete("content-encoding");
+    headers.delete("content-length");
+  }
+  const converted = new Response(
+    Readable.toWeb(body),
+    { status: response.statusCode, statusText: response.statusMessage, headers }
+  );
+  Object.defineProperty(converted, "url", { value: url });
+  return converted;
+}
+function incomingResponse(response, request) {
+  const stream = response.body ? Readable.fromWeb(response.body) : Readable.from([]);
+  const headers = {};
+  for (const [name, value] of response.headers) headers[name] = value;
+  if (["gzip", "x-gzip", "deflate", "br"].includes(String(headers["content-encoding"]).toLowerCase())) {
+    delete headers["content-encoding"];
+    delete headers["content-length"];
+  }
+  const cookies = response.headers.getSetCookie();
+  if (cookies.length) headers["set-cookie"] = cookies;
+  const rawHeaders = Object.entries(headers).flatMap(([name, value]) => (Array.isArray(value) ? value : [value]).flatMap((item) => item === void 0 ? [] : [name, String(item)]));
+  return Object.assign(stream, {
+    statusCode: response.status,
+    statusMessage: response.statusText,
+    headers,
+    rawHeaders,
+    trailers: {},
+    rawTrailers: [],
+    httpVersion: "1.1",
+    httpVersionMajor: 1,
+    httpVersionMinor: 1,
+    complete: true,
+    req: request
+  });
+}
+function captureBody(request) {
+  let chunks = [];
+  let size = 0;
+  let complete = true;
+  const record = (chunk, encoding) => {
+    if (chunk === void 0 || chunk === null || typeof chunk === "function" || !complete) return;
+    const bytes = typeof chunk === "string" ? Buffer.from(chunk, encoding) : Buffer.from(chunk);
+    size += bytes.byteLength;
+    if (size > REQUEST_LIMIT) {
+      complete = false;
+      chunks = [];
+      return;
+    }
+    chunks.push(bytes);
+  };
+  const write = request.write;
+  request.write = ((...args) => {
+    record(args[0], typeof args[1] === "string" ? args[1] : void 0);
+    return Reflect.apply(write, request, args);
+  });
+  const end = request.end;
+  request.end = ((...args) => {
+    record(args[0], typeof args[1] === "string" ? args[1] : void 0);
+    return Reflect.apply(end, request, args);
+  });
+  return { body: () => {
+    if (!complete) return { body: null, complete: false };
+    const header = request.getHeader("content-type");
+    const contentType = Array.isArray(header) ? header[0] : header === void 0 ? void 0 : String(header);
+    const parsed = parseRequestBody(Buffer.concat(chunks, size), contentType);
+    return { body: parsed.body, complete: parsed.valid };
+  } };
+}
+function requestSignal(args) {
+  for (const value of args.slice(0, 2)) {
+    if (value && typeof value === "object" && "signal" in value && value.signal instanceof AbortSignal) return value.signal;
+  }
+}
+function cancellation(request, external) {
+  const controller = new AbortController();
+  const destroy = request.destroy.bind(request);
+  request.destroy = ((error) => {
+    if (!controller.signal.aborted) controller.abort(error);
+    return destroy(error);
+  });
+  return external ? AbortSignal.any([external, controller.signal]) : controller.signal;
+}
+
+// src/index.ts
+var STATE = /* @__PURE__ */ Symbol.for("mnfst.node.runtime.v1");
+var EXIT_FLUSH_MS = 2e3;
+var globals = globalThis;
+function manifest(options = {}) {
+  const key = options.key || process.env.MNFST_KEY;
+  if (!key) {
+    warn("MNFST_KEY is not set; Manifest is disabled");
+    return;
+  }
+  const url = new URL(
+    options.url || process.env.MNFST_URL || "https://api.manifest.build"
+  );
+  if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+    throw new TypeError(
+      "Manifest URL must be an HTTP(S) base URL without credentials, query or fragment"
+    );
+  }
+  if (!url.pathname.endsWith("/")) url.pathname += "/";
+  const resolved = { ...options, key, url: url.toString() };
+  const existing = globals[STATE];
+  if (existing) {
+    if (existing.options.key !== key || existing.options.url !== resolved.url || existing.options.onHeal !== options.onHeal) {
+      warn(
+        "Manifest is already configured; changing configuration requires a process restart"
+      );
+    }
+    return;
+  }
+  const runtime = new Runtime(resolved, globalThis.fetch.bind(globalThis));
+  globalThis.fetch = runtime.fetch;
+  installHttp(runtime);
+  globals[STATE] = runtime;
+  runtime.api.hello(`node-${process.versions.node}`);
+  process.once("beforeExit", () => {
+    if (runtime.tracker.size() > 0) void runtime.tracker.flush(EXIT_FLUSH_MS);
+  });
+}
+
+export {
+  manifest
+};