manifest 5.45.0 → 6.0.0

package/dist/index.cjs

@@ -0,0 +1,472 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  VERSION: () => VERSION,
+  flush: () => flush,
+  manifest: () => manifest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/runtime.ts
+var import_node_crypto = require("crypto");
+
+// src/wire.ts
+var secretNames = /* @__PURE__ */ new Set([
+  "api_key",
+  "apikey",
+  "api_token",
+  "key",
+  "token",
+  "access_token",
+  "refresh_token",
+  "auth",
+  "authorization",
+  "signature",
+  "sig",
+  "secret",
+  "client_secret",
+  "password",
+  "session",
+  "session_id",
+  "bearer",
+  "jwt",
+  "id_token",
+  "auth_token",
+  "pwd",
+  "passwd",
+  "private_key"
+]);
+var roots = ["auth", "key", "token", "secret", "session", "password", "passwd", "cookie", "signature", "credential", "bearer", "jwt"];
+var normalize = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase().replace(/^x_/, "");
+var isSecret = (name) => secretNames.has(normalize(name));
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function safeUrl(raw) {
+  const url = new URL(raw);
+  url.username = "";
+  url.password = "";
+  url.hash = "";
+  const pairs = [...url.searchParams].map(([key, value]) => [key, isSecret(key) ? "REDACTED" : value]);
+  url.search = new URLSearchParams(pairs).toString();
+  return url.toString();
+}
+function safeHeaders(headers) {
+  return Object.fromEntries([...headers].map(([key, value]) => [
+    key,
+    isSecret(key) || roots.some((root) => normalize(key).includes(root)) ? "REDACTED" : value.slice(0, 1024)
+  ]));
+}
+function travelingBody(body) {
+  return isObject(body) ? Object.fromEntries(Object.entries(body).filter(([key]) => !isSecret(key))) : body;
+}
+function mergeBody(original, healed) {
+  if (!isObject(original) || !isObject(healed)) return healed;
+  return { ...Object.fromEntries(Object.entries(original).filter(([key]) => isSecret(key) && !Object.hasOwn(healed, key))), ...healed };
+}
+function boundedJson(value) {
+  const stack = [[value, 0]];
+  let count = 0;
+  while (stack.length) {
+    const [item, depth] = stack.pop();
+    if (++count > 1e5 || depth > 64) return false;
+    if (item !== null && typeof item === "object") {
+      for (const child of Object.values(item)) stack.push([child, depth + 1]);
+    }
+  }
+  return true;
+}
+function parseJson(bytes) {
+  try {
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    return boundedJson(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function errorBody(bytes) {
+  const parsed = parseJson(bytes);
+  const text = Buffer.from(bytes).toString("utf8");
+  return parsed ?? new TextDecoder().decode(Buffer.from(text).subarray(0, 65536), { stream: true });
+}
+var TRANSPORT_ERROR = "Upstream retry failed before an HTTP response";
+
+// src/capture.ts
+var REQUEST_LIMIT = 262144;
+var RESPONSE_LIMIT = 65536;
+var CAPTURE_MS = 1e3;
+async function prefix(reader, limit, timeoutMs) {
+  const chunks = [];
+  let size = 0;
+  let pending;
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(null), timeoutMs);
+  });
+  let complete = false;
+  try {
+    while (size <= limit) {
+      pending = reader.read();
+      const read = await Promise.race([pending, deadline]);
+      if (read === null) break;
+      pending = void 0;
+      if (read.done) {
+        complete = true;
+        break;
+      }
+      chunks.push(read.value);
+      size += read.value.byteLength;
+    }
+  } catch {
+  } finally {
+    clearTimeout(timer);
+  }
+  return { chunks, complete, pending, bytes: Buffer.concat(chunks, size).subarray(0, limit) };
+}
+async function captureRequest(request) {
+  if (!request.body) return { body: null, complete: true };
+  const clone = request.clone();
+  const reader = clone.body.getReader();
+  try {
+    const result = await prefix(reader, REQUEST_LIMIT, CAPTURE_MS);
+    return { body: result.complete ? parseJson(result.bytes) : null, complete: result.complete };
+  } finally {
+    void reader.cancel().catch(() => {
+    });
+  }
+}
+function metadata(response, original) {
+  const clone = response.clone.bind(response);
+  Object.defineProperties(response, {
+    url: { value: original.url },
+    redirected: { value: original.redirected },
+    type: { value: original.type },
+    clone: { value: () => metadata(clone(), original) }
+  });
+  return response;
+}
+async function captureResponse(original, limit = RESPONSE_LIMIT, timeoutMs = CAPTURE_MS) {
+  if (!original.body) return { response: original, body: null, truncated: false, complete: true };
+  const reader = original.body.getReader();
+  const captured = await prefix(reader, limit, timeoutMs);
+  let index = 0;
+  let pending = captured.pending;
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        if (index < captured.chunks.length) {
+          controller.enqueue(captured.chunks[index++]);
+          return;
+        }
+        const read = await (pending ?? reader.read());
+        pending = void 0;
+        if (read.done) {
+          reader.releaseLock();
+          controller.close();
+        } else controller.enqueue(read.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      await reader.cancel(reason);
+    }
+  }, { highWaterMark: 0 });
+  const response = metadata(new Response(stream, {
+    status: original.status,
+    statusText: original.statusText,
+    headers: original.headers
+  }), original);
+  return { response, body: errorBody(captured.bytes), truncated: !captured.complete || Buffer.byteLength(Buffer.from(captured.bytes).toString("utf8")) > limit, complete: captured.complete };
+}
+
+// src/api.ts
+var VERSION = "6.0.0";
+var warn = (message) => process.emitWarning(message, { code: "MNFST" });
+var HealApi = class {
+  constructor(rawFetch, key, url, timeoutMs = 6e4, reportTimeoutMs = 5e3) {
+    this.rawFetch = rawFetch;
+    this.key = key;
+    this.url = url;
+    this.timeoutMs = timeoutMs;
+    this.reportTimeoutMs = reportTimeoutMs;
+  }
+  rawFetch;
+  key;
+  url;
+  timeoutMs;
+  reportTimeoutMs;
+  disabledUntil = 0;
+  inFlight = 0;
+  pending = /* @__PURE__ */ new Set();
+  enabled() {
+    return performance.now() >= this.disabledUntil;
+  }
+  headers() {
+    return {
+      authorization: `Bearer ${this.key}`,
+      "content-type": "application/json",
+      "user-agent": `mnfst-node/${VERSION}`,
+      "x-mnfst-source": "node-sdk"
+    };
+  }
+  async heal(capture, signal) {
+    if (!this.enabled() || this.inFlight >= 8) return null;
+    this.inFlight++;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.rawFetch(new URL("v1/heal", this.url), {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(capture),
+        signal: AbortSignal.any([signal, controller.signal]),
+        redirect: "error"
+      });
+      if (response.status !== 200 && response.status !== 403) {
+        void response.body?.cancel().catch(() => {
+        });
+        return null;
+      }
+      const captured = await captureResponse(response, 1048576, this.timeoutMs);
+      void captured.response.body?.cancel().catch(() => {
+      });
+      if (!captured.complete || !isObject(captured.body) || !boundedJson(captured.body)) return null;
+      if (response.status === 403 && captured.body.error === "project_disabled") {
+        this.disabledUntil = performance.now() + 3e5;
+      }
+      if (response.status !== 200 || typeof captured.body.status !== "string") return null;
+      return {
+        status: captured.body.status,
+        ...typeof captured.body.healAttemptId === "string" ? { healAttemptId: captured.body.healAttemptId } : {},
+        ...Array.isArray(captured.body.operations) ? { operations: captured.body.operations } : {},
+        ...isObject(captured.body.healedRequest) ? { healedRequest: captured.body.healedRequest } : {}
+      };
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timer);
+      this.inFlight--;
+    }
+  }
+  report(id, outcome) {
+    if (!id) return;
+    if (this.pending.size >= 64) {
+      warn("Outcome report capacity reached; report dropped");
+      return;
+    }
+    const promise = this.send(id, outcome);
+    this.pending.add(promise);
+    void promise.then(() => this.pending.delete(promise));
+  }
+  async send(id, outcome) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.reportTimeoutMs);
+    try {
+      const response = await this.rawFetch(new URL(`v1/heal-attempts/${encodeURIComponent(id)}`, this.url), {
+        method: "PATCH",
+        headers: this.headers(),
+        body: JSON.stringify(outcome),
+        signal: controller.signal,
+        redirect: "error"
+      });
+      void response.body?.cancel().catch(() => {
+      });
+      if (!response.ok) warn("Outcome report rejected; attempt remains unconfirmed");
+    } catch {
+      warn("Outcome report failed; attempt remains unconfirmed");
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async flush(timeoutMs = 5e3) {
+    let timer;
+    try {
+      await Promise.race([
+        Promise.allSettled([...this.pending]),
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, Math.max(0, timeoutMs));
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/runtime.ts
+var eligible = /* @__PURE__ */ new Set([400, 404, 422]);
+var Runtime = class {
+  constructor(options, original, api) {
+    this.options = options;
+    this.original = original;
+    this.api = api ?? new HealApi(original, options.key, options.url);
+  }
+  options;
+  original;
+  api;
+  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 started = performance.now();
+    const response = await this.original(request, extras);
+    const responseTimeMs = performance.now() - started;
+    if (!eligible.has(response.status) || response.redirected || !this.api.enabled()) return response;
+    return this.repair(request, extras, response, await bodyPromise, 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: (0, import_node_crypto.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);
+    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 && !["GET", "HEAD"].includes(request.method)) return null;
+    return new Request(url, {
+      method: request.method,
+      headers,
+      body: ["GET", "HEAD"].includes(request.method) ? void 0 : JSON.stringify(body),
+      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/index.ts
+var STATE = /* @__PURE__ */ Symbol.for("mnfst.node.runtime.v1");
+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;
+  globals[STATE] = runtime;
+}
+async function flush(options = {}) {
+  await globals[STATE]?.api.flush(options.timeoutMs ?? 5e3);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VERSION,
+  flush,
+  manifest
+});

package/dist/index.d.cts

@@ -0,0 +1,24 @@
+interface ManifestOptions {
+    key?: string;
+    url?: string;
+    onHeal?: (event: HealEvent) => void | Promise<void>;
+}
+interface HealEvent {
+    url: string;
+    statusCode: number;
+    healStatus: string;
+    replayStatusCode: number | null;
+    healMs: number;
+    operations?: unknown[];
+}
+
+declare const VERSION = "6.0.0";
+
+/** Install once, before libraries capture their own reference to global fetch. */
+declare function manifest(options?: ManifestOptions): void;
+/** Wait for queued outcome reports within one total deadline. Does not uninstall. */
+declare function flush(options?: {
+    timeoutMs?: number;
+}): Promise<void>;
+
+export { type HealEvent, type ManifestOptions, VERSION, flush, manifest };

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+interface ManifestOptions {
+    key?: string;
+    url?: string;
+    onHeal?: (event: HealEvent) => void | Promise<void>;
+}
+interface HealEvent {
+    url: string;
+    statusCode: number;
+    healStatus: string;
+    replayStatusCode: number | null;
+    healMs: number;
+    operations?: unknown[];
+}
+
+declare const VERSION = "6.0.0";
+
+/** Install once, before libraries capture their own reference to global fetch. */
+declare function manifest(options?: ManifestOptions): void;
+/** Wait for queued outcome reports within one total deadline. Does not uninstall. */
+declare function flush(options?: {
+    timeoutMs?: number;
+}): Promise<void>;
+
+export { type HealEvent, type ManifestOptions, VERSION, flush, manifest };