xytara 3.1.16 → 3.2.0

package/lib/stripe_mpp_payment_front.js

@@ -1,258 +0,0 @@
-"use strict";
-
-const crypto = require("crypto");
-const mppAdapter = require("./mpp_adapter");
-
-function normalizeString(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-function safeEqualHex(left, right) {
-  const a = Buffer.from(String(left || ""), "hex");
-  const b = Buffer.from(String(right || ""), "hex");
-  if (a.length === 0 || b.length === 0 || a.length !== b.length) return false;
-  return crypto.timingSafeEqual(a, b);
-}
-
-function decodeBase64UrlJson(value) {
-  try {
-    return JSON.parse(Buffer.from(String(value || ""), "base64url").toString("utf8"));
-  } catch (_) {
-    return null;
-  }
-}
-
-function loadStripeMppFrontConfig() {
-  const sharedSecret = normalizeString(process.env.XYTARA_MPP_SHARED_SECRET);
-  return {
-    enabled: String(process.env.XYTARA_MPP_ENABLED || (sharedSecret ? "true" : "false")).trim().toLowerCase() !== "false",
-    shared_secret: sharedSecret || null,
-    provider: normalizeString(process.env.XYTARA_MPP_PROVIDER) || "stripe_tempo_compatible",
-    settlement_family: normalizeString(process.env.XYTARA_MPP_SETTLEMENT_FAMILY) || "cards_or_stablecoin_or_lightning",
-    max_age_seconds: Math.max(30, Number(process.env.XYTARA_MPP_MAX_AGE_SECONDS || 300) || 300),
-    required_headers: ["authorization"],
-    auth_scheme: "SPT",
-    token_shape: "base64url_json_with_shared_payment_token_and_hmac_signed_payload"
-  };
-}
-
-function parseStripeMppAuthorization(headers) {
-  const authorization = headers && typeof headers.authorization === "string"
-    ? headers.authorization.trim()
-    : "";
-  const match = authorization.match(/^SPT\s+(.+)$/i);
-  if (!match) return null;
-  const decoded = decodeBase64UrlJson(match[1]);
-  if (!decoded || typeof decoded !== "object") return null;
-  return {
-    wallet_id: decoded.wallet_id || decoded.gateway_id || decoded.customer_id || "mpp_gateway",
-    encoded: decoded.payload || null,
-    signature: decoded.signature || null,
-    token_id: decoded.token_id || decoded.spt_id || null,
-    payment_method_type: decoded.payment_method_type || null,
-    provider_reference: decoded.provider_reference || null,
-    settlement_asset: decoded.settlement_asset || null,
-    scheme: "mpp"
-  };
-}
-
-function verifyStripeMppPayload(paymentPayload, quote, walletId, maxAgeSeconds) {
-  if (!paymentPayload || typeof paymentPayload !== "object") return { ok: false, reason: "mpp_payload_invalid" };
-  if (!paymentPayload.quote_id || paymentPayload.quote_id !== quote.quote_id) return { ok: false, reason: "mpp_quote_mismatch" };
-  if (paymentPayload.amount_minor !== quote.amount_minor) return { ok: false, reason: "mpp_amount_mismatch" };
-  if (paymentPayload.currency !== quote.currency) return { ok: false, reason: "mpp_currency_mismatch" };
-  if (paymentPayload.account_id && paymentPayload.account_id !== quote.account_id) return { ok: false, reason: "mpp_account_mismatch" };
-  if (walletId && paymentPayload.wallet_id && paymentPayload.wallet_id !== walletId) return { ok: false, reason: "mpp_wallet_mismatch" };
-  if (!paymentPayload.nonce || typeof paymentPayload.nonce !== "string") return { ok: false, reason: "mpp_nonce_missing" };
-  if (!paymentPayload.issued_at_iso || Number.isNaN(Date.parse(paymentPayload.issued_at_iso))) return { ok: false, reason: "mpp_issued_at_invalid" };
-  const ageSeconds = Math.max(0, Math.floor((Date.now() - Date.parse(paymentPayload.issued_at_iso)) / 1000));
-  if (ageSeconds > maxAgeSeconds) return { ok: false, reason: "mpp_token_expired" };
-  if (!normalizeString(paymentPayload.token_id || paymentPayload.spt_id)) return { ok: false, reason: "mpp_token_missing" };
-  if (!normalizeString(paymentPayload.provider_reference || paymentPayload.payment_intent_id || paymentPayload.checkout_session_id)) {
-    return { ok: false, reason: "mpp_provider_reference_missing" };
-  }
-  return { ok: true, age_seconds: ageSeconds };
-}
-
-async function verifyStripeMppAccessToken(headers, quote, state) {
-  // Real Stripe path: when configured, verify a paid Stripe PaymentIntent/Session
-  // ("SPT <pi_...|cs_...>") covering the quoted amount, with single-use (per-reference)
-  // replay protection. Otherwise fall through to the existing token scheme below.
-  const stripeConfig = mppAdapter.loadMppConfig();
-  if (mppAdapter.isConfigured(stripeConfig)) {
-    const authorization = headers && typeof headers.authorization === "string" ? headers.authorization : "";
-    const parsed = mppAdapter.parseMppHeader(authorization);
-    if (!parsed) return { ok: false, status: 402, reason: "mpp_authorization_malformed" };
-    if (state && state.acceptedPaymentNonces && state.acceptedPaymentNonces.has(parsed.reference)) {
-      return { ok: false, status: 403, reason: "mpp_reference_replayed" };
-    }
-    const expectedRef = mppAdapter.computeBindingRef(stripeConfig.bindingSecret, quote);
-    const result = await mppAdapter.verifyMppPayment(stripeConfig, parsed.reference, quote && quote.amount_minor, undefined, { expectedRef });
-    if (!result.ok) return { ok: false, status: 403, reason: result.reason, detail: result.detail || null };
-    return {
-      ok: true,
-      verification_mode: "mpp_stripe",
-      wallet_id: "mpp",
-      payment_payload: {
-        nonce: result.reference,
-        provider_reference: result.reference,
-        amount_minor: result.amount_minor,
-        quote_id: quote && quote.quote_id,
-        issued_at_iso: new Date().toISOString()
-      },
-      mpp: { provider_reference: result.reference, amount_minor: result.amount_minor, currency: result.currency, provider: "stripe" }
-    };
-  }
-
-  const config = loadStripeMppFrontConfig();
-  if (!config.enabled) return { ok: false, status: 503, reason: "mpp_not_enabled" };
-  if (!config.shared_secret) return { ok: false, status: 503, reason: "mpp_shared_secret_missing" };
-  const payment = parseStripeMppAuthorization(headers || {});
-  if (!payment || !payment.encoded || !payment.signature) {
-    return { ok: false, status: 402, reason: "mpp_headers_incomplete" };
-  }
-  const expectedSignature = crypto.createHmac("sha256", config.shared_secret).update(payment.encoded).digest("hex");
-  if (!safeEqualHex(expectedSignature, payment.signature)) {
-    return { ok: false, status: 403, reason: "mpp_signature_invalid" };
-  }
-  const payload = decodeBase64UrlJson(payment.encoded);
-  const validation = verifyStripeMppPayload(payload, quote, payment.wallet_id, config.max_age_seconds);
-  if (!validation.ok) return { ok: false, status: 403, reason: validation.reason };
-  return {
-    ok: true,
-    verification_mode: "mpp_gateway_signed",
-    wallet_id: payment.wallet_id,
-    payment_payload: payload,
-    age_seconds: validation.age_seconds,
-    mpp: {
-      token_id: payment.token_id || payload.token_id || payload.spt_id || null,
-      provider_reference: payment.provider_reference || payload.provider_reference || payload.payment_intent_id || payload.checkout_session_id || null,
-      payment_method_type: payment.payment_method_type || payload.payment_method_type || null,
-      settlement_asset: payment.settlement_asset || payload.settlement_asset || null,
-      provider: config.provider,
-      settlement_family: config.settlement_family
-    }
-  };
-}
-
-function buildStripeMppSecuritySummary() {
-  const config = loadStripeMppFrontConfig();
-  const blockers = [];
-  if (config.enabled && !config.shared_secret) blockers.push("mpp_shared_secret_missing");
-  return {
-    ok: true,
-    category: "machine-commerce-stripe-mpp-security-summary",
-    summary_version: "xytara-stripe-mpp-security-summary-v1",
-    enabled: config.enabled,
-    shared_secret_configured: Boolean(config.shared_secret),
-    provider: config.provider,
-    settlement_family: config.settlement_family,
-    max_age_seconds: config.max_age_seconds,
-    auth_scheme: config.auth_scheme,
-    token_shape: config.token_shape,
-    ready: config.enabled && blockers.length === 0,
-    blockers,
-    linked_surfaces: {
-      stripe_mpp_lane_ref: "/v1/stripe-mpp",
-      commands_execute_ref: "/mpp/commands/execute",
-      mcp_invoke_ref: "/mpp/mcp/tools/invoke"
-    }
-  };
-}
-
-function stripeMinAmountMinor() {
-  const raw = Number(process.env.XYTARA_MPP_MIN_AMOUNT_MINOR);
-  return Number.isFinite(raw) && raw > 0 ? Math.round(raw) : 50;
-}
-
-async function buildStripeMppChallengePayload(quote) {
-  const stripeConfig = mppAdapter.loadMppConfig();
-  if (mppAdapter.isConfigured(stripeConfig)) {
-    const amountMinor = Number(quote && quote.amount_minor);
-    const minMinor = stripeMinAmountMinor();
-    // Stripe rejects charges below its per-charge floor (~$0.50). Surface this as
-    // a clear challenge error pointing to micro-payment lanes rather than letting
-    // the PaymentIntent create call fail opaquely.
-    if (!Number.isFinite(amountMinor) || amountMinor < minMinor) {
-      return {
-        ok: false,
-        payment_required: {
-          scheme: "mpp",
-          quote,
-          error: "mpp_amount_below_processor_minimum",
-          minimum_amount_minor: minMinor,
-          operator_requirements: {
-            auth_scheme: "SPT",
-            security_ref: "/v1/stripe-mpp/security",
-            recommended_micro_payment_lanes: ["x402 (/commands/execute)", "l402 (/l402/commands/execute)"]
-          }
-        }
-      };
-    }
-    const ref = mppAdapter.computeBindingRef(stripeConfig.bindingSecret, quote);
-    const intent = await mppAdapter.createMppPaymentIntent(stripeConfig, {
-      amountMinor,
-      currency: quote && quote.currency,
-      ref,
-      quoteId: quote && quote.quote_id
-    });
-    if (!intent.ok) {
-      return {
-        ok: false,
-        payment_required: {
-          scheme: "mpp",
-          quote,
-          error: intent.reason,
-          detail: intent.detail || null,
-          operator_requirements: { auth_scheme: "SPT", security_ref: "/v1/stripe-mpp/security" }
-        }
-      };
-    }
-    return {
-      ok: false,
-      payment_required: {
-        scheme: "mpp",
-        quote,
-        stripe: {
-          provider: "stripe",
-          payment_intent: intent.reference,
-          client_secret: intent.client_secret,
-          amount_minor: amountMinor,
-          currency: "usd",
-          naxytra_ref: ref,
-          instructions: "Pay the PaymentIntent above (it is bound to this quote), then retry with 'Authorization: SPT " + intent.reference + "'."
-        },
-        operator_requirements: {
-          auth_scheme: "SPT",
-          token_shape: "authorization_header_SPT_stripe_reference",
-          security_ref: "/v1/stripe-mpp/security",
-          proof_requirements: ["pay_the_bound_payment_intent_then_present_its_reference"]
-        }
-      }
-    };
-  }
-  return {
-    ok: false,
-    payment_required: {
-      scheme: "mpp",
-      quote,
-      operator_requirements: {
-        auth_scheme: "SPT",
-        token_shape: "base64url_json_with_shared_payment_token_and_hmac_signed_payload",
-        security_ref: "/v1/stripe-mpp/security",
-        proof_requirements: [
-          "token_id",
-          "provider_reference"
-        ]
-      }
-    }
-  };
-}
-
-module.exports = {
-  buildStripeMppChallengePayload,
-  buildStripeMppSecuritySummary,
-  loadStripeMppFrontConfig,
-  parseStripeMppAuthorization,
-  verifyStripeMppAccessToken
-};

package/lib/telemetry_lane_contract.js

@@ -1,54 +0,0 @@
-"use strict";
-
-function buildTelemetryLanePack() {
-  return {
-    product: "xytara",
-    category: "machine-commerce-telemetry-lane-pack",
-    pack_version: "xytara-telemetry-lane-pack-v1",
-    lane_state: "first_party_observability_lane_present",
-    posture: "runtime_observability_and_scale_signal_lane",
-    standards: ["opentelemetry"],
-    core_signals: ["traces", "metrics", "logs", "events"],
-    supported_surfaces: {
-      cloudevents_ref: "/cloudevents.json",
-      asyncapi_ref: "/asyncapi.json",
-      integration_matrix_ref: "/v1/integration-matrix",
-      trust_layer_ref: "/v1/economics/accounts/:account_id/trust-layer-summary",
-      operator_intelligence_ref: "/v1/operator-intelligence"
-    },
-    first_run_flows: [
-      {
-        flow_ref: "runtime_observability_alignment",
-        recommended_reason: "best path for operators who need scalable traces and machine-visible runtime signals before wider external adoption",
-        sequence: [
-          "inspect_telemetry_lane_summary",
-          "align_runtime_events_to_cloudevents_and_asyncapi",
-          "map_runtime_traces_and_metrics_to_operator_intelligence",
-          "carry_relevant_execution_signals_into_proof_followthrough"
-        ]
-      }
-    ],
-    guardrails: [
-      "telemetry should improve observability without becoming the canonical runtime truth",
-      "operator visibility and scale diagnostics should remain aligned to runtime and proof boundaries rather than flattening them"
-    ]
-  };
-}
-
-function summarizeTelemetryLanePack() {
-  const pack = buildTelemetryLanePack();
-  return {
-    product: "xytara",
-    category: "machine-commerce-telemetry-lane-pack-summary",
-    summary_version: "xytara-telemetry-lane-pack-summary-v1",
-    lane_state: pack.lane_state,
-    standard_count: pack.standards.length,
-    signal_count: pack.core_signals.length,
-    linked_surfaces: pack.supported_surfaces
-  };
-}
-
-module.exports = {
-  buildTelemetryLanePack,
-  summarizeTelemetryLanePack
-};