z-zero-mcp-server 1.0.7 → 1.1.0

package/dist/index.js

@@ -1,26 +1,85 @@
 #!/usr/bin/env node
 "use strict";
-// OpenClaw MCP Server (z-zero-mcp-server) v1.0.3
+// OpenClaw MCP Server (z-zero-mcp-server) v1.1.0
 // Exposes secure JIT payment tools to AI Agents via Model Context Protocol
 // Status: Connected to Z-ZERO Gateway — produces secure JIT virtual cards
+// WDK Mode: Set Z_ZERO_WALLET_MODE=wdk for non-custodial WDK payments
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const CURRENT_MCP_VERSION = "1.1.0"; // ← bump this on every release
+const ZZERO_VERSION_API = "https://www.clawcard.store/api/version";
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod_1 = require("zod");
-const api_backend_js_1 = require("./api_backend.js");
+// ── Backend selection (resolved at startup, before server init) ──────────────
+// tsx / Node ESM: import() is async, so we use a synchronous pattern here.
+// Both backends export identical function signatures (drop-in swap).
+const WALLET_MODE = process.env.Z_ZERO_WALLET_MODE || "custodial";
+const isWDKMode = WALLET_MODE === "wdk";
+// Import both backends; pick which one to use based on env var.
+// In production build, tree-shaking will handle this. In dev (tsx), both load.
+const custodialBackend = __importStar(require("./api_backend.js"));
+const wdkBackend = __importStar(require("./wdk_backend.js"));
+const activeBackend = isWDKMode ? wdkBackend : custodialBackend;
+const issueTokenRemote = activeBackend.issueTokenRemote;
+const resolveTokenRemote = activeBackend.resolveTokenRemote;
+const burnTokenRemote = activeBackend.burnTokenRemote;
+const cancelTokenRemote = activeBackend.cancelTokenRemote;
+const refundUnderspendRemote = activeBackend.refundUnderspendRemote;
+const getBalanceRemote = activeBackend.getBalanceRemote;
+const listCardsRemote = activeBackend.listCardsRemote;
+const getDepositAddressesRemote = activeBackend.getDepositAddressesRemote;
+console.error(`[Z-ZERO MCP] 🚀 Wallet mode: ${WALLET_MODE.toUpperCase()}`);
+// ────────────────────────────────────────────────────────────────────────────
 const playwright_bridge_js_1 = require("./playwright_bridge.js");
+const web3_detector_js_1 = require("./lib/web3-detector.js");
+const extract_total_price_js_1 = require("./lib/extract-total-price.js");
+const playwright_1 = require("playwright");
+const key_store_js_1 = require("./lib/key-store.js"); // ✅ Hot-Swap support
 // ============================================================
 // CREATE MCP SERVER
 // ============================================================
 const server = new mcp_js_1.McpServer({
     name: "z-zero-mcp-server",
-    version: "1.0.3",
+    version: "2.0.0",
 });
 // ============================================================
 // TOOL 1: List available cards (safe - no sensitive data)
 // ============================================================
 server.tool("list_cards", "List all available virtual card aliases and their balances. No sensitive data is returned.", {}, async () => {
-    const data = await (0, api_backend_js_1.listCardsRemote)();
+    const data = await listCardsRemote();
     if (data?.error === "AUTH_REQUIRED") {
         return {
             content: [{
@@ -43,7 +102,7 @@ server.tool("list_cards", "List all available virtual card aliases and their bal
     }
     const cards = data?.cards || [];
     const activeTokens = data?.active_tokens || [];
-    const recentTokens = data?.recent_tokens || [];
+    const historySummary = data?.history_summary || {};
     return {
         content: [
             {
@@ -51,8 +110,8 @@ server.tool("list_cards", "List all available virtual card aliases and their bal
                 text: JSON.stringify({
                     cards,
                     active_tokens: activeTokens,
-                    recent_tokens: recentTokens,
-                    note: "Use card aliases to request payment tokens. Never ask for real card numbers.",
+                    history_summary: historySummary,
+                    note: "Only active tokens are shown. Use card aliases to request payment tokens.",
                 }, null, 2),
             },
         ],
@@ -66,7 +125,7 @@ server.tool("check_balance", "Check the wallet balance (human-level total). This
         .string()
         .describe("The alias of the card to check, e.g. 'Card_01'"),
 }, async ({ card_alias }) => {
-    const data = await (0, api_backend_js_1.getBalanceRemote)(card_alias);
+    const data = await getBalanceRemote(card_alias);
     if (data?.error === "AUTH_REQUIRED") {
         return {
             content: [{
@@ -102,7 +161,7 @@ server.tool("check_balance", "Check the wallet balance (human-level total). This
 // TOOL 2.5: Get deposit addresses (Phase 14 feature)
 // ============================================================
 server.tool("get_deposit_addresses", "Get your unique deposit addresses for EVM networks (Base, BSC, Ethereum) and Tron. Provide these to the human user when they need to add funds to their Z-ZERO balance.", {}, async () => {
-    const data = await (0, api_backend_js_1.getDepositAddressesRemote)();
+    const data = await getDepositAddressesRemote();
     if (data?.error === "AUTH_REQUIRED") {
         return {
             content: [{
@@ -114,39 +173,55 @@ server.tool("get_deposit_addresses", "Get your unique deposit addresses for EVM
             isError: true
         };
     }
+    // ── WDK Non-Custodial Mode ────────────────────────────────────────────
+    if (data?.wdk_wallet?.address) {
+        const wdkAddr = data.wdk_wallet.address;
+        const balance = data.wdk_wallet.balance_usdt ?? 0;
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        wallet_type: "non-custodial (WDK)",
+                        address: wdkAddr,
+                        balance_usdt: balance,
+                        supported_chains: [
+                            { chain: "Polygon", token: "USDT", address: wdkAddr },
+                        ],
+                        instructions: `Send USDT (Polygon/ERC-20) to this address: ${wdkAddr}. Funds will appear in your agent wallet within 1-3 minutes.`,
+                        note: "Gasless payments via ERC-4337 Paymaster. Your agent pays ~$0.001 in gas per tx."
+                    }, null, 2),
+                }],
+        };
+    }
+    // ── Custodial Mode Fallback ───────────────────────────────────────────
     const addresses = data?.deposit_addresses;
     if (!addresses) {
         return {
-            content: [
-                {
+            content: [{
                     type: "text",
                     text: "Failed to retrieve deposit addresses. Please ensure your Z_ZERO_API_KEY (Passport Key) is valid. You can find it at https://www.clawcard.store/dashboard/agents",
-                },
-            ],
+                }],
             isError: true,
         };
     }
     return {
-        content: [
-            {
+        content: [{
                 type: "text",
                 text: JSON.stringify({
-                    networks: {
-                        evm: {
-                            address: addresses.evm,
-                            supported_chains: ["Base", "BNB Smart Chain (BSC)", "Ethereum"],
-                            tokens: ["USDC", "USDT"]
-                        },
-                        tron: {
-                            address: addresses.tron,
-                            supported_chains: ["Tron (TRC-20)"],
-                            tokens: ["USDT"]
-                        }
+                    wallet_type: "custodial",
+                    evm: {
+                        address: addresses.evm,
+                        supported_chains: ["Base", "BNB Smart Chain (BSC)", "Ethereum"],
+                        tokens: ["USDC", "USDT"]
+                    },
+                    tron: {
+                        address: addresses.tron,
+                        supported_chains: ["Tron (TRC-20)"],
+                        tokens: ["USDT"]
                     },
                     note: "Funds sent to these addresses will be automatically credited to your Z-ZERO balance within minutes."
                 }, null, 2),
-            },
-        ],
+            }],
     };
 });
 // ============================================================
@@ -165,7 +240,7 @@ server.tool("request_payment_token", "Request a temporary payment token for a sp
         .string()
         .describe("Name or URL of the merchant/service being purchased"),
 }, async ({ card_alias, amount, merchant }) => {
-    const token = await (0, api_backend_js_1.issueTokenRemote)(card_alias, amount, merchant);
+    const token = await issueTokenRemote(card_alias, amount, merchant);
     if (token?.error === "AUTH_REQUIRED") {
         return {
             content: [{
@@ -187,7 +262,7 @@ server.tool("request_payment_token", "Request a temporary payment token for a sp
                 isError: true,
             };
         }
-        const balanceData = await (0, api_backend_js_1.getBalanceRemote)(card_alias);
+        const balanceData = await getBalanceRemote(card_alias);
         const balance = balanceData?.balance;
         return {
             content: [
@@ -208,6 +283,7 @@ server.tool("request_payment_token", "Request a temporary payment token for a sp
                 type: "text",
                 text: JSON.stringify({
                     token: token.token,
+                    token_ref: `...${token.token.slice(-6)}`,
                     amount: token.amount,
                     merchant: token.merchant,
                     expires_at: expiresAt,
@@ -235,7 +311,7 @@ server.tool("execute_payment", "Execute a payment using a temporary token. This
         .describe("The actual final amount on the checkout page. If different from token amount, system will auto-refund the difference."),
 }, async ({ token, checkout_url, actual_amount }) => {
     // Step 1: Resolve token → card data (RAM only)
-    const cardData = await (0, api_backend_js_1.resolveTokenRemote)(token);
+    const cardData = await resolveTokenRemote(token);
     if (cardData?.error === "AUTH_REQUIRED") {
         return {
             content: [{
@@ -257,13 +333,60 @@ server.tool("execute_payment", "Execute a payment using a temporary token. This
             isError: true,
         };
     }
+    // 🔒 PRE-FLIGHT AMOUNT GUARD (Prompt Injection Defense)
+    // If the agent passes actual_amount, verify it doesn't exceed the token's authorized amount.
+    // Tolerance: 5% to allow for minor price rounding (e.g., taxes calculated at checkout).
+    // Attack scenario: Merchant shows $99 on page, but agent was authorized $10 → block + alert human.
+    if (actual_amount !== undefined && cardData.authorized_amount !== undefined) {
+        const tokenAmount = Number(cardData.authorized_amount);
+        const TOLERANCE = 1.05; // 5% buffer
+        if (actual_amount > tokenAmount * TOLERANCE) {
+            // Auto-cancel the token to free up funds
+            await cancelTokenRemote(token);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            blocked: true,
+                            reason: "PRICE_MISMATCH",
+                            message: `🚨 PAYMENT BLOCKED: Checkout shows $${actual_amount} but token only authorizes $${tokenAmount}. Token has been cancelled and funds returned to wallet.`,
+                            token_status: "CANCELLED",
+                            action_required: "Request a new token with the correct amount if you wish to proceed.",
+                        }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+    }
     // Step 2: Use Playwright to inject card into checkout form
     const result = await (0, playwright_bridge_js_1.fillCheckoutForm)(checkout_url, cardData);
-    // Step 3: Burn the token (wallet was pre-debited at issue time)
-    await (0, api_backend_js_1.burnTokenRemote)(token);
+    // Step 3: Burn the token ONLY if payment succeeded
+    // If merchant declines → keep token ACTIVE so webhook decline flow can refund correctly
+    if (result.success) {
+        await burnTokenRemote(token);
+    }
+    else {
+        // Payment failed — do NOT burn token
+        // Airwallex will fire a 'card.authorization.declined' webhook → refund handled there
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: false,
+                        message: result.message || "Payment was declined by merchant.",
+                        token_status: "ACTIVE",
+                        note: "Token NOT burned. Funds will be refunded automatically via webhook within minutes.",
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
     // Step 4: Refund underspend if actual amount was less than token amount
     if (actual_amount !== undefined && result.success) {
-        await (0, api_backend_js_1.refundUnderspendRemote)(token, actual_amount);
+        await refundUnderspendRemote(token, actual_amount);
     }
     // Step 5: Return result (NEVER includes card numbers)
     return {
@@ -292,7 +415,7 @@ server.tool("cancel_payment_token", "Cancel a payment token that has not been us
         .string()
         .describe("Reason for cancellation, e.g. 'Price mismatch: checkout shows $20 but token is $15'"),
 }, async ({ token, reason }) => {
-    const result = await (0, api_backend_js_1.cancelTokenRemote)(token);
+    const result = await cancelTokenRemote(token);
     if (result?.error === "AUTH_REQUIRED") {
         return {
             content: [{
@@ -372,6 +495,331 @@ server.tool("request_human_approval", "Request human approval before proceeding
     };
 });
 // ============================================================
+// TOOL 6.4: Check for Updates (polls clawcard.store, not npm)
+// ============================================================
+server.tool("check_for_updates", "Check if a newer version of this MCP server is available. Polls clawcard.store/api/version — independent of npm so works even if distribution changes. Call this when: (1) user asks if MCP is up to date, (2) a payment fails and you want to rule out a stale MCP version.", {}, async () => {
+    try {
+        const res = await fetch(ZZERO_VERSION_API, {
+            headers: { "User-Agent": `z-zero-mcp/${CURRENT_MCP_VERSION}` },
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        const latest = data.latest_version;
+        const isUpToDate = CURRENT_MCP_VERSION === latest;
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        current_version: CURRENT_MCP_VERSION,
+                        latest_version: latest,
+                        up_to_date: isUpToDate,
+                        status: isUpToDate ? "✅ You are on the latest version." : `⚠️ Update available: ${CURRENT_MCP_VERSION} → ${latest}`,
+                        release_notes: isUpToDate ? null : data.release_notes,
+                        how_to_update: isUpToDate ? null : data.update_instructions,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        current_version: CURRENT_MCP_VERSION,
+                        status: "⚠️ Could not reach version server. Check your internet connection.",
+                        error: err.message,
+                        fallback_check: `Visit https://www.clawcard.store to see latest version.`,
+                    }, null, 2),
+                }],
+            isError: true,
+        };
+    }
+});
+// ============================================================
+// TOOL 6.5: Set API Key (Hot-Swap Passport Key — NO restart needed)
+// ============================================================
+server.tool("set_api_key", "Update the Z-ZERO Passport Key immediately WITHOUT restarting the AI tool. Call this when the human provides a new key (e.g. 'zk_live_xxxxx'). The key is validated and activated instantly for all subsequent API calls. IMPORTANT: Never ask for the key proactively — only call this when the human explicitly provides it.", {
+    api_key: zod_1.z
+        .string()
+        .describe("The new Passport Key to activate. Must start with 'zk_live_' or 'zk_test_'. Get from: https://www.clawcard.store/dashboard/agents"),
+}, async ({ api_key }) => {
+    const result = (0, key_store_js_1.setPassportKey)(api_key);
+    if (!result.ok) {
+        return {
+            content: [{ type: "text", text: `❌ ${result.message}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    status: "SUCCESS",
+                    message: `✅ ${result.message}`,
+                    active_key_prefix: api_key.slice(0, 12) + "...",
+                    note: "All subsequent API calls will use this key. No restart needed.",
+                }, null, 2),
+            }],
+    };
+});
+// ============================================================
+// TOOL 6.6: Show current API Key status (for debugging)
+// ============================================================
+server.tool("show_api_key_status", "Show whether a Passport Key is currently configured, and its prefix (first 12 chars). Does NOT reveal the full key. Use this to debug authentication issues.", {}, async () => {
+    const key = (0, key_store_js_1.getPassportKey)();
+    const hasKey = key.length > 0;
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    configured: hasKey,
+                    key_prefix: hasKey ? key.slice(0, 12) + "..." : null,
+                    wallet_mode: process.env.Z_ZERO_WALLET_MODE || "custodial",
+                    note: hasKey
+                        ? "Key is active. Call set_api_key to update it."
+                        : "No key configured. Call set_api_key with your Passport Key from https://www.clawcard.store/dashboard/agents",
+                }, null, 2),
+            }],
+    };
+});
+// ============================================================
+// TOOL 7: Auto Pay Checkout (Phase 2 — Smart Routing)
+// ============================================================
+server.tool("auto_pay_checkout", "[Phase 2] Autonomous Smart Routing checkout tool. Provide a checkout URL and this tool will:\n" +
+    "1. Scan the page to detect if it supports Web3 (Crypto) payments via window.ethereum or EIP-681 links.\n" +
+    "2. SCENARIO A (Web3): If detected, automatically send USDT on-chain via WDK (gas ~$0.001). No Visa card needed.\n" +
+    "3. SCENARIO B (Fiat): If no Web3 detected, scan DOM for total price, issue a JIT Visa card for exact amount, auto-fill form.", {
+    checkout_url: zod_1.z
+        .string()
+        .url()
+        .describe("Full URL of the checkout/payment page to analyze and pay."),
+    card_alias: zod_1.z
+        .string()
+        .describe("Card alias to charge for JIT Fiat fallback, e.g. 'Card_01'. Required even if Web3 route is used (used for WDK wallet lookup)."),
+}, async ({ checkout_url, card_alias }) => {
+    const ZZERO_API = process.env.Z_ZERO_API_BASE || "https://www.clawcard.store";
+    const API_KEY = process.env.Z_ZERO_API_KEY || "";
+    // ── C2 FIX: API key guard ────────────────────────────────────────────
+    if (!API_KEY) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        status: "CONFIG_ERROR",
+                        message: "Z_ZERO_API_KEY is not configured on this MCP server. Cannot proceed.",
+                    }, null, 2) }],
+            isError: true,
+        };
+    }
+    // ── C1 FIX: SSRF guard — validate checkout_url ───────────────────────
+    // Block non-https and internal/private IP ranges
+    (() => {
+        let url;
+        try {
+            url = new URL(checkout_url);
+        }
+        catch {
+            throw new Error(`Invalid checkout_url: ${checkout_url}`);
+        }
+        const isDev = process.env.NODE_ENV !== "production";
+        const hostname = url.hostname;
+        // ✅ BUG 4 FIX: Allow http://localhost in dev for testing local checkout pages
+        if (isDev && (hostname === "localhost" || hostname === "127.0.0.1")) {
+            console.error(`[SMART ROUTE] Dev mode: allowing localhost checkout URL`);
+        }
+        else {
+            if (url.protocol !== "https:") {
+                throw new Error(`checkout_url must use HTTPS. Got: ${url.protocol}`);
+            }
+            const privatePatterns = [
+                /^localhost$/i, /^127\./, /^10\./,
+                /^172\.(1[6-9]|2\d|3[01])\./, /^192\.168\./,
+                /^169\.254\./, /^\[::1\]$/, /^0\.0\.0\.0$/,
+            ];
+            if (privatePatterns.some(p => p.test(hostname))) {
+                throw new Error(`SSRF blocked: checkout_url points to private/internal host: ${hostname}`);
+            }
+        }
+    })();
+    // ── STEP A: Try to detect Web3 payment on the page ──────────────────
+    console.error(`[SMART ROUTE] Scanning ${checkout_url} for Web3 payment...`);
+    const web3Result = await (0, web3_detector_js_1.detectWeb3Payment)(checkout_url);
+    if (web3Result.detected && web3Result.params) {
+        // ── SCENARIO A: Web3 Payment Detected ────────────────────────────
+        const { to, eip681_amount, data } = web3Result.params;
+        // If amount is baked into EIP-681 link, use it. Otherwise need user to confirm.
+        if (!eip681_amount && !data) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            route: "WEB3",
+                            detected: true,
+                            status: "AMOUNT_REQUIRED",
+                            recipient: to,
+                            message: `Web3 payment gateway detected (${web3Result.method}), recipient: ${to}. Could not determine exact USDT amount automatically. Please confirm the amount with the user, then call this tool again with the amount in the checkout_url or use pay_crypto(to=${to}, amount=<confirmed_amount>).`,
+                        }, null, 2),
+                    }],
+            };
+        }
+        // Call backend WDK transfer API
+        let amount = eip681_amount ?? 0;
+        // Decode ERC-20 transfer amount from calldata if EIP-681 amount not available
+        if (!amount && data && data.length >= 138) {
+            const amountHex = data.slice(-64);
+            const amountRaw = BigInt(`0x${amountHex}`);
+            amount = Number(amountRaw) / 1_000_000;
+        }
+        // Guard: if we still can't determine amount, ask user
+        if (!amount || amount <= 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            route: "WEB3",
+                            detected: true,
+                            status: "AMOUNT_REQUIRED",
+                            recipient: to,
+                            message: `Web3 tx detected but could not decode USDT amount from calldata. Please confirm the exact amount with the user and use pay_crypto(to=${to}, amount=<amount>).`,
+                        }, null, 2),
+                    }],
+            };
+        }
+        const resp = await fetch(`${ZZERO_API}/api/wdk/transfer`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-passport-key": API_KEY,
+            },
+            body: JSON.stringify({ to, amount, card_alias }),
+        });
+        const txResult = await resp.json();
+        if (!resp.ok || !txResult.success) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            route: "WEB3",
+                            status: "FAILED",
+                            reason: txResult.message || txResult.error || "Unknown error from WDK transfer API",
+                        }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        route: "WEB3",
+                        method: web3Result.method,
+                        status: "SUCCESS",
+                        recipient: to,
+                        amount_usdt: amount,
+                        tx_hash: txResult.txHash,
+                        message: `✅ Web3 payment sent on-chain! ${amount} USDT → ${to}. Tx: ${txResult.txHash}`,
+                        gas_savings: "~$0.001 (ERC-4337 Paymaster, gasless for user)",
+                    }, null, 2),
+                }],
+        };
+    }
+    // ── SCENARIO B: No Web3 — Fiat JIT Card fallback ────────────────────
+    console.error(`[SMART ROUTE] No Web3 detected. Scanning DOM for total price...`);
+    // ✅ BUG 1+2 FIX: Use try/finally so browser ALWAYS closes (even on success).
+    // fillCheckoutForm opens its own browser — this avoids triple browser + leak.
+    let totalPrice = null;
+    const priceBrowser = await playwright_1.chromium.launch({ headless: true });
+    try {
+        const pricePage = await priceBrowser.newPage();
+        await pricePage.goto(checkout_url, { waitUntil: "domcontentloaded", timeout: 20_000 });
+        totalPrice = await (0, extract_total_price_js_1.extractTotalPrice)(pricePage);
+    }
+    catch {
+        // ignore — totalPrice stays null, handled below
+    }
+    finally {
+        await priceBrowser.close().catch(() => { }); // ✅ Always close
+    }
+    if (!totalPrice) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        route: "FIAT",
+                        status: "PRICE_NOT_FOUND",
+                        message: "Could not automatically detect the total price on this page. Please manually confirm the exact checkout price and use request_payment_token + execute_payment instead.",
+                    }, null, 2),
+                }],
+            isError: true,
+        };
+    }
+    if (totalPrice < 1 || totalPrice > 100) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        route: "FIAT",
+                        status: "AMOUNT_OUT_OF_RANGE",
+                        detected_price: totalPrice,
+                        message: `Detected price $${totalPrice} is outside the JIT card limit ($1-$100). Please confirm with user and use request_payment_token manually.`,
+                    }, null, 2),
+                }],
+            isError: true,
+        };
+    }
+    // Issue JIT card for exactly the detected total
+    console.error(`[SMART ROUTE] Fiat route: issuing JIT card for $${totalPrice}`);
+    const token = await issueTokenRemote(card_alias, totalPrice, checkout_url);
+    if (!token || token.error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        route: "FIAT",
+                        status: "TOKEN_ISSUE_FAILED",
+                        message: token?.message || "Could not issue JIT card. Check balance or card alias.",
+                    }, null, 2),
+                }],
+            isError: true,
+        };
+    }
+    // Resolve token and auto-fill form
+    const cardData = await resolveTokenRemote(token.token);
+    if (!cardData || cardData.error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        route: "FIAT",
+                        status: "CARD_RESOLVE_FAILED",
+                        message: "Failed to resolve JIT card data. Token may have expired.",
+                    }, null, 2),
+                }],
+            isError: true,
+        };
+    }
+    const fillResult = await (0, playwright_bridge_js_1.fillCheckoutForm)(checkout_url, cardData);
+    if (fillResult.success) {
+        await burnTokenRemote(token.token);
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    route: "FIAT",
+                    status: fillResult.success ? "SUCCESS" : "FILL_FAILED",
+                    detected_price: totalPrice,
+                    jit_card_issued: true,
+                    message: fillResult.success
+                        ? `✅ JIT Visa card issued for $${totalPrice} and checkout filled successfully.`
+                        : `❌ JIT card issued but checkout form fill failed: ${fillResult.message}`,
+                    receipt_id: fillResult.receipt_id || null,
+                }, null, 2),
+            }],
+        isError: !fillResult.success,
+    };
+});
+// ============================================================
 // RESOURCE: Z-ZERO Autonomous Payment SOP
 // ============================================================
 server.resource("Standard Operating Procedure (SOP) for Autonomous Payments", "mcp://resources/sop", {
@@ -426,8 +874,8 @@ When asked to make a purchase, execute the following steps precisely in order:
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
-    console.error("🔐 OpenClaw MCP Server v1.0.3 running...");
+    console.error("🔐 OpenClaw MCP Server v2.0.0 running (Phase 2: Smart Routing enabled)...");
     console.error("Status: Secure & Connected to Z-ZERO Gateway");
-    console.error("Tools: list_cards, check_balance, request_payment_token, execute_payment, cancel_payment_token, request_human_approval");
+    console.error("Tools: list_cards, check_balance, request_payment_token, execute_payment, cancel_payment_token, request_human_approval, auto_pay_checkout");
 }
 main().catch(console.error);

package/dist/lib/extract-total-price.d.ts

@@ -0,0 +1,9 @@
+import type { Page } from "playwright";
+/**
+ * Multi-strategy total price extractor.
+ * Strategy order (most reliable → least reliable):
+ *   1. Known CSS selectors for major platforms (Shopify, Stripe, Woo)
+ *   2. Aria / data-testid patterns
+ *   3. Text heuristic: find largest $ amount near keywords "total", "amount due"
+ */
+export declare function extractTotalPrice(page: Page): Promise<number | null>;