mppx 0.8.12 → 0.8.13

package/src/cli/cli.test.ts

@@ -32,6 +32,7 @@ import cli from './cli.js'
 const testPrivateKey = generatePrivateKey()
 const testAccount = privateKeyToAccount(testPrivateKey)
 const cliTestXdgDataHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-cli-xdg-'))
+let cliServeInvocation = 0
 const unfundedToken = '0x20c0000000000000000000000000000000000002' as Address
 const cliSessionFeePayerPolicy = {
   maxGas: 2_250_000n,
@@ -47,7 +48,13 @@ async function serve(argv: string[], options?: { env?: Record<string, string | u
   let stderr = ''
   let exitCode: number | undefined
   const saved: Record<string, string | undefined> = {}
-  const env = { XDG_DATA_HOME: cliTestXdgDataHome, ...options?.env }
+  const invocationHome = path.join(cliTestXdgDataHome, `serve-${cliServeInvocation++}`)
+  const env = {
+    XDG_CONFIG_HOME: path.join(invocationHome, 'config'),
+    XDG_DATA_HOME: cliTestXdgDataHome,
+    XDG_STATE_HOME: path.join(invocationHome, 'state'),
+    ...options?.env,
+  }
   for (const [key, value] of Object.entries(env)) {
     saved[key] = process.env[key]
     if (value === undefined) delete process.env[key]
@@ -1049,10 +1056,10 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
 
     try {
       const { output } = await serve(
-        [httpServer.url, '--rpc-url', rpcUrl, '-s', '-M', 'deposit=10'],
+        [httpServer.url, '--rpc-url', rpcUrl, '--include', '-M', 'deposit=10'],
         { env: { MPPX_PRIVATE_KEY: testPrivateKey } },
       )
-      expect(output).toContain('scraped-content')
+      expect(output).toBe('scraped-content')
     } finally {
       httpServer.close()
     }
@@ -1133,71 +1140,108 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
     }
   })
 
-  test('bug: non-SSE open should not double-charge tick amount', { timeout: 120_000 }, async () => {
-    await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
-    await fundAccount({ address: testAccount.address, token: asset })
-
-    const escrow = tip20ChannelEscrow
-    const store = Store.memory()
-    const tickAmount = '0.001'
-    const server = Mppx_server.create({
-      methods: [
-        tempo.session({
-          account: accounts[0],
-          store,
-          getClient: () => client,
-          currency: asset,
-          escrowContract: escrow,
-          chainId: client.chain.id,
-          feePayer: true,
-          feePayerPolicy: cliSessionFeePayerPolicy,
-        }),
-      ],
-      realm: 'cli-test-double-charge',
-      secretKey: 'cli-test-secret-cli-test-secret-32',
-    })
+  test(
+    'selects retained non-SSE channels with auto, explicit, and new modes',
+    { timeout: 120_000 },
+    async () => {
+      await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
+      await fundAccount({ address: testAccount.address, token: asset })
 
-    // Track voucher cumulative amounts from credential payloads
-    const voucherAmounts: string[] = []
+      const escrow = tip20ChannelEscrow
+      const store = Store.memory()
+      const tickAmount = '0.001'
+      const server = Mppx_server.create({
+        methods: [
+          tempo.session({
+            account: accounts[0],
+            store,
+            getClient: () => client,
+            currency: asset,
+            escrowContract: escrow,
+            chainId: client.chain.id,
+            feePayer: true,
+            feePayerPolicy: cliSessionFeePayerPolicy,
+          }),
+        ],
+        realm: 'cli-test-double-charge',
+        secretKey: 'cli-test-secret-cli-test-secret-32',
+      })
 
-    const httpServer = await Http.createServer(async (req, res) => {
-      const authHeader = req.headers.authorization
-      if (authHeader) {
-        try {
-          const cred = Credential.deserialize<SessionCredentialPayload>(authHeader)
-          if (cred.payload.action === 'voucher' && 'cumulativeAmount' in cred.payload) {
-            voucherAmounts.push(cred.payload.cumulativeAmount)
-          }
-        } catch {}
-      }
+      const voucherAmounts: string[] = []
+      const credentials: { action: string; channelId: string }[] = []
 
-      const result = await toNodeListener(
-        server.session({
-          amount: tickAmount,
-          recipient: accounts[0].address,
-          unitType: 'page',
-        }),
-      )(req, res)
-      if (result.status === 402) return
-      // Non-SSE: plain text response (not text/event-stream)
-      res.end('scraped-content')
-    })
+      const httpServer = await Http.createServer(async (req, res) => {
+        const authHeader = req.headers.authorization
+        if (authHeader) {
+          try {
+            const cred = Credential.deserialize<SessionCredentialPayload>(authHeader)
+            credentials.push({
+              action: cred.payload.action,
+              channelId: cred.payload.channelId,
+            })
+            if (cred.payload.action === 'voucher' && 'cumulativeAmount' in cred.payload) {
+              voucherAmounts.push(cred.payload.cumulativeAmount)
+            }
+          } catch {}
+        }
 
-    try {
-      await serve([httpServer.url, '--rpc-url', rpcUrl, '-s', '-M', 'deposit=10'], {
-        env: { MPPX_PRIVATE_KEY: testPrivateKey },
+        const result = await toNodeListener(
+          server.session({
+            amount: tickAmount,
+            recipient: accounts[0].address,
+            unitType: 'page',
+          }),
+        )(req, res)
+        if (result.status === 402) return
+        // Non-SSE: plain text response (not text/event-stream)
+        res.end('scraped-content')
       })
 
-      // No follow-up voucher should be sent after a non-SSE open.
-      // The open credential already paid for this unit, so the CLI
-      // should NOT send a redundant voucher that would double-charge.
-      expect(voucherAmounts.length).toBe(0)
-    } finally {
-      httpServer.close()
-    }
-  })
+      try {
+        const stateHome = fs.mkdtempSync(path.join(cliTestXdgDataHome, 'reuse-state-'))
+        const env = { MPPX_PRIVATE_KEY: testPrivateKey, XDG_STATE_HOME: stateHome }
+        const runRequest = async (argv: string[]) => {
+          const result = await serve(argv, { env })
+          expect(result.exitCode, `${result.output}\n${result.stderr}`).toBeUndefined()
+        }
+        await runRequest([httpServer.url, '--rpc-url', rpcUrl, '-s', '-M', 'deposit=10'])
+        const retainedChannelId = credentials.find(({ action }) => action === 'open')!.channelId
+        await runRequest([httpServer.url, '--rpc-url', rpcUrl, '-s', '-M', 'deposit=10'])
+        await runRequest([
+          httpServer.url,
+          '--rpc-url',
+          rpcUrl,
+          '--session',
+          retainedChannelId,
+          '-s',
+          '-M',
+          'deposit=10',
+        ])
+        await runRequest([
+          httpServer.url,
+          '--rpc-url',
+          rpcUrl,
+          '--session',
+          'new',
+          '-s',
+          '-M',
+          'deposit=10',
+        ])
+
+        const payments = credentials.filter(({ action }) => ['open', 'voucher'].includes(action))
+        expect(voucherAmounts).toEqual(['2000', '3000'])
+        expect(payments.map(({ action }) => action)).toEqual(['open', 'voucher', 'voucher', 'open'])
+        expect(new Set(payments.slice(0, 3).map(({ channelId }) => channelId))).toEqual(
+          new Set([retainedChannelId]),
+        )
+        expect(payments[3]?.channelId).not.toBe(retainedChannelId)
+      } finally {
+        httpServer.close()
+      }
+    },
+  )
 
-  test('bug: closeChannel sends action "close" not "voucher"', { timeout: 120_000 }, async () => {
+  test('retains a session until `sessions close` is invoked', { timeout: 120_000 }, async () => {
     await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
     await fundAccount({ address: testAccount.address, token: asset })
 
@@ -1212,7 +1256,7 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
           currency: asset,
           escrowContract: escrow,
           chainId: client.chain.id,
-          feePayer: true,
+          feePayer: accounts[1],
           feePayerPolicy: cliSessionFeePayerPolicy,
         }),
       ],
@@ -1220,8 +1264,8 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
       secretKey: 'cli-test-secret-cli-test-secret-32',
     })
 
-    // Track the credential payload action from the close request
     const credentialActions: string[] = []
+    let channelId: string | undefined
 
     const httpServer = await Http.createServer(async (req, res) => {
       // Capture credential action from every request with Authorization header
@@ -1230,6 +1274,7 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
         try {
           const cred = Credential.deserialize<SessionCredentialPayload>(authHeader)
           credentialActions.push(cred.payload.action)
+          channelId = cred.payload.channelId
         } catch {}
       }
 
@@ -1245,13 +1290,31 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
     })
 
     try {
+      const stateHome = fs.mkdtempSync(path.join(cliTestXdgDataHome, 'close-state-'))
+      const env = { MPPX_PRIVATE_KEY: testPrivateKey, XDG_STATE_HOME: stateHome }
       await serve([httpServer.url, '--rpc-url', rpcUrl, '-s', '-M', 'deposit=10'], {
-        env: { MPPX_PRIVATE_KEY: testPrivateKey },
+        env,
+      })
+
+      expect(credentialActions).toEqual(['open'])
+      expect(channelId).toMatch(/^0x[0-9a-f]{64}$/)
+
+      const listed = await serve(['sessions', 'list', '--json'], { env })
+      expect(JSON.parse(listed.output).sessions).toEqual([
+        expect.objectContaining({ channelId, status: 'open' }),
+      ])
+
+      const closed = await serve(['sessions', 'close', channelId!, '--rpc-url', rpcUrl, '--json'], {
+        env,
       })
+      expect(closed.exitCode, `${closed.output}\n${closed.stderr}`).toBeUndefined()
+      expect(JSON.parse(closed.output)).toEqual(
+        expect.objectContaining({ channelId, status: 'closed' }),
+      )
+      expect(credentialActions.at(-1)).toBe('close')
 
-      // The last credential sent should be the close request with action: 'close'
-      const lastAction = credentialActions[credentialActions.length - 1]
-      expect(lastAction).toBe('close')
+      const empty = await serve(['sessions', 'list', '--json'], { env })
+      expect(JSON.parse(empty.output)).toEqual({ sessions: [] })
     } finally {
       httpServer.close()
     }
@@ -1298,7 +1361,9 @@ describe('session sse (examples/session/sse)', () => {
       secretKey: 'cli-test-secret-cli-test-secret-32',
     })
 
+    const paidAcceptHeaders: (string | undefined)[] = []
     const httpServer = await Http.createServer(async (req, res) => {
+      if (req.headers.authorization) paidAcceptHeaders.push(req.headers.accept)
       const result = await toNodeListener(
         server.session({
           amount: '0.001',
@@ -1322,10 +1387,12 @@ describe('session sse (examples/session/sse)', () => {
     })
 
     try {
-      const { output } = await serve([httpServer.url, '--rpc-url', rpcUrl, '-M', 'deposit=10'], {
-        env: { MPPX_PRIVATE_KEY: testPrivateKey },
-      })
+      const { output } = await serve(
+        [httpServer.url, '--rpc-url', rpcUrl, '-H', 'Accept: application/json', '-M', 'deposit=10'],
+        { env: { MPPX_PRIVATE_KEY: testPrivateKey } },
+      )
       expect(output.trim()).toBe('Hello world!')
+      expect(paidAcceptHeaders).toEqual(['application/json'])
     } finally {
       httpServer.close()
     }
@@ -1836,8 +1903,36 @@ test('mppx --help', async () => {
   expect(output).toContain('mppx')
   expect(output).toContain('<url>')
   expect(output).toContain('account')
+  expect(output).toContain('sessions')
   expect(output).toContain('services')
   expect(output).toContain('sign')
+  expect(output).toContain('--session')
+})
+
+test('mppx sessions --help', async () => {
+  const { output } = await serve(['sessions', '--help'])
+  expect(output).toContain('close  Cooperatively close')
+  expect(output).toContain('list   List persistent')
+  expect(output).toContain('view   View a persistent')
+})
+
+test('mppx sessions close --help', async () => {
+  const { output } = await serve(['sessions', 'close', '--help'])
+  expect(output).toContain('--all')
+  expect(output).toContain('--yes')
+  expect(output).toContain('--url')
+})
+
+test('mppx sessions close --all requires confirmation', async () => {
+  const { exitCode, output } = await serve(['sessions', 'close', '--all'])
+  expect(exitCode).toBe(2)
+  expect(output).toContain('requires --yes')
+})
+
+test('mppx sessions close --all returns an empty structured result', async () => {
+  const { exitCode, output } = await serve(['sessions', 'close', '--all', '--yes', '--json'])
+  expect(exitCode).toBeUndefined()
+  expect(JSON.parse(output)).toEqual({ closed: [], failed: [] })
 })
 
 describe('account fund help', () => {

package/src/cli/cli.ts

@@ -13,6 +13,7 @@ import { normalizeHeaders } from '../client/internal/Fetch.js'
 import * as Mppx from '../client/Mppx.js'
 import * as Constants from '../Constants.js'
 import { validate as validateDiscovery } from '../discovery/Validate.js'
+import { isTempoSessionChallenge } from '../tempo/session/client/Transports.js'
 import { createDefaultStore, createKeychain, resolveAccountName } from './account.js'
 import { loadConfig, resolveAcceptPayment, selectChallenge } from './internal.js'
 import type { Plugin } from './plugins/plugin.js'
@@ -21,6 +22,9 @@ import {
   readTempoKeystore,
   resolveTempoAccount,
 } from './plugins/tempo.js'
+import sessions, { sessionCommandError } from './sessions/commands.js'
+import { runPersistentSessionRequest } from './sessions/request.js'
+import { createSessionRegistry } from './sessions/store.js'
 import {
   chainName,
   confirm,
@@ -244,6 +248,15 @@ const cli = Cli.create('mppx', {
       .string()
       .optional()
       .describe('RPC endpoint, defaults to public RPC for chain (env: MPPX_RPC_URL)'),
+    session: z
+      .string()
+      .optional()
+      .default('auto')
+      .refine(
+        (value) => value === 'auto' || value === 'new' || /^0x[0-9a-fA-F]{64}$/.test(value),
+        'Expected auto, new, or a 32-byte channel ID',
+      )
+      .describe('Session selection: auto, new, or channel ID'),
     silent: z.boolean().default(false).describe('Silent mode (suppress progress and info)'),
     slippage: z.number().optional().describe('Tempo auto-swap max slippage percentage'),
     userAgent: z
@@ -347,6 +360,9 @@ const cli = Cli.create('mppx', {
     }
 
     try {
+      const methodOpts = parseMethodOpts(c.options.methodOpt)
+      const sessionRegistry = createSessionRegistry()
+
       const init: RequestInit = { redirect: c.options.location ? 'follow' : 'manual' }
       if (c.options.jsonBody) {
         init.body = c.options.jsonBody
@@ -368,6 +384,12 @@ const cli = Cli.create('mppx', {
       if (c.options.verbose >= 2) printRequestHeaders(url, init, info)
       const challengeResponse = await targetFetch(fetchUrl, init)
       if (challengeResponse.status !== 402) {
+        if (c.options.session !== 'auto')
+          return c.error({
+            code: 'UNSUPPORTED_SESSION',
+            message: '--session requires a tempo/session payment challenge.',
+            exitCode: 2,
+          })
         if (c.options.fail && challengeResponse.status >= 400)
           return c.error({
             code: 'HTTP_ERROR',
@@ -379,7 +401,6 @@ const cli = Cli.create('mppx', {
         return
       }
 
-      const methodOpts = parseMethodOpts(c.options.methodOpt)
       const offeredChallenges = Challenge.fromResponseList(challengeResponse)
       const currencyChallenges = filterChallengesByCurrency(offeredChallenges, c.options.currency)
       if (c.options.currency && currencyChallenges.length === 0) {
@@ -446,7 +467,12 @@ const cli = Cli.create('mppx', {
       // Display challenge
       const shownKeys = new Set<string>()
       {
-        printResponseHeaders(challengeResponse, headerOpts)
+        printResponseHeaders(
+          challengeResponse,
+          challenge.method === 'tempo' && challenge.intent === 'session' && c.options.include
+            ? { ...headerOpts, include: false, verbose: Math.max(headerOpts.verbose, 2) }
+            : headerOpts,
+        )
 
         const challengeRows = (() => {
           const skip = new Set(['id', 'request'])
@@ -517,6 +543,44 @@ const cli = Cli.create('mppx', {
         }
       }
 
+      const persistentSessionAccount =
+        process.env.MPPX_PRIVATE_KEY?.trim() ||
+        !isTempoAccount(resolveAccountName(c.options.account))
+      if (isTempoSessionChallenge(challenge) && persistentSessionAccount) {
+        try {
+          await runPersistentSessionRequest({
+            challenge,
+            challengeResponse: selectedChallengeResponse,
+            endpoint: url,
+            fetch: targetFetch,
+            fetchInput: fetchUrl,
+            init,
+            info,
+            methodOptions: methodOpts,
+            options: {
+              account: c.options.account,
+              fail: c.options.fail,
+              include: c.options.include,
+              network: c.options.network,
+              rpcUrl: c.options.rpcUrl,
+              session: c.options.session,
+              silent: c.options.silent,
+              verbose: c.options.verbose,
+            },
+            registry: sessionRegistry,
+          })
+        } catch (error) {
+          return sessionCommandError(error, 'SESSION_REQUEST_FAILED')
+        }
+        return
+      }
+      if (c.options.session !== 'auto')
+        return c.error({
+          code: 'UNSUPPORTED_SESSION',
+          message: '--session requires a tempo/session payment challenge.',
+          exitCode: 2,
+        })
+
       // Create credential
       let credential: string
       if (pluginResult?.createCredential)
@@ -1578,6 +1642,7 @@ cli.command(account)
 cli.command(discover)
 cli.command(init)
 cli.command(services)
+cli.command(sessions)
 cli.command(sign)
 cli.command(validate)
 

package/src/cli/mcp.test.ts

@@ -193,6 +193,9 @@ test('tools/list exposes mppx commands with input and output schemas', async ()
     'services_endpoints',
     'services_list',
     'services_show',
+    'sessions_close',
+    'sessions_list',
+    'sessions_view',
     'sign',
     'validate',
   ])
@@ -208,6 +211,14 @@ test('tools/list exposes mppx commands with input and output schemas', async ()
       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([])
 })