mppx 0.8.15 → 0.8.18

package/src/mcp/server/Transport.ts

@@ -1,111 +0,0 @@
-import type { CallToolResult, McpError } from '@modelcontextprotocol/sdk/types.js'
-
-import type * as Credential from '../../Credential.js'
-import * as core_Mcp from '../../Mcp.js'
-import * as Transport from '../../server/Transport.js'
-
-/**
- * MCP SDK tool handler "extra" parameter.
- * Compatible with `@modelcontextprotocol/sdk` RequestHandlerExtra.
- */
-export type Extra = {
-  _meta?:
-    | {
-        [core_Mcp.credentialMetaKey]?: Credential.Credential
-        [key: string]: unknown
-      }
-    | undefined
-  [key: string]: unknown
-}
-
-export type McpSdk = Transport.Transport<Extra, McpError, CallToolResult>
-
-/**
- * MCP SDK transport for server-side payment handling with `@modelcontextprotocol/sdk`.
- *
- * - Reads credentials from `_meta["org.paymentauth/credential"]`
- * - Issues challenges as `McpError` with code `-32042` and challenge in `error.data`
- * - Attaches receipts via `_meta["org.paymentauth/receipt"]` on tool results
- *
- * @example
- * ```ts
- * import { McpServer } from '@modelcontextprotocol/sdk/server/mcp'
- * import { Mppx, Transport } from 'mppx/server'
- *
- * const payment = Mppx.create({
- *   method: tempo(),
- *   secretKey: process.env.SECRET_KEY,
- *   transport: Transport.mcpSdk(),
- * })
- *
- * server.registerTool('premium', { description: '...' }, async (extra) => {
- *   const result = await payment.charge({ request: { ... } })(extra)
- *   if (result.status === 402) throw result.challenge
- *   return result.withReceipt({ content: [...] })
- * })
- * ```
- */
-export function mcpSdk(): McpSdk {
-  let McpErrorClass: typeof McpError | undefined
-
-  return Transport.from<Extra, McpError, CallToolResult>({
-    name: 'mcp-sdk',
-
-    captureRequest() {
-      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/sdk'),
-      }
-    },
-
-    getCredential(extra) {
-      const credential = extra._meta?.[core_Mcp.credentialMetaKey]
-      if (!credential) return null
-      return credential
-    },
-
-    async respondChallenge({ challenge, error }) {
-      if (!McpErrorClass) {
-        try {
-          const mod = await import('@modelcontextprotocol/sdk/types.js')
-          McpErrorClass = mod.McpError
-        } catch (error) {
-          const err = new Error(
-            'Missing optional dependency "@modelcontextprotocol/sdk". Install it to use mppx MCP SDK transports.',
-          )
-          ;(err as Error & { cause?: unknown }).cause = error
-          throw err
-        }
-      }
-      return new McpErrorClass(core_Mcp.paymentRequiredCode, error?.message ?? 'Payment Required', {
-        httpStatus: 402,
-        challenges: [challenge],
-        ...(error && { problem: error.toProblemDetails(challenge.id) }),
-      })
-    },
-
-    respondReceipt({ receipt, response, challengeId }) {
-      const mcpReceipt: core_Mcp.Receipt = {
-        ...receipt,
-        challengeId,
-      }
-
-      const normalizedResponse =
-        response instanceof globalThis.Response
-          ? ({ content: [] } as CallToolResult)
-          : (response as CallToolResult)
-
-      return {
-        ...normalizedResponse,
-        _meta: {
-          ...normalizedResponse._meta,
-          [core_Mcp.receiptMetaKey]: mcpReceipt,
-        },
-      }
-    },
-  })
-}

package/src/mcp/server/index.ts

@@ -1 +0,0 @@
-export * as Transport from './Transport.js'

package/src/middlewares/elysia.test.ts

@@ -1,295 +0,0 @@
-import * as http from 'node:http'
-
-import { Elysia } from 'elysia'
-import { Receipt } from 'mppx'
-import {
-  Mppx as Mppx_client,
-  sessionLegacy as sessionIntent,
-  tempo as tempo_client,
-} from 'mppx/client'
-import { Mppx, discovery, payment } from 'mppx/elysia'
-import { tempo as tempo_server } from 'mppx/server'
-import type { Address } from 'viem'
-import { Addresses } from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vp/test'
-import * as TestHttp from '~test/Http.js'
-import { deployEscrow } from '~test/tempo/legacy/session.js'
-import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
-
-function createServer(app: Elysia<any, any, any, any, any, any, any>) {
-  return new Promise<TestHttp.TestServer>((resolve) => {
-    const server = http.createServer(async (req, res) => {
-      const url = `http://localhost${req.url}`
-      const headers = new Headers()
-      for (let i = 0; i < req.rawHeaders.length; i += 2)
-        headers.append(req.rawHeaders[i]!, req.rawHeaders[i + 1]!)
-      const request = new Request(url, { method: req.method!, headers })
-      const response = await app.fetch(request)
-      res.writeHead(response.status, Object.fromEntries(response.headers))
-      const body = await response.text()
-      if (body) res.write(body)
-      res.end()
-    })
-    server.listen(0, () => {
-      const { port } = server.address() as { port: number }
-      resolve(TestHttp.wrapServer(server, { port, url: `http://localhost:${port}` }))
-    })
-  })
-}
-
-const secretKey = 'test-secret-key-test-secret-key-32'
-
-describe('payment', () => {
-  test('short-circuits management responses', async () => {
-    let handlerRan = false
-    const intent = () => async () => ({
-      status: 200 as const,
-      withReceipt: () =>
-        new Response(null, {
-          headers: { 'Payment-Receipt': 'management-receipt' },
-          status: 204,
-        }),
-    })
-
-    const app = new Elysia().guard({ beforeHandle: payment(intent as any, {} as any) }, (app) =>
-      app.get('/', () => {
-        handlerRan = true
-        return { data: 'content' }
-      }),
-    )
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(204)
-    expect(response.headers.get('Payment-Receipt')).toBe('management-receipt')
-    expect(await response.text()).toBe('')
-    expect(handlerRan).toBe(false)
-
-    server.close()
-  })
-
-  test('copies transport-specific success headers', async () => {
-    const intent = () => async () => ({
-      status: 200 as const,
-      withReceipt: (response?: Response) =>
-        new Response(response?.body ?? null, {
-          headers: {
-            ...(response ? Object.fromEntries(response.headers) : {}),
-            'PAYMENT-RESPONSE': 'x402-response',
-          },
-          status: response?.status ?? 200,
-        }),
-    })
-
-    const app = new Elysia().guard({ beforeHandle: payment(intent as any, {} as any) }, (app) =>
-      app.get('/', () => ({ data: 'content' })),
-    )
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(response.headers.get('PAYMENT-RESPONSE')).toBe('x402-response')
-
-    server.close()
-  })
-})
-
-function createChargeHarness(feePayer: boolean) {
-  const mppx = Mppx.create({
-    methods: [
-      tempo_server.charge({
-        getClient: () => client,
-        currency: asset,
-        recipient: accounts[0].address,
-        ...(feePayer ? { feePayer: true } : {}),
-      }),
-    ],
-    secretKey,
-  })
-
-  const { fetch } = Mppx_client.create({
-    polyfill: false,
-    methods: [
-      tempo_client.charge({
-        account: accounts[1],
-        getClient: () => client,
-      }),
-    ],
-  })
-
-  return { fetch, mppx }
-}
-
-describe('charge', () => {
-  test('returns 402 when no credential', async () => {
-    const { mppx } = createChargeHarness(false)
-
-    const app = new Elysia().guard({ beforeHandle: mppx.charge({ amount: '1' }) }, (app) =>
-      app.get('/', () => ({ fortune: 'You will be rich' })),
-    )
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(402)
-    expect(response.headers.get('WWW-Authenticate')).toContain('Payment')
-
-    server.close()
-  })
-
-  test('returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createChargeHarness(false)
-
-    const app = new Elysia().guard({ beforeHandle: mppx.charge({ amount: '1' }) }, (app) =>
-      app.get('/', () => ({ fortune: 'You will be rich' })),
-    )
-
-    const server = await createServer(app)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-
-    const body = await response.json()
-    expect(body).toEqual({ fortune: 'You will be rich' })
-
-    const receipt = Receipt.fromResponse(response)
-    expect(receipt.status).toBe('success')
-    expect(receipt.method).toBe('tempo')
-
-    server.close()
-  })
-
-  test('fee payer: returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createChargeHarness(true)
-
-    const app = new Elysia().guard({ beforeHandle: mppx.charge({ amount: '1' }) }, (app) =>
-      app.get('/', () => ({ fortune: 'You will be rich' })),
-    )
-
-    const server = await createServer(app)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(Receipt.fromResponse(response).status).toBe('success')
-
-    server.close()
-  })
-
-  test('serves /openapi.json from discovery plugin', async () => {
-    const { mppx } = createChargeHarness(false)
-
-    const app = new Elysia().use(
-      discovery(mppx, {
-        info: { title: 'Elysia API', version: '1.0.0' },
-        routes: [{ handler: mppx.charge({ amount: '1' }), method: 'get', path: '/' }],
-      }),
-    )
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(`${server.url}/openapi.json`)
-    expect(response.status).toBe(200)
-    expect(response.headers.get('cache-control')).toBe('public, max-age=300')
-
-    const body = (await response.json()) as Record<string, any>
-    expect(body.info).toEqual({ title: 'Elysia API', version: '1.0.0' })
-    expect(body.paths['/'].get['x-payment-info'].offers[0]).toMatchObject({
-      amount: '1000000',
-      currency: asset,
-      intent: 'charge',
-      method: 'tempo',
-    })
-
-    server.close()
-  })
-})
-
-describe('session', () => {
-  let escrowContract: Address
-
-  function createSessionHarness(feePayer: boolean) {
-    const mppx = Mppx.create({
-      methods: [
-        tempo_server.sessionLegacy({
-          getClient: () => client,
-          account: accounts[0],
-          currency: asset,
-          escrowContract,
-          ...(feePayer ? { feePayer: accounts[1] } : {}),
-        } as any),
-      ],
-      secretKey,
-    })
-
-    const { fetch } = Mppx_client.create({
-      polyfill: false,
-      methods: [
-        sessionIntent({
-          account: accounts[2],
-          maxDeposit: '10',
-          getClient: () => client,
-        }),
-      ],
-    })
-
-    return { fetch, mppx }
-  }
-
-  beforeAll(async () => {
-    escrowContract = await deployEscrow()
-    await fundAccount({ address: accounts[1].address, token: Addresses.pathUsd })
-    await fundAccount({ address: accounts[1].address, token: asset })
-    await fundAccount({ address: accounts[2].address, token: Addresses.pathUsd })
-    await fundAccount({ address: accounts[2].address, token: asset })
-  })
-
-  test('returns 402 when no credential', async () => {
-    const { mppx } = createSessionHarness(false)
-
-    const app = new Elysia().guard(
-      { beforeHandle: mppx.session({ amount: '1', currency: asset, unitType: 'token' }) },
-      (app) => app.get('/', () => ({ data: 'streamed' })),
-    )
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(402)
-    expect(response.headers.get('WWW-Authenticate')).toContain('Payment')
-
-    server.close()
-  })
-
-  test('returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createSessionHarness(false)
-
-    const app = new Elysia().guard(
-      { beforeHandle: mppx.session({ amount: '1', currency: asset, unitType: 'token' }) },
-      (app) => app.get('/', () => ({ data: 'streamed' })),
-    )
-
-    const server = await createServer(app)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-
-    const body = await response.json()
-    expect(body).toEqual({ data: 'streamed' })
-
-    const receipt = Receipt.fromResponse(response)
-    expect(receipt.status).toBe('success')
-    expect(receipt.method).toBe('tempo')
-
-    server.close()
-  })
-
-  test('fee payer: returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createSessionHarness(true)
-
-    const app = new Elysia().guard(
-      { beforeHandle: mppx.session({ amount: '1', currency: asset, unitType: 'token' }) },
-      (app) => app.get('/', () => ({ data: 'streamed' })),
-    )
-
-    const server = await createServer(app)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(Receipt.fromResponse(response).status).toBe('success')
-
-    server.close()
-  })
-})

package/src/middlewares/elysia.ts

@@ -1,116 +0,0 @@
-import { Elysia, type Context } from 'elysia'
-
-import { generate, type GenerateConfig, type RouteConfig } from '../discovery/OpenApi.js'
-import * as Mppx_core from '../server/Mppx.js'
-import * as Mppx_internal from './internal/mppx.js'
-
-export * from '../server/Methods.js'
-
-type ElysiaHook = (context: Context) => Promise<Response | undefined>
-
-export namespace Mppx {
-  /**
-   * Creates an Elysia-aware payment handler where each intent
-   * returns an Elysia `beforeHandle` hook.
-   *
-   * Use with `.guard()` to scope payment to specific routes,
-   * or `.onBeforeHandle()` to apply globally.
-   *
-   * @example
-   * ```ts
-   * import { Elysia } from 'elysia'
-   * import { Mppx, tempo } from 'mppx/elysia'
-   *
-   * const mppx = Mppx.create({ methods: [tempo()] })
-   *
-   * const app = new Elysia()
-   *   .guard(
-   *     { beforeHandle: mppx.charge({ amount: '1' }) },
-   *     (app) => app.get('/premium', () => ({ data: 'paid content' })),
-   *   )
-   * ```
-   */
-  export function create<const methods extends Mppx_core.Methods>(
-    config: Mppx_core.create.Config<methods>,
-  ): Mppx_internal.Wrap<Mppx_core.Mppx<methods>, ElysiaHook> {
-    return Mppx_internal.wrap(Mppx_core.create(config), payment)
-  }
-}
-
-/**
- * Elysia `beforeHandle` hook that gates a route behind a payment intent.
- *
- * Returns a 402 challenge if no valid credential is provided.
- *
- * @example
- * ```ts
- * import { Elysia } from 'elysia'
- * import { Mppx } from 'mppx/server'
- * import { payment } from 'mppx/elysia'
- *
- * const mppx = Mppx.create({ methods: [tempo()] })
- *
- * const app = new Elysia()
- *   .guard(
- *     { beforeHandle: payment(mppx.charge, { amount: '1' }) },
- *     (app) => app.get('/premium', () => ({ data: 'paid content' })),
- *   )
- * ```
- */
-export function payment<const intent extends Mppx_internal.AnyMethodFn>(
-  intent: intent,
-  options: intent extends (options: infer options) => any ? options : never,
-): ElysiaHook {
-  return async ({ request, set }) => {
-    const result = await intent(options)(request)
-    if (result.status === 402) return result.challenge
-    const managementResponse = getManagementResponse(result)
-    if (managementResponse) return managementResponse
-    const receipt = result.withReceipt(new Response())
-    for (const [key, value] of receipt.headers) set.headers[key] = value
-  }
-}
-
-function getManagementResponse(result: { withReceipt: (response?: Response) => Response }) {
-  try {
-    return result.withReceipt()
-  } catch (error) {
-    if (Mppx_core.isMissingReceiptResponseError(error)) {
-      return null
-    }
-    throw error
-  }
-}
-
-export type DiscoveryConfig = Omit<GenerateConfig, 'routes'> & {
-  path?: string
-  routes?: RouteConfig[]
-}
-
-const discoveryHeaders = { 'Cache-Control': 'public, max-age=300' }
-
-/**
- * Returns an Elysia plugin that serves an OpenAPI discovery document.
- */
-export function discovery(
-  mppx: { methods: readonly Mppx_internal.AnyServer[]; realm: string },
-  config: DiscoveryConfig = {},
-) {
-  const mountPath = config.path ?? '/openapi.json'
-
-  const cached = JSON.stringify(
-    generate(mppx, {
-      ...(config.info ? { info: config.info } : {}),
-      routes: config.routes ?? [],
-      ...(config.serviceInfo ? { serviceInfo: config.serviceInfo } : {}),
-    }),
-  )
-
-  return new Elysia().get(
-    mountPath,
-    () =>
-      new Response(cached, {
-        headers: { ...discoveryHeaders, 'Content-Type': 'application/json' },
-      }),
-  )
-}