mppx 0.8.17 → 0.8.19

package/src/cli/config.test.ts

@@ -1,89 +0,0 @@
-import * as fs from 'node:fs'
-import * as os from 'node:os'
-import * as path from 'node:path'
-
-import { defineConfig } from './config.js'
-import { loadConfig } from './internal.js'
-
-let tmpDir: string
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-config-test-'))
-  vi.stubEnv('MPPX_CONFIG', '')
-})
-
-afterEach(() => {
-  vi.unstubAllEnvs()
-  fs.rmSync(tmpDir, { recursive: true, force: true })
-})
-
-describe('defineConfig', () => {
-  test('returns the config object as-is', () => {
-    const config = defineConfig({ methods: [] })
-    expect(config).toEqual({ methods: [] })
-  })
-})
-
-describe('loadConfig', () => {
-  test('returns undefined when no config file exists', async () => {
-    vi.spyOn(process, 'cwd').mockReturnValue(tmpDir)
-    const config = await loadConfig()
-    expect(config).toBeUndefined()
-    vi.mocked(process.cwd).mockRestore()
-  })
-
-  test('loads config from MPPX_CONFIG env var', async () => {
-    const configPath = path.join(tmpDir, 'custom.mjs')
-    fs.writeFileSync(configPath, 'export default { methods: [] }')
-    vi.stubEnv('MPPX_CONFIG', configPath)
-    const result = await loadConfig()
-    expect(result?.config).toEqual({ methods: [] })
-    expect(result?.path).toBe(configPath)
-  })
-
-  test('loads config from explicit config file', async () => {
-    const configPath = path.join(tmpDir, 'custom.mjs')
-    fs.writeFileSync(configPath, 'export default { methods: [] }')
-    const result = await loadConfig(configPath)
-    expect(result?.config).toEqual({ methods: [] })
-    expect(result?.path).toBe(configPath)
-  })
-
-  test('returns undefined when MPPX_CONFIG points to nonexistent file', async () => {
-    vi.stubEnv('MPPX_CONFIG', path.join(tmpDir, 'nonexistent.ts'))
-    const config = await loadConfig()
-    expect(config).toBeUndefined()
-  })
-
-  test('ignores mppx.config.mjs from cwd without explicit selection', async () => {
-    const configPath = path.join(tmpDir, 'mppx.config.mjs')
-    fs.writeFileSync(configPath, 'export default { methods: [] }')
-    vi.spyOn(process, 'cwd').mockReturnValue(tmpDir)
-    const result = await loadConfig()
-    expect(result).toBeUndefined()
-    vi.mocked(process.cwd).mockRestore()
-  })
-
-  test('does not walk up from cwd to find config', async () => {
-    const nested = path.join(tmpDir, 'a', 'b', 'c')
-    fs.mkdirSync(nested, { recursive: true })
-    const configPath = path.join(tmpDir, 'mppx.config.mjs')
-    fs.writeFileSync(configPath, 'export default { methods: [] }')
-    vi.spyOn(process, 'cwd').mockReturnValue(nested)
-    const result = await loadConfig()
-    expect(result).toBeUndefined()
-    vi.mocked(process.cwd).mockRestore()
-  })
-
-  test('MPPX_CONFIG loads even when cwd config exists', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'mppx.config.mjs'), 'export default { methods: ["cwd"] }')
-    const envConfig = path.join(tmpDir, 'env.mjs')
-    fs.writeFileSync(envConfig, 'export default { methods: ["env"] }')
-    vi.stubEnv('MPPX_CONFIG', envConfig)
-    vi.spyOn(process, 'cwd').mockReturnValue(tmpDir)
-    const result = await loadConfig()
-    expect(result?.config).toEqual({ methods: ['env'] })
-    expect(result?.path).toBe(envConfig)
-    vi.mocked(process.cwd).mockRestore()
-  })
-})

package/src/cli/config.ts

@@ -1,50 +0,0 @@
-export { resolveAccount } from './account.js'
-
-import type * as Mppx from '../client/Mppx.js'
-import type { Plugin } from './plugins/plugin.js'
-
-/**
- * Define mppx configuration file
- *
- * @example Add plugins for more custom logging/handling (default: [stripe(), tempo()])
- * ```ts
- * // mppx.config.ts
- * import { defineConfig } from 'mppx/cli'
- * import { tempo } from 'mppx/cli/plugins'
- *
- * export default defineConfig({
- *   plugins: [tempo()],
- * })
- * ```
- *
- * @example Add client methods to extend mppx support (e.g. third-party mppx packages)
- * ```ts
- * // mppx.config.ts
- * import { defineConfig, resolveAccount } from 'mppx/cli'
- * import { tempo } from 'mppx/client'
- *
- * export default defineConfig({
- *   methods: [tempo({ account: await resolveAccount() })],
- * })
- * ```
- */
-export function defineConfig<const methods extends Mppx.Methods | undefined = undefined>(
-  config: defineConfig.Config<methods>,
-): defineConfig.Config<methods> {
-  return config
-}
-
-export declare namespace defineConfig {
-  type Config<methods extends Mppx.Methods | undefined = undefined> = {
-    /** Array of methods to use. */
-    methods?: methods
-    /** Optional payment preferences for configured client methods. */
-    paymentPreferences?: methods extends Mppx.Methods
-      ? Mppx.create.Config<methods>['paymentPreferences']
-      : undefined
-    /** Array of plugins to use. */
-    plugins?: Plugin[] | undefined
-  }
-}
-
-export type Config = defineConfig.Config<Mppx.Methods>

package/src/cli/internal.ts

@@ -1,114 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-import type * as Challenge from '../Challenge.js'
-import * as AcceptPayment from '../internal/AcceptPayment.js'
-import type * as Method from '../Method.js'
-import type { Config } from './config.js'
-import { evm as evmPlugin, stripe as stripePlugin, tempo as tempoPlugin } from './plugins/index.js'
-import type { Plugin } from './plugins/plugin.js'
-
-const builtinPlugins: Plugin[] = [tempoPlugin(), stripePlugin(), evmPlugin()]
-
-export function resolvePlugin(
-  challenge: Challenge.Challenge,
-  config?: { plugins?: Plugin[] | undefined; methods?: any },
-): { plugin?: Plugin | undefined; method?: Method.AnyClient | undefined } {
-  const configPlugin = config?.plugins?.find((p) => supportsPlugin(p, challenge))
-  if (configPlugin) return { plugin: configPlugin }
-
-  const builtin = builtinPlugins.find((p) => supportsPlugin(p, challenge))
-  if (builtin) return { plugin: builtin }
-
-  const configMethods = flattenConfigMethods(config)
-  const matched = configMethods?.find(
-    (m) => m.name === challenge.method && m.intent === challenge.intent,
-  )
-  if (matched) return { method: matched }
-
-  return {}
-}
-
-export function selectChallenge(
-  challenges: readonly Challenge.Challenge[],
-  config?: Config | undefined,
-):
-  | ({ challenge: Challenge.Challenge } & {
-      plugin?: Plugin | undefined
-      method?: Method.AnyClient | undefined
-    })
-  | undefined {
-  const configMethods = flattenConfigMethods(config)
-  if (configMethods?.length) {
-    const resolvedPreferences = AcceptPayment.resolve(
-      configMethods,
-      config?.paymentPreferences as AcceptPayment.Config<typeof configMethods> | undefined,
-    )
-    const selected = AcceptPayment.selectChallenge(
-      challenges,
-      configMethods,
-      resolvedPreferences.entries,
-    )
-    if (selected) {
-      return { challenge: selected.challenge, ...resolvePlugin(selected.challenge, config) }
-    }
-
-    return undefined
-  }
-
-  for (const challenge of challenges) {
-    const resolved = resolvePlugin(challenge, config)
-    if (resolved.plugin || resolved.method) return { challenge, ...resolved }
-  }
-
-  return undefined
-}
-
-export function resolveAcceptPayment(config?: Config | undefined): string | undefined {
-  const methods = flattenConfigMethods(config)
-  if (!methods?.length) return undefined
-
-  return AcceptPayment.resolve(
-    methods,
-    config?.paymentPreferences as AcceptPayment.Config<typeof methods> | undefined,
-  ).header
-}
-
-export function flattenConfigMethods(
-  config?: Pick<Config, 'methods'> | undefined,
-): Method.AnyClient[] | undefined {
-  return Array.isArray(config?.methods) ? (config.methods.flat() as Method.AnyClient[]) : undefined
-}
-
-function supportsPlugin(plugin: Plugin, challenge: Challenge.Challenge): boolean {
-  return plugin.supports ? plugin.supports(challenge) : plugin.method === challenge.method
-}
-
-/** Loads CLI config only from explicit, user-selected paths. */
-export async function loadConfig(
-  configFile?: string | undefined,
-): Promise<{ config: Config; path: string } | undefined> {
-  const configPath = resolveConfigPath(configFile)
-  if (!configPath) return undefined
-  const mod = await import(configPath)
-  return { config: (mod.default ?? mod) as Config, path: configPath }
-}
-
-function resolveConfigPath(configFile?: string | undefined): string | undefined {
-  // 0. Explicit --config flag
-  if (configFile) {
-    const resolved = path.resolve(configFile)
-    if (fs.existsSync(resolved)) return resolved
-    return undefined
-  }
-
-  // 1. Explicit env var
-  const envPath = process.env.MPPX_CONFIG?.trim()
-  if (envPath) {
-    const resolved = path.resolve(envPath)
-    if (fs.existsSync(resolved)) return resolved
-    return undefined
-  }
-
-  return undefined
-}

package/src/cli/mcp.test.ts

@@ -1,262 +0,0 @@
-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
-    drainLines()
-    drainJsonBuffer()
-  })
-  child.stderr.on('data', (chunk) => {
-    stderr += chunk
-  })
-
-  function drainLines() {
-    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)
-      }
-    }
-  }
-
-  function drainJsonBuffer() {
-    const text = buffer.trim()
-    if (!text) return
-    try {
-      messages.push(JSON.parse(text))
-      buffer = ''
-    } catch {}
-  }
-
-  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} buffer=${JSON.stringify(
-          buffer,
-        )} 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',
-    'services_endpoints',
-    'services_list',
-    'services_show',
-    'sessions_close',
-    'sessions_list',
-    'sessions_view',
-    'sign',
-    'validate',
-  ])
-  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(
-    tools.find((tool: { name: string }) => tool.name === 'sessions_list').outputSchema,
-  ).toEqual(
-    expect.objectContaining({
-      properties: expect.objectContaining({ sessions: 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/cli/plugins/evm.ts

@@ -1,55 +0,0 @@
-import { type Address, type Chain, createClient, erc20Abi, http } from 'viem'
-import { readContract } from 'viem/actions'
-import * as viemChains from 'viem/chains'
-
-import { evm as evmMethods, assets as evmAssets } from '../../evm/client/index.js'
-import { resolveAccount } from '../account.js'
-import { createPlugin } from './plugin.js'
-
-export function evm() {
-  return createPlugin({
-    method: 'evm',
-
-    async setup({ challenge }) {
-      const request = challenge.request as Record<string, unknown>
-      const methodDetails = request.methodDetails as Record<string, unknown> | undefined
-      const chainId = methodDetails?.chainId as number | undefined
-      const chain = chainId ? resolveChain(chainId) : undefined
-      const currency = request.currency as string | undefined
-
-      const account = await resolveAccount()
-      // Known assets provide EIP-712 domain metadata (token name/version) needed for EIP-3009 signing
-      const knownCurrencies = [
-        ...Object.values(evmAssets.base),
-        ...Object.values(evmAssets.baseSepolia),
-        ...Object.values(evmAssets.celo),
-        ...Object.values(evmAssets.celoSepolia),
-      ]
-
-      let tokenSymbol = currency ?? ''
-      if (chain && currency) {
-        try {
-          const client = createClient({ chain, transport: http() })
-          const symbol = await readContract(client, {
-            address: currency as Address,
-            abi: erc20Abi,
-            functionName: 'symbol',
-          })
-          if (symbol) tokenSymbol = symbol
-        } catch {}
-      }
-
-      return {
-        tokenSymbol,
-        tokenDecimals: (methodDetails?.decimals as number | undefined) ?? 6,
-        explorerUrl: chain?.blockExplorers?.default?.url,
-        methods: [...evmMethods({ account, currencies: knownCurrencies })],
-      }
-    },
-  })
-}
-
-function resolveChain(chainId: number): Chain | undefined {
-  const all = Object.values(viemChains) as Chain[]
-  return all.find((c) => c.id === chainId)
-}

package/src/cli/plugins/index.ts

@@ -1,4 +0,0 @@
-export { evm } from './evm.js'
-export { createPlugin, type Plugin } from './plugin.js'
-export { stripe } from './stripe.js'
-export { tempo } from './tempo.js'

package/src/cli/plugins/plugin.ts

@@ -1,84 +0,0 @@
-import type * as Challenge from '../../Challenge.js'
-import type * as Method from '../../Method.js'
-import type { Network } from '../utils.js'
-
-export function createPlugin(plugin: Plugin): Plugin {
-  return plugin
-}
-
-export interface Plugin {
-  /** Payment method name (e.g., 'tempo', 'stripe') */
-  method: string
-
-  /** Optional predicate for challenge support when a plugin does not support every intent for its method. */
-  supports?(challenge: Challenge.Challenge): boolean
-
-  /**
-   * Resolve account, client, and display info for a challenge.
-   * Returns methods for credential creation.
-   */
-  setup(ctx: {
-    challenge: Challenge.Challenge
-    options: {
-      account?: string | undefined
-      autoSwap?: boolean | undefined
-      network?: Network | undefined
-      payWith?: string | undefined
-      rpcUrl?: string | undefined
-      slippage?: number | undefined
-    }
-    methodOpts: Record<string, string>
-  }): Promise<{
-    /** Token symbol for display (e.g., 'PathUSD', 'USD') */
-    tokenSymbol: string
-    /** Token decimals for display */
-    tokenDecimals: number
-    /** Block explorer URL for links */
-    explorerUrl?: string | undefined
-    /** Client methods for credential creation */
-    methods: Method.AnyClient[]
-    /** Optional context to pass to createCredential */
-    credentialContext?: unknown
-    /** Override credential creation entirely (e.g., delegating to an external CLI) */
-    createCredential?: ((response: Response) => Promise<string>) | undefined
-  }>
-
-  /**
-   * Modify the credential request before sending.
-   * Called after credential creation, before the fetch with Authorization header.
-   * Plugins can add headers (e.g., Accept: text/event-stream for sessions).
-   */
-  prepareCredentialRequest?(ctx: {
-    challenge: Challenge.Challenge
-    credential: string
-    headers: Record<string, string>
-  }): void
-
-  /**
-   * Handle the full post-credential response lifecycle.
-   * Return `true` if fully handled (caller skips default body printing).
-   * Return `false` or leave unimplemented for default behavior (print body).
-   */
-  handleResponse?(ctx: ResponseContext): Promise<boolean>
-
-  /** Format a receipt field for display. Return undefined to use default formatting. */
-  formatReceiptField?(key: string, value: unknown): string | undefined
-}
-
-/** Context passed to handleResponse */
-export interface ResponseContext {
-  challenge: Challenge.Challenge
-  credential: string
-  response: Response
-  fetchUrl: string
-  fetchInit: RequestInit
-  silent: boolean
-  verbose: number
-  confirmEnabled: boolean
-  confirm: (msg: string, defaultYes?: boolean) => Promise<boolean>
-  tokenSymbol: string
-  tokenDecimals: number
-  explorerUrl?: string | undefined
-  /** Keys already shown in the challenge display (to avoid duplicating in receipts) */
-  shownKeys: Set<string>
-}