@probemesh/sdk 0.1.0

package/dist/chunk-257Y7LN2.js

@@ -0,0 +1,827 @@
+import {
+  createProbeMesh,
+  startHostedRouter
+} from "./chunk-TV42EZSI.js";
+import {
+  createProviderCatalogArtifact,
+  formatProviderCatalogArtifact
+} from "./chunk-3H7UGVI6.js";
+import {
+  loadCliConfigDefault,
+  redactX402Secrets
+} from "./chunk-NYTV263W.js";
+import {
+  ProbeMeshError,
+  isProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/protocols/x402Acceptance.ts
+var DEFAULT_REQUIRED_RECEIPT_TYPES = [
+  "payment_proof",
+  "settlement_confirmation",
+  "provider_delivery"
+];
+async function runX402ProviderAcceptance(options) {
+  assertAcceptanceOptions(options);
+  const telemetryEvents = [];
+  const requiredReceiptTypes = options.requiredReceiptTypes ?? DEFAULT_REQUIRED_RECEIPT_TYPES;
+  const hostedRouter = await startHostedRouter({
+    port: 0,
+    adapters: options.adapters,
+    apiKeys: options.apiKey ? [options.apiKey] : void 0,
+    onTelemetryEvent(event) {
+      telemetryEvents.push(event);
+    }
+  });
+  let response;
+  let error;
+  try {
+    const probemesh = createProbeMesh({
+      hosted: {
+        baseUrl: hostedRouter.url,
+        apiKey: options.apiKey
+      }
+    });
+    try {
+      response = await probemesh.call(options.request);
+    } catch (caught) {
+      error = toAcceptanceError(caught);
+    }
+  } finally {
+    await hostedRouter.close();
+  }
+  const baseChecks = createAcceptanceChecks({
+    response,
+    error,
+    telemetryEvents,
+    expectedProviderId: options.expectedProviderId,
+    requiredReceiptTypes
+  });
+  const checks = [
+    ...baseChecks,
+    createSecretSafeOutputCheck({
+      response,
+      error,
+      telemetryEvents,
+      checks: baseChecks,
+      requiredReceiptTypes,
+      forbiddenOutputValues: options.forbiddenOutputValues ?? []
+    })
+  ];
+  const status = checks.every((check) => check.status === "passed") ? "passed" : "failed";
+  const forbiddenOutputValues = options.forbiddenOutputValues ?? [];
+  const sanitizedChecks = sanitizeAcceptanceOutput(checks, forbiddenOutputValues);
+  const sanitizedResponse = sanitizeAcceptanceOutput(response, forbiddenOutputValues);
+  const sanitizedError = sanitizeAcceptanceOutput(error, forbiddenOutputValues);
+  const sanitizedTelemetryEvents = sanitizeAcceptanceOutput(
+    telemetryEvents,
+    forbiddenOutputValues
+  );
+  return {
+    status,
+    checks: sanitizedChecks,
+    response: sanitizedResponse,
+    error: sanitizedError,
+    telemetryEvents: sanitizedTelemetryEvents,
+    summary: createSummary({
+      status,
+      checks: sanitizedChecks,
+      response: sanitizedResponse,
+      error: sanitizedError,
+      telemetryEvents: sanitizedTelemetryEvents,
+      requiredReceiptTypes
+    })
+  };
+}
+function summarizeX402AcceptanceResult(result) {
+  return createSummary({
+    status: result.status,
+    checks: result.checks,
+    response: result.response,
+    error: result.error,
+    telemetryEvents: result.telemetryEvents,
+    requiredReceiptTypes: result.summary.requiredReceiptTypes
+  });
+}
+function evaluateX402ProviderAcceptanceGate(result, options = {}) {
+  const requiredCheckNames = options.requiredCheckNames ?? result.checks.map((check) => check.name);
+  const failedRequiredCheckNames = requiredCheckNames.filter((checkName) => {
+    const check = result.checks.find((candidate) => candidate.name === checkName);
+    return check?.status !== "passed";
+  });
+  const reasons = createGateReasons({
+    result,
+    requiredCheckNames,
+    failedRequiredCheckNames
+  });
+  const accepted = result.status === "passed" && failedRequiredCheckNames.length === 0;
+  return {
+    accepted,
+    status: accepted ? "accepted" : "rejected",
+    requiredCheckNames: [...requiredCheckNames],
+    failedRequiredCheckNames,
+    reasons: accepted ? ["All required x402 provider acceptance checks passed."] : reasons
+  };
+}
+function createX402ProviderAcceptanceReport(result, options = {}) {
+  const summary = summarizeX402AcceptanceResult(result);
+  const receiptRefs = result.response?.receiptRefs ?? result.error?.receiptRefs;
+  const report = {
+    title: options.title ?? "x402 Provider Acceptance Report",
+    status: result.status,
+    gate: evaluateX402ProviderAcceptanceGate(result, options.gate),
+    summary,
+    checks: result.checks,
+    receipts: summarizeAcceptanceReceipts(receiptRefs),
+    route: summary.route,
+    timelineEventTypes: summary.timelineEventTypes,
+    telemetryEventTypes: summary.telemetryEventTypes,
+    safety: summary.safety,
+    retrySafety: summary.retrySafety,
+    error: result.error
+  };
+  return sanitizeAcceptanceOutput(report, options.forbiddenOutputValues ?? []);
+}
+function formatX402ProviderAcceptanceReport(report, options = {}) {
+  const sanitizedReport = sanitizeAcceptanceOutput(report, []);
+  if ((options.format ?? "markdown") === "json") {
+    return JSON.stringify(sanitizedReport, null, 2);
+  }
+  return formatAcceptanceReportMarkdown(sanitizedReport);
+}
+function createAcceptanceChecks(options) {
+  return [
+    completedResponseCheck(options.response, options.error),
+    selectedProviderCheck(
+      options.response,
+      options.error,
+      options.expectedProviderId
+    ),
+    routeMetadataCheck(options.response, options.error),
+    timelineEventsCheck(options.response, options.error),
+    requiredReceiptsCheck(options.response, options.error, options.requiredReceiptTypes),
+    safetySettledDeliveredCheck(options.response, options.error),
+    retrySafetyAfterSuccessCheck(options.response, options.error),
+    telemetryMatchesTimelineCheck(options.response, options.telemetryEvents)
+  ];
+}
+function createGateReasons(options) {
+  const reasons = [];
+  if (options.result.status !== "passed") {
+    reasons.push(`Acceptance result status is "${options.result.status}".`);
+  }
+  for (const checkName of options.failedRequiredCheckNames) {
+    const check = options.result.checks.find(
+      (candidate) => candidate.name === checkName
+    );
+    if (!check) {
+      reasons.push(`Required check "${checkName}" was not found.`);
+      continue;
+    }
+    reasons.push(`Required check "${checkName}" failed: ${check.message}`);
+  }
+  return reasons;
+}
+function summarizeAcceptanceReceipts(receiptRefs) {
+  const receipts = receiptRefs ?? [];
+  const byType = {};
+  for (const receiptRef of receipts) {
+    byType[receiptRef.type] = (byType[receiptRef.type] ?? 0) + 1;
+  }
+  return {
+    total: receipts.length,
+    types: getReceiptTypes(receipts),
+    providers: [
+      ...new Set(receipts.map((receiptRef) => receiptRef.provider))
+    ],
+    byType,
+    hasPaymentProof: receipts.some(
+      (receiptRef) => receiptRef.type === "payment_proof"
+    ),
+    hasSettlementConfirmation: receipts.some(
+      (receiptRef) => receiptRef.type === "settlement_confirmation"
+    ),
+    hasProviderDelivery: receipts.some(
+      (receiptRef) => receiptRef.type === "provider_delivery"
+    )
+  };
+}
+function formatAcceptanceReportMarkdown(report) {
+  const lines = [
+    `# ${report.title}`,
+    "",
+    `Gate: ${report.gate.status}`,
+    `Acceptance: ${report.status}`,
+    `Provider: ${report.summary.providerId ?? "unknown"}`,
+    `Call: ${report.summary.callId ?? "unknown"}`,
+    `Error: ${report.summary.errorCode ?? "none"}`,
+    "",
+    "## Gate Reasons",
+    ...formatList(report.gate.reasons),
+    "",
+    "## Checks",
+    ...report.checks.map(
+      (check) => `- [${check.status === "passed" ? "x" : " "}] ${check.name}: ${check.message}`
+    ),
+    "",
+    "## Receipts",
+    `- Total: ${report.receipts.total}`,
+    `- Types: ${formatInlineList(report.receipts.types)}`,
+    `- Providers: ${formatInlineList(report.receipts.providers)}`,
+    `- Payment proof: ${String(report.receipts.hasPaymentProof)}`,
+    `- Settlement confirmation: ${String(
+      report.receipts.hasSettlementConfirmation
+    )}`,
+    `- Provider delivery: ${String(report.receipts.hasProviderDelivery)}`,
+    "",
+    "## Route",
+    `- Route ID: ${report.route?.routeId ?? "none"}`,
+    `- Selected provider: ${report.route?.selectedProviderId ?? "none"}`,
+    `- Fallback used: ${String(report.route?.fallbackUsed ?? false)}`,
+    `- Stop reason: ${report.route?.stopReason ?? "none"}`,
+    "",
+    "## Safety",
+    `- Payment: ${report.safety?.paymentStatus ?? "unknown"}`,
+    `- Settlement: ${report.safety?.settlementStatus ?? "unknown"}`,
+    `- Delivery: ${report.safety?.deliveryStatus ?? "unknown"}`,
+    `- Money may have moved: ${String(
+      report.safety?.moneyMayHaveMoved ?? false
+    )}`,
+    "",
+    "## Retry Safety",
+    `- Retryable: ${String(report.retrySafety?.retryable ?? false)}`,
+    `- Safe to auto retry: ${String(
+      report.retrySafety?.safeToAutoRetry ?? false
+    )}`,
+    `- Reason: ${report.retrySafety?.reason ?? "unknown"}`,
+    "",
+    "## Timeline",
+    `- Events: ${formatInlineList(report.timelineEventTypes)}`,
+    `- Telemetry: ${formatInlineList(report.telemetryEventTypes)}`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function formatList(values) {
+  if (values.length === 0) {
+    return ["- none"];
+  }
+  return values.map((value) => `- ${value}`);
+}
+function formatInlineList(values) {
+  return values.length > 0 ? values.join(", ") : "none";
+}
+function completedResponseCheck(response, error) {
+  if (response?.status === "completed") {
+    return pass("completed_response", "Hosted x402 call completed.");
+  }
+  return fail(
+    "completed_response",
+    error ? `Hosted x402 call failed with ${error.code}.` : "Hosted x402 call did not return a completed response.",
+    {
+      errorCode: error?.code,
+      errorMessage: error?.message
+    }
+  );
+}
+function selectedProviderCheck(response, error, expectedProviderId) {
+  const providerId = response?.provider.id;
+  if (providerId && (!expectedProviderId || providerId === expectedProviderId)) {
+    return pass("selected_provider", "Hosted route selected the expected provider.", {
+      providerId
+    });
+  }
+  return fail("selected_provider", "Hosted route did not select the expected provider.", {
+    expectedProviderId,
+    providerId,
+    errorProvider: error?.provider
+  });
+}
+function routeMetadataCheck(response, error) {
+  if (response?.route?.mode === "hosted" && typeof response.route.routeId === "string" && response.route.routeId.length > 0) {
+    return pass("route_metadata", "Hosted route metadata is present.", {
+      routeId: response.route.routeId,
+      selectedProviderId: response.route.selectedProviderId
+    });
+  }
+  return fail("route_metadata", "Hosted route metadata is missing.", {
+    errorRouteId: error?.route?.routeId
+  });
+}
+function timelineEventsCheck(response, error) {
+  const timelineEventTypes = response?.timeline?.events.map((event) => event.type) ?? [];
+  const requiredEvents = [
+    "call.requested",
+    "provider.attempted",
+    "provider.selected",
+    "payment.attempted",
+    "receipt.recorded",
+    "call.completed"
+  ];
+  const missingEvents = requiredEvents.filter(
+    (eventType) => !timelineEventTypes.includes(eventType)
+  );
+  if (missingEvents.length === 0) {
+    return pass("timeline_events", "Hosted timeline contains the x402 acceptance events.", {
+      timelineEventTypes
+    });
+  }
+  return fail("timeline_events", "Hosted timeline is missing required x402 events.", {
+    missingEvents,
+    timelineEventTypes,
+    errorTimelineEventTypes: error?.timeline?.events.map((event) => event.type)
+  });
+}
+function requiredReceiptsCheck(response, error, requiredReceiptTypes) {
+  const receiptTypes = getReceiptTypes(response?.receiptRefs);
+  const missingReceiptTypes = requiredReceiptTypes.filter(
+    (receiptType) => !receiptTypes.includes(receiptType)
+  );
+  if (missingReceiptTypes.length === 0) {
+    return pass("required_receipts", "Required x402 receipts are present.", {
+      receiptTypes
+    });
+  }
+  return fail("required_receipts", "Required x402 receipts are missing.", {
+    missingReceiptTypes,
+    receiptTypes,
+    errorReceiptTypes: getReceiptTypes(error?.receiptRefs)
+  });
+}
+function safetySettledDeliveredCheck(response, error) {
+  const safety = response?.safety;
+  if (safety?.paymentStatus === "authorized" && safety.settlementStatus === "settled" && safety.deliveryStatus === "delivered" && safety.moneyMayHaveMoved === true) {
+    return pass("safety_settled_delivered", "Safety metadata proves authorized, settled delivery.", {
+      safety
+    });
+  }
+  return fail(
+    "safety_settled_delivered",
+    "Safety metadata does not prove settled delivery.",
+    {
+      safety,
+      errorSafety: error?.safety
+    }
+  );
+}
+function retrySafetyAfterSuccessCheck(response, error) {
+  const retrySafety = response?.retrySafety;
+  if (retrySafety?.retryable === false && retrySafety.safeToAutoRetry === false && retrySafety.reason === "completed") {
+    return pass("retry_safety_after_success", "Completed paid call is not retryable.", {
+      retrySafety
+    });
+  }
+  return fail(
+    "retry_safety_after_success",
+    "Completed paid call retry safety is missing or incorrect.",
+    {
+      retrySafety,
+      errorRetrySafety: error?.retrySafety
+    }
+  );
+}
+function telemetryMatchesTimelineCheck(response, telemetryEvents) {
+  const timelineEventTypes = response?.timeline?.events.map((event) => event.type) ?? [];
+  const telemetryEventTypes = telemetryEvents.map((event) => event.type);
+  const matches = timelineEventTypes.length > 0 && timelineEventTypes.length === telemetryEventTypes.length && timelineEventTypes.every(
+    (eventType, index) => eventType === telemetryEventTypes[index]
+  );
+  if (matches) {
+    return pass("telemetry_matches_timeline", "Telemetry mirrors the hosted timeline.", {
+      telemetryEventTypes
+    });
+  }
+  return fail("telemetry_matches_timeline", "Telemetry does not mirror the hosted timeline.", {
+    timelineEventTypes,
+    telemetryEventTypes
+  });
+}
+function createSecretSafeOutputCheck(options) {
+  const forbiddenOutputValues = options.forbiddenOutputValues.filter(
+    (value) => value.length > 0
+  );
+  const candidate = {
+    response: options.response,
+    error: options.error,
+    telemetryEvents: options.telemetryEvents,
+    checks: options.checks,
+    summary: createSummary({
+      status: options.checks.every((check) => check.status === "passed") ? "passed" : "failed",
+      checks: options.checks,
+      response: options.response,
+      error: options.error,
+      telemetryEvents: options.telemetryEvents,
+      requiredReceiptTypes: options.requiredReceiptTypes
+    })
+  };
+  const serialized = JSON.stringify(candidate);
+  const leakedValues = forbiddenOutputValues.filter(
+    (value) => serialized.includes(value)
+  );
+  if (leakedValues.length === 0) {
+    return pass("secret_safe_output", "Serialized acceptance output contains no forbidden values.", {
+      checkedForbiddenValueCount: forbiddenOutputValues.length
+    });
+  }
+  return fail("secret_safe_output", "Serialized acceptance output contains forbidden values.", {
+    leakedValueCount: leakedValues.length
+  });
+}
+function createSummary(options) {
+  const receiptRefs = options.response?.receiptRefs ?? options.error?.receiptRefs;
+  const timeline = options.response?.timeline ?? options.error?.timeline;
+  const route = options.response?.route ?? options.error?.route;
+  const failedCheckNames = options.checks.filter((check) => check.status === "failed").map((check) => check.name);
+  return {
+    status: options.status,
+    totalChecks: options.checks.length,
+    passedChecks: options.checks.length - failedCheckNames.length,
+    failedChecks: failedCheckNames.length,
+    failedCheckNames,
+    callId: options.response?.callId ?? options.error?.callId,
+    providerId: options.response?.provider.id ?? options.error?.provider,
+    errorCode: options.error?.code,
+    receiptTypes: getReceiptTypes(receiptRefs),
+    requiredReceiptTypes: [...options.requiredReceiptTypes],
+    timelineEventTypes: timeline?.events.map((event) => event.type) ?? [],
+    telemetryEventTypes: options.telemetryEvents.map((event) => event.type),
+    safety: options.response?.safety ?? options.error?.safety,
+    retrySafety: options.response?.retrySafety ?? options.error?.retrySafety,
+    route: route ? {
+      routeId: route.routeId,
+      selectedProviderId: route.selectedProviderId,
+      fallbackUsed: route.explanation?.fallbackUsed,
+      fallbackCount: route.explanation?.fallbackCount,
+      stopReason: route.explanation?.stopReason
+    } : void 0
+  };
+}
+function toAcceptanceError(error) {
+  if (isProbeMeshError(error)) {
+    return {
+      name: "ProbeMeshError",
+      code: error.code,
+      message: error.message,
+      status: "failed",
+      capability: error.capability,
+      provider: error.provider,
+      callId: error.callId,
+      receiptRefs: error.receiptRefs,
+      safety: error.safety,
+      timeline: error.timeline,
+      retrySafety: error.retrySafety,
+      route: error.route
+    };
+  }
+  return {
+    name: "ProbeMeshError",
+    code: "provider_unavailable",
+    message: error instanceof Error ? error.message : "x402 provider acceptance call failed.",
+    status: "failed"
+  };
+}
+function getReceiptTypes(receiptRefs) {
+  return [...new Set((receiptRefs ?? []).map((receiptRef) => receiptRef.type))];
+}
+function sanitizeAcceptanceOutput(value, forbiddenOutputValues) {
+  const forbiddenValues = forbiddenOutputValues.filter((entry) => entry.length > 0);
+  return redactX402Secrets(
+    replaceForbiddenValues(value, forbiddenValues, /* @__PURE__ */ new WeakSet())
+  );
+}
+function replaceForbiddenValues(value, forbiddenValues, seen) {
+  if (typeof value === "string") {
+    return forbiddenValues.reduce(
+      (current, forbidden) => current.split(forbidden).join("[REDACTED]"),
+      value
+    );
+  }
+  if (value === null || typeof value !== "object" || value instanceof Date) {
+    return value;
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const entries2 = value.map(
+      (entry) => replaceForbiddenValues(entry, forbiddenValues, seen)
+    );
+    seen.delete(value);
+    return entries2;
+  }
+  const entries = Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      replaceForbiddenValues(entry, forbiddenValues, seen)
+    ])
+  );
+  seen.delete(value);
+  return entries;
+}
+function pass(name, message, details) {
+  return {
+    name,
+    status: "passed",
+    message,
+    details
+  };
+}
+function fail(name, message, details) {
+  return {
+    name,
+    status: "failed",
+    message,
+    details
+  };
+}
+function assertAcceptanceOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw invalidOptions("x402 acceptance options must be an object.");
+  }
+  if (!Array.isArray(options.adapters) || options.adapters.length === 0) {
+    throw invalidOptions("x402 acceptance options require at least one adapter.");
+  }
+  if (!options.request || typeof options.request !== "object" || Array.isArray(options.request)) {
+    throw invalidOptions("x402 acceptance options require a call request object.");
+  }
+  if (options.apiKey !== void 0 && (typeof options.apiKey !== "string" || options.apiKey.length === 0)) {
+    throw invalidOptions("x402 acceptance apiKey must be a non-empty string.");
+  }
+  if (options.expectedProviderId !== void 0 && (typeof options.expectedProviderId !== "string" || options.expectedProviderId.length === 0)) {
+    throw invalidOptions(
+      "x402 acceptance expectedProviderId must be a non-empty string."
+    );
+  }
+  if (options.requiredReceiptTypes !== void 0 && (!Array.isArray(options.requiredReceiptTypes) || options.requiredReceiptTypes.some(
+    (receiptType) => typeof receiptType !== "string" || receiptType.length === 0
+  ))) {
+    throw invalidOptions(
+      "x402 acceptance requiredReceiptTypes must be an array of receipt type strings."
+    );
+  }
+  if (options.forbiddenOutputValues !== void 0 && (!Array.isArray(options.forbiddenOutputValues) || options.forbiddenOutputValues.some((value) => typeof value !== "string"))) {
+    throw invalidOptions(
+      "x402 acceptance forbiddenOutputValues must be an array of strings."
+    );
+  }
+}
+function invalidOptions(message) {
+  return new ProbeMeshError({
+    code: "invalid_request",
+    message
+  });
+}
+
+// src/cli/x402AcceptanceCli.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
+var USAGE = `Usage: probemesh-x402-accept --config <path> [--format markdown|json] [--out-json <path>] [--out-md <path>] [--out-catalog <path>] [--title <text>]`;
+async function runX402ProviderAcceptanceCli(options = {}) {
+  const argv = options.argv ?? [];
+  const cwd = options.cwd ?? process.cwd();
+  try {
+    const parsedArgs = parseCliArgs(argv);
+    if (parsedArgs.help) {
+      return {
+        exitCode: 0,
+        skipped: true,
+        stdout: `${USAGE}
+`
+      };
+    }
+    if (!parsedArgs.configPath) {
+      return cliFailure("--config <path> is required.");
+    }
+    const configExport = await loadCliConfig(parsedArgs.configPath, {
+      argv,
+      cwd
+    });
+    if (isCliSkip(configExport)) {
+      return {
+        exitCode: 0,
+        skipped: true,
+        skip: configExport,
+        stdout: `x402 acceptance skipped: ${configExport.reason}
+`
+      };
+    }
+    assertCliConfig(configExport);
+    const result = await runX402ProviderAcceptance(configExport.acceptance);
+    const report = createX402ProviderAcceptanceReport(result, {
+      ...configExport.report ?? {},
+      title: parsedArgs.title ?? configExport.report?.title,
+      forbiddenOutputValues: mergeForbiddenOutputValues(configExport)
+    });
+    const selectedFormat = parsedArgs.format ?? configExport.report?.format ?? "markdown";
+    const stdout = formatX402ProviderAcceptanceReport(report, {
+      format: selectedFormat
+    });
+    const catalogArtifact = createOptionalCatalogArtifact(
+      configExport,
+      report,
+      parsedArgs.outCatalog
+    );
+    const artifactPaths = await writeArtifacts({
+      cwd,
+      report,
+      catalogArtifact,
+      outputs: {
+        json: parsedArgs.outJson ?? configExport.outputs?.json,
+        markdown: parsedArgs.outMarkdown ?? configExport.outputs?.markdown,
+        catalog: parsedArgs.outCatalog ?? configExport.outputs?.catalog
+      }
+    });
+    return {
+      exitCode: report.gate.accepted ? 0 : 1,
+      skipped: false,
+      report,
+      catalogArtifact,
+      stdout,
+      artifactPaths
+    };
+  } catch (error) {
+    return cliFailure(error instanceof Error ? error.message : "Unknown CLI failure.");
+  }
+}
+function parseCliArgs(argv) {
+  const parsedArgs = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      parsedArgs.help = true;
+      continue;
+    }
+    if (arg === "--config") {
+      parsedArgs.configPath = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--format") {
+      const format = requireValue(argv, index, arg);
+      if (format !== "markdown" && format !== "json") {
+        throw new Error("--format must be markdown or json.");
+      }
+      parsedArgs.format = format;
+      index += 1;
+      continue;
+    }
+    if (arg === "--out-json") {
+      parsedArgs.outJson = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--out-md") {
+      parsedArgs.outMarkdown = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--out-catalog") {
+      parsedArgs.outCatalog = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--title") {
+      parsedArgs.title = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument "${arg}".`);
+  }
+  return parsedArgs;
+}
+function requireValue(argv, index, flag) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value.`);
+  }
+  return value;
+}
+async function loadCliConfig(configPath, context) {
+  const configExport = await loadCliConfigDefault(configPath, context.cwd);
+  if (typeof configExport === "function") {
+    return configExport(context);
+  }
+  return configExport;
+}
+function isCliSkip(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && value.skip === true && typeof value.reason === "string";
+}
+function assertCliConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("x402 acceptance CLI config must export an object.");
+  }
+  if (!("acceptance" in value) || !value.acceptance || typeof value.acceptance !== "object") {
+    throw new Error("x402 acceptance CLI config requires acceptance options.");
+  }
+  const outputs = value.outputs;
+  if (outputs !== void 0 && (!outputs || typeof outputs !== "object" || Array.isArray(outputs) || outputs.json !== void 0 && typeof outputs.json !== "string" || outputs.markdown !== void 0 && typeof outputs.markdown !== "string" || outputs.catalog !== void 0 && typeof outputs.catalog !== "string")) {
+    throw new Error("x402 acceptance CLI outputs must contain string paths.");
+  }
+  const catalog = value.catalog;
+  if (catalog !== void 0) {
+    if (!catalog || typeof catalog !== "object" || Array.isArray(catalog)) {
+      throw new Error("x402 acceptance CLI catalog config must be an object.");
+    }
+    if (!("manifest" in catalog) || !catalog.manifest || typeof catalog.manifest !== "object") {
+      throw new Error("x402 acceptance CLI catalog config requires manifest.");
+    }
+    if (catalog.artifactId !== void 0 && typeof catalog.artifactId !== "string") {
+      throw new Error("x402 acceptance CLI catalog artifactId must be a string.");
+    }
+    if (catalog.generatedAt !== void 0 && typeof catalog.generatedAt !== "string") {
+      throw new Error("x402 acceptance CLI catalog generatedAt must be a string.");
+    }
+  }
+}
+function mergeForbiddenOutputValues(config) {
+  return [
+    ...config.acceptance.forbiddenOutputValues ?? [],
+    ...config.report?.forbiddenOutputValues ?? []
+  ];
+}
+function createOptionalCatalogArtifact(config, report, requestedCatalogOutput) {
+  if (!config.catalog) {
+    if (requestedCatalogOutput ?? config.outputs?.catalog) {
+      throw new Error(
+        "x402 acceptance CLI catalog output requires catalog manifest config."
+      );
+    }
+    return void 0;
+  }
+  return createProviderCatalogArtifact({
+    manifest: config.catalog.manifest,
+    acceptanceReport: report,
+    artifactId: config.catalog.artifactId,
+    generatedAt: config.catalog.generatedAt,
+    forbiddenOutputValues: mergeForbiddenOutputValues(config)
+  });
+}
+async function writeArtifacts(options) {
+  const artifactPaths = {};
+  if (options.outputs.json) {
+    const outputPath = resolve(options.cwd, options.outputs.json);
+    await writeArtifact(
+      outputPath,
+      formatX402ProviderAcceptanceReport(options.report, {
+        format: "json"
+      })
+    );
+    artifactPaths.json = outputPath;
+  }
+  if (options.outputs.markdown) {
+    const outputPath = resolve(options.cwd, options.outputs.markdown);
+    await writeArtifact(
+      outputPath,
+      formatX402ProviderAcceptanceReport(options.report, {
+        format: "markdown"
+      })
+    );
+    artifactPaths.markdown = outputPath;
+  }
+  if (options.outputs.catalog) {
+    if (!options.catalogArtifact) {
+      throw new Error(
+        "x402 acceptance CLI catalog output requires a catalog artifact."
+      );
+    }
+    const outputPath = resolve(options.cwd, options.outputs.catalog);
+    await writeArtifact(
+      outputPath,
+      formatProviderCatalogArtifact(options.catalogArtifact, {
+        format: "json"
+      })
+    );
+    artifactPaths.catalog = outputPath;
+  }
+  return artifactPaths;
+}
+async function writeArtifact(outputPath, body) {
+  await mkdir(dirname(outputPath), {
+    recursive: true
+  });
+  await writeFile(outputPath, body, "utf8");
+}
+function cliFailure(message) {
+  return {
+    exitCode: 2,
+    skipped: false,
+    stdout: "",
+    stderr: `${message}
+${USAGE}
+`
+  };
+}
+
+export {
+  runX402ProviderAcceptance,
+  summarizeX402AcceptanceResult,
+  evaluateX402ProviderAcceptanceGate,
+  createX402ProviderAcceptanceReport,
+  formatX402ProviderAcceptanceReport,
+  runX402ProviderAcceptanceCli
+};
+//# sourceMappingURL=chunk-257Y7LN2.js.map