mppx 0.8.15 → 0.8.18

package/src/server/Transport.ts

@@ -1,320 +0,0 @@
-import * as Challenge from '../Challenge.js'
-import * as Constants from '../Constants.js'
-import * as Credential from '../Credential.js'
-import * as Errors from '../Errors.js'
-import type { Distribute, MaybePromise, UnionToIntersection } from '../internal/types.js'
-import * as core_Mcp from '../Mcp.js'
-import type * as Method from '../Method.js'
-import * as Receipt from '../Receipt.js'
-import * as Html from './internal/html/config.js'
-import { serviceWorker } from './internal/html/serviceWorker.gen.js'
-
-export { type McpSdk, mcpSdk } from '../mcp/server/Transport.js'
-
-/**
- * Server-side transport adapter.
- *
- * Abstracts how challenges are issued and credentials are received
- * across different transport protocols (HTTP, MCP, etc.).
- */
-export type Transport<
-  in out input = unknown,
-  in out challengeOutput = unknown,
-  in receiptResponse = challengeOutput,
-  out receiptOutput = receiptResponse,
-> = {
-  /** Transport name for identification. */
-  name: string
-  /** Captures the transport request into an immutable verification snapshot. */
-  captureRequest?: ((input: input) => MaybePromise<Method.CapturedRequest>) | undefined
-  /**
-   * Rebinds a transport-native credential to the route challenge after request
-   * normalization. Transports with non-Payment-auth wire formats can parse their
-   * payload early, then attach the canonical mppx challenge here.
-   */
-  bindCredential?:
-    | ((options: {
-        challenge: Challenge.Challenge
-        credential: Credential.Credential
-        input: input
-      }) => MaybePromise<Credential.Credential>)
-    | undefined
-  /**
-   * Extracts credential from the transport input.
-   * Returns `null` if no credential was provided, or throws if malformed.
-   */
-  getCredential: (input: input) => Credential.Credential | null
-  /** Creates a transport response for a payment challenge. */
-  respondChallenge: (options: {
-    challenge: Challenge.Challenge
-    error?: Errors.PaymentError | undefined
-    html?: Html.Options | undefined
-    input: input
-  }) => challengeOutput | Promise<challengeOutput>
-  /** Attaches a receipt to a successful response. */
-  respondReceipt: (options: {
-    challengeId: string
-    credential: Credential.Credential
-    envelope?: Method.VerifiedChallengeEnvelope | undefined
-    input: input
-    receipt: Receipt.Receipt
-    response: receiptResponse
-  }) => receiptOutput
-}
-export type AnyTransport = Transport<any, any, any, any>
-
-export type Http = Transport<Request, Response>
-
-export type Mcp = Transport<core_Mcp.JsonRpcRequest, core_Mcp.Response>
-
-export type Sse<stream = any> = Transport<
-  Request,
-  Response,
-  Response | AsyncIterable<string> | ((stream: stream) => AsyncIterable<string>),
-  Response
->
-
-/** Extracts the input type from a transport. */
-export type InputOf<transport extends AnyTransport = AnyTransport> =
-  transport extends Transport<infer input, any, any> ? input : never
-
-/** Extracts the challenge output type from a transport. */
-export type ChallengeOutputOf<transport extends AnyTransport = AnyTransport> =
-  transport extends Transport<any, infer challengeOutput, any> ? challengeOutput : never
-
-/** Extracts the receipt output type from a transport. */
-export type ReceiptResponseOf<transport extends AnyTransport = AnyTransport> =
-  transport extends Transport<any, any, infer response, any> ? response : never
-
-/** Extracts the resolved receipt type (return type of respondReceipt). */
-export type ReceiptOutputOf<transport extends AnyTransport = AnyTransport> =
-  transport extends Transport<any, any, any, infer output> ? output : never
-
-/**
- * The `withReceipt` overload set for a given transport.
- *
- * Produces one overload per union member of `ReceiptOutputOf<transport>`,
- * so TypeScript can contextually type generator function parameters.
- */
-export type WithReceipt<transport extends AnyTransport = Http> = WithReceiptOverloads<transport>
-
-/**
- * Creates a custom server-side transport.
- *
- * @example
- * ```ts
- * import { Transport } from 'mppx/server'
- *
- * const custom = Transport.from({
- *   name: 'custom',
- *   captureRequest(input) { ... },
- *   getCredential(input) { ... },
- *   respondChallenge({ challenge, input }) { ... },
- *   respondReceipt({ receipt, response, challengeId, credential, envelope, input }) { ... },
- * })
- * ```
- */
-export function from<
-  input = unknown,
-  challengeOutput = unknown,
-  receiptOutput = challengeOutput,
-  receiptResolved = receiptOutput,
->(
-  transport: Transport<input, challengeOutput, receiptOutput, receiptResolved>,
-): Transport<input, challengeOutput, receiptOutput, receiptResolved> {
-  return transport
-}
-
-/**
- * HTTP transport for server-side payment handling.
- *
- * - Reads credentials from the `Authorization` header
- * - Issues challenges via `WWW-Authenticate` header with 402 status
- * - Attaches receipts via `Payment-Receipt` header
- */
-export function http(): Http {
-  return from<Request, Response>({
-    name: 'http',
-
-    captureRequest(request) {
-      return {
-        hasBody: request.body !== null,
-        headers: new Headers(request.headers),
-        method: request.method,
-        url: safeUrl(request.url),
-      }
-    },
-
-    getCredential(request) {
-      const header = request.headers.get(Constants.Headers.authorization)
-      if (!header) return null
-      const payment = Credential.extractPaymentScheme(header)
-      if (!payment) return null
-      return Credential.deserialize(payment)
-    },
-
-    async respondChallenge(options) {
-      const { challenge, error, input } = options
-
-      if (options.html && new URL(input.url).searchParams.has(Html.params.serviceWorker))
-        return new Response(serviceWorker, {
-          status: 200,
-          headers: {
-            'Content-Type': 'application/javascript',
-            'Cache-Control': 'no-store',
-          },
-        })
-
-      const headers: Record<string, string> = {
-        [Constants.Headers.wwwAuthenticate]: Challenge.serialize(challenge),
-        'Cache-Control': 'no-store',
-      }
-
-      const body = await (async () => {
-        if (options.html && input.headers.get('Accept')?.includes('text/html')) {
-          headers['Content-Type'] = 'text/html; charset=utf-8'
-
-          const { theme, text } = Html.resolveOptions(options.html)
-          const amount = await options.html.formatAmount(challenge.request)
-
-          const dataMap = {
-            [challenge.id]: {
-              label: challenge.method,
-              rootId: Html.ids.root,
-              formattedAmount: amount,
-              config: options.html.config,
-              challenge,
-              text,
-              theme,
-            },
-          } satisfies Record<string, Html.Data>
-
-          return Html.render({
-            entries: [{ challenge, content: options.html.content }],
-            dataMap,
-            formattedAmount: amount,
-            text,
-            theme,
-          })
-        }
-        if (error) {
-          headers['Content-Type'] = 'application/problem+json'
-          return JSON.stringify(error.toProblemDetails(challenge.id))
-        }
-        return null
-      })()
-
-      return new Response(body, { status: error?.status ?? 402, headers })
-    },
-
-    respondReceipt({ receipt, response }) {
-      const headers = new Headers(response.headers)
-      headers.set('Cache-Control', withPrivateCacheControl(headers.get('Cache-Control')))
-      headers.set(Constants.Headers.paymentReceipt, Receipt.serialize(receipt))
-      return new Response(response.body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers,
-      })
-    },
-  })
-}
-
-function withPrivateCacheControl(value: string | null): string {
-  if (!value) return 'private'
-  const directives = value.split(',').map((directive) => directive.trim().toLowerCase())
-  if (directives.includes('private')) return value
-  return `${value}, private`
-}
-
-/**
- * MCP transport for server-side payment handling with raw JSON-RPC.
- *
- * - Reads credentials from `_meta["org.paymentauth/credential"]`
- * - Issues challenges via JSON-RPC error with code -32042/-32043
- * - Attaches receipts via `_meta["org.paymentauth/receipt"]`
- *
- * Use this transport when handling raw JSON-RPC messages directly.
- * For use with `@modelcontextprotocol/sdk`, use `mcpSdk()` instead.
- */
-export function mcp() {
-  return from<core_Mcp.JsonRpcRequest, core_Mcp.Response>({
-    name: 'mcp',
-
-    captureRequest(request) {
-      return {
-        // MCP tool invocations are application content requests even though
-        // they do not carry HTTP body headers on the transport boundary.
-        hasBody: true,
-        headers: new Headers(),
-        method: 'POST',
-        url: new URL(`mcp://request/${encodeURIComponent(request.method ?? 'unknown')}`),
-      }
-    },
-
-    getCredential(request) {
-      const meta = request.params?._meta
-      const credential = meta?.[core_Mcp.credentialMetaKey]
-      if (!credential) return null
-      return credential
-    },
-
-    respondChallenge({ challenge, input, error }) {
-      return {
-        jsonrpc: '2.0',
-        id: input.id,
-        error: {
-          code: mcpErrorCode(error),
-          message: error?.message ?? 'Payment Required',
-          data: {
-            httpStatus: error?.status ?? 402,
-            challenges: [challenge],
-            ...(error && { problem: error.toProblemDetails(challenge.id) }),
-          },
-        },
-      }
-    },
-
-    respondReceipt({ receipt, response, challengeId }) {
-      if ('error' in response) return response
-
-      const mcpReceipt: core_Mcp.Receipt = {
-        ...receipt,
-        challengeId,
-      }
-
-      return {
-        ...response,
-        result: {
-          ...response.result,
-          _meta: {
-            ...response.result._meta,
-            [core_Mcp.receiptMetaKey]: mcpReceipt,
-          },
-        },
-      }
-    },
-  })
-}
-
-/** @internal */
-function mcpErrorCode(error?: Errors.PaymentError): number {
-  if (!error) return core_Mcp.paymentRequiredCode
-  if (error instanceof Errors.MalformedCredentialError) return -32602
-  if (error instanceof Errors.PaymentRequiredError) return core_Mcp.paymentRequiredCode
-  return core_Mcp.paymentVerificationFailedCode
-}
-
-export function safeUrl(url: string | URL | undefined): URL {
-  try {
-    if (url instanceof URL) return new URL(url.toString())
-    if (url) return new URL(url)
-  } catch {}
-  return new URL('about:blank')
-}
-
-/** @internal Distributes over the receipt response union to create overloads. */
-type WithReceiptOverloads<transport extends AnyTransport = Http> = {
-  // biome-ignore lint/style/useShorthandFunctionType: _
-  (): ReceiptOutputOf<transport>
-} & UnionToIntersection<Distribute<ReceiptResponseOf<transport>, ReceiptOutputOf<transport>>>

package/src/server/index.ts

@@ -1,9 +0,0 @@
-export * as Constants from '../Constants.js'
-export * as Expires from '../Expires.js'
-export * as Store from '../Store.js'
-export { evm, stripe, tempo } from './Methods.js'
-export * as Mppx from './Mppx.js'
-export * as NodeListener from './NodeListener.js'
-export * as Request from './Request.js'
-export * as Response from './Response.js'
-export * as Transport from './Transport.js'

package/src/server/internal/html/compose.main.gen.ts

@@ -1,2 +0,0 @@
-// Generated — do not edit.
-export const tabScript = "<script>(function(){let e={serviceWorker:`__mppx_worker`,tab:`__mppx_tab`},t={error:`mppx-error`,header:`mppx-header`,logo:`mppx-logo`,summary:`mppx-summary`,summaryAmount:`mppx-summary-amount`,summaryDescription:`mppx-summary-description`,summaryExpires:`mppx-summary-expires`,tab:`mppx-tab`,tabList:`mppx-tablist`,tabPanel:`mppx-tabpanel`},n=document.querySelector(`.${t.tabList}`),r=document.querySelector(`.${t.summary}`),i=r.querySelector(`.${t.summaryAmount}`),a=Array.from(n.querySelectorAll(`[role=\"tab\"]`)),o=[],s={};for(let e of a){let t=e.textContent.trim().toLowerCase();s[t]=(s[t]||0)+1,o.push(s[t]===1?t:`${t}-${s[t]}`)}function c(e){if(i.textContent=e.dataset.amount,r.querySelector(`.${t.summaryDescription}`)?.remove(),e.dataset.description){let n=document.createElement(`p`);n.className=t.summaryDescription,n.textContent=e.dataset.description,i.after(n)}if(r.querySelector(`.${t.summaryExpires}`)?.remove(),e.dataset.expires){let n=document.createElement(`p`);n.className=t.summaryExpires;let i=new Date(e.dataset.expires),a=document.createElement(`time`);a.dateTime=i.toISOString(),a.textContent=i.toLocaleString(),n.textContent=`${e.dataset.expiresLabel} `,n.appendChild(a),r.appendChild(n)}}function l(t,n=!0){if(a.forEach(e=>{e.setAttribute(`aria-selected`,`false`),e.setAttribute(`tabindex`,`-1`)}),t.setAttribute(`aria-selected`,`true`),t.removeAttribute(`tabindex`),t.focus(),document.querySelectorAll(`[role=\"tabpanel\"]`).forEach(e=>{e.hidden=!0}),document.getElementById(t.getAttribute(`aria-controls`)).hidden=!1,c(t),n){let n=new URL(location.href);n.searchParams.set(e.tab,o[a.indexOf(t)]),history.replaceState(null,``,n)}}let u=new URL(location.href).searchParams.get(e.tab);if(u!==null){let e=o.indexOf(u);e>=0&&l(a[e],!1)}n.addEventListener(`click`,e=>{let t=e.target.closest(`[role=\"tab\"]`);t&&l(t)}),n.addEventListener(`keydown`,e=>{let t=a.indexOf(e.target);if(t<0)return;let n;e.key===`ArrowRight`?n=a[(t+1)%a.length]:e.key===`ArrowLeft`?n=a[(t-1+a.length)%a.length]:e.key===`Home`?n=a[0]:e.key===`End`&&(n=a[a.length-1]),n&&(e.preventDefault(),l(n))})})();</script>"

package/src/server/internal/html/compose.main.ts

@@ -1,88 +0,0 @@
-import { classNames, params } from './constants.js'
-
-const tablist = document.querySelector<HTMLElement>(`.${classNames.tabList}`)!
-const summary = document.querySelector<HTMLElement>(`.${classNames.summary}`)!
-const amount = summary.querySelector<HTMLElement>(`.${classNames.summaryAmount}`)!
-const tabs = Array.from(tablist.querySelectorAll<HTMLElement>('[role="tab"]'))
-
-// Generate unique slugs: tempo, stripe, stripe-2
-const slugs: string[] = []
-const counts: Record<string, number> = {}
-for (const tab of tabs) {
-  const name = tab.textContent!.trim().toLowerCase()
-  counts[name] = (counts[name] || 0) + 1
-  slugs.push(counts[name] === 1 ? name : `${name}-${counts[name]}`)
-}
-
-function updateSummary(tab: HTMLElement) {
-  amount.textContent = tab.dataset.amount!
-
-  summary.querySelector(`.${classNames.summaryDescription}`)?.remove()
-  if (tab.dataset.description) {
-    const p = document.createElement('p')
-    p.className = classNames.summaryDescription
-    p.textContent = tab.dataset.description
-    amount.after(p)
-  }
-
-  summary.querySelector(`.${classNames.summaryExpires}`)?.remove()
-  if (tab.dataset.expires) {
-    const p = document.createElement('p')
-    p.className = classNames.summaryExpires
-    const date = new Date(tab.dataset.expires)
-    const time = document.createElement('time')
-    time.dateTime = date.toISOString()
-    time.textContent = date.toLocaleString()
-    p.textContent = `${tab.dataset.expiresLabel} `
-    p.appendChild(time)
-    summary.appendChild(p)
-  }
-}
-
-function activate(tab: HTMLElement, updateUrl = true) {
-  tabs.forEach((t) => {
-    t.setAttribute('aria-selected', 'false')
-    t.setAttribute('tabindex', '-1')
-  })
-  tab.setAttribute('aria-selected', 'true')
-  tab.removeAttribute('tabindex')
-  tab.focus()
-  document.querySelectorAll<HTMLElement>('[role="tabpanel"]').forEach((p) => {
-    p.hidden = true
-  })
-  document.getElementById(tab.getAttribute('aria-controls')!)!.hidden = false
-
-  updateSummary(tab)
-
-  if (updateUrl) {
-    const url = new URL(location.href)
-    url.searchParams.set(params.tab, slugs[tabs.indexOf(tab)]!)
-    history.replaceState(null, '', url)
-  }
-}
-
-// Restore tab from URL on load
-const initial = new URL(location.href).searchParams.get(params.tab)
-if (initial !== null) {
-  const index = slugs.indexOf(initial)
-  if (index >= 0) activate(tabs[index]!, false)
-}
-
-tablist.addEventListener('click', (event) => {
-  const tab = (event.target as HTMLElement).closest<HTMLElement>('[role="tab"]')
-  if (tab) activate(tab)
-})
-
-tablist.addEventListener('keydown', (event) => {
-  const index = tabs.indexOf(event.target as HTMLElement)
-  if (index < 0) return
-  let next: HTMLElement | undefined
-  if (event.key === 'ArrowRight') next = tabs[(index + 1) % tabs.length]
-  else if (event.key === 'ArrowLeft') next = tabs[(index - 1 + tabs.length) % tabs.length]
-  else if (event.key === 'Home') next = tabs[0]
-  else if (event.key === 'End') next = tabs[tabs.length - 1]
-  if (next) {
-    event.preventDefault()
-    activate(next)
-  }
-})