mppx 0.6.3 → 0.6.6

package/src/cli/mcp.test.ts

@@ -0,0 +1,233 @@
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+
+import { afterEach, expect, test } from 'vp/test'
+
+const cwd = path.resolve(import.meta.dirname, '../..')
+const binPath = path.join(cwd, 'src/bin.ts')
+const children = new Set<ChildProcessWithoutNullStreams>()
+const homes = new Set<string>()
+
+afterEach(() => {
+  for (const child of children) {
+    if (!child.killed) child.kill('SIGTERM')
+  }
+  children.clear()
+  for (const home of homes) fs.rmSync(home, { force: true, recursive: true })
+  homes.clear()
+})
+
+function startMcpServer() {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-mcp-home-'))
+  homes.add(home)
+  const child = spawn(process.execPath, ['--import', 'tsx', binPath, '--mcp'], {
+    cwd,
+    env: {
+      ...process.env,
+      HOME: home,
+      NODE_NO_WARNINGS: '1',
+      XDG_DATA_HOME: path.join(home, '.local', 'share'),
+    },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  })
+  children.add(child)
+
+  const client = createLineClient(child)
+  return { child, client, home }
+}
+
+function createLineClient(child: ChildProcessWithoutNullStreams) {
+  let buffer = ''
+  const messages: any[] = []
+  const nonJsonLines: string[] = []
+  let stderr = ''
+
+  child.stdout.setEncoding('utf8')
+  child.stderr.setEncoding('utf8')
+  child.stdout.on('data', (chunk) => {
+    buffer += chunk
+    for (;;) {
+      const index = buffer.indexOf('\n')
+      if (index === -1) break
+      const line = buffer.slice(0, index)
+      buffer = buffer.slice(index + 1)
+      if (!line.trim()) continue
+      try {
+        messages.push(JSON.parse(line))
+      } catch {
+        nonJsonLines.push(line)
+      }
+    }
+  })
+  child.stderr.on('data', (chunk) => {
+    stderr += chunk
+  })
+
+  return {
+    get nonJsonLines() {
+      return nonJsonLines
+    },
+    get stderr() {
+      return stderr
+    },
+    notify(method: string, params: Record<string, unknown> = {}) {
+      child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`)
+    },
+    request(id: number, method: string, params: Record<string, unknown>) {
+      child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`)
+    },
+    async waitFor(id: number) {
+      const started = Date.now()
+      while (Date.now() - started < 5_000) {
+        const message = messages.find((candidate) => candidate.id === id)
+        if (message) return message
+        if (child.exitCode !== null)
+          throw new Error(`MCP server exited before response ${id}: ${child.exitCode}`)
+        await new Promise((resolve) => setTimeout(resolve, 20))
+      }
+      throw new Error(
+        `Timed out waiting for MCP response ${id}. stderr=${stderr} nonJson=${JSON.stringify(
+          nonJsonLines,
+        )}`,
+      )
+    },
+  }
+}
+
+async function initialize(client: ReturnType<typeof createLineClient>) {
+  client.request(1, 'initialize', {
+    capabilities: {},
+    clientInfo: { name: 'mppx-test', version: '0' },
+    protocolVersion: '2025-03-26',
+  })
+  const response = await client.waitFor(1)
+  client.notify('notifications/initialized')
+  return response
+}
+
+function writeDiscoveryDocument() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-mcp-discovery-'))
+  homes.add(dir)
+  const file = path.join(dir, 'openapi.json')
+  fs.writeFileSync(
+    file,
+    JSON.stringify({
+      info: { title: 'MCP 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' },
+            },
+          },
+        },
+      },
+    }),
+  )
+  return file
+}
+
+async function callTool(
+  client: ReturnType<typeof createLineClient>,
+  id: number,
+  name: string,
+  args: Record<string, unknown> = {},
+) {
+  client.request(id, 'tools/call', { arguments: args, name })
+  const response = await client.waitFor(id)
+  await new Promise((resolve) => setTimeout(resolve, 100))
+  expect(client.nonJsonLines).toEqual([])
+  return response
+}
+
+test('mppx --mcp stays alive long enough to handle initialize', async () => {
+  const { client } = startMcpServer()
+
+  const response = await initialize(client)
+
+  expect(response.result.serverInfo.name).toBe('mppx')
+  expect(client.nonJsonLines).toEqual([])
+})
+
+test('tools/list exposes mppx commands with input and output schemas', async () => {
+  const { client } = startMcpServer()
+  await initialize(client)
+
+  client.request(2, 'tools/list', {})
+  const response = await client.waitFor(2)
+  const tools = response.result.tools
+
+  expect(tools.map((tool: { name: string }) => tool.name)).toEqual([
+    'account_create',
+    'account_default',
+    'account_delete',
+    'account_export',
+    'account_fund',
+    'account_list',
+    'account_view',
+    'discover_generate',
+    'discover_validate',
+    'init',
+    'sign',
+  ])
+  expect(tools.find((tool: { name: string }) => tool.name === 'account_list').outputSchema).toEqual(
+    expect.objectContaining({
+      properties: expect.objectContaining({ accounts: expect.any(Object) }),
+      type: 'object',
+    }),
+  )
+  expect(tools.find((tool: { name: string }) => tool.name === 'sign').inputSchema).toEqual(
+    expect.objectContaining({
+      properties: expect.objectContaining({ challenge: expect.any(Object) }),
+      type: 'object',
+    }),
+  )
+  expect(client.nonJsonLines).toEqual([])
+})
+
+test('MCP tool calls return structured data without raw stdout lines', async () => {
+  const { client } = startMcpServer()
+  await initialize(client)
+
+  const response = await callTool(client, 2, 'account_list')
+
+  expect(response.result.content[0].text).not.toBe('null')
+  expect(JSON.parse(response.result.content[0].text)).toEqual({ accounts: [] })
+  expect(response.result.structuredContent).toEqual({ accounts: [] })
+})
+
+test('MCP session survives mixed success and error tool calls without stdout pollution', async () => {
+  const { client } = startMcpServer()
+  await initialize(client)
+
+  const discovery = await callTool(client, 2, 'discover_validate', {
+    input: writeDiscoveryDocument(),
+  })
+  expect(JSON.parse(discovery.result.content[0].text)).toEqual({
+    errorCount: 0,
+    issues: [],
+    valid: true,
+    warningCount: 0,
+  })
+  expect(discovery.result.structuredContent).toEqual({
+    errorCount: 0,
+    issues: [],
+    valid: true,
+    warningCount: 0,
+  })
+
+  const sign = await callTool(client, 3, 'sign')
+  expect(sign.result.isError).toBe(true)
+  expect(sign.result.content[0].text).toContain('No challenge provided')
+
+  const accounts = await callTool(client, 4, 'account_list')
+  expect(JSON.parse(accounts.result.content[0].text)).toEqual({ accounts: [] })
+})

package/src/discovery/Discovery.test.ts

@@ -1,14 +1,26 @@
 import { DiscoveryDocument, PaymentInfo, ServiceInfo } from './Discovery.js'
 
 describe('PaymentInfo', () => {
-  test('parses a valid charge payment info', () => {
+  test('normalizes legacy shorthand to offers', () => {
     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' })
+    expect(result.data).toEqual({
+      offers: [{ amount: '1000', intent: 'charge', method: 'tempo' }],
+    })
+  })
+
+  test('parses offers format without modification', () => {
+    const result = PaymentInfo.safeParse({
+      offers: [{ amount: '1000', intent: 'charge', method: 'tempo' }],
+    })
+    expect(result.success).toBe(true)
+    expect(result.data).toEqual({
+      offers: [{ amount: '1000', intent: 'charge', method: 'tempo' }],
+    })
   })
 
   test('parses a session with null amount', () => {
@@ -18,7 +30,7 @@ describe('PaymentInfo', () => {
       method: 'tempo',
     })
     expect(result.success).toBe(true)
-    expect(result.data?.amount).toBeNull()
+    expect(result.data?.offers[0]?.amount).toBeNull()
   })
 
   test('accepts custom intents', () => {
@@ -28,7 +40,7 @@ describe('PaymentInfo', () => {
       method: 'tempo',
     })
     expect(result.success).toBe(true)
-    expect(result.data?.intent).toBe('subscribe')
+    expect(result.data?.offers[0]?.intent).toBe('subscribe')
   })
 
   test('rejects invalid amount pattern', () => {
@@ -40,6 +52,26 @@ describe('PaymentInfo', () => {
     expect(result.success).toBe(false)
   })
 
+  test('rejects mixed shorthand and offers shapes', () => {
+    const result = PaymentInfo.safeParse({
+      amount: '100',
+      offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  test('rejects empty offers arrays', () => {
+    const result = PaymentInfo.safeParse({ offers: [] })
+    expect(result.success).toBe(false)
+  })
+
+  test('rejects malformed offers', () => {
+    const result = PaymentInfo.safeParse({
+      offers: [{ 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',
@@ -47,6 +79,9 @@ describe('PaymentInfo', () => {
       protocols: ['x402', 'mpp'],
     })
     expect(result.success).toBe(true)
+    expect(result.data).toEqual({
+      offers: [{ price: '0.54', pricingMode: 'fixed', protocols: ['x402', 'mpp'] }],
+    })
   })
 })
 
@@ -118,6 +153,33 @@ describe('DiscoveryDocument', () => {
       },
     })
     expect(result.success).toBe(true)
+    expect(result.data?.paths?.['/search']?.post?.['x-payment-info']).toEqual({
+      offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
+    })
+  })
+
+  test('normalizes offers-based discovery documents', () => {
+    const result = DiscoveryDocument.safeParse({
+      info: { title: 'Test', version: '1.0.0' },
+      openapi: '3.1.0',
+      paths: {
+        '/search': {
+          post: {
+            'x-payment-info': {
+              offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
+            },
+            responses: {
+              '200': { description: 'OK' },
+              '402': { description: 'Payment Required' },
+            },
+          },
+        },
+      },
+    })
+    expect(result.success).toBe(true)
+    expect(result.data?.paths?.['/search']?.post?.['x-payment-info']).toEqual({
+      offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
+    })
   })
 
   test('accepts path items with summary, parameters, and extensions', () => {

package/src/discovery/Discovery.ts

@@ -1,18 +1,13 @@
 import * as z from '../zod.js'
 
 const uriOrPathPattern = /^([a-zA-Z][a-zA-Z\d+.-]*:\/\/\S+|\/\S*)$/
+const paymentInfoFieldNames = new Set(['amount', 'currency', 'description', 'intent', 'method'])
 
 function uriOrPath() {
   return z.string().check(z.regex(uriOrPathPattern, 'Invalid URI or path'))
 }
 
-/**
- * Schema for the `x-payment-info` OpenAPI extension on an operation.
- *
- * Only validates spec-defined fields when present; unknown fields are ignored.
- * Discovery is advisory only. Runtime 402 challenges remain authoritative.
- */
-export const PaymentInfo = z.looseObject({
+const PaymentOffer = z.looseObject({
   amount: z.optional(
     z.union([z.null(), z.string().check(z.regex(/^(0|[1-9][0-9]*)$/, 'Invalid amount'))]),
   ),
@@ -21,6 +16,44 @@ export const PaymentInfo = z.looseObject({
   intent: z.optional(z.string()),
   method: z.optional(z.string()),
 })
+
+/**
+ * Schema for the `x-payment-info` OpenAPI extension on an operation.
+ *
+ * Only validates spec-defined fields when present; unknown fields are ignored.
+ * Discovery is advisory only. Runtime 402 challenges remain authoritative.
+ */
+export const PaymentInfo = z.pipe(
+  z
+    .looseObject({
+      amount: z.optional(
+        z.union([z.null(), z.string().check(z.regex(/^(0|[1-9][0-9]*)$/, 'Invalid amount'))]),
+      ),
+      currency: z.optional(z.string()),
+      description: z.optional(z.string()),
+      intent: z.optional(z.string()),
+      method: z.optional(z.string()),
+      offers: z.optional(z.array(PaymentOffer).check(z.minLength(1))),
+    })
+    .check(
+      z.refine(
+        (value) =>
+          value.offers === undefined || Object.keys(value).every((key) => key === 'offers'),
+        'Cannot mix offers with flat payment info fields',
+      ),
+    ),
+  z.transform((value) => {
+    if (value.offers) return { offers: value.offers }
+
+    const offer: Record<string, unknown> = {}
+    for (const [key, field] of Object.entries(value)) {
+      if (key === 'offers') continue
+      if (paymentInfoFieldNames.has(key) || field !== undefined) offer[key] = field
+    }
+
+    return { offers: [offer] }
+  }),
+)
 export type PaymentInfo = z.infer<typeof PaymentInfo>
 
 const ServiceDocs = z.looseObject({

package/src/discovery/OpenApi.test.ts

@@ -110,11 +110,15 @@ describe('generate', () => {
                 },
               },
               "x-payment-info": {
-                "amount": "100",
-                "currency": "0xUSDC",
-                "intent": "charge",
-                "method": "tempo",
-                "recipient": "0x123",
+                "offers": [
+                  {
+                    "amount": "100",
+                    "currency": "0xUSDC",
+                    "intent": "charge",
+                    "method": "tempo",
+                    "recipient": "0x123",
+                  },
+                ],
               },
             },
           },
@@ -161,11 +165,15 @@ describe('generate', () => {
                 },
               },
               "x-payment-info": {
-                "amount": "50",
-                "currency": "usd",
-                "intent": "charge",
-                "method": "tempo",
-                "recipient": "0x1",
+                "offers": [
+                  {
+                    "amount": "50",
+                    "currency": "usd",
+                    "intent": "charge",
+                    "method": "tempo",
+                    "recipient": "0x1",
+                  },
+                ],
               },
             },
           },
@@ -206,10 +214,14 @@ describe('generate', () => {
                 },
               },
               "x-payment-info": {
-                "amount": null,
-                "intent": "session",
-                "method": "tempo",
-                "recipient": "0x123",
+                "offers": [
+                  {
+                    "amount": null,
+                    "intent": "session",
+                    "method": "tempo",
+                    "recipient": "0x123",
+                  },
+                ],
               },
             },
           },
@@ -305,11 +317,15 @@ describe('generate', () => {
                 },
               },
               "x-payment-info": {
-                "amount": "100",
-                "currency": "0xUSDC",
-                "intent": "charge",
-                "method": "tempo",
-                "recipient": "0xABC",
+                "offers": [
+                  {
+                    "amount": "100",
+                    "currency": "0xUSDC",
+                    "intent": "charge",
+                    "method": "tempo",
+                    "recipient": "0xABC",
+                  },
+                ],
               },
             },
           },
@@ -334,11 +350,15 @@ describe('generate', () => {
               },
               "summary": "Search the index",
               "x-payment-info": {
-                "amount": "500",
-                "currency": "0xUSDC",
-                "intent": "charge",
-                "method": "tempo",
-                "recipient": "0xABC",
+                "offers": [
+                  {
+                    "amount": "500",
+                    "currency": "0xUSDC",
+                    "intent": "charge",
+                    "method": "tempo",
+                    "recipient": "0xABC",
+                  },
+                ],
               },
             },
           },
@@ -353,10 +373,14 @@ describe('generate', () => {
                 },
               },
               "x-payment-info": {
-                "amount": null,
-                "intent": "session",
-                "method": "tempo",
-                "recipient": "0xABC",
+                "offers": [
+                  {
+                    "amount": null,
+                    "intent": "session",
+                    "method": "tempo",
+                    "recipient": "0xABC",
+                  },
+                ],
               },
             },
           },
@@ -410,11 +434,15 @@ describe('generate', () => {
               },
               "summary": "Monthly subscription",
               "x-payment-info": {
-                "amount": "100",
-                "intent": "subscribe",
-                "interval": "monthly",
-                "method": "tempo",
-                "recipient": "0xABC",
+                "offers": [
+                  {
+                    "amount": "100",
+                    "intent": "subscribe",
+                    "interval": "monthly",
+                    "method": "tempo",
+                    "recipient": "0xABC",
+                  },
+                ],
               },
             },
           },

package/src/discovery/OpenApi.ts

@@ -1,5 +1,5 @@
 import type * as Method from '../Method.js'
-import type { ServiceInfo } from './Discovery.js'
+import { PaymentInfo, type ServiceInfo } from './Discovery.js'
 
 export type DiscoveryHandler = ((...args: any[]) => unknown) & {
   _internal?: {
@@ -121,7 +121,7 @@ function createDocument(config: {
       },
     }
 
-    if (route.payment) operation['x-payment-info'] = route.payment
+    if (route.payment) operation['x-payment-info'] = PaymentInfo.parse(route.payment)
     if (route.summary) operation.summary = route.summary
     if (route.requestBody) operation.requestBody = route.requestBody