wip-agent-pay 1.0.1

package/cli.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+// wip-pay CLI
+// Your agent's wallet.
+//
+// Commands:
+//   wip-pay pay <url>                  Pay for paywalled content
+//   wip-pay fund <amount>              Fund wallet (Apple Pay)
+//   wip-pay balance                    Check wallet balance
+//   wip-pay history                    Transaction history
+//   wip-pay budget                     View/set spending limits
+//   wip-pay <amount> <service> [note]  Mint one-time URL
+//
+// Default: Pool Mode (Apple Pay per transaction, Parker's float)
+// --wallet=cdp or --wallet=privy: Path 1 (self-custody, instant)
+
+import { argv } from 'node:process';
+import { pay, fund, mint, balance, history, budget } from './providers/index.js';
+
+const args = argv.slice(2);
+const command = args[0];
+
+// --- Help ---
+if (args.includes('--help') || args.length === 0) {
+  console.log('\n  wip-pay ... your agent\'s wallet');
+  console.log('\n  Commands:');
+  console.log('    wip-pay pay <url>                  Pay for paywalled content');
+  console.log('    wip-pay fund <amount>              Fund wallet (Apple Pay)');
+  console.log('    wip-pay balance                    Check wallet balance');
+  console.log('    wip-pay history                    Transaction history');
+  console.log('    wip-pay budget                     View spending limits');
+  console.log('    wip-pay budget set <daily> [perTx] Set spending limits');
+  console.log('    wip-pay <amount> <service> [note]  Mint one-time URL');
+  console.log('\n  Options:');
+  console.log('    --wallet=cdp     Use your CDP wallet (instant, no Apple Pay)');
+  console.log('    --wallet=privy   Use your Privy wallet (instant, no Apple Pay)');
+  console.log('    (no flag)        Pool Mode: Apple Pay per transaction');
+  console.log('\n  Pool Mode pricing:');
+  console.log('    x402 price + Stripe fees + $0.25 flat fee');
+  console.log('    Max $25 per transaction. Over $25 requires your own wallet.');
+  console.log('\n  Examples:');
+  console.log('    wip-pay pay https://morning-stew.../v1/issues/MS-3');
+  console.log('    wip-pay pay https://morning-stew.../v1/issues/MS-3 --wallet=cdp');
+  console.log('    wip-pay fund 10');
+  console.log('    wip-pay balance');
+  console.log('    wip-pay history');
+  console.log('    wip-pay budget set 5.00 1.00');
+  console.log('    wip-pay 0.10 morning-stew "MS-#8"');
+  console.log('\n  Setup:');
+  console.log('    See SETUP.md for configuration.\n');
+  process.exit(0);
+}
+
+// Parse flags
+const walletFlag = args.find(a => a.startsWith('--wallet='));
+const wallet = walletFlag ? walletFlag.split('=')[1] : undefined; // undefined = Pool Mode
+const cleanArgs = args.filter(a => !a.startsWith('--'));
+
+// --- Pay ---
+if (command === 'pay') {
+  const url = cleanArgs[1];
+  if (!url) {
+    console.error('  Error: url is required. Usage: wip-pay pay <url>');
+    process.exit(1);
+  }
+
+  const result = await pay(url, { wallet });
+
+  // Path 1: wallet-signed payment (instant)
+  if (result.success && !result.needsPayment) {
+    if (result.free) {
+      console.log(`\n  Content is free. No payment needed.\n`);
+    } else {
+      console.log(`\n  Paid: $${result.amount}`);
+      console.log(`  Service: ${result.service}`);
+      if (result.txHash) console.log(`  Tx: ${result.txHash}`);
+      console.log();
+    }
+  }
+  // Pool Mode: needs Apple Pay
+  else if (result.success && result.needsPayment) {
+    const p = result.pricing;
+    console.log(`\n  x402 price:    $${p.x402Amount}`);
+    console.log(`  Our fee:       $${p.poolFee}`);
+    console.log(`  Stripe fee:    $${p.stripeFee}`);
+    console.log(`  Total charge:  $${p.totalCharge}`);
+    console.log(`  Service: ${result.service}`);
+    console.log(`\n  Opening Apple Pay checkout...`);
+
+    // Open checkout in browser
+    try {
+      const { execSync } = await import('node:child_process');
+      execSync(`open "${result.checkoutUrl}"`, { stdio: 'ignore' });
+      console.log('  (Opened in your browser)');
+    } catch {
+      console.log(`  Open this URL to pay: ${result.checkoutUrl}`);
+    }
+
+    // Wait for payment confirmation
+    console.log('  Waiting for payment...\n');
+    const { waitForPayment } = await import('./providers/passthrough.js');
+    const confirmation = await waitForPayment(result.paymentId);
+
+    if (confirmation.success) {
+      console.log(`  Paid. Content received.\n`);
+    } else {
+      console.error(`  ${confirmation.error || 'Payment not completed.'}\n`);
+      process.exit(1);
+    }
+  }
+  // Over pool limit
+  else if (result.overPoolLimit) {
+    console.log(`\n  This costs $${result.amount}. That exceeds the $${result.poolMax} pool limit.`);
+    console.log(`  Use your own wallet: wip-pay pay ${url} --wallet=cdp`);
+    console.log(`  Or set up a user wallet: see SETUP.md\n`);
+    process.exit(1);
+  }
+  // Error
+  else {
+    console.error(`\n  Payment failed: ${result.error || 'unknown error'}\n`);
+    process.exit(1);
+  }
+}
+
+// --- Fund (Apple Pay) ---
+else if (command === 'fund') {
+  const amount = parseFloat(cleanArgs[1]);
+  if (isNaN(amount) || amount <= 0) {
+    console.error('  Error: amount must be a positive number. Usage: wip-pay fund <amount>');
+    process.exit(1);
+  }
+
+  const result = await fund(amount, { wallet });
+
+  if (result.success) {
+    console.log(`\n  Checkout ready. Open this URL to fund your wallet:`);
+    console.log(`  ${result.checkoutUrl}`);
+    console.log(`\n  Amount: $${result.amount}`);
+    console.log(`  Wallet: ${result.wallet}\n`);
+
+    // Try to open in browser
+    try {
+      const { execSync } = await import('node:child_process');
+      execSync(`open "${result.checkoutUrl}"`, { stdio: 'ignore' });
+      console.log('  (Opened in your browser)\n');
+    } catch {
+      // Not on macOS or open failed
+    }
+  } else {
+    console.error(`\n  Funding failed: ${result.error || 'unknown error'}\n`);
+    process.exit(1);
+  }
+}
+
+// --- Balance ---
+else if (command === 'balance') {
+  const result = await balance({ wallet });
+
+  if (result.error) {
+    console.error(`\n  ${result.error}\n`);
+    process.exit(1);
+  }
+
+  console.log(`\n  Wallet: ${wallet || 'pool'}`);
+  console.log(`  Balance: $${result.balance || '0.00'}`);
+  if (result.address) console.log(`  Address: ${result.address}`);
+  console.log();
+}
+
+// --- History ---
+else if (command === 'history') {
+  const limit = parseInt(cleanArgs[1]) || 20;
+  const result = await history({ wallet, limit });
+
+  if (result.error) {
+    console.error(`\n  ${result.error}\n`);
+    process.exit(1);
+  }
+
+  console.log(`\n  Wallet: ${wallet || 'pool'}`);
+  console.log(`  Recent transactions:\n`);
+
+  if (!result.transactions || result.transactions.length === 0) {
+    console.log('  No transactions yet.\n');
+  } else {
+    for (const tx of result.transactions) {
+      const dir = tx.type === 'fund' ? '+' : '-';
+      const date = new Date(tx.timestamp).toLocaleString();
+      console.log(`  ${dir}$${tx.amount}  ${tx.service || tx.type}  ${date}`);
+      if (tx.note) console.log(`    ${tx.note}`);
+    }
+    console.log();
+  }
+}
+
+// --- Budget ---
+else if (command === 'budget') {
+  const subcommand = cleanArgs[1];
+
+  if (subcommand === 'set') {
+    const daily = parseFloat(cleanArgs[2]);
+    const perTx = cleanArgs[3] ? parseFloat(cleanArgs[3]) : undefined;
+
+    if (isNaN(daily) || daily <= 0) {
+      console.error('  Error: daily limit required. Usage: wip-pay budget set <daily> [perTx]');
+      process.exit(1);
+    }
+
+    const result = await budget({ wallet, daily, perTx });
+
+    if (result.error) {
+      console.error(`\n  ${result.error}\n`);
+      process.exit(1);
+    }
+
+    console.log(`\n  Budget updated:`);
+    console.log(`  Daily limit: $${result.daily}`);
+    if (result.perTx) console.log(`  Per-transaction limit: $${result.perTx}`);
+    console.log();
+  } else {
+    // View current budget
+    const result = await budget({ wallet });
+
+    if (result.error) {
+      console.error(`\n  ${result.error}\n`);
+      process.exit(1);
+    }
+
+    console.log(`\n  Wallet: ${wallet || 'pool'}`);
+    console.log(`  Daily limit: $${result.daily || 'none'}`);
+    console.log(`  Per-transaction limit: $${result.perTx || 'none'}`);
+    console.log(`  Spent today: $${result.spentToday || '0.00'}`);
+    console.log(`  Remaining today: $${result.remainingToday || result.daily || 'unlimited'}`);
+    console.log();
+  }
+}
+
+// --- Mint one-time URL (existing Mode B) ---
+else {
+  const amount = parseFloat(cleanArgs[0]);
+  const service = cleanArgs[1];
+  const note = cleanArgs[2] || '';
+
+  if (isNaN(amount) || amount <= 0) {
+    console.error('  Error: amount must be a positive number');
+    process.exit(1);
+  }
+  if (!service) {
+    console.error('  Error: service is required. Usage: wip-pay <amount> <service> [note]');
+    process.exit(1);
+  }
+
+  const result = await mint(amount, service, note);
+
+  if (result.success) {
+    if (result.demo) {
+      console.log(`  Demo URL (not real): ${result.url}\n`);
+    } else {
+      console.log(`\n  One-time URL (paste this back to your agent):`);
+      console.log(`  ${result.url}\n`);
+    }
+  } else {
+    console.error(`\n  Payment failed: ${result.error || 'unknown error'}\n`);
+    process.exit(1);
+  }
+}

package/detect.mjs

@@ -0,0 +1,13 @@
+import fs from 'fs';
+
+export default async function detect(dir) {
+  try {
+    return (
+      fs.existsSync(`${dir}/SKILL.md`) &&
+      fs.existsSync(`${dir}/SPEC.md`) &&
+      fs.existsSync(`${dir}/package.json`)
+    );
+  } catch {
+    return false;
+  }
+}

package/examples/minimal/README.md

@@ -0,0 +1,17 @@
+# examples/minimal/
+
+Minimal example of using wip-agent-pay in your agent.
+
+Just say to any agent:
+
+> Authorize 0.10 USDC for morning-stew MS-#8
+
+The agent will automatically call:
+
+```bash
+wip-agent-pay 0.10 morning-stew "MS-#8"
+```
+
+You run it ... approve on Coinbase ... paste the returned URL back to the agent.
+
+See REFERENCE.md for full setup.

package/install.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+console.log('\n  wip-agent-pay installed successfully!');
+console.log('');
+console.log('   Run `wip-agent-pay --help` to see usage');
+console.log('   Complete the one-time Coinbase setup in REFERENCE.md');
+console.log('');

package/lib/cdp-auth.js

@@ -0,0 +1,131 @@
+// lib/cdp-auth.js
+// Ed25519 JWT generation for Coinbase CDP Server Wallets v2.
+// Uses Web Crypto API ... works in Cloudflare Workers and Node 20+.
+//
+// CDP requires two JWTs per request:
+//   1. Bearer token (API auth) ... signed with API Key Secret
+//   2. X-Wallet-Auth (wallet auth) ... signed with Wallet Secret
+//
+// Both use Ed25519 (EdDSA).
+
+/**
+ * Base64url encode a buffer.
+ */
+function base64url(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let str = '';
+  for (const b of bytes) str += String.fromCharCode(b);
+  return btoa(str).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+/**
+ * Import an Ed25519 private key from base64-encoded raw bytes.
+ */
+async function importEd25519Key(base64Secret) {
+  const raw = Uint8Array.from(atob(base64Secret), c => c.charCodeAt(0));
+  // Ed25519 PKCS8 wrapping: OID prefix + raw 32-byte key
+  // PKCS8 header for Ed25519: 302e020100300506032b657004220420
+  const pkcs8Prefix = new Uint8Array([
+    0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06,
+    0x03, 0x2b, 0x65, 0x70, 0x04, 0x22, 0x04, 0x20
+  ]);
+  const pkcs8 = new Uint8Array(pkcs8Prefix.length + raw.length);
+  pkcs8.set(pkcs8Prefix);
+  pkcs8.set(raw, pkcs8Prefix.length);
+
+  return crypto.subtle.importKey(
+    'pkcs8', pkcs8, { name: 'Ed25519' }, false, ['sign']
+  );
+}
+
+/**
+ * Sign a JWT payload with Ed25519.
+ */
+async function signJWT(payload, key) {
+  const header = { alg: 'EdDSA', typ: 'JWT' };
+  const enc = new TextEncoder();
+  const headerB64 = base64url(enc.encode(JSON.stringify(header)));
+  const payloadB64 = base64url(enc.encode(JSON.stringify(payload)));
+  const signingInput = `${headerB64}.${payloadB64}`;
+  const signature = await crypto.subtle.sign('Ed25519', key, enc.encode(signingInput));
+  return `${signingInput}.${base64url(signature)}`;
+}
+
+/**
+ * Generate the Bearer token (API auth JWT).
+ *
+ * @param {string} apiKeyId - CDP API Key ID
+ * @param {string} apiKeySecret - CDP API Key Secret (base64 Ed25519)
+ * @param {string} method - HTTP method (GET, POST, etc.)
+ * @param {string} url - Full request URL
+ */
+export async function createBearerToken(apiKeyId, apiKeySecret, method, url) {
+  const key = await importEd25519Key(apiKeySecret);
+  const now = Math.floor(Date.now() / 1000);
+  const parsed = new URL(url);
+  const uri = `${method.toUpperCase()} ${parsed.host}${parsed.pathname}`;
+
+  const payload = {
+    sub: apiKeyId,
+    iss: 'cdp',
+    aud: ['cdp_service'],
+    nbf: now,
+    exp: now + 120,
+    uris: [uri],
+  };
+
+  return signJWT(payload, key);
+}
+
+/**
+ * Generate the X-Wallet-Auth JWT.
+ *
+ * @param {string} walletSecret - Wallet Secret (base64 Ed25519)
+ * @param {string} method - HTTP method
+ * @param {string} url - Full request URL
+ * @param {string} body - Request body (JSON string) or empty
+ */
+export async function createWalletAuth(walletSecret, method, url, body = '') {
+  const key = await importEd25519Key(walletSecret);
+  const now = Math.floor(Date.now() / 1000);
+  const parsed = new URL(url);
+  const uri = `${method.toUpperCase()} ${parsed.host}${parsed.pathname}`;
+
+  // SHA-256 hash of canonical request body
+  const enc = new TextEncoder();
+  const bodyHash = await crypto.subtle.digest('SHA-256', enc.encode(body));
+  const reqHash = base64url(bodyHash);
+
+  const jti = crypto.randomUUID();
+
+  const payload = {
+    iat: now,
+    nbf: now,
+    exp: now + 120,
+    jti,
+    uris: [uri],
+    reqHash,
+  };
+
+  return signJWT(payload, key);
+}
+
+/**
+ * Generate both auth headers for a CDP API request.
+ *
+ * @param {object} creds - { apiKeyId, apiKeySecret, walletSecret }
+ * @param {string} method - HTTP method
+ * @param {string} url - Full request URL
+ * @param {string} body - Request body JSON string
+ * @returns {{ authorization: string, walletAuth: string }}
+ */
+export async function createAuthHeaders(creds, method, url, body = '') {
+  const [bearer, walletAuth] = await Promise.all([
+    createBearerToken(creds.apiKeyId, creds.apiKeySecret, method, url),
+    createWalletAuth(creds.walletSecret, method, url, body),
+  ]);
+  return {
+    authorization: `Bearer ${bearer}`,
+    walletAuth,
+  };
+}

package/mcp-server.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// wip-agent-pay MCP server
+// Exposes agent_pay, agent_pay_x402, agent_pay_fund tools via MCP stdio transport.
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { pay, fund, mint } from './providers/index.js';
+
+const server = new Server(
+  { name: 'wip-agent-pay', version: '2.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'agent_pay',
+      description: 'Authorize a micropayment from the agent wallet. Returns a one-time self-destructing URL.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          amount: { type: 'number', description: 'Payment amount in USD' },
+          service: { type: 'string', description: 'Service identifier (e.g. "morning-stew")' },
+          note: { type: 'string', description: 'Optional note (e.g. "MS-#8")' },
+        },
+        required: ['amount', 'service'],
+      },
+    },
+    {
+      name: 'agent_pay_x402',
+      description: 'Pay for a paywalled URL. The agent wallet handles payment automatically. Returns the content.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'The paywalled URL to pay for' },
+          wallet: { type: 'string', enum: ['cdp', 'privy'], description: 'Which wallet to use (default: cdp)' },
+        },
+        required: ['url'],
+      },
+    },
+    {
+      name: 'agent_pay_fund',
+      description: 'Fund the agent wallet. Returns a checkout URL the user opens to pay via Apple Pay.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          amount: { type: 'number', description: 'USD amount to fund' },
+          wallet: { type: 'string', enum: ['cdp', 'privy'], description: 'Which wallet to fund (default: cdp)' },
+        },
+        required: ['amount'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    if (name === 'agent_pay') {
+      if (typeof args.amount !== 'number' || args.amount <= 0) {
+        return { content: [{ type: 'text', text: 'amount must be a positive number' }], isError: true };
+      }
+      if (typeof args.service !== 'string' || args.service.length === 0) {
+        return { content: [{ type: 'text', text: 'service is required' }], isError: true };
+      }
+      const result = await mint(args.amount, args.service, args.note || '');
+      if (result.success) {
+        const prefix = result.demo ? '[DEMO] ' : '';
+        return { content: [{ type: 'text', text: `${prefix}Payment authorized. One-time URL: ${result.url}` }] };
+      }
+      return { content: [{ type: 'text', text: `Payment failed: ${result.error || 'unknown error'}` }], isError: true };
+    }
+
+    if (name === 'agent_pay_x402') {
+      if (!args.url) {
+        return { content: [{ type: 'text', text: 'url is required' }], isError: true };
+      }
+      const result = await pay(args.url, { wallet: args.wallet || 'cdp' });
+      if (result.success) {
+        return { content: [{ type: 'text', text: `Paid ${result.amount} USDC on ${result.network || 'base'}. Service: ${result.service}.` }] };
+      }
+      return { content: [{ type: 'text', text: `Payment failed: ${result.error || 'unknown error'}` }], isError: true };
+    }
+
+    if (name === 'agent_pay_fund') {
+      if (typeof args.amount !== 'number' || args.amount <= 0) {
+        return { content: [{ type: 'text', text: 'amount must be a positive number' }], isError: true };
+      }
+      const result = await fund(args.amount, { wallet: args.wallet || 'cdp' });
+      if (result.success) {
+        return { content: [{ type: 'text', text: `Checkout ready. Have the user open: ${result.checkoutUrl}` }] };
+      }
+      return { content: [{ type: 'text', text: `Funding failed: ${result.error || 'unknown error'}` }], isError: true };
+    }
+
+    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  } catch (err) {
+    return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/openclaw.mjs

@@ -0,0 +1,88 @@
+// wip-agent-pay OpenClaw plugin
+// Registers agent_pay, agent_pay_x402, agent_pay_fund as tools in the agent context.
+
+import { pay, fund, mint } from './providers/index.js';
+
+export default {
+  register(api) {
+    // --- Mint one-time URL (Mode B) ---
+    api.registerTool({
+      name: 'agent_pay',
+      label: 'Authorize Agent Payment',
+      description: 'Authorize a micropayment from the agent wallet. Returns a one-time self-destructing URL.',
+      parameters: {
+        type: 'object',
+        properties: {
+          amount: { type: 'number', description: 'Payment amount in USD' },
+          service: { type: 'string', description: 'Service identifier (e.g. "morning-stew")' },
+          note: { type: 'string', description: 'Optional note (e.g. "MS-#8")' },
+        },
+        required: ['amount', 'service'],
+      },
+      async execute(_id, params) {
+        try {
+          const result = await mint(params.amount, params.service, params.note || '');
+          if (result.success) {
+            const prefix = result.demo ? '[DEMO] ' : '';
+            return { content: [{ type: 'text', text: `${prefix}Payment authorized. One-time URL: ${result.url}` }] };
+          }
+          return { content: [{ type: 'text', text: `Payment failed: ${result.error || 'unknown error'}` }], isError: true };
+        } catch (err) {
+          return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+      },
+    }, { optional: true });
+
+    // --- Pay paywalled URL (x402) ---
+    api.registerTool({
+      name: 'agent_pay_x402',
+      label: 'Pay Paywalled URL',
+      description: 'Pay for a paywalled URL. The agent wallet handles payment automatically. Returns the content.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'The paywalled URL to pay for' },
+          wallet: { type: 'string', enum: ['cdp', 'privy'], description: 'Which wallet to use (default: cdp)' },
+        },
+        required: ['url'],
+      },
+      async execute(_id, params) {
+        try {
+          const result = await pay(params.url, { wallet: params.wallet || 'cdp' });
+          if (result.success) {
+            return { content: [{ type: 'text', text: `Paid ${result.amount} USDC on ${result.network || 'base'}. Service: ${result.service}.` }] };
+          }
+          return { content: [{ type: 'text', text: `Payment failed: ${result.error || 'unknown error'}` }], isError: true };
+        } catch (err) {
+          return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+      },
+    }, { optional: true });
+
+    // --- Fund wallet (Apple Pay) ---
+    api.registerTool({
+      name: 'agent_pay_fund',
+      label: 'Fund Agent Wallet',
+      description: 'Fund the agent wallet. Returns a checkout URL the user opens to pay via Apple Pay.',
+      parameters: {
+        type: 'object',
+        properties: {
+          amount: { type: 'number', description: 'USD amount to fund' },
+          wallet: { type: 'string', enum: ['cdp', 'privy'], description: 'Which wallet to fund (default: cdp)' },
+        },
+        required: ['amount'],
+      },
+      async execute(_id, params) {
+        try {
+          const result = await fund(params.amount, { wallet: params.wallet || 'cdp' });
+          if (result.success) {
+            return { content: [{ type: 'text', text: `Checkout ready. Have the user open: ${result.checkoutUrl}` }] };
+          }
+          return { content: [{ type: 'text', text: `Funding failed: ${result.error || 'unknown error'}` }], isError: true };
+        } catch (err) {
+          return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+      },
+    }, { optional: true });
+  }
+};

package/openclaw.plugin.json

@@ -0,0 +1,17 @@
+{
+  "id": "wip-agent-pay",
+  "name": "Agent Pay",
+  "description": "Disposable wallet for agents. x402 + Coinbase isolated portfolio.",
+  "activation": {
+    "onStartup": true
+  },
+  "contracts": {
+    "tools": ["agent_pay", "agent_pay_x402", "agent_pay_fund"]
+  },
+  "skills": ["./skills"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "wip-agent-pay",
+  "version": "1.0.1",
+  "type": "module",
+  "description": "Give your agent a way to pay. AI CASH (Apple/Google Pay) + AGENT WALLET (x402).",
+  "main": "providers/index.js",
+  "bin": {
+    "wip-pay": "./cli.js",
+    "wip-agent-pay": "./cli.js"
+  },
+  "exports": {
+    ".": "./providers/index.js",
+    "./providers/*": "./providers/*",
+    "./mcp-server": "./mcp-server.mjs"
+  },
+  "openclaw": {
+    "extensions": [
+      "./openclaw.mjs"
+    ]
+  },
+  "scripts": {
+    "test": "node cli.js --help"
+  },
+  "keywords": [
+    "agent",
+    "payment",
+    "coinbase",
+    "micropayments",
+    "1password",
+    "universal-interface",
+    "cloudflare"
+  ],
+  "author": "Parker Todd Brooks",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wipcomputer/wip-agent-pay.git"
+  },
+  "homepage": "https://github.com/wipcomputer/wip-agent-pay",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  }
+}