mppx 0.4.9 → 0.4.10

package/src/Expires.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vp/test'
 
 import * as Expires from './Expires.js'
 

package/src/Method.test.ts

@@ -1,5 +1,5 @@
 import { Method, z } from 'mppx'
-import { describe, expect, expectTypeOf, test } from 'vitest'
+import { describe, expect, expectTypeOf, test } from 'vp/test'
 
 describe('from', () => {
   test('behavior: creates intent', () => {

package/src/PaymentRequest.test.ts

@@ -1,6 +1,6 @@
 import { PaymentRequest } from 'mppx'
 import { Methods } from 'mppx/tempo'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 describe('from', () => {
   test('creates a request', () => {

package/src/Receipt.test.ts

@@ -1,5 +1,5 @@
 import { Receipt } from 'mppx'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 describe('from', () => {
   test('behavior: creates receipt with success status', () => {

package/src/Store.test-d.ts

@@ -1,4 +1,4 @@
-import { expectTypeOf, test } from 'vitest'
+import { expectTypeOf, test } from 'vp/test'
 
 import * as Store from './Store.js'
 

package/src/Store.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Store from './Store.js'
 

package/src/cli/cli.test.ts

@@ -6,7 +6,7 @@ import * as path from 'node:path'
 import { parseUnits } from 'viem'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { Addresses } from 'viem/tempo'
-import { afterAll, describe, expect, test } from 'vitest'
+import { afterAll, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { rpcUrl } from '~test/tempo/prool.js'
 import { deployEscrow } from '~test/tempo/session.js'
@@ -76,6 +76,217 @@ async function serve(argv: string[], options?: { env?: Record<string, string | u
   return { output, stderr, exitCode }
 }
 
+describe('discover validate', () => {
+  test('validates a local discovery document', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-discovery-'))
+    const file = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      file,
+      JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              requestBody: {
+                content: { 'application/json': { schema: { type: 'object' } } },
+              },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      }),
+    )
+
+    const { output, exitCode } = await serve(['discover', 'validate', file])
+    expect(exitCode).toBeUndefined()
+    expect(output).toContain('Discovery document is valid.')
+  })
+
+  test('returns non-zero for invalid discovery documents', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-discovery-'))
+    const file = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      file,
+      JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              responses: {
+                '200': { description: 'OK' },
+              },
+            },
+          },
+        },
+      }),
+    )
+
+    const { output, exitCode } = await serve(['discover', 'validate', file])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('[error]')
+    expect(output).toContain('402')
+  })
+
+  test(
+    'validates remote discovery documents and reports warnings',
+    { timeout: 20_000 },
+    async () => {
+      const body = JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      })
+      const server = await Http.createServer((_req, res) => {
+        res.setHeader('Content-Type', 'application/json')
+        res.end(body)
+      })
+
+      try {
+        const { output, exitCode } = await serve(['discover', 'validate', server.url])
+        expect(exitCode).toBeUndefined()
+        expect(output).toContain('[warning]')
+        expect(output).toContain('requestBody')
+        expect(output).toContain('valid with 1 warning')
+      } finally {
+        server.close()
+      }
+    },
+  )
+
+  test(
+    'rejects oversized discovery documents via content-length',
+    { timeout: 20_000 },
+    async () => {
+      const server = await Http.createServer((_req, res) => {
+        res.setHeader('Content-Type', 'application/json')
+        res.setHeader('Content-Length', String(11 * 1024 * 1024))
+        res.end('{}')
+      })
+
+      try {
+        const { exitCode, output } = await serve(['discover', 'validate', server.url])
+        expect(exitCode).toBe(1)
+        expect(output).toContain('10 MB')
+      } finally {
+        server.close()
+      }
+    },
+  )
+})
+
+describe('discover generate', () => {
+  test('generates from a pre-built OpenAPI document module', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'doc.mjs')
+    fs.writeFileSync(
+      mod,
+      `export default ${JSON.stringify({
+        openapi: '3.1.0',
+        info: { title: 'Test', version: '1.0.0' },
+        paths: {
+          '/pay': {
+            post: {
+              'x-payment-info': { amount: '100', intent: 'charge', method: 'tempo' },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      })}`,
+    )
+
+    const { output, exitCode } = await serve(['discover', 'generate', mod])
+    expect(exitCode).toBeUndefined()
+    const doc = JSON.parse(output)
+    expect(doc.openapi).toBe('3.1.0')
+    expect(doc.paths['/pay'].post['x-payment-info'].amount).toBe('100')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+
+  test('writes to file with --output', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'doc.mjs')
+    const outFile = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      mod,
+      `export default ${JSON.stringify({
+        openapi: '3.1.0',
+        info: { title: 'Test', version: '1.0.0' },
+        paths: {},
+      })}`,
+    )
+
+    const { output, stderr, exitCode } = await serve([
+      'discover',
+      'generate',
+      mod,
+      '--output',
+      outFile,
+    ])
+    expect(exitCode).toBeUndefined()
+    expect(output).toBe('')
+    expect(stderr).toContain(outFile)
+    const written = JSON.parse(fs.readFileSync(outFile, 'utf-8'))
+    expect(written.openapi).toBe('3.1.0')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+
+  test('errors when module not found', async () => {
+    const { output, exitCode } = await serve([
+      'discover',
+      'generate',
+      '/tmp/nonexistent-mppx-module.mjs',
+    ])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('MODULE_NOT_FOUND')
+  })
+
+  test('errors when module has no mppx or openapi export', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'bad.mjs')
+    fs.writeFileSync(mod, 'export default { foo: "bar" }')
+
+    const { output, exitCode } = await serve(['discover', 'generate', mod])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('INVALID_MODULE')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+})
+
 describe('basic charge (examples/basic)', () => {
   test('happy path: makes payment and receives response', { timeout: 120_000 }, async () => {
     const { Actions } = await import('viem/tempo')

package/src/cli/cli.ts

@@ -11,6 +11,7 @@ import { tempo as tempoMainnet } from 'viem/chains'
 import * as Challenge from '../Challenge.js'
 import { normalizeHeaders } from '../client/internal/Fetch.js'
 import * as Mppx from '../client/Mppx.js'
+import { validate as validateDiscovery } from '../discovery/Validate.js'
 import { createDefaultStore, createKeychain, resolveAccountName } from './account.js'
 import { loadConfig, resolvePlugin } from './internal.js'
 import type { Plugin } from './plugins/plugin.js'
@@ -915,7 +916,168 @@ export default defineConfig({
   },
 })
 
+const discover = Cli.create('discover', {
+  description: 'Discovery tooling',
+})
+  .command('generate', {
+    description: 'Generate a static OpenAPI discovery document from a module',
+    args: z.object({
+      module: z.string().describe('Path to a module that default-exports a discovery config'),
+    }),
+    options: z.object({
+      output: z.string().optional().describe('Write output to a file instead of stdout'),
+    }),
+    alias: { output: 'o' },
+    async run(c) {
+      const modulePath = path.resolve(c.args.module)
+      if (!fs.existsSync(modulePath)) {
+        return c.error({
+          code: 'MODULE_NOT_FOUND',
+          message: `Module not found: ${modulePath}`,
+          exitCode: 1,
+        })
+      }
+
+      let mod: Record<string, unknown>
+      try {
+        mod = await import(modulePath)
+      } catch (error) {
+        return c.error({
+          code: 'MODULE_IMPORT_FAILED',
+          message: `Failed to import module: ${(error as Error).message}`,
+          exitCode: 1,
+        })
+      }
+
+      const exported = (mod.default ?? mod) as Record<string, unknown>
+
+      // If the export is already a plain OpenAPI doc (has `openapi` key), use it directly.
+      // Otherwise, expect { mppx, ...GenerateConfig } and call generate().
+      let doc: Record<string, unknown>
+      if (typeof exported.openapi === 'string') {
+        doc = exported
+      } else {
+        const { generate } = await import('../discovery/OpenApi.js')
+        const mppx = exported.mppx as { methods: readonly any[]; realm: string }
+        if (!mppx) {
+          return c.error({
+            code: 'INVALID_MODULE',
+            message:
+              'Module must default-export an OpenAPI document (with `openapi` key) or an object with `mppx` (server instance) and `routes`.',
+            exitCode: 1,
+          })
+        }
+        doc = generate(mppx, exported as any)
+      }
+
+      const json = JSON.stringify(doc, null, 2)
+      if (c.options.output) {
+        const outPath = path.resolve(c.options.output)
+        fs.writeFileSync(outPath, `${json}\n`)
+        process.stderr.write(`Wrote ${outPath}\n`)
+      } else {
+        console.log(json)
+      }
+    },
+  })
+  .command('validate', {
+    description: 'Validate an OpenAPI discovery document from a file or URL',
+    args: z.object({
+      input: z.string().describe('Path or URL to a discovery document'),
+    }),
+    async run(c) {
+      const input = c.args.input
+      let raw: string
+      if (/^https?:\/\//.test(input)) {
+        const controller = new AbortController()
+        const timeout = setTimeout(() => controller.abort(), 30_000)
+        let response: Response
+        try {
+          response = await globalThis.fetch(input, { signal: controller.signal })
+        } catch (error) {
+          clearTimeout(timeout)
+          const msg =
+            error instanceof DOMException && error.name === 'AbortError'
+              ? 'Request timed out after 30s'
+              : (error as Error).message
+          return c.error({
+            code: 'DISCOVERY_FETCH_FAILED',
+            message: `Failed to fetch discovery document: ${msg}`,
+            exitCode: 1,
+          })
+        }
+        clearTimeout(timeout)
+        if (!response.ok) {
+          return c.error({
+            code: 'DISCOVERY_FETCH_FAILED',
+            message: `Failed to fetch discovery document: HTTP ${response.status}`,
+            exitCode: 1,
+          })
+        }
+        const maxSize = 10 * 1024 * 1024 // 10 MB
+        const contentLength = response.headers.get('content-length')
+        if (contentLength && Number(contentLength) > maxSize) {
+          return c.error({
+            code: 'DISCOVERY_TOO_LARGE',
+            message: `Discovery document exceeds 10 MB limit`,
+            exitCode: 1,
+          })
+        }
+        raw = await response.text()
+        if (raw.length > maxSize) {
+          return c.error({
+            code: 'DISCOVERY_TOO_LARGE',
+            message: `Discovery document exceeds 10 MB limit`,
+            exitCode: 1,
+          })
+        }
+      } else {
+        const resolved = path.resolve(input)
+        if (!fs.existsSync(resolved)) {
+          return c.error({
+            code: 'DISCOVERY_NOT_FOUND',
+            message: `Discovery document not found: ${resolved}`,
+            exitCode: 1,
+          })
+        }
+        raw = fs.readFileSync(resolved, 'utf-8')
+      }
+
+      let doc: unknown
+      try {
+        doc = JSON.parse(raw)
+      } catch (error) {
+        return c.error({
+          code: 'DISCOVERY_INVALID_JSON',
+          message: `Invalid discovery JSON: ${(error as Error).message}`,
+          exitCode: 1,
+        })
+      }
+
+      const issues = validateDiscovery(doc)
+      for (const issue of issues) console.log(`[${issue.severity}] ${issue.path}: ${issue.message}`)
+
+      const errorCount = issues.filter((issue) => issue.severity === 'error').length
+      const warningCount = issues.filter((issue) => issue.severity === 'warning').length
+
+      if (errorCount > 0) {
+        return c.error({
+          code: 'DISCOVERY_INVALID',
+          message: `Discovery document has ${errorCount} error(s) and ${warningCount} warning(s).`,
+          exitCode: 1,
+        })
+      }
+
+      console.log(
+        warningCount > 0
+          ? `Discovery document is valid with ${warningCount} warning(s).`
+          : 'Discovery document is valid.',
+      )
+    },
+  })
+
 cli.command(account)
+cli.command(discover)
 cli.command(init)
 cli.command(sign)
 

package/src/client/Mppx.test-d.ts

@@ -1,5 +1,5 @@
 import type { Account } from 'viem'
-import { describe, expectTypeOf, test } from 'vitest'
+import { describe, expectTypeOf, test } from 'vp/test'
 
 import * as Method from '../Method.js'
 import { charge } from '../tempo/client/Charge.js'

package/src/client/Mppx.test.ts

@@ -2,7 +2,7 @@ import { Challenge, Credential, Mcp, Method, Receipt } from 'mppx'
 import { Mppx, Transport, tempo } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import { Methods } from 'mppx/tempo'
-import { afterEach, describe, expect, test } from 'vitest'
+import { afterEach, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { accounts, asset, client } from '~test/tempo/viem.js'
 

package/src/client/Transport.test.ts

@@ -1,7 +1,7 @@
 import { Challenge, Credential, Mcp } from 'mppx'
 import { Transport } from 'mppx/client'
 import { Methods } from 'mppx/tempo'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 const realm = 'api.example.com'
 const secretKey = 'test-secret-key'

package/src/client/internal/Fetch.browser.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from 'vitest'
+import { describe, expect, test, vi } from 'vp/test'
 
 import * as Fetch from './Fetch.js'
 

package/src/client/internal/Fetch.test-d.ts

@@ -1,5 +1,5 @@
 import type { Account } from 'viem'
-import { describe, expectTypeOf, test } from 'vitest'
+import { describe, expectTypeOf, test } from 'vp/test'
 
 import { charge } from '../../tempo/client/Charge.js'
 import * as Fetch from './Fetch.js'

package/src/client/internal/Fetch.test.ts

@@ -2,7 +2,7 @@ import { Receipt } from 'mppx'
 import { tempo } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import { createClient, defineChain } from 'viem'
-import { describe, expect, test, vi } from 'vitest'
+import { describe, expect, test, vi } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { rpcUrl } from '~test/tempo/prool.js'
 import { accounts, asset, chain, client, http } from '~test/tempo/viem.js'
@@ -16,6 +16,7 @@ const server = Mppx_server.create({
   methods: [
     tempo_server({
       getClient: () => client,
+      account: accounts[0],
     }),
   ],
   realm,

package/src/discovery/Discovery.test.ts

@@ -0,0 +1,152 @@
+import { DiscoveryDocument, PaymentInfo, ServiceInfo } from './Discovery.js'
+
+describe('PaymentInfo', () => {
+  test('parses a valid charge payment info', () => {
+    const result = PaymentInfo.safeParse({
+      amount: '1000',
+      intent: 'charge',
+      method: 'tempo',
+    })
+    expect(result.success).toBe(true)
+    expect(result.data).toEqual({ amount: '1000', intent: 'charge', method: 'tempo' })
+  })
+
+  test('parses a session with null amount', () => {
+    const result = PaymentInfo.safeParse({
+      amount: null,
+      intent: 'session',
+      method: 'tempo',
+    })
+    expect(result.success).toBe(true)
+    expect(result.data?.amount).toBeNull()
+  })
+
+  test('accepts custom intents', () => {
+    const result = PaymentInfo.safeParse({
+      amount: '100',
+      intent: 'subscribe',
+      method: 'tempo',
+    })
+    expect(result.success).toBe(true)
+    expect(result.data?.intent).toBe('subscribe')
+  })
+
+  test('rejects invalid amount pattern', () => {
+    const result = PaymentInfo.safeParse({
+      amount: '01',
+      intent: 'charge',
+      method: 'tempo',
+    })
+    expect(result.success).toBe(false)
+  })
+
+  test('accepts x402 format with unknown fields', () => {
+    const result = PaymentInfo.safeParse({
+      price: '0.54',
+      pricingMode: 'fixed',
+      protocols: ['x402', 'mpp'],
+    })
+    expect(result.success).toBe(true)
+  })
+})
+
+describe('ServiceInfo', () => {
+  test('parses a full service info', () => {
+    const result = ServiceInfo.safeParse({
+      categories: ['ai', 'search'],
+      docs: {
+        apiReference: 'https://example.com/api',
+        homepage: 'https://example.com',
+        llms: 'https://example.com/llms.txt',
+      },
+    })
+    expect(result.success).toBe(true)
+    expect(result.data?.categories).toEqual(['ai', 'search'])
+  })
+
+  test('accepts relative paths for doc links', () => {
+    const result = ServiceInfo.safeParse({
+      docs: {
+        llms: '/llms.txt',
+        apiReference: '/docs/api',
+      },
+    })
+    expect(result.success).toBe(true)
+    expect(result.data?.docs?.llms).toBe('/llms.txt')
+  })
+
+  test('rejects invalid doc URIs', () => {
+    const result = ServiceInfo.safeParse({
+      docs: {
+        homepage: 'not-a-uri',
+      },
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('DiscoveryDocument', () => {
+  test('parses a minimal document', () => {
+    const result = DiscoveryDocument.safeParse({
+      info: { title: 'Test', version: '1.0.0' },
+      openapi: '3.1.0',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  test('parses a document with discovery extensions', () => {
+    const result = DiscoveryDocument.safeParse({
+      info: { title: 'Test', version: '1.0.0' },
+      openapi: '3.1.0',
+      paths: {
+        '/search': {
+          post: {
+            'x-payment-info': {
+              amount: '100',
+              intent: 'charge',
+              method: 'tempo',
+            },
+            responses: {
+              '200': { description: 'OK' },
+              '402': { description: 'Payment Required' },
+            },
+          },
+        },
+      },
+      'x-service-info': {
+        categories: ['search'],
+      },
+    })
+    expect(result.success).toBe(true)
+  })
+
+  test('accepts path items with summary, parameters, and extensions', () => {
+    const result = DiscoveryDocument.safeParse({
+      info: { title: 'Test', version: '1.0.0' },
+      openapi: '3.1.0',
+      paths: {
+        '/search': {
+          summary: 'Search endpoints',
+          parameters: [{ name: 'q', in: 'query' }],
+          'x-custom': 'hello',
+          post: {
+            'x-payment-info': {
+              amount: '100',
+              intent: 'charge',
+              method: 'tempo',
+            },
+            responses: { '402': { description: 'Payment Required' } },
+          },
+        },
+      },
+    })
+    expect(result.success).toBe(true)
+  })
+
+  test('rejects missing info', () => {
+    const result = DiscoveryDocument.safeParse({
+      openapi: '3.1.0',
+    })
+    expect(result.success).toBe(false)
+  })
+})