manifest 6.0.0 → 7.0.0

package/dist/index.js

@@ -1,443 +1,8 @@
-// src/runtime.ts
-import { randomUUID } from "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: 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);
-}
+import {
+  VERSION,
+  manifest
+} from "./chunk-DP2C4E42.js";
 export {
   VERSION,
-  flush,
   manifest
 };