@paytaca/opencode-plugin 0.3.0 → 0.3.1

package/dist/bundled/proxy.js

@@ -64,7 +64,7 @@ let requestCounter = 0;
 // Utility: run shell command and return output
 function runCommand(cmd, args = []) {
   return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, { shell: false });
+    const child = spawn(cmd, args, { shell: process.platform === 'win32' });
     let stdout = '';
     let stderr = '';
     
@@ -115,7 +115,7 @@ const LIFT_TOKEN_ID = '5932b2fd4915d6a75d3ec53282cd49118149a2176ee67ed68b1111ff0
 async function getLiftBalance() {
   try {
     const output = await runCommand(PAYTACA_CMD, ['token', 'info', LIFT_TOKEN_ID]);
-    const match = output.match(/Balance:\\s*([\\d.]+)\\s*LIFT/i);
+    const match = output.match(/Balance:\s*([\d.]+)\s*LIFT/i);
     if (match) return Math.round(parseFloat(match[1]) * 100);
     return null;
   } catch (err) {
@@ -124,6 +124,23 @@ async function getLiftBalance() {
   }
 }
 
+// Short-lived cache of wallet + LIFT balances so we don't shell out to the CLI
+// on every forwarded prompt. The backend concierge reads these headers to give
+// free balance answers when the wallet has no paid capacity.
+const BALANCE_CACHE_TTL = 15000;
+let balanceCache = { at: 0, sats: null, lift: null };
+
+async function getCachedBalances() {
+  const now = Date.now();
+  if (balanceCache.at && now - balanceCache.at < BALANCE_CACHE_TTL) {
+    return { sats: balanceCache.sats, lift: balanceCache.lift };
+  }
+  const sats = await getWalletBalance();
+  const lift = await getLiftBalance();
+  balanceCache = { at: now, sats, lift };
+  return { sats, lift };
+}
+
 // LIFT payment discount percent advertised by the backend (/v1/config), cached
 // briefly (30s) so a server-side rate change is picked up quickly. Returns 0
 // when unset/unavailable so callers can fall back to no-discount messaging.
@@ -381,7 +398,8 @@ async function streamLowBalanceNotice(res, modelName, otherModels) {
 }
 
 // Forward request to Django and return response (buffered, for non-streaming)
-function forwardToDjango(req, body, callback) {
+async function forwardToDjango(req, body, callback) {
+  const balances = await getCachedBalances();
   const options = {
     hostname: DJANGO_HOST,
     port: DJANGO_PORT,
@@ -390,6 +408,8 @@ function forwardToDjango(req, body, callback) {
     headers: {
       'Content-Type': req.headers['content-type'] || 'application/json',
       'X-Wallet-Hash': req.headers['x-wallet-hash'] || '',
+      'X-Wallet-Balance-Sats': balances.sats !== null ? String(balances.sats) : '',
+      'X-Lift-Balance-Units': balances.lift !== null ? String(balances.lift) : '',
       'Content-Length': Buffer.byteLength(body),
     },
   };
@@ -433,7 +453,8 @@ function forwardToDjango(req, body, callback) {
 }
 
 // Forward streaming request to Django
-function forwardStreaming(req, res, body, callback) {
+async function forwardStreaming(req, res, body, callback) {
+  const balances = await getCachedBalances();
   const options = {
     hostname: DJANGO_HOST,
     port: DJANGO_PORT,
@@ -442,6 +463,8 @@ function forwardStreaming(req, res, body, callback) {
     headers: {
       'Content-Type': req.headers['content-type'] || 'application/json',
       'X-Wallet-Hash': req.headers['x-wallet-hash'] || '',
+      'X-Wallet-Balance-Sats': balances.sats !== null ? String(balances.sats) : '',
+      'X-Lift-Balance-Units': balances.lift !== null ? String(balances.lift) : '',
       'Content-Length': Buffer.byteLength(body),
     },
   };
@@ -866,6 +889,184 @@ function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, paymentMethod,
   });
 }
 
+// ---------------------------------------------------------------------------
+// Auto-refill: when armed via the MCP auto_refill tool, the proxy silently buys
+// a plan of the configured size on 402 (credits exhausted) and retries instead
+// of showing the interactive tier prompt. It stops when the cumulative budget
+// (maxMinutes) is reached, the requested model mismatches, funds are short, or
+// 24h pass without a refill (so a stale armed state cannot keep spending in a
+// later session).
+const AUTO_REFILL_FILE = path.join(LOG_DIR, 'auto-refill.json');
+
+function getAutoRefillState() {
+  try {
+    const s = JSON.parse(fs.readFileSync(AUTO_REFILL_FILE, 'utf8'));
+    if (!s || s.enabled !== true) {
+      return null;
+    }
+    return {
+      enabled: true,
+      minutes: Number(s.minutes) || 0,
+      maxMinutes: Number(s.maxMinutes) || 0,
+      spentMinutes: Number(s.spentMinutes) || 0,
+      model: s.model ? String(s.model) : '',
+      paymentMethod: s.paymentMethod === 'lift' ? 'lift' : 'bch',
+      startedAt: s.startedAt || new Date().toISOString(),
+      lastRefillAt: s.lastRefillAt || null,
+    };
+  } catch (err) {
+    log('Failed to read auto-refill state: ' + err.message);
+    return null;
+  }
+}
+
+function saveAutoRefillState(s) {
+  try {
+    fs.writeFileSync(AUTO_REFILL_FILE, JSON.stringify(s, null, 2), 'utf8');
+  } catch (err) {
+    log('Failed to write auto-refill state: ' + err.message);
+  }
+}
+
+// Can the proxy buy another plan right now? Handles budget, model scope and a
+// staleness rule — when it returns false the caller falls through to the normal
+// interactive tier prompt so the user can buy manually.
+function autoRefillCanBuy(s, modelId) {
+  if (!s || !s.enabled) return false;
+  if (s.minutes <= 0 || s.maxMinutes < s.minutes) {
+    log('Auto-refill disarmed: bad config (minutes=' + s.minutes + ' maxMinutes=' + s.maxMinutes + ')');
+    s.enabled = false;
+    saveAutoRefillState(s);
+    return false;
+  }
+  if (s.spentMinutes >= s.maxMinutes) {
+    return false;
+  }
+  if (s.model && (!modelId || s.model !== modelId)) {
+    return false;
+  }
+  const now = Date.now();
+  const anchorMs = new Date(s.lastRefillAt || s.startedAt || now).getTime();
+  if (isNaN(anchorMs) || now - anchorMs > 24 * 3600 * 1000) {
+    log('Auto-refill disarmed: stale (no refill for 24h)');
+    s.enabled = false;
+    saveAutoRefillState(s);
+    return false;
+  }
+  return true;
+}
+
+// Buy the configured plan automatically and retry the request. Mirrors the
+// interactive payment path (keepalive + paytaca pay + SSE delivery) but never
+// asks the user to pick a tier. On failure it disarms auto-refill and streams
+// the payment-error prompt so the user can retry by hand.
+async function autoRefillAndRetry(res, walletHash, pendingPayload, refill) {
+  log('AUTO-REFILL: buying ' + refill.minutes + '-min plan for wallet ' + walletHash?.substring(0, 16) + '...');
+  pendingPayload.step = 'processing';
+  const extraHeaders = {};
+  if (pendingPayload.modelId) {
+    extraHeaders['X-Model-Id'] = pendingPayload.modelId;
+  }
+  extraHeaders['X-Duration-Minutes'] = String(refill.minutes);
+  if (refill.paymentMethod === 'lift') {
+    extraHeaders['X-Payment-Method'] = 'lift';
+  }
+
+  if (!res.headersSent) {
+    try {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'X-Payment-Processing': 'true',
+      });
+    } catch (e) {
+      log('autoRefillAndRetry writeHead failed: ' + e.message);
+    }
+  }
+  const keepalive = setInterval(() => {
+    if (res.destroyed || res.writableEnded) { clearInterval(keepalive); return; }
+    res.write(': keepalive\\n\\n');
+  }, 2000);
+
+  runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, refill.paymentMethod || 'bch', async (err, responseJson) => {
+    clearInterval(keepalive);
+    pendingPayments.delete(walletHash);
+
+    const disarmAndFail = async (msg) => {
+      refill.enabled = false;
+      saveAutoRefillState(refill);
+      log('AUTO-REFILL: failed (' + msg + ') — disarmed');
+      if (res.headersSent && !res.destroyed && !res.writableEnded) {
+        await streamPaymentFailureAndRetry(res, walletHash, pendingPayload, '\\n\\n❌ Auto-refill payment failed: ' + msg + '\\n\\n');
+      } else if (!res.headersSent) {
+        try {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Payment failed', message: msg }));
+        } catch (e) { log('Failed to write auto-refill error JSON: ' + e.message); }
+      } else {
+        log('Cannot send auto-refill failure — response already ended or destroyed');
+      }
+    };
+
+    if (err) {
+      return await disarmAndFail(err.message);
+    }
+    if (!responseJson.success) {
+      const msg = responseJson.timeout
+        ? 'response timed out after payment — check credits with \\'credits\\' and retry'
+        : (responseJson.error || 'Unknown payment error');
+      return await disarmAndFail(msg);
+    }
+
+    // Payment succeeded — count it toward the budget.
+    const spent = Math.min(refill.spentMinutes + refill.minutes, refill.maxMinutes);
+    const exhausted = spent >= refill.maxMinutes;
+    refill.spentMinutes = spent;
+    refill.lastRefillAt = new Date().toISOString();
+    if (exhausted) {
+      refill.enabled = false;
+    }
+    saveAutoRefillState(refill);
+
+    const chatCompletion = responseJson?.data || responseJson;
+    let wasStreaming = false;
+    try {
+      wasStreaming = JSON.parse(pendingPayload.body).stream === true;
+    } catch (e) {}
+
+    log('AUTO-REFILL: payment ok, spent=' + spent + ' min, exhausted=' + exhausted);
+
+    if (res.destroyed || res.writableEnded) {
+      log('Auto-refill payment succeeded but response connection is gone — cannot deliver chat response');
+      return;
+    }
+
+    let note = '⚡ Auto-refill active: bought a ' + refill.minutes + '-minute plan for ' + (pendingPayload.displayName || pendingPayload.modelId || 'this model') + ' (' + spent + '/' + refill.maxMinutes + ' min budget used)';
+    if (exhausted) {
+      note += ' — **budget reached, auto-refill is now OFF**. Reply to buy more manually if you need to keep going.';
+    }
+    note += '. Generating your response...\\n\\n';
+
+    if (wasStreaming) {
+      try {
+        jsonToSse(res, chatCompletion, { prependContent: PROXY_MARKER + '\\n' + note });
+      } catch (e) {
+        log('auto-refill jsonToSse threw: ' + e.message);
+      }
+    } else {
+      try {
+        if (!res.headersSent) {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+        }
+        res.end(JSON.stringify(chatCompletion));
+      } catch (e) {
+        log('auto-refill non-stream send failed: ' + e.message);
+      }
+    }
+  });
+}
+
 // Extract the last user message content from a chat payload
 function getLastUserMessageContent(body) {
   try {
@@ -1635,6 +1836,42 @@ const server = http.createServer(async (req, res) => {
           });
           
           if (tiers && tiers.length > 0) {
+            // AUTO-REFILL: when armed, buy the configured plan and retry the
+            // request without the interactive tier prompt. Falls through to the
+            // prompt when not armed, model mismatched, budget exhausted, plan
+            // no longer offered, or the wallet cannot fund the refill.
+            const refill = getAutoRefillState();
+            if (refill && autoRefillCanBuy(refill, modelId || requestModel)) {
+              const refillTier = (tiers || []).find((t) => Number(t.minutes) === Number(refill.minutes));
+              if (refillTier && refillTier.price_sats) {
+                if (refill.paymentMethod !== 'lift') {
+                  const currentBalanceSats = await getWalletBalance();
+                  if (currentBalanceSats === null || currentBalanceSats >= Number(refillTier.price_sats)) {
+                    const pp = pendingPayments.get(walletHash);
+                    await autoRefillAndRetry(res, walletHash, pp, refill);
+                    return;
+                  }
+                  log('AUTO-REFILL: insufficient balance (' + (currentBalanceSats === null ? 'n/a' : currentBalanceSats) + ' sats < ' + refillTier.price_sats + ') — disarming');
+                  refill.enabled = false;
+                  saveAutoRefillState(refill);
+                } else {
+                  const liftUnits = await getLiftBalance();
+                  if (liftUnits !== null && liftUnits > 0) {
+                    const pp = pendingPayments.get(walletHash);
+                    await autoRefillAndRetry(res, walletHash, pp, refill);
+                    return;
+                  }
+                  log('AUTO-REFILL: no LIFT tokens — disarming');
+                  refill.enabled = false;
+                  saveAutoRefillState(refill);
+                }
+              } else {
+                log('AUTO-REFILL: configured ' + refill.minutes + '-min plan not offered — disarming');
+                refill.enabled = false;
+                saveAutoRefillState(refill);
+              }
+            }
+
             // New flow: show tier selection prompt. Also tell the user about
             // other models that still have paid credits, so they can switch
             // instead of buying a plan for the currently selected model.
@@ -1728,9 +1965,9 @@ const server = http.createServer(async (req, res) => {
       };
 
       if (isStreaming) {
-        forwardStreaming(req, res, body, handleResponse);
+        await forwardStreaming(req, res, body, handleResponse);
       } else {
-        forwardToDjango(req, body, handleResponse);
+        await forwardToDjango(req, body, handleResponse);
       }
       
     } catch (err) {

package/dist/bundled/proxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAquDnC,CAAC"}
+{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAk9DnC,CAAC"}

package/dist/bundled/wrapper.d.ts

@@ -1,2 +1,2 @@
-export declare const WRAPPER_SCRIPT_CONTENT = "#!/usr/bin/env node\n/**\n * Paytaca Pay Wrapper \u2014 handles large request bodies by reading from a file.\n * Imports paytaca-cli modules directly (avoids CLI argument size limits).\n */\n\nimport { readFileSync } from 'fs';\nimport { execSync } from 'child_process';\nimport { fileURLToPath } from 'url';\nimport { dirname, join } from 'path';\n\n// How long to wait for the server to respond before treating the payment as timed out.\n// Default 240s so heavy non-streaming generations (large context / long output) can\n// complete; override with PAYTACA_PAY_TIMEOUT_MS.\nconst PAY_TIMEOUT_MS = Number(process.env.PAYTACA_PAY_TIMEOUT_MS || 240000);\n\n// Find paytaca-cli installation\nfunction findPaytacaCliPath() {\n  const possiblePaths = [];\n  \n  // Try to get global npm root\n  try {\n    const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();\n    possiblePaths.push(\n      join(globalPath, 'paytaca-cli'),\n      join(globalPath, 'opencode-plugin', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Common global locations\n  possiblePaths.push(\n    '/usr/lib/node_modules/paytaca-cli',\n    '/usr/local/lib/node_modules/paytaca-cli',\n    '/opt/homebrew/lib/node_modules/paytaca-cli',\n  );\n  \n  // Try current file's node_modules (for bundled installs)\n  try {\n    const currentFile = fileURLToPath(import.meta.url);\n    const currentDir = dirname(currentFile);\n    possiblePaths.push(\n      join(currentDir, '..', 'node_modules', 'paytaca-cli'),\n      join(currentDir, '..', '..', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Find first valid path\n  for (const basePath of possiblePaths) {\n    try {\n      const walletPath = join(basePath, 'dist', 'wallet', 'index.js');\n      readFileSync(walletPath);\n      return basePath;\n    } catch {}\n  }\n  \n  throw new Error('paytaca-cli not found. Try reinstalling opencode-plugin: npm install @paytaca/opencode-plugin');\n}\n\n// Load paytaca-cli modules\nlet loadMnemonic, loadWallet, LibauthHDWallet, X402Payer, parsePaymentRequiredJson, selectBchPaymentRequirements, BCH_DERIVATION_PATH;\n\ntry {\n  const basePath = findPaytacaCliPath();\n  \n  ({ loadMnemonic, loadWallet } = await import(join(basePath, 'dist', 'wallet', 'index.js')));\n  ({ LibauthHDWallet } = await import(join(basePath, 'dist', 'wallet', 'keys.js')));\n  ({ X402Payer } = await import(join(basePath, 'dist', 'wallet', 'x402.js')));\n  ({ parsePaymentRequiredJson, selectBchPaymentRequirements } = await import(join(basePath, 'dist', 'utils', 'x402.js')));\n  ({ BCH_DERIVATION_PATH } = await import(join(basePath, 'dist', 'utils', 'network.js')));\n} catch (err) {\n  console.log(JSON.stringify({ success: false, error: 'Failed to load paytaca-cli: ' + err.message }));\n  process.exit(1);\n}\n\n// Cauldron payment support (opt-in via config.paymentMethod === 'lift').\n// The LIFT token is sold in a single swap transaction whose output pays the\n// x402 payTo address directly. Uses the same machinery as paytaca-cli's\n// \"paytaca swap\" command, imported via absolute paths because the wrapper runs\n// outside any node_modules tree.\nconst LIFT_TOKEN_ID = process.env.PAYTACA_PAYMENT_TOKEN_ID || '5932b2fd4915d6a75d3ec53282cd49118149a2176ee67ed68b1111ff0786f7fc';\nlet cauldronLoaded = false;\nlet fetchPoolsForToken, apiPoolToMicroPool, microPoolToPoolV0, attemptTrade, watchtowerUtxosToSpendableCoins, ExchangeLab, PayoutAmountRuleType, cashAddressToLockingBytecode, binToHex;\ntry {\n  const basePath = findPaytacaCliPath();\n  const cauldronDir = join(basePath, 'dist', 'wallet', 'cauldron');\n  const cashlabDir = join(basePath, 'node_modules', '@cashlab');\n  ({ fetchPoolsForToken } = await import(join(cauldronDir, 'api.js')));\n  ({ apiPoolToMicroPool, microPoolToPoolV0 } = await import(join(cauldronDir, 'pools.js')));\n  ({ attemptTrade, watchtowerUtxosToSpendableCoins } = await import(join(cauldronDir, 'transact.js')));\n  ({ default: ExchangeLab } = await import(join(cashlabDir, 'cauldron', 'out', 'exchange-lab.js')));\n  ({ PayoutAmountRuleType } = await import(join(cashlabDir, 'common', 'out', 'constants.js')));\n  ({ cashAddressToLockingBytecode, binToHex } = await import(join(cashlabDir, 'common', 'out', 'libauth.js')));\n  cauldronLoaded = true;\n} catch (err) {\n  // Cauldron modules are only needed for LIFT payments; BCH payments still work.\n  cauldronLoaded = false;\n}\n\nasync function main() {\n  const configPath = process.argv[2];\n  if (!configPath) {\n    console.log(JSON.stringify({ success: false, error: 'Usage: node paytaca-pay-wrapper.mjs <config.json>' }));\n    process.exit(1);\n  }\n\n  const config = JSON.parse(readFileSync(configPath, 'utf8'));\n  const { url, method, headers, bodyFile, chipnet, confirmed, paymentMethod } = config;\n\n  const body = readFileSync(bodyFile, 'utf8');\n\n  const data = loadMnemonic();\n  if (!data) {\n    console.log(JSON.stringify({ success: false, error: 'No wallet found. Run paytaca wallet create first.' }));\n    process.exit(1);\n  }\n\n  const wallet = loadWallet();\n  const isChipnet = Boolean(chipnet);\n  const bchWallet = wallet.forNetwork(isChipnet);\n  const hdWallet = new LibauthHDWallet(data.mnemonic, BCH_DERIVATION_PATH, isChipnet ? 'chipnet' : 'mainnet');\n  const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });\n\n  try {\n    const result = await executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod);\n    console.log(JSON.stringify(result, null, 2));\n  } catch (err) {\n    console.log(JSON.stringify({ success: false, error: err.message || String(err) }, null, 2));\n    process.exit(1);\n  }\n}\n\n// Sell LIFT tokens via Cauldron in a single swap transaction that pays the\n// x402 payTo address directly. Returns { txid, vout } for the payment payload.\nasync function payWithLift(bchWallet, hdWallet, requirements, changeAddress) {\n  if (!cauldronLoaded) {\n    throw new Error('Cauldron payment modules unavailable. Update paytaca-cli to 0.5.0+ to pay with LIFT.');\n  }\n  const tokenId = LIFT_TOKEN_ID;\n  const amountSats = BigInt(requirements.amount);\n\n  const [apiPools, allUtxos, tokenUtxos] = await Promise.all([\n    fetchPoolsForToken(tokenId),\n    bchWallet.getUtxos(),\n    bchWallet.getUtxos({ category: tokenId }),\n  ]);\n  if (!apiPools || apiPools.length === 0) {\n    throw new Error('No active Cauldron pools for the payment token.');\n  }\n  const pools = apiPools.map(apiPoolToMicroPool).map(microPoolToPoolV0);\n\n  const tokenBalance = (tokenUtxos || []).reduce((sum, u) => sum + BigInt(u.amount || 0), 0n);\n  if (tokenBalance <= 0n) {\n    throw new Error('No LIFT tokens in the wallet. Add LIFT to pay this plan with tokens, or pay with BCH.');\n  }\n\n  const bchUtxos = allUtxos.filter((utxo) => !utxo.is_cashtoken);\n  const spendableCoins = watchtowerUtxosToSpendableCoins({\n    utxos: [...bchUtxos, ...(tokenUtxos || [])],\n    wallet: hdWallet,\n  });\n  if (spendableCoins.length === 0) {\n    throw new Error('No spendable UTXOs available.');\n  }\n\n  const payToDecoded = cashAddressToLockingBytecode(requirements.payTo);\n  if (!payToDecoded || typeof payToDecoded === 'string' || !payToDecoded.bytecode) {\n    throw new Error('Invalid payment address: ' + requirements.payTo);\n  }\n  const changeDecoded = cashAddressToLockingBytecode(changeAddress);\n  if (!changeDecoded || typeof changeDecoded === 'string' || !changeDecoded.bytecode) {\n    throw new Error('Invalid change address: ' + changeAddress);\n  }\n\n  const exlab = new ExchangeLab();\n  const payoutRules = [\n    { type: PayoutAmountRuleType.FIXED, locking_bytecode: payToDecoded.bytecode, amount: amountSats },\n    { type: PayoutAmountRuleType.CHANGE, locking_bytecode: changeDecoded.bytecode, allow_mixing_native_and_token: false, allow_mixing_native_and_token_when_bch_change_is_dust: false, add_change_to_txfee_when_bch_change_is_dust: true },\n  ];\n\n  // Back-compute the token supply for a demand target slightly above the plan\n  // cost so the received BCH covers the fixed payout plus fees (excess becomes\n  // change). Retry with a bigger buffer if the first target leaves no change.\n  let trade = null;\n  let tradeTx = null;\n  let lastError = null;\n  for (const buffer of [2000n, 20000n, 100000n]) {\n    try {\n      trade = attemptTrade({ pools, isBuyingToken: false, supply: undefined, demand: amountSats + buffer });\n      tradeTx = exlab.createTradeTx(trade.entries, spendableCoins, payoutRules, null, 1n);\n      exlab.verifyTradeTx(tradeTx);\n      break;\n    } catch (e) {\n      lastError = e;\n    }\n  }\n  if (!tradeTx) {\n    const supply = trade?.summary?.supply;\n    if (supply && tokenBalance < supply) {\n      throw new Error('Insufficient LIFT balance: this payment needs ' + supply + ' base units but the wallet has ' + tokenBalance + '.');\n    }\n    throw new Error('Could not fund the payment by selling LIFT: ' + (lastError?.message || 'unknown error'));\n  }\n\n  const tx = tradeTx.libauth_generated_transaction;\n  const payToHex = binToHex(payToDecoded.bytecode);\n  const vout = tx.outputs.findIndex((o) => binToHex(o.lockingBytecode) === payToHex);\n  if (vout === -1) {\n    throw new Error('Payment output missing from built transaction.');\n  }\n\n  const txHex = binToHex(tradeTx.txbin);\n  const broadcastResponse = await bchWallet.watchtower.BCH._api.post('broadcast/', { transaction: txHex });\n  const data = broadcastResponse.data;\n  if (data?.result) {\n    data[data.success ? 'txid' : 'error'] = data.result;\n    delete data.result;\n  }\n  if (!data?.success || !data?.txid) {\n    throw new Error(data?.error || 'Broadcast failed');\n  }\n  return { txid: data.txid, vout };\n}\n\nasync function executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod) {\n  // Tell the backend the payment method so it can apply the LIFT discount and\n  // record how the plan was paid. Set once here \u2014 the same headers object is\n  // reused for the 402 fetch and the PAYMENT-SIGNATURE retry.\n  if (paymentMethod === 'lift') {\n    headers['X-Payment-Method'] = 'lift';\n  }\n\n  const response = await fetch(url, {\n    method,\n    headers,\n    body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n    signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n  });\n\n  const responseHeaders = {};\n  response.headers.forEach((value, key) => { responseHeaders[key] = value; });\n  const responseText = await response.text();\n  let responseData;\n  try { responseData = JSON.parse(responseText); } catch { responseData = responseText; }\n\n  if (response.status === 402) {\n    const paymentRequired = parsePaymentRequiredJson(responseData);\n    if (!paymentRequired) {\n      return { success: false, status: 402, error: 'Could not parse PaymentRequired from 402 response body' };\n    }\n    const requirements = selectBchPaymentRequirements(paymentRequired, isChipnet ? 'chipnet' : 'mainnet');\n    if (!requirements) {\n      return {\n        success: false, status: 402, error: 'Server does not accept BCH payment',\n        data: { acceptedSchemes: paymentRequired.accepts.map(a => ({ scheme: a.scheme, network: a.network })) },\n      };\n    }\n\n    const payerAddress = x402Payer.getPayerAddress();\n    const address = requirements.payTo;\n    const amountBch = Number(requirements.amount) / 1e8;\n    const changeAddressSet = bchWallet.getAddressSetAt(0);\n    const changeAddress = changeAddressSet.change;\n\n    if (!confirmed) {\n      return {\n        success: false, status: 402, error: 'Payment not confirmed.',\n        payment: { required: true, amount: requirements.amount, payTo: address },\n      };\n    }\n\n    let txid, vout = 0;\n    if (paymentMethod === 'lift') {\n      // Sell LIFT via Cauldron; the swap transaction pays the plan directly.\n      const liftPayment = await payWithLift(bchWallet, hdWallet, requirements, changeAddress);\n      txid = liftPayment.txid;\n      vout = liftPayment.vout;\n    } else {\n      const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);\n      if (!sendResult.success) {\n        return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };\n      }\n      txid = sendResult.txid;\n    }\n\n    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, vout, requirements.amount);\n    headers['PAYMENT-SIGNATURE'] = JSON.stringify(paymentPayload);\n\n    let retryResponse;\n    try {\n      retryResponse = await fetch(url, {\n        method,\n        headers,\n        body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n        signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n      });\n    } catch (e) {\n      if (e.name === 'AbortError') {\n        return { success: false, timeout: true, error: 'Response timed out from server.' };\n      }\n      throw e;\n    }\n    const retryResponseHeaders = {};\n    retryResponse.headers.forEach((value, key) => { retryResponseHeaders[key] = value; });\n    const retryResponseText = await retryResponse.text();\n    let retryResponseData;\n    try { retryResponseData = JSON.parse(retryResponseText); } catch { retryResponseData = retryResponseText; }\n\n    return {\n      success: retryResponse.ok,\n      status: retryResponse.status,\n      statusText: retryResponse.statusText,\n      headers: retryResponseHeaders,\n      data: retryResponseData,\n      payment: { required: true, txid, recipientAddress: address, method: paymentMethod === 'lift' ? 'lift' : 'bch' },\n    };\n  }\n\n  return {\n    success: response.ok,\n    status: response.status,\n    statusText: response.statusText,\n    headers: responseHeaders,\n    data: responseData,\n    payment: { required: false },\n  };\n}\n\nmain();\n";
+export declare const WRAPPER_SCRIPT_CONTENT = "#!/usr/bin/env node\n/**\n * Paytaca Pay Wrapper \u2014 handles large request bodies by reading from a file.\n * Imports paytaca-cli modules directly (avoids CLI argument size limits).\n */\n\nimport { readFileSync, realpathSync } from 'fs';\nimport { execSync } from 'child_process';\nimport { fileURLToPath } from 'url';\nimport { dirname, join } from 'path';\n\n// How long to wait for the server to respond before treating the payment as timed out.\n// Default 240s so heavy non-streaming generations (large context / long output) can\n// complete; override with PAYTACA_PAY_TIMEOUT_MS.\nconst PAY_TIMEOUT_MS = Number(process.env.PAYTACA_PAY_TIMEOUT_MS || 240000);\n\n// Pre-payment stability probe. Before broadcasting the payment we sample the\n// plan/config endpoint several times ~500ms apart to catch a \"flapping\"\n// backend (reachable one moment, unreachable the next, e.g. right after a\n// purchase). If any sample fails while others succeed, or the plan price\n// changes between samples, we abort BEFORE any money moves. Disable with\n// PAYTACA_PLAN_PROBE=0.\nconst PLAN_PROBE_ENABLED = process.env.PAYTACA_PLAN_PROBE !== '0';\nconst PLAN_PROBE_SAMPLES = 3;\nconst PLAN_PROBE_SPACING_MS = 500;\nconst PLAN_PROBE_TIMEOUT_MS = 6000;\n\nfunction planProbeSleep(ms) {\n  return new Promise(function (resolve) { setTimeout(resolve, ms); });\n}\n\n// Probe /v1/config (models + price tiers) repeatedly. Throws when the endpoint\n// is flapping or the plan price changes between samples. Returns undefined on\n// a stable backend.\nasync function probePlanStability(url, headers) {\n  const modelId = headers['X-Model-Id'];\n  const minutes = headers['X-Duration-Minutes'];\n  if (!modelId || !minutes) return;\n  let origin = null;\n  try { origin = new URL(url).origin; } catch (e) { return; }\n  if (!origin) return;\n\n  let okSamples = 0;\n  let totalSamples = 0;\n  const priceSamples = [];\n  let lastError = '';\n\n  for (let i = 0; i < PLAN_PROBE_SAMPLES; i++) {\n    totalSamples++;\n    try {\n      const controller = new AbortController();\n      const timer = setTimeout(function () { controller.abort(); }, PLAN_PROBE_TIMEOUT_MS);\n      let res;\n      try {\n        res = await fetch(origin + '/v1/config', { signal: controller.signal });\n      } finally {\n        clearTimeout(timer);\n      }\n      if (!res.ok) { lastError = 'HTTP ' + res.status; continue; }\n      const data = await res.json();\n      const models = Array.isArray(data.models) ? data.models : [];\n      const model = models.find(function (m) {\n        const id = String(m.id || '').toLowerCase();\n        const name = String(m.display_name || '').toLowerCase();\n        const q = String(modelId).toLowerCase();\n        return id.indexOf(q) !== -1 || name.indexOf(q) !== -1;\n      });\n      if (!model) { lastError = 'model ' + modelId + ' not in plan config'; continue; }\n      const tiers = Array.isArray(model.price_tiers) ? model.price_tiers : [];\n      const tier = tiers.find(function (t) { return Number(t.minutes) === Number(minutes); });\n      if (!tier) { lastError = 'no ' + minutes + '-min plan for ' + modelId + ' in plan config'; continue; }\n      priceSamples.push(Number(tier.price_sats) || 0);\n      okSamples++;\n    } catch (e) {\n      lastError = (e && e.name === 'AbortError') ? 'timeout' : (e && e.message) || String(e);\n    }\n    if (i < PLAN_PROBE_SAMPLES - 1) await planProbeSleep(PLAN_PROBE_SPACING_MS);\n  }\n\n  // Stable = every sample succeeded AND every sample quoted the same price.\n  if (okSamples === totalSamples && priceSamples.length > 0) {\n    const first = priceSamples[0];\n    const allEqual = priceSamples.every(function (p) { return p === first; });\n    if (allEqual) return;\n  }\n  throw new Error('Backend plan endpoint looked unstable before purchase (reachable ' + okSamples + '/' + totalSamples + (lastError ? ', last error: ' + lastError : '') + '). No payment was broadcast \u2014 please retry in a few seconds.');\n}\n\n// Find paytaca-cli installation\nfunction findPaytacaCliPath() {\n  const possiblePaths = [];\n\n  // Resolve the paytaca command itself when it's on PATH. This covers local\n  // installs (e.g. the plugin's own node_modules) and per-node asdf globals\n  // that `npm root -g` may not reflect when multiple node versions exist.\n  try {\n    const whichCmd = process.platform === 'win32' ? 'where' : 'which';\n    const bin = execSync(`${whichCmd} paytaca`, { encoding: 'utf8' }).trim();\n    if (bin) {\n      let dir = dirname(realpathSync(bin));\n      for (let i = 0; i < 6; i++) {\n        const parent = dirname(dir);\n        if (parent === dir) break;\n        possiblePaths.push(dir);\n        dir = parent;\n      }\n    }\n  } catch {}\n\n  // Try to get global npm root\n  try {\n    const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();\n    possiblePaths.push(\n      join(globalPath, 'paytaca-cli'),\n      join(globalPath, 'opencode-plugin', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Common global locations\n  possiblePaths.push(\n    '/usr/lib/node_modules/paytaca-cli',\n    '/usr/local/lib/node_modules/paytaca-cli',\n    '/opt/homebrew/lib/node_modules/paytaca-cli',\n  );\n  \n  // Windows global npm location\n  if (process.platform === 'win32' && process.env.APPDATA) {\n    possiblePaths.push(join(process.env.APPDATA, 'npm', 'node_modules', 'paytaca-cli'));\n  }\n  \n  // Try current file's node_modules (for bundled installs)\n  try {\n    const currentFile = fileURLToPath(import.meta.url);\n    const currentDir = dirname(currentFile);\n    possiblePaths.push(\n      join(currentDir, '..', 'node_modules', 'paytaca-cli'),\n      join(currentDir, '..', '..', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Find first valid path\n  for (const basePath of possiblePaths) {\n    try {\n      const walletPath = join(basePath, 'dist', 'wallet', 'index.js');\n      readFileSync(walletPath);\n      return basePath;\n    } catch {}\n  }\n  \n  throw new Error('paytaca-cli not found. Try reinstalling opencode-plugin: npm install @paytaca/opencode-plugin');\n}\n\n// Load paytaca-cli modules\nlet loadMnemonic, loadWallet, LibauthHDWallet, X402Payer, parsePaymentRequiredJson, selectBchPaymentRequirements, BCH_DERIVATION_PATH;\n\ntry {\n  const basePath = findPaytacaCliPath();\n  \n  ({ loadMnemonic, loadWallet } = await import(join(basePath, 'dist', 'wallet', 'index.js')));\n  ({ LibauthHDWallet } = await import(join(basePath, 'dist', 'wallet', 'keys.js')));\n  ({ X402Payer } = await import(join(basePath, 'dist', 'wallet', 'x402.js')));\n  ({ parsePaymentRequiredJson, selectBchPaymentRequirements } = await import(join(basePath, 'dist', 'utils', 'x402.js')));\n  ({ BCH_DERIVATION_PATH } = await import(join(basePath, 'dist', 'utils', 'network.js')));\n} catch (err) {\n  console.log(JSON.stringify({ success: false, error: 'Failed to load paytaca-cli: ' + err.message }));\n  process.exit(1);\n}\n\n// Cauldron payment support (opt-in via config.paymentMethod === 'lift').\n// The LIFT token is sold in a single swap transaction whose output pays the\n// x402 payTo address directly. Uses the same machinery as paytaca-cli's\n// \"paytaca swap\" command, imported via absolute paths because the wrapper runs\n// outside any node_modules tree.\nconst LIFT_TOKEN_ID = process.env.PAYTACA_PAYMENT_TOKEN_ID || '5932b2fd4915d6a75d3ec53282cd49118149a2176ee67ed68b1111ff0786f7fc';\nlet cauldronLoaded = false;\nlet fetchPoolsForToken, apiPoolToMicroPool, microPoolToPoolV0, attemptTrade, watchtowerUtxosToSpendableCoins, ExchangeLab, PayoutAmountRuleType, cashAddressToLockingBytecode, binToHex;\ntry {\n  const basePath = findPaytacaCliPath();\n  const cauldronDir = join(basePath, 'dist', 'wallet', 'cauldron');\n  const cashlabDir = findCashlabDir(basePath);\n  ({ fetchPoolsForToken } = await import(join(cauldronDir, 'api.js')));\n  ({ apiPoolToMicroPool, microPoolToPoolV0 } = await import(join(cauldronDir, 'pools.js')));\n  ({ attemptTrade, watchtowerUtxosToSpendableCoins } = await import(join(cauldronDir, 'transact.js')));\n  ({ default: ExchangeLab } = await import(join(cashlabDir, 'cauldron', 'out', 'exchange-lab.js')));\n  ({ PayoutAmountRuleType } = await import(join(cashlabDir, 'common', 'out', 'constants.js')));\n  ({ cashAddressToLockingBytecode, binToHex } = await import(join(cashlabDir, 'common', 'out', 'libauth.js')));\n  cauldronLoaded = true;\n} catch (err) {\n  // Cauldron modules are only needed for LIFT payments; BCH payments still work.\n  cauldronLoaded = false;\n}\n\n// Locate the @cashlab package dir by walking up from the paytaca-cli path.\n// Handles hoisted installs (top-level node_modules) and nested installs.\nfunction findCashlabDir(cliPath) {\n  for (let dir = cliPath, i = 0; i < 8; i++) {\n    const candidate = join(dir, 'node_modules', '@cashlab');\n    try {\n      readFileSync(join(candidate, 'cauldron', 'out', 'exchange-lab.js'));\n      return candidate;\n    } catch {}\n    const parent = dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n  return null;\n}\n\nasync function main() {\n  const configPath = process.argv[2];\n  if (!configPath) {\n    console.log(JSON.stringify({ success: false, error: 'Usage: node paytaca-pay-wrapper.mjs <config.json>' }));\n    process.exit(1);\n  }\n\n  const config = JSON.parse(readFileSync(configPath, 'utf8'));\n  const { url, method, headers, bodyFile, chipnet, confirmed, paymentMethod } = config;\n\n  const body = readFileSync(bodyFile, 'utf8');\n\n  const data = loadMnemonic();\n  if (!data) {\n    console.log(JSON.stringify({ success: false, error: 'No wallet found. Run paytaca wallet create first.' }));\n    process.exit(1);\n  }\n\n  const wallet = loadWallet();\n  const isChipnet = Boolean(chipnet);\n  const bchWallet = wallet.forNetwork(isChipnet);\n  const hdWallet = new LibauthHDWallet(data.mnemonic, BCH_DERIVATION_PATH, isChipnet ? 'chipnet' : 'mainnet');\n  const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });\n\n  try {\n    if (PLAN_PROBE_ENABLED) {\n      await probePlanStability(url, headers);\n    }\n    const result = await executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod);\n    console.log(JSON.stringify(result, null, 2));\n  } catch (err) {\n    console.log(JSON.stringify({ success: false, error: err.message || String(err) }, null, 2));\n    process.exit(1);\n  }\n}\n\n// Sell LIFT tokens via Cauldron in a single swap transaction that pays the\n// x402 payTo address directly. Returns { txid, vout } for the payment payload.\nasync function payWithLift(bchWallet, hdWallet, requirements, changeAddress) {\n  if (!cauldronLoaded) {\n    throw new Error('Cauldron payment modules unavailable. Update paytaca-cli to 0.5.0+ to pay with LIFT.');\n  }\n  const tokenId = LIFT_TOKEN_ID;\n  const amountSats = BigInt(requirements.amount);\n\n  const [apiPools, allUtxos, tokenUtxos] = await Promise.all([\n    fetchPoolsForToken(tokenId),\n    bchWallet.getUtxos(),\n    bchWallet.getUtxos({ category: tokenId }),\n  ]);\n  if (!apiPools || apiPools.length === 0) {\n    throw new Error('No active Cauldron pools for the payment token.');\n  }\n  const pools = apiPools.map(apiPoolToMicroPool).map(microPoolToPoolV0);\n\n  const tokenBalance = (tokenUtxos || []).reduce((sum, u) => sum + BigInt(u.amount || 0), 0n);\n  if (tokenBalance <= 0n) {\n    throw new Error('No LIFT tokens in the wallet. Add LIFT to pay this plan with tokens, or pay with BCH.');\n  }\n\n  const bchUtxos = allUtxos.filter((utxo) => !utxo.is_cashtoken);\n  const spendableCoins = watchtowerUtxosToSpendableCoins({\n    utxos: [...bchUtxos, ...(tokenUtxos || [])],\n    wallet: hdWallet,\n  });\n  if (spendableCoins.length === 0) {\n    throw new Error('No spendable UTXOs available.');\n  }\n\n  const payToDecoded = cashAddressToLockingBytecode(requirements.payTo);\n  if (!payToDecoded || typeof payToDecoded === 'string' || !payToDecoded.bytecode) {\n    throw new Error('Invalid payment address: ' + requirements.payTo);\n  }\n  const changeDecoded = cashAddressToLockingBytecode(changeAddress);\n  if (!changeDecoded || typeof changeDecoded === 'string' || !changeDecoded.bytecode) {\n    throw new Error('Invalid change address: ' + changeAddress);\n  }\n\n  const exlab = new ExchangeLab();\n  const payoutRules = [\n    { type: PayoutAmountRuleType.FIXED, locking_bytecode: payToDecoded.bytecode, amount: amountSats },\n    { type: PayoutAmountRuleType.CHANGE, locking_bytecode: changeDecoded.bytecode, allow_mixing_native_and_token: false, allow_mixing_native_and_token_when_bch_change_is_dust: false, add_change_to_txfee_when_bch_change_is_dust: true },\n  ];\n\n  // Back-compute the token supply for a demand target slightly above the plan\n  // cost so the received BCH covers the fixed payout plus fees (excess becomes\n  // change). Retry with a bigger buffer if the first target leaves no change.\n  let trade = null;\n  let tradeTx = null;\n  let lastError = null;\n  for (const buffer of [2000n, 20000n, 100000n]) {\n    try {\n      trade = attemptTrade({ pools, isBuyingToken: false, supply: undefined, demand: amountSats + buffer });\n      tradeTx = exlab.createTradeTx(trade.entries, spendableCoins, payoutRules, null, 1n);\n      exlab.verifyTradeTx(tradeTx);\n      break;\n    } catch (e) {\n      lastError = e;\n    }\n  }\n  if (!tradeTx) {\n    const supply = trade?.summary?.supply;\n    if (supply && tokenBalance < supply) {\n      throw new Error('Insufficient LIFT balance: this payment needs ' + supply + ' base units but the wallet has ' + tokenBalance + '.');\n    }\n    throw new Error('Could not fund the payment by selling LIFT: ' + (lastError?.message || 'unknown error'));\n  }\n\n  const tx = tradeTx.libauth_generated_transaction;\n  const payToHex = binToHex(payToDecoded.bytecode);\n  const vout = tx.outputs.findIndex((o) => binToHex(o.lockingBytecode) === payToHex);\n  if (vout === -1) {\n    throw new Error('Payment output missing from built transaction.');\n  }\n\n  const txHex = binToHex(tradeTx.txbin);\n  const broadcastResponse = await bchWallet.watchtower.BCH._api.post('broadcast/', { transaction: txHex });\n  const data = broadcastResponse.data;\n  if (data?.result) {\n    data[data.success ? 'txid' : 'error'] = data.result;\n    delete data.result;\n  }\n  if (!data?.success || !data?.txid) {\n    throw new Error(data?.error || 'Broadcast failed');\n  }\n  return { txid: data.txid, vout };\n}\n\nasync function executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod) {\n  // Tell the backend the payment method so it can apply the LIFT discount and\n  // record how the plan was paid. Set once here \u2014 the same headers object is\n  // reused for the 402 fetch and the PAYMENT-SIGNATURE retry.\n  if (paymentMethod === 'lift') {\n    headers['X-Payment-Method'] = 'lift';\n  }\n\n  const response = await fetch(url, {\n    method,\n    headers,\n    body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n    signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n  });\n\n  const responseHeaders = {};\n  response.headers.forEach((value, key) => { responseHeaders[key] = value; });\n  const responseText = await response.text();\n  let responseData;\n  try { responseData = JSON.parse(responseText); } catch { responseData = responseText; }\n\n  if (response.status === 402) {\n    const paymentRequired = parsePaymentRequiredJson(responseData);\n    if (!paymentRequired) {\n      return { success: false, status: 402, error: 'Could not parse PaymentRequired from 402 response body' };\n    }\n    const requirements = selectBchPaymentRequirements(paymentRequired, isChipnet ? 'chipnet' : 'mainnet');\n    if (!requirements) {\n      return {\n        success: false, status: 402, error: 'Server does not accept BCH payment',\n        data: { acceptedSchemes: paymentRequired.accepts.map(a => ({ scheme: a.scheme, network: a.network })) },\n      };\n    }\n\n    const payerAddress = x402Payer.getPayerAddress();\n    const address = requirements.payTo;\n    const amountBch = Number(requirements.amount) / 1e8;\n    const changeAddressSet = bchWallet.getAddressSetAt(0);\n    const changeAddress = changeAddressSet.change;\n\n    if (!confirmed) {\n      return {\n        success: false, status: 402, error: 'Payment not confirmed.',\n        payment: { required: true, amount: requirements.amount, payTo: address },\n      };\n    }\n\n    let txid, vout = 0;\n    if (paymentMethod === 'lift') {\n      // Sell LIFT via Cauldron; the swap transaction pays the plan directly.\n      const liftPayment = await payWithLift(bchWallet, hdWallet, requirements, changeAddress);\n      txid = liftPayment.txid;\n      vout = liftPayment.vout;\n    } else {\n      const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);\n      if (!sendResult.success) {\n        return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };\n      }\n      txid = sendResult.txid;\n    }\n\n    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, vout, requirements.amount);\n    headers['PAYMENT-SIGNATURE'] = JSON.stringify(paymentPayload);\n\n    let retryResponse;\n    try {\n      retryResponse = await fetch(url, {\n        method,\n        headers,\n        body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n        signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n      });\n    } catch (e) {\n      if (e.name === 'AbortError') {\n        return { success: false, timeout: true, error: 'Response timed out from server.' };\n      }\n      throw e;\n    }\n    const retryResponseHeaders = {};\n    retryResponse.headers.forEach((value, key) => { retryResponseHeaders[key] = value; });\n    const retryResponseText = await retryResponse.text();\n    let retryResponseData;\n    try { retryResponseData = JSON.parse(retryResponseText); } catch { retryResponseData = retryResponseText; }\n\n    return {\n      success: retryResponse.ok,\n      status: retryResponse.status,\n      statusText: retryResponse.statusText,\n      headers: retryResponseHeaders,\n      data: retryResponseData,\n      payment: { required: true, txid, recipientAddress: address, method: paymentMethod === 'lift' ? 'lift' : 'bch' },\n    };\n  }\n\n  return {\n    success: response.ok,\n    status: response.status,\n    statusText: response.statusText,\n    headers: responseHeaders,\n    data: responseData,\n    payment: { required: false },\n  };\n}\n\nmain();\n";
 //# sourceMappingURL=wrapper.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,6lbAwUlC,CAAC"}
+{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,+wkBAyblC,CAAC"}

package/dist/bundled/wrapper.js

@@ -10,7 +10,7 @@ exports.WRAPPER_SCRIPT_CONTENT = `#!/usr/bin/env node
  * Imports paytaca-cli modules directly (avoids CLI argument size limits).
  */
 
-import { readFileSync } from 'fs';
+import { readFileSync, realpathSync } from 'fs';
 import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
@@ -20,10 +20,99 @@ import { dirname, join } from 'path';
 // complete; override with PAYTACA_PAY_TIMEOUT_MS.
 const PAY_TIMEOUT_MS = Number(process.env.PAYTACA_PAY_TIMEOUT_MS || 240000);
 
+// Pre-payment stability probe. Before broadcasting the payment we sample the
+// plan/config endpoint several times ~500ms apart to catch a "flapping"
+// backend (reachable one moment, unreachable the next, e.g. right after a
+// purchase). If any sample fails while others succeed, or the plan price
+// changes between samples, we abort BEFORE any money moves. Disable with
+// PAYTACA_PLAN_PROBE=0.
+const PLAN_PROBE_ENABLED = process.env.PAYTACA_PLAN_PROBE !== '0';
+const PLAN_PROBE_SAMPLES = 3;
+const PLAN_PROBE_SPACING_MS = 500;
+const PLAN_PROBE_TIMEOUT_MS = 6000;
+
+function planProbeSleep(ms) {
+  return new Promise(function (resolve) { setTimeout(resolve, ms); });
+}
+
+// Probe /v1/config (models + price tiers) repeatedly. Throws when the endpoint
+// is flapping or the plan price changes between samples. Returns undefined on
+// a stable backend.
+async function probePlanStability(url, headers) {
+  const modelId = headers['X-Model-Id'];
+  const minutes = headers['X-Duration-Minutes'];
+  if (!modelId || !minutes) return;
+  let origin = null;
+  try { origin = new URL(url).origin; } catch (e) { return; }
+  if (!origin) return;
+
+  let okSamples = 0;
+  let totalSamples = 0;
+  const priceSamples = [];
+  let lastError = '';
+
+  for (let i = 0; i < PLAN_PROBE_SAMPLES; i++) {
+    totalSamples++;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(function () { controller.abort(); }, PLAN_PROBE_TIMEOUT_MS);
+      let res;
+      try {
+        res = await fetch(origin + '/v1/config', { signal: controller.signal });
+      } finally {
+        clearTimeout(timer);
+      }
+      if (!res.ok) { lastError = 'HTTP ' + res.status; continue; }
+      const data = await res.json();
+      const models = Array.isArray(data.models) ? data.models : [];
+      const model = models.find(function (m) {
+        const id = String(m.id || '').toLowerCase();
+        const name = String(m.display_name || '').toLowerCase();
+        const q = String(modelId).toLowerCase();
+        return id.indexOf(q) !== -1 || name.indexOf(q) !== -1;
+      });
+      if (!model) { lastError = 'model ' + modelId + ' not in plan config'; continue; }
+      const tiers = Array.isArray(model.price_tiers) ? model.price_tiers : [];
+      const tier = tiers.find(function (t) { return Number(t.minutes) === Number(minutes); });
+      if (!tier) { lastError = 'no ' + minutes + '-min plan for ' + modelId + ' in plan config'; continue; }
+      priceSamples.push(Number(tier.price_sats) || 0);
+      okSamples++;
+    } catch (e) {
+      lastError = (e && e.name === 'AbortError') ? 'timeout' : (e && e.message) || String(e);
+    }
+    if (i < PLAN_PROBE_SAMPLES - 1) await planProbeSleep(PLAN_PROBE_SPACING_MS);
+  }
+
+  // Stable = every sample succeeded AND every sample quoted the same price.
+  if (okSamples === totalSamples && priceSamples.length > 0) {
+    const first = priceSamples[0];
+    const allEqual = priceSamples.every(function (p) { return p === first; });
+    if (allEqual) return;
+  }
+  throw new Error('Backend plan endpoint looked unstable before purchase (reachable ' + okSamples + '/' + totalSamples + (lastError ? ', last error: ' + lastError : '') + '). No payment was broadcast — please retry in a few seconds.');
+}
+
 // Find paytaca-cli installation
 function findPaytacaCliPath() {
   const possiblePaths = [];
-  
+
+  // Resolve the paytaca command itself when it's on PATH. This covers local
+  // installs (e.g. the plugin's own node_modules) and per-node asdf globals
+  // that \`npm root -g\` may not reflect when multiple node versions exist.
+  try {
+    const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+    const bin = execSync(\`\${whichCmd} paytaca\`, { encoding: 'utf8' }).trim();
+    if (bin) {
+      let dir = dirname(realpathSync(bin));
+      for (let i = 0; i < 6; i++) {
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        possiblePaths.push(dir);
+        dir = parent;
+      }
+    }
+  } catch {}
+
   // Try to get global npm root
   try {
     const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();
@@ -40,6 +129,11 @@ function findPaytacaCliPath() {
     '/opt/homebrew/lib/node_modules/paytaca-cli',
   );
   
+  // Windows global npm location
+  if (process.platform === 'win32' && process.env.APPDATA) {
+    possiblePaths.push(join(process.env.APPDATA, 'npm', 'node_modules', 'paytaca-cli'));
+  }
+  
   // Try current file's node_modules (for bundled installs)
   try {
     const currentFile = fileURLToPath(import.meta.url);
@@ -89,7 +183,7 @@ let fetchPoolsForToken, apiPoolToMicroPool, microPoolToPoolV0, attemptTrade, wat
 try {
   const basePath = findPaytacaCliPath();
   const cauldronDir = join(basePath, 'dist', 'wallet', 'cauldron');
-  const cashlabDir = join(basePath, 'node_modules', '@cashlab');
+  const cashlabDir = findCashlabDir(basePath);
   ({ fetchPoolsForToken } = await import(join(cauldronDir, 'api.js')));
   ({ apiPoolToMicroPool, microPoolToPoolV0 } = await import(join(cauldronDir, 'pools.js')));
   ({ attemptTrade, watchtowerUtxosToSpendableCoins } = await import(join(cauldronDir, 'transact.js')));
@@ -102,6 +196,22 @@ try {
   cauldronLoaded = false;
 }
 
+// Locate the @cashlab package dir by walking up from the paytaca-cli path.
+// Handles hoisted installs (top-level node_modules) and nested installs.
+function findCashlabDir(cliPath) {
+  for (let dir = cliPath, i = 0; i < 8; i++) {
+    const candidate = join(dir, 'node_modules', '@cashlab');
+    try {
+      readFileSync(join(candidate, 'cauldron', 'out', 'exchange-lab.js'));
+      return candidate;
+    } catch {}
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
 async function main() {
   const configPath = process.argv[2];
   if (!configPath) {
@@ -127,6 +237,9 @@ async function main() {
   const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });
 
   try {
+    if (PLAN_PROBE_ENABLED) {
+      await probePlanStability(url, headers);
+    }
     const result = await executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod);
     console.log(JSON.stringify(result, null, 2));
   } catch (err) {

package/dist/bundled/wrapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":";AAAA,oEAAoE;AACpE,4EAA4E;AAC5E,mFAAmF;;;AAEtE,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwUrC,CAAC"}
+{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":";AAAA,oEAAoE;AACpE,4EAA4E;AAC5E,mFAAmF;;;AAEtE,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAybrC,CAAC"}

package/dist/credits.d.ts

@@ -0,0 +1,9 @@
+export interface CreditsToastDeps {
+    client: any;
+    backendUrl: () => string;
+    walletHash: () => string;
+}
+export declare function createCreditsToastWatch(deps: CreditsToastDeps): {
+    check: () => Promise<void>;
+};
+//# sourceMappingURL=credits.d.ts.map

package/dist/credits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credits.d.ts","sourceRoot":"","sources":["../src/credits.ts"],"names":[],"mappings":"AAkCA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,GAAG,CAAC;IACZ,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,MAAM,CAAC;CAC1B;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,gBAAgB;;EAiG7D"}