@paytaca/opencode-plugin 0.1.16 → 0.2.0

package/README.md

@@ -34,6 +34,48 @@ Once installed and configured in your OpenCode settings, the plugin automaticall
 - Creates a wallet on first run (recovery phrase is printed — save it securely)
 - Starts a local proxy that manages x402 payment flows transparently
 - Provides the `paytaca-ai` provider with the `deepseek/deepseek-v4-flash` model
+- Registers a local MCP server (`paytaca`) whose tools let the assistant work with real Paytaca data — AI account (credits, models, plan pricing) and wallet (balance, transactions, addresses, tokens, sending)
+
+### Asking about your account and wallet
+
+Because the MCP server is loaded automatically, you can ask in plain language:
+
+- "How many credits do I have left?"
+- "What models are available?"
+- "How much does DeepSeek V4 Pro cost?"
+- "What's my wallet balance?"
+- "Show my latest transactions"
+- "What's my receiving address?"
+
+The assistant answers using live data via these tools:
+
+| Tool | Description |
+|---|---|
+| `get_credits` | Remaining time credits per active model session |
+| `get_balance` | BCH balance of the Paytaca wallet |
+| `get_models` | Available models (id, display name, tier) |
+| `get_plans` | Plan pricing grouped by tier (minutes, USD, BCH) |
+| `get_transactions` | Recent wallet transactions (filter by direction, page) |
+| `get_receiving_address` | Receiving address, optionally as a BIP21 URI with amount |
+| `get_tokens` | CashToken holdings, or details for one token category |
+
+### Sending funds
+
+You can ask the assistant to send BCH or CashTokens ("send 0.01 BCH to
+bitcoincash:qp..."). Because that spends real funds, opencode will always
+prompt you for approval before the `send` tool executes — the plugin sets the
+`paytaca_send` permission to `ask` (an explicit choice in your own config is
+respected). Token amounts are in base units and recipients should use
+token-aware (z-prefix) addresses.
+
+### Proxy chatter never reaches the model
+
+Payment prompts, tier-selection menus, credits output, and payment notices
+produced by the proxy stay visible in your session for you — but they are
+stripped from the context sent to the LLM, so coding conversations are not
+polluted by payment flow messages. Your replies in those flows (e.g. picking
+a plan tier) are also excluded, while all genuine coding messages pass
+through untouched.
 
 ### Wallet management
 

package/dist/bundled/mcp.d.ts

@@ -0,0 +1,2 @@
+export declare const MCP_SERVER_CONTENT = "#!/usr/bin/env node\n/**\n * Paytaca MCP Server\n *\n * Registers Paytaca tools with opencode so the assistant can work with real\n * data instead of guessing. Two groups:\n * - Paytaca AI account (backend): credits, models, plan pricing\n * - Paytaca wallet (paytaca CLI): balance, transactions, receiving address,\n *   token holdings, and sending funds\n *\n * The send tool moves real funds \u2014 opencode is configured (via the plugin's\n * config hook) to require explicit user approval before it runs.\n *\n * Loaded automatically via the plugin's config hook (cfg.mcp['paytaca']).\n * Uses only Node.js built-in modules.\n */\n\nconst http = require('http');\nconst https = require('https');\nconst { spawn } = require('child_process');\nconst fs = require('fs');\nconst path = require('path');\nconst os = require('os');\n\nconst CONFIG_DIR = process.env.PAYTACA_CONFIG_DIR || path.join(os.homedir(), '.opencode-paytaca');\nconst PAYTACA_CMD = process.env.PAYTACA_CMD || 'paytaca';\nconst DEFAULT_BACKEND = process.env.PAYTACA_BACKEND_URL || 'https://api.paytaca.ai';\n\nconst PROTOCOL_VERSION = '2025-06-18';\n\n// Logging setup\nconst LOG_FILE = path.join(CONFIG_DIR, 'mcp.log');\nconst logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });\nfunction log(message) {\n  const timestamp = new Date().toISOString();\n  logStream.write(timestamp + ' [MCP] ' + message + '\\n');\n}\n\n// Load fresh config on every call so walletHash/backendUrl never go stale\nfunction loadConfig() {\n  try {\n    return JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, 'config.json'), 'utf8'));\n  } catch (e) {\n    return {};\n  }\n}\n\nlet BACKEND_URL = DEFAULT_BACKEND;\nlet WALLET_HASH = '';\nfunction refreshConfig() {\n  const cfg = loadConfig();\n  BACKEND_URL = process.env.PAYTACA_BACKEND_URL || cfg.backendUrl || DEFAULT_BACKEND;\n  WALLET_HASH = cfg.walletHash || '';\n}\n\n// Fetch a JSON payload over HTTP(S)\nfunction getJson(url, headers) {\n  return new Promise((resolve, reject) => {\n    let u;\n    try {\n      u = new URL(url);\n    } catch (e) {\n      return reject(new Error('Invalid URL: ' + url));\n    }\n    const requester = u.protocol === 'https:' ? https : http;\n    const req = requester.get({\n      hostname: u.hostname,\n      port: u.port || (u.protocol === 'https:' ? 443 : 80),\n      path: u.pathname + u.search,\n      headers: headers || {},\n    }, (res) => {\n      let data = '';\n      res.on('data', (chunk) => { data += chunk; });\n      res.on('end', () => {\n        if (res.statusCode >= 400) {\n          reject(new Error('HTTP ' + res.statusCode + ': ' + data.substring(0, 200)));\n          return;\n        }\n        try {\n          resolve(JSON.parse(data));\n        } catch (e) {\n          reject(new Error('Invalid JSON response'));\n        }\n      });\n    });\n    req.on('error', reject);\n    req.setTimeout(15000, () => {\n      req.destroy();\n      reject(new Error('Request timed out'));\n    });\n  });\n}\n\n// Run a shell command with a timeout\nfunction runCommand(cmd, args, timeoutMs) {\n  return new Promise((resolve, reject) => {\n    const child = spawn(cmd, args, { shell: false });\n    let stdout = '';\n    let stderr = '';\n    let settled = false;\n    const timer = setTimeout(() => {\n      if (settled) return;\n      settled = true;\n      try { child.kill(); } catch (e) {}\n      reject(new Error('Command timed out'));\n    }, timeoutMs || 15000);\n    child.stdout.on('data', (d) => { stdout += d.toString(); });\n    child.stderr.on('data', (d) => { stderr += d.toString(); });\n    child.on('close', (code) => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      if (code === 0) resolve(stdout.trim());\n      else reject(new Error(stderr.trim() || 'Command exited with code ' + code));\n    });\n    child.on('error', (err) => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      reject(err);\n    });\n  });\n}\n\n// Format seconds as MM:SS or HH:MM:SS\nfunction formatDuration(totalSeconds) {\n  const hours = Math.floor(totalSeconds / 3600);\n  const minutes = Math.floor((totalSeconds % 3600) / 60);\n  const secs = totalSeconds % 60;\n  if (hours > 0) {\n    return hours + ':' + String(minutes).padStart(2, '0') + ':' + String(secs).padStart(2, '0');\n  }\n  return minutes + ':' + String(secs).padStart(2, '0');\n}\n\n// Remaining time credits per model session\nasync function getCredits() {\n  const data = await getJson(BACKEND_URL + '/v1/wallet/status', { 'X-Wallet-Hash': WALLET_HASH });\n  const sessions = Array.isArray(data.sessions) ? data.sessions : [];\n  const active = sessions.filter((s) => s.time_remaining_seconds > 0 && s.model_active);\n  const inactive = sessions.filter((s) => s.time_remaining_seconds > 0 && !s.model_active);\n  const parts = [];\n  if (active.length > 0) {\n    parts.push('Active time credits:');\n    for (const s of active) {\n      const total = formatDuration(s.time_credits_seconds);\n      const remaining = formatDuration(s.time_remaining_seconds);\n      const used = formatDuration(s.time_used_seconds);\n      parts.push('- ' + (s.display_name || s.ai_model) + ': ' + remaining + ' remaining of ' + total + ' (' + used + ' used)');\n    }\n  }\n  if (inactive.length > 0) {\n    parts.push('');\n    parts.push('Inactive models (credits but session not active):');\n    for (const s of inactive) {\n      parts.push('- ' + (s.display_name || s.ai_model) + ': ' + formatDuration(s.time_remaining_seconds) + ' remaining');\n    }\n  }\n  if (parts.length === 0) {\n    return 'No active time credits.';\n  }\n  return parts.join('\\n');\n}\n\n// Wallet BCH balance via the paytaca CLI\nasync function getBalance() {\n  const out = await runCommand(PAYTACA_CMD, ['wallet', 'info']);\n  const match = out.match(/Balance:\\s*([\\d.]+)\\s*BCH/i);\n  if (match) {\n    return 'Wallet balance: ' + match[1] + ' BCH.';\n  }\n  return 'Could not parse balance. Raw output:\\n' + out.split('\\n').slice(0, 5).join('\\n');\n}\n\n// List all available models\nasync function getModels() {\n  const data = await getJson(BACKEND_URL + '/v1/config', {});\n  const models = Array.isArray(data.models) ? data.models : [];\n  const lines = ['Available models:'];\n  for (const m of models) {\n    let line = m.id || 'unknown';\n    if (m.display_name && m.display_name !== m.id) line += ' (' + m.display_name + ')';\n    if (m.tier) line += ' [' + m.tier + ']';\n    lines.push('- ' + line);\n  }\n  return lines.join('\\n');\n}\n\n// Plan pricing grouped by tier, optionally filtered to one model\nasync function getPlans(filterModel) {\n  const data = await getJson(BACKEND_URL + '/v1/config', {});\n  let models = Array.isArray(data.models) ? data.models : [];\n  if (filterModel) {\n    const f = String(filterModel).toLowerCase();\n    models = models.filter((m) => {\n      const id = String(m.id || '').toLowerCase();\n      const name = String(m.display_name || '').toLowerCase();\n      return id.indexOf(f) !== -1 || name.indexOf(f) !== -1;\n    });\n  }\n  const groups = { budget: [], premium: [], frontier: [], other: [] };\n  for (const m of models) {\n    const key = String(m.tier || '').toLowerCase();\n    const groupKey = (key === 'budget' || key === 'premium' || key === 'frontier') ? key : 'other';\n    groups[groupKey].push(m);\n  }\n  const lines = ['Paytaca AI \u2014 Model Pricing'];\n  const order = [\n    { key: 'budget', label: 'Budget' },\n    { key: 'premium', label: 'Premium' },\n    { key: 'frontier', label: 'Frontier' },\n    { key: 'other', label: 'Other' },\n  ];\n  let any = false;\n  for (const g of order) {\n    const group = groups[g.key];\n    if (group.length === 0) continue;\n    any = true;\n    lines.push('');\n    lines.push(g.label);\n    for (const m of group) {\n      lines.push('');\n      const tiers = Array.isArray(m.price_tiers) ? m.price_tiers : [];\n      if (tiers.length === 0) {\n        lines.push('- ' + (m.display_name || m.id) + ': no pricing configured');\n        continue;\n      }\n      const sorted = tiers.slice().sort((a, b) => (a.minutes || 0) - (b.minutes || 0));\n      lines.push((m.display_name || m.id) + ':');\n      for (const t of sorted) {\n        const sats = typeof t.price_sats === 'number' ? t.price_sats : 0;\n        const bch = (sats / 100000000).toFixed(8);\n        const usd = typeof t.price_usd === 'number' ? t.price_usd.toFixed(4) : '?.??';\n        lines.push('  ' + (t.minutes || 0) + ' minutes \u2014 USD ' + usd + ' (' + bch + ' BCH)');\n      }\n    }\n  }\n  if (!any) {\n    lines.push('No models available.');\n  }\n  return lines.join('\\n');\n}\n\n// Recent wallet transactions via the paytaca CLI\nasync function getTransactions(args) {\n  const cmdArgs = ['history'];\n  if (args.type === 'incoming' || args.type === 'outgoing') {\n    cmdArgs.push('--type', args.type);\n  }\n  const page = parseInt(args.page, 10);\n  if (!isNaN(page) && page > 0) {\n    cmdArgs.push('--page', String(page));\n  }\n  const out = await runCommand(PAYTACA_CMD, cmdArgs, 30000);\n  return out || 'No transactions found.';\n}\n\n// Receiving address via the paytaca CLI (QR art suppressed)\nasync function getReceivingAddress(args) {\n  const cmdArgs = ['receive', '--no-qr'];\n  const amount = parseFloat(args.amount);\n  if (!isNaN(amount) && amount > 0) {\n    cmdArgs.push('--amount', String(amount));\n  }\n  const out = await runCommand(PAYTACA_CMD, cmdArgs, 30000);\n  return out.trim() || 'Could not get receiving address.';\n}\n\n// CashToken holdings via the paytaca CLI (all tokens, or one category)\nasync function getTokens(args) {\n  const category = args.category ? String(args.category).trim() : '';\n  const cmdArgs = category ? ['token', 'info', category] : ['token', 'list'];\n  const out = await runCommand(PAYTACA_CMD, cmdArgs, 30000);\n  return out.trim() || (category ? 'Token not found: ' + category : 'No tokens found.');\n}\n\n// Send BCH or CashTokens. This spends real funds \u2014 opencode requires manual\n// user approval for this tool (permission 'paytaca_send' set to 'ask' by the\n// plugin's config hook), so it must never be called without the user asking\n// for the send.\nasync function sendFunds(args) {\n  const address = String(args.address || '').trim();\n  const amount = String(args.amount || '').trim();\n  const unit = args.unit === 'sats' ? 'sats' : 'bch';\n  const tokenCategory = args.token_category ? String(args.token_category).trim() : '';\n  if (!address) {\n    throw new Error('Missing recipient address.');\n  }\n  if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {\n    throw new Error('Missing or invalid amount.');\n  }\n  const cmdArgs = tokenCategory\n    ? ['token', 'send', address, amount, '--token', tokenCategory]\n    : ['send', address, amount];\n  if (!tokenCategory && unit === 'sats') {\n    cmdArgs.push('--unit', 'sats');\n  }\n  log('Send requested: ' + cmdArgs.join(' '));\n  const out = await runCommand(PAYTACA_CMD, cmdArgs, 90000);\n  log('Send completed');\n  return 'Transaction sent.\\n\\n' + out;\n}\n\n// Tool schemas (concise descriptions so MCP tool context stays small)\nconst TOOLS = [\n  {\n    name: 'get_credits',\n    description: 'Get remaining Paytaca AI time credits (active model sessions, time left). Use when the user asks about credits, remaining time, session status, or how much usage they have left.',\n    inputSchema: { type: 'object', properties: {} },\n  },\n  {\n    name: 'get_balance',\n    description: 'Get the BCH balance of the user\\'s Paytaca wallet. Use when the user asks about wallet balance or funds.',\n    inputSchema: { type: 'object', properties: {} },\n  },\n  {\n    name: 'get_models',\n    description: 'List the AI models available on Paytaca AI (id, display name, tier). Use when the user asks which models are available.',\n    inputSchema: { type: 'object', properties: {} },\n  },\n  {\n    name: 'get_plans',\n    description: 'Get Paytaca AI plan pricing: time tiers in minutes with USD and BCH prices, grouped by tier. Optionally pass a model id/name to filter one model. Use when the user asks about plans, pricing, costs, or how much a model costs.',\n    inputSchema: {\n      type: 'object',\n      properties: {\n        model: { type: 'string', description: 'Optional model id or display name to filter pricing to a single model.' },\n      },\n    },\n  },\n  {\n    name: 'get_transactions',\n    description: 'Get recent Paytaca wallet transactions (sent/received BCH). Use when the user asks about transaction history or latest transactions.',\n    inputSchema: {\n      type: 'object',\n      properties: {\n        type: { type: 'string', enum: ['incoming', 'outgoing'], description: 'Optional direction filter.' },\n        page: { type: 'number', description: 'Optional 1-based page number for older history.' },\n      },\n    },\n  },\n  {\n    name: 'get_receiving_address',\n    description: 'Get a Paytaca wallet receiving address for depositing BCH, optionally as a BIP21 URI with an amount. Use when the user wants to fund the wallet or needs their address.',\n    inputSchema: {\n      type: 'object',\n      properties: {\n        amount: { type: 'number', description: 'Optional BCH amount to embed in a BIP21 payment URI.' },\n      },\n    },\n  },\n  {\n    name: 'get_tokens',\n    description: 'List CashToken holdings of the Paytaca wallet, or get details (name, symbol, balance, NFTs) for one token category. Use when the user asks about tokens or NFTs.',\n    inputSchema: {\n      type: 'object',\n      properties: {\n        category: { type: 'string', description: 'Optional token category id for details of a single token.' },\n      },\n    },\n  },\n  {\n    name: 'send',\n    description: 'Send BCH or CashTokens from the Paytaca wallet to an address. SPENDS REAL FUNDS \u2014 only call when the user explicitly asks to send; opencode will prompt the user for approval and that prompt must never be bypassed. Token amounts are in base units; recipients of tokens should use token-aware (z-prefix) addresses.',\n    inputSchema: {\n      type: 'object',\n      required: ['address', 'amount'],\n      properties: {\n        address: { type: 'string', description: 'Recipient CashAddr (e.g. bitcoincash:qp...).' },\n        amount: { type: 'string', description: 'Amount to send.' },\n        unit: { type: 'string', enum: ['bch', 'sats'], description: 'Amount unit, default bch. Ignored for token sends.' },\n        token_category: { type: 'string', description: 'Token category id to send CashTokens instead of BCH.' },\n      },\n    },\n  },\n];\n\n// JSON-RPC over stdio (newline-delimited)\nlet buffer = '';\nfunction handleMessage(msg) {\n  if (msg.method === 'initialize') {\n    const requestedVersion = msg.params && msg.params.protocolVersion;\n    send(msg.id, {\n      protocolVersion: requestedVersion || PROTOCOL_VERSION,\n      capabilities: { tools: {} },\n      serverInfo: { name: 'paytaca', version: '1.1.0' },\n    });\n    return;\n  }\n  if (msg.method === 'notifications/initialized') {\n    return;\n  }\n  if (msg.method === 'ping') {\n    send(msg.id, {});\n    return;\n  }\n  if (msg.method === 'tools/list') {\n    send(msg.id, { tools: TOOLS });\n    return;\n  }\n  if (msg.method === 'tools/call') {\n    const name = msg.params && msg.params.name;\n    const args = (msg.params && msg.params.arguments) || {};\n    refreshConfig();\n    (async () => {\n      let text;\n      try {\n        switch (name) {\n          case 'get_credits': text = await getCredits(); break;\n          case 'get_balance': text = await getBalance(); break;\n          case 'get_models': text = await getModels(); break;\n          case 'get_plans': text = await getPlans(args.model); break;\n          case 'get_transactions': text = await getTransactions(args); break;\n          case 'get_receiving_address': text = await getReceivingAddress(args); break;\n          case 'get_tokens': text = await getTokens(args); break;\n          case 'send': text = await sendFunds(args); break;\n          default: throw new Error('Unknown tool: ' + name);\n        }\n        send(msg.id, { content: [{ type: 'text', text: text }] });\n      } catch (e) {\n        log('Tool ' + name + ' failed: ' + e.message);\n        send(msg.id, { content: [{ type: 'text', text: 'Error: ' + e.message }], isError: true });\n      }\n    })();\n    return;\n  }\n  // Unknown request \u2014 respond with an empty result so the client never hangs\n  if (typeof msg.id !== 'undefined' && msg.id !== null) {\n    send(msg.id, {});\n  }\n}\n\nfunction send(id, result) {\n  const payload = { jsonrpc: '2.0', id, result };\n  process.stdout.write(JSON.stringify(payload) + '\\n');\n}\n\nprocess.stdin.on('data', (chunk) => {\n  buffer += chunk.toString();\n  let idx;\n  while ((idx = buffer.indexOf('\\n')) !== -1) {\n    const line = buffer.substring(0, idx).trim();\n    buffer = buffer.substring(idx + 1);\n    if (!line) continue;\n    let msg;\n    try {\n      msg = JSON.parse(line);\n    } catch (e) {\n      continue;\n    }\n    try {\n      handleMessage(msg);\n    } catch (e) {\n      log('handleMessage error: ' + e.message);\n    }\n  }\n});\n\nrefreshConfig();\nlog('MCP server started (backend=' + BACKEND_URL + ')');\n";
+//# sourceMappingURL=mcp.d.ts.map

package/dist/bundled/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/bundled/mcp.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,y6hBA4c9B,CAAC"}

package/dist/bundled/mcp.js

@@ -0,0 +1,467 @@
+"use strict";
+// This file contains the bundled MCP server script as a string
+// It gets written to ~/.opencode-paytaca/mcp-server.js at runtime
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_SERVER_CONTENT = void 0;
+exports.MCP_SERVER_CONTENT = `#!/usr/bin/env node
+/**
+ * Paytaca MCP Server
+ *
+ * Registers Paytaca tools with opencode so the assistant can work with real
+ * data instead of guessing. Two groups:
+ * - Paytaca AI account (backend): credits, models, plan pricing
+ * - Paytaca wallet (paytaca CLI): balance, transactions, receiving address,
+ *   token holdings, and sending funds
+ *
+ * The send tool moves real funds — opencode is configured (via the plugin's
+ * config hook) to require explicit user approval before it runs.
+ *
+ * Loaded automatically via the plugin's config hook (cfg.mcp['paytaca']).
+ * Uses only Node.js built-in modules.
+ */
+
+const http = require('http');
+const https = require('https');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = process.env.PAYTACA_CONFIG_DIR || path.join(os.homedir(), '.opencode-paytaca');
+const PAYTACA_CMD = process.env.PAYTACA_CMD || 'paytaca';
+const DEFAULT_BACKEND = process.env.PAYTACA_BACKEND_URL || 'https://api.paytaca.ai';
+
+const PROTOCOL_VERSION = '2025-06-18';
+
+// Logging setup
+const LOG_FILE = path.join(CONFIG_DIR, 'mcp.log');
+const logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
+function log(message) {
+  const timestamp = new Date().toISOString();
+  logStream.write(timestamp + ' [MCP] ' + message + '\\n');
+}
+
+// Load fresh config on every call so walletHash/backendUrl never go stale
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, 'config.json'), 'utf8'));
+  } catch (e) {
+    return {};
+  }
+}
+
+let BACKEND_URL = DEFAULT_BACKEND;
+let WALLET_HASH = '';
+function refreshConfig() {
+  const cfg = loadConfig();
+  BACKEND_URL = process.env.PAYTACA_BACKEND_URL || cfg.backendUrl || DEFAULT_BACKEND;
+  WALLET_HASH = cfg.walletHash || '';
+}
+
+// Fetch a JSON payload over HTTP(S)
+function getJson(url, headers) {
+  return new Promise((resolve, reject) => {
+    let u;
+    try {
+      u = new URL(url);
+    } catch (e) {
+      return reject(new Error('Invalid URL: ' + url));
+    }
+    const requester = u.protocol === 'https:' ? https : http;
+    const req = requester.get({
+      hostname: u.hostname,
+      port: u.port || (u.protocol === 'https:' ? 443 : 80),
+      path: u.pathname + u.search,
+      headers: headers || {},
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode >= 400) {
+          reject(new Error('HTTP ' + res.statusCode + ': ' + data.substring(0, 200)));
+          return;
+        }
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error('Invalid JSON response'));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.setTimeout(15000, () => {
+      req.destroy();
+      reject(new Error('Request timed out'));
+    });
+  });
+}
+
+// Run a shell command with a timeout
+function runCommand(cmd, args, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { shell: false });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try { child.kill(); } catch (e) {}
+      reject(new Error('Command timed out'));
+    }, timeoutMs || 15000);
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('close', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout.trim());
+      else reject(new Error(stderr.trim() || 'Command exited with code ' + code));
+    });
+    child.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+// Format seconds as MM:SS or HH:MM:SS
+function formatDuration(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const secs = totalSeconds % 60;
+  if (hours > 0) {
+    return hours + ':' + String(minutes).padStart(2, '0') + ':' + String(secs).padStart(2, '0');
+  }
+  return minutes + ':' + String(secs).padStart(2, '0');
+}
+
+// Remaining time credits per model session
+async function getCredits() {
+  const data = await getJson(BACKEND_URL + '/v1/wallet/status', { 'X-Wallet-Hash': WALLET_HASH });
+  const sessions = Array.isArray(data.sessions) ? data.sessions : [];
+  const active = sessions.filter((s) => s.time_remaining_seconds > 0 && s.model_active);
+  const inactive = sessions.filter((s) => s.time_remaining_seconds > 0 && !s.model_active);
+  const parts = [];
+  if (active.length > 0) {
+    parts.push('Active time credits:');
+    for (const s of active) {
+      const total = formatDuration(s.time_credits_seconds);
+      const remaining = formatDuration(s.time_remaining_seconds);
+      const used = formatDuration(s.time_used_seconds);
+      parts.push('- ' + (s.display_name || s.ai_model) + ': ' + remaining + ' remaining of ' + total + ' (' + used + ' used)');
+    }
+  }
+  if (inactive.length > 0) {
+    parts.push('');
+    parts.push('Inactive models (credits but session not active):');
+    for (const s of inactive) {
+      parts.push('- ' + (s.display_name || s.ai_model) + ': ' + formatDuration(s.time_remaining_seconds) + ' remaining');
+    }
+  }
+  if (parts.length === 0) {
+    return 'No active time credits.';
+  }
+  return parts.join('\\n');
+}
+
+// Wallet BCH balance via the paytaca CLI
+async function getBalance() {
+  const out = await runCommand(PAYTACA_CMD, ['wallet', 'info']);
+  const match = out.match(/Balance:\\s*([\\d.]+)\\s*BCH/i);
+  if (match) {
+    return 'Wallet balance: ' + match[1] + ' BCH.';
+  }
+  return 'Could not parse balance. Raw output:\\n' + out.split('\\n').slice(0, 5).join('\\n');
+}
+
+// List all available models
+async function getModels() {
+  const data = await getJson(BACKEND_URL + '/v1/config', {});
+  const models = Array.isArray(data.models) ? data.models : [];
+  const lines = ['Available models:'];
+  for (const m of models) {
+    let line = m.id || 'unknown';
+    if (m.display_name && m.display_name !== m.id) line += ' (' + m.display_name + ')';
+    if (m.tier) line += ' [' + m.tier + ']';
+    lines.push('- ' + line);
+  }
+  return lines.join('\\n');
+}
+
+// Plan pricing grouped by tier, optionally filtered to one model
+async function getPlans(filterModel) {
+  const data = await getJson(BACKEND_URL + '/v1/config', {});
+  let models = Array.isArray(data.models) ? data.models : [];
+  if (filterModel) {
+    const f = String(filterModel).toLowerCase();
+    models = models.filter((m) => {
+      const id = String(m.id || '').toLowerCase();
+      const name = String(m.display_name || '').toLowerCase();
+      return id.indexOf(f) !== -1 || name.indexOf(f) !== -1;
+    });
+  }
+  const groups = { budget: [], premium: [], frontier: [], other: [] };
+  for (const m of models) {
+    const key = String(m.tier || '').toLowerCase();
+    const groupKey = (key === 'budget' || key === 'premium' || key === 'frontier') ? key : 'other';
+    groups[groupKey].push(m);
+  }
+  const lines = ['Paytaca AI — Model Pricing'];
+  const order = [
+    { key: 'budget', label: 'Budget' },
+    { key: 'premium', label: 'Premium' },
+    { key: 'frontier', label: 'Frontier' },
+    { key: 'other', label: 'Other' },
+  ];
+  let any = false;
+  for (const g of order) {
+    const group = groups[g.key];
+    if (group.length === 0) continue;
+    any = true;
+    lines.push('');
+    lines.push(g.label);
+    for (const m of group) {
+      lines.push('');
+      const tiers = Array.isArray(m.price_tiers) ? m.price_tiers : [];
+      if (tiers.length === 0) {
+        lines.push('- ' + (m.display_name || m.id) + ': no pricing configured');
+        continue;
+      }
+      const sorted = tiers.slice().sort((a, b) => (a.minutes || 0) - (b.minutes || 0));
+      lines.push((m.display_name || m.id) + ':');
+      for (const t of sorted) {
+        const sats = typeof t.price_sats === 'number' ? t.price_sats : 0;
+        const bch = (sats / 100000000).toFixed(8);
+        const usd = typeof t.price_usd === 'number' ? t.price_usd.toFixed(4) : '?.??';
+        lines.push('  ' + (t.minutes || 0) + ' minutes — USD ' + usd + ' (' + bch + ' BCH)');
+      }
+    }
+  }
+  if (!any) {
+    lines.push('No models available.');
+  }
+  return lines.join('\\n');
+}
+
+// Recent wallet transactions via the paytaca CLI
+async function getTransactions(args) {
+  const cmdArgs = ['history'];
+  if (args.type === 'incoming' || args.type === 'outgoing') {
+    cmdArgs.push('--type', args.type);
+  }
+  const page = parseInt(args.page, 10);
+  if (!isNaN(page) && page > 0) {
+    cmdArgs.push('--page', String(page));
+  }
+  const out = await runCommand(PAYTACA_CMD, cmdArgs, 30000);
+  return out || 'No transactions found.';
+}
+
+// Receiving address via the paytaca CLI (QR art suppressed)
+async function getReceivingAddress(args) {
+  const cmdArgs = ['receive', '--no-qr'];
+  const amount = parseFloat(args.amount);
+  if (!isNaN(amount) && amount > 0) {
+    cmdArgs.push('--amount', String(amount));
+  }
+  const out = await runCommand(PAYTACA_CMD, cmdArgs, 30000);
+  return out.trim() || 'Could not get receiving address.';
+}
+
+// CashToken holdings via the paytaca CLI (all tokens, or one category)
+async function getTokens(args) {
+  const category = args.category ? String(args.category).trim() : '';
+  const cmdArgs = category ? ['token', 'info', category] : ['token', 'list'];
+  const out = await runCommand(PAYTACA_CMD, cmdArgs, 30000);
+  return out.trim() || (category ? 'Token not found: ' + category : 'No tokens found.');
+}
+
+// Send BCH or CashTokens. This spends real funds — opencode requires manual
+// user approval for this tool (permission 'paytaca_send' set to 'ask' by the
+// plugin's config hook), so it must never be called without the user asking
+// for the send.
+async function sendFunds(args) {
+  const address = String(args.address || '').trim();
+  const amount = String(args.amount || '').trim();
+  const unit = args.unit === 'sats' ? 'sats' : 'bch';
+  const tokenCategory = args.token_category ? String(args.token_category).trim() : '';
+  if (!address) {
+    throw new Error('Missing recipient address.');
+  }
+  if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {
+    throw new Error('Missing or invalid amount.');
+  }
+  const cmdArgs = tokenCategory
+    ? ['token', 'send', address, amount, '--token', tokenCategory]
+    : ['send', address, amount];
+  if (!tokenCategory && unit === 'sats') {
+    cmdArgs.push('--unit', 'sats');
+  }
+  log('Send requested: ' + cmdArgs.join(' '));
+  const out = await runCommand(PAYTACA_CMD, cmdArgs, 90000);
+  log('Send completed');
+  return 'Transaction sent.\\n\\n' + out;
+}
+
+// Tool schemas (concise descriptions so MCP tool context stays small)
+const TOOLS = [
+  {
+    name: 'get_credits',
+    description: 'Get remaining Paytaca AI time credits (active model sessions, time left). Use when the user asks about credits, remaining time, session status, or how much usage they have left.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'get_balance',
+    description: 'Get the BCH balance of the user\\'s Paytaca wallet. Use when the user asks about wallet balance or funds.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'get_models',
+    description: 'List the AI models available on Paytaca AI (id, display name, tier). Use when the user asks which models are available.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'get_plans',
+    description: 'Get Paytaca AI plan pricing: time tiers in minutes with USD and BCH prices, grouped by tier. Optionally pass a model id/name to filter one model. Use when the user asks about plans, pricing, costs, or how much a model costs.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        model: { type: 'string', description: 'Optional model id or display name to filter pricing to a single model.' },
+      },
+    },
+  },
+  {
+    name: 'get_transactions',
+    description: 'Get recent Paytaca wallet transactions (sent/received BCH). Use when the user asks about transaction history or latest transactions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', enum: ['incoming', 'outgoing'], description: 'Optional direction filter.' },
+        page: { type: 'number', description: 'Optional 1-based page number for older history.' },
+      },
+    },
+  },
+  {
+    name: 'get_receiving_address',
+    description: 'Get a Paytaca wallet receiving address for depositing BCH, optionally as a BIP21 URI with an amount. Use when the user wants to fund the wallet or needs their address.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        amount: { type: 'number', description: 'Optional BCH amount to embed in a BIP21 payment URI.' },
+      },
+    },
+  },
+  {
+    name: 'get_tokens',
+    description: 'List CashToken holdings of the Paytaca wallet, or get details (name, symbol, balance, NFTs) for one token category. Use when the user asks about tokens or NFTs.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: { type: 'string', description: 'Optional token category id for details of a single token.' },
+      },
+    },
+  },
+  {
+    name: 'send',
+    description: 'Send BCH or CashTokens from the Paytaca wallet to an address. SPENDS REAL FUNDS — only call when the user explicitly asks to send; opencode will prompt the user for approval and that prompt must never be bypassed. Token amounts are in base units; recipients of tokens should use token-aware (z-prefix) addresses.',
+    inputSchema: {
+      type: 'object',
+      required: ['address', 'amount'],
+      properties: {
+        address: { type: 'string', description: 'Recipient CashAddr (e.g. bitcoincash:qp...).' },
+        amount: { type: 'string', description: 'Amount to send.' },
+        unit: { type: 'string', enum: ['bch', 'sats'], description: 'Amount unit, default bch. Ignored for token sends.' },
+        token_category: { type: 'string', description: 'Token category id to send CashTokens instead of BCH.' },
+      },
+    },
+  },
+];
+
+// JSON-RPC over stdio (newline-delimited)
+let buffer = '';
+function handleMessage(msg) {
+  if (msg.method === 'initialize') {
+    const requestedVersion = msg.params && msg.params.protocolVersion;
+    send(msg.id, {
+      protocolVersion: requestedVersion || PROTOCOL_VERSION,
+      capabilities: { tools: {} },
+      serverInfo: { name: 'paytaca', version: '1.1.0' },
+    });
+    return;
+  }
+  if (msg.method === 'notifications/initialized') {
+    return;
+  }
+  if (msg.method === 'ping') {
+    send(msg.id, {});
+    return;
+  }
+  if (msg.method === 'tools/list') {
+    send(msg.id, { tools: TOOLS });
+    return;
+  }
+  if (msg.method === 'tools/call') {
+    const name = msg.params && msg.params.name;
+    const args = (msg.params && msg.params.arguments) || {};
+    refreshConfig();
+    (async () => {
+      let text;
+      try {
+        switch (name) {
+          case 'get_credits': text = await getCredits(); break;
+          case 'get_balance': text = await getBalance(); break;
+          case 'get_models': text = await getModels(); break;
+          case 'get_plans': text = await getPlans(args.model); break;
+          case 'get_transactions': text = await getTransactions(args); break;
+          case 'get_receiving_address': text = await getReceivingAddress(args); break;
+          case 'get_tokens': text = await getTokens(args); break;
+          case 'send': text = await sendFunds(args); break;
+          default: throw new Error('Unknown tool: ' + name);
+        }
+        send(msg.id, { content: [{ type: 'text', text: text }] });
+      } catch (e) {
+        log('Tool ' + name + ' failed: ' + e.message);
+        send(msg.id, { content: [{ type: 'text', text: 'Error: ' + e.message }], isError: true });
+      }
+    })();
+    return;
+  }
+  // Unknown request — respond with an empty result so the client never hangs
+  if (typeof msg.id !== 'undefined' && msg.id !== null) {
+    send(msg.id, {});
+  }
+}
+
+function send(id, result) {
+  const payload = { jsonrpc: '2.0', id, result };
+  process.stdout.write(JSON.stringify(payload) + '\\n');
+}
+
+process.stdin.on('data', (chunk) => {
+  buffer += chunk.toString();
+  let idx;
+  while ((idx = buffer.indexOf('\\n')) !== -1) {
+    const line = buffer.substring(0, idx).trim();
+    buffer = buffer.substring(idx + 1);
+    if (!line) continue;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch (e) {
+      continue;
+    }
+    try {
+      handleMessage(msg);
+    } catch (e) {
+      log('handleMessage error: ' + e.message);
+    }
+  }
+});
+
+refreshConfig();
+log('MCP server started (backend=' + BACKEND_URL + ')');
+`;
+//# sourceMappingURL=mcp.js.map

package/dist/bundled/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","sourceRoot":"","sources":["../../src/bundled/mcp.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,kEAAkE;;;AAErD,QAAA,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4cjC,CAAC"}