mppx 0.4.1 → 0.4.3

package/src/cli/config.test.ts

@@ -0,0 +1,82 @@
+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('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('loads mppx.config.mjs from cwd', 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?.config).toEqual({ methods: [] })
+    expect(result?.path).toBe(configPath)
+    vi.mocked(process.cwd).mockRestore()
+  })
+
+  test('walks 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?.config).toEqual({ methods: [] })
+    expect(result?.path).toBe(configPath)
+    vi.mocked(process.cwd).mockRestore()
+  })
+
+  test('MPPX_CONFIG takes priority over cwd config', 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

@@ -0,0 +1,44 @@
+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(config: defineConfig.Config): defineConfig.Config {
+  return config
+}
+
+export declare namespace defineConfig {
+  type Config = {
+    /** Array of methods to use. */
+    methods?: Mppx.create.Config['methods'] | undefined
+    /** Array of plugins to use. */
+    plugins?: Plugin[] | undefined
+  }
+}
+
+export type Config = defineConfig.Config

package/src/cli/internal.ts

@@ -0,0 +1,72 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import type * as Challenge from '../Challenge.js'
+import type * as Method from '../Method.js'
+import type { Config } from './config.js'
+import { stripe as stripePlugin, tempo as tempoPlugin } from './plugins/index.js'
+import type { Plugin } from './plugins/plugin.js'
+
+const builtinPlugins: Plugin[] = [tempoPlugin(), stripePlugin()]
+
+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) => p.method === challenge.method)
+  if (configPlugin) return { plugin: configPlugin }
+
+  const builtin = builtinPlugins.find((p) => p.method === challenge.method)
+  if (builtin) return { plugin: builtin }
+
+  const configMethods = config?.methods?.flat() as Method.AnyClient[] | undefined
+  const matched = configMethods?.find(
+    (m) => m.name === challenge.method && m.intent === challenge.intent,
+  )
+  if (matched) return { method: matched }
+
+  return {}
+}
+
+const CONFIG_NAMES = ['mppx.config.ts', 'mppx.config.js', 'mppx.config.mjs'] as const
+
+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
+  }
+
+  // 2. Walk up from cwd, stopping at project root
+  let dir = process.cwd()
+  while (true) {
+    for (const name of CONFIG_NAMES) {
+      const candidate = path.join(dir, name)
+      if (fs.existsSync(candidate)) return candidate
+    }
+    const isProjectRoot =
+      fs.existsSync(path.join(dir, 'package.json')) || fs.existsSync(path.join(dir, '.git'))
+    const parent = path.dirname(dir)
+    if (isProjectRoot || parent === dir) break
+    dir = parent
+  }
+
+  return undefined
+}

package/src/cli/plugins/index.ts

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

package/src/cli/plugins/plugin.ts

@@ -0,0 +1,73 @@
+import type * as Challenge from '../../Challenge.js'
+import type * as Method from '../../Method.js'
+
+export function createPlugin(plugin: Plugin): Plugin {
+  return plugin
+}
+
+export interface Plugin {
+  /** Payment method name (e.g., 'tempo', 'stripe') */
+  method: string
+
+  /**
+   * Resolve account, client, and display info for a challenge.
+   * Returns methods for credential creation.
+   */
+  setup(ctx: {
+    challenge: Challenge.Challenge
+    options: { account?: string | undefined; rpcUrl?: string | 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>
+}

package/src/cli/plugins/stripe.ts

@@ -0,0 +1,143 @@
+import { Errors, z } from 'incur'
+import { stripe as stripeMethods } from '../../stripe/client/index.js'
+import { pc } from '../utils.js'
+import { createPlugin } from './plugin.js'
+
+export function stripe() {
+  return createPlugin({
+    method: 'stripe',
+
+    async setup({ challenge, methodOpts }) {
+      const challengeRequest = challenge.request as Record<string, unknown>
+      const currency = challengeRequest.currency as string | undefined
+
+      const stripeOpts = parseOptions(
+        z.object({
+          paymentMethod: z.string(),
+        }),
+        methodOpts,
+      )
+
+      const stripeSecretKey = process.env.MPPX_STRIPE_SECRET_KEY
+      if (!stripeSecretKey)
+        throw new Errors.IncurError({
+          code: 'MISSING_ENV',
+          message: 'MPPX_STRIPE_SECRET_KEY environment variable is required for Stripe payments.',
+          exitCode: 2,
+        })
+      if (!stripeSecretKey.startsWith('sk_test_'))
+        throw new Errors.IncurError({
+          code: 'UNSUPPORTED_MODE',
+          message:
+            'Stripe CLI payments are currently only supported in test mode (sk_test_... keys).',
+          exitCode: 2,
+        })
+
+      return {
+        tokenSymbol: currency?.toUpperCase() ?? '',
+        tokenDecimals: (challengeRequest.decimals as number | undefined) ?? 2,
+        methods: [
+          stripeMethods.charge({
+            paymentMethod: stripeOpts.paymentMethod,
+            createToken: async ({
+              paymentMethod,
+              amount,
+              currency,
+              networkId,
+              expiresAt,
+              metadata,
+            }) => {
+              const body = new URLSearchParams({
+                payment_method: paymentMethod!,
+                'usage_limits[currency]': currency,
+                'usage_limits[max_amount]': amount,
+                'usage_limits[expires_at]': expiresAt.toString(),
+              })
+              if (networkId) body.set('seller_details[network_id]', networkId)
+              if (metadata) {
+                for (const [key, value] of Object.entries(metadata)) {
+                  body.set(`metadata[${key}]`, value)
+                }
+              }
+
+              const sptUrl =
+                process.env.MPPX_STRIPE_SPT_URL ??
+                'https://api.stripe.com/v1/test_helpers/shared_payment/granted_tokens'
+              const sptHeaders = {
+                Authorization: `Basic ${btoa(`${stripeSecretKey}:`)}`,
+                'Content-Type': 'application/x-www-form-urlencoded',
+              }
+
+              let response = await globalThis.fetch(sptUrl, {
+                method: 'POST',
+                headers: sptHeaders,
+                body,
+              })
+              if (!response.ok) {
+                const errorBody = (await response.json()) as { error: { message: string } }
+                if (
+                  (metadata || networkId) &&
+                  errorBody.error.message.includes('Received unknown parameter')
+                ) {
+                  const fallbackBody = new URLSearchParams({
+                    payment_method: paymentMethod!,
+                    'usage_limits[currency]': currency,
+                    'usage_limits[max_amount]': amount,
+                    'usage_limits[expires_at]': expiresAt.toString(),
+                  })
+                  response = await globalThis.fetch(sptUrl, {
+                    method: 'POST',
+                    headers: sptHeaders,
+                    body: fallbackBody,
+                  })
+                  if (!response.ok) {
+                    const fallbackError = (await response.json()) as {
+                      error: { message: string }
+                    }
+                    throw new Errors.IncurError({
+                      code: 'STRIPE_ERROR',
+                      message: `Failed to create SPT: ${fallbackError.error.message}`,
+                      exitCode: 77,
+                    })
+                  }
+                } else
+                  throw new Errors.IncurError({
+                    code: 'STRIPE_ERROR',
+                    message: `Failed to create SPT: ${errorBody.error.message}`,
+                    exitCode: 77,
+                  })
+              }
+              const { id } = (await response.json()) as { id: string }
+              return id
+            },
+          }),
+        ],
+      }
+    },
+
+    formatReceiptField(key, value) {
+      if (key === 'reference' && typeof value === 'string' && value.startsWith('pi_')) {
+        const isTest = process.env.MPPX_STRIPE_SECRET_KEY?.startsWith('sk_test_')
+        const url = `https://dashboard.stripe.com${isTest ? '/test' : ''}/payments/${value}`
+        return pc.link(url, value, true)
+      }
+    },
+  })
+}
+
+// --- Helpers ---
+
+function parseOptions<const schema extends z.ZodType>(
+  schema: schema,
+  rawOptions: unknown,
+): z.output<schema> {
+  const result = schema.safeParse(rawOptions ?? {})
+  if (result.success) return result.data
+  const summary = result.error.issues
+    .map((issue) => {
+      const path = issue.path.length ? issue.path.join('.') : 'options'
+      return `${path}: ${issue.message}`
+    })
+    .join(', ')
+  throw new Error(`Invalid CLI options (${summary})`)
+}