@mcpaid/sdk 2.0.0

package/dist/cli.js

@@ -0,0 +1,1560 @@
+#!/usr/bin/env node
+/**
+ * ToolPay CLI
+ * Command-line interface for MCP developers to configure, validate, and launch ToolPay gateways.
+ */
+import { writeFileSync, readFileSync, existsSync, mkdirSync, unlinkSync, realpathSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { resolve, join } from 'node:path';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { createServer } from 'node:http';
+import { loadConfigFile, generateSampleConfigFile } from './gateway/config-loader.js';
+import { ServerRegistry } from './gateway/server-registry.js';
+import { ToolPayGateway } from './gateway/toolpay-gateway.js';
+import { PaymentOrchestrator } from './settlement/payment-orchestrator.js';
+import { NonceStore } from './settlement/nonce-store.js';
+import { PermitVerifier } from './settlement/permit-verifier.js';
+import { OnChainVerifier } from './settlement/onchain-verifier.js';
+import { SessionWalletManager } from './settlement/session-wallet.js';
+import { FeeCalculator } from './fee/fee-calculator.js';
+import { FeeLedger } from './fee/fee-ledger.js';
+import { CircuitBreaker } from './circuit-breaker/circuit-breaker.js';
+import { StdioBridge } from './transports/stdio-bridge.js';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+function loadEnvFile() {
+    let dir = process.cwd();
+    for (let i = 0; i < 4; i++) {
+        const envPath = resolve(dir, '.env');
+        if (existsSync(envPath)) {
+            const lines = readFileSync(envPath, 'utf-8').split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const eqIdx = trimmed.indexOf('=');
+                if (eqIdx !== -1) {
+                    const key = trimmed.slice(0, eqIdx).trim();
+                    const val = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
+                    if (!process.env[key]) {
+                        process.env[key] = val;
+                    }
+                }
+            }
+            break;
+        }
+        const parent = resolve(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+}
+loadEnvFile();
+export function getCredentialsPath() {
+    const dir = join(homedir(), '.mcpaid');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return join(dir, 'credentials.json');
+}
+export function loadCredentials() {
+    try {
+        const p = getCredentialsPath();
+        if (existsSync(p)) {
+            const data = JSON.parse(readFileSync(p, 'utf-8'));
+            if (data && data.token)
+                return data;
+        }
+    }
+    catch { }
+    return null;
+}
+export function saveCredentials(creds) {
+    const p = getCredentialsPath();
+    writeFileSync(p, JSON.stringify(creds, null, 2), 'utf-8');
+}
+export function clearCredentials() {
+    try {
+        const p = getCredentialsPath();
+        if (existsSync(p)) {
+            unlinkSync(p);
+        }
+    }
+    catch { }
+}
+export function getFlagValue(flags, name, alias) {
+    for (let i = 0; i < flags.length; i++) {
+        const f = flags[i];
+        if (f === `--${name}` || (alias && f === `-${alias}`)) {
+            return flags[i + 1];
+        }
+        if (f.startsWith(`--${name}=`)) {
+            return f.slice(name.length + 3);
+        }
+    }
+    return undefined;
+}
+export function hasFlag(flags, name, alias) {
+    return flags.some((f) => f === `--${name}` || (alias && f === `-${alias}`) || f.startsWith(`--${name}=`));
+}
+export function promptQuestion(query) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((res) => {
+        rl.question(query, (ans) => {
+            rl.close();
+            res(ans.trim());
+        });
+    });
+}
+function printHelp() {
+    console.log(`
+MCPaid CLI - Zero-Friction MCP Monetization Gateway
+
+Commands:
+  init                     Generate a sample mcpaid.config.json in the current directory
+  validate [config-path]   Validate an mcpaid.config.json or toolpay.config.json file
+  start [config-path]      Start local MCPaid gateway proxy on port 8080 (or PORT env)
+  dev [config-path]        Run live zero-config development tunnel with security shield
+  bridge --gateway <url>   Run stdio bridge piping local MCP desktop calls to MCPaid
+  agent-proxy --url <url>  Connect local MCP clients / AI agents to remote monetized gateway (alias for bridge)
+  publish [config-path]    Publish/deploy an MCP server to MCPaid Edge Gateway
+  tunnel [port]            Launch zero-config Cloudflare tunnel for local MCP (default: 3000)
+  server add [config-path] Register an MCP server on MCPaid Edge Gateway
+  server list              List your registered MCP servers
+  server remove <id>       Disconnect and remove an MCP server from MCPaid
+  login                    Sign in to your MCPaid developer account
+  logout                   Log out and remove local credentials
+  whoami                   Show currently authenticated developer account
+  withdraw [amount]        Withdraw available USDC earnings to your Base L2 payout wallet
+  withdrawals              View payout and withdrawal history and live transfer statuses
+  relayer [options]        Inspect automated Base L2 settlement status (operator --run gated)
+  wallet new               Generate a fresh EVM wallet with funding instructions
+    --developer, -d        Generate developer payout wallet for receiving earnings
+    --agent, -a            Generate autonomous agent spending wallet for tool calls
+  wallet status            Inspect configured agent wallet address and network settings
+
+Options:
+  --port, -p <number>      Port to listen on (default: 8080)
+  --gateway <url>          Gateway URL (default: https://mcpaid.dev)
+  --upstream <url>         Override upstream URL when publishing (e.g. tunnel URL)
+  --help, -h               Show this help message
+`);
+}
+async function handleInit() {
+    const targetPath = resolve(process.cwd(), 'mcpaid.config.json');
+    if (existsSync(targetPath)) {
+        console.error(`Error: ${targetPath} already exists.`);
+        process.exit(1);
+    }
+    const sample = generateSampleConfigFile();
+    writeFileSync(targetPath, sample, 'utf-8');
+    console.log(`✅ Created sample MCPaid configuration at: ${targetPath}`);
+    console.log(`\nNext steps:`);
+    console.log(`1. Open mcpaid.config.json and set your payoutWallet (Base/EVM address).`);
+    console.log(`2. Define your free vs paid tools.`);
+    console.log(`3. Run: npx @mcpaid/sdk start mcpaid.config.json\n`);
+}
+async function handleValidate(configPath) {
+    try {
+        const defaultPath = existsSync(resolve(process.cwd(), 'mcpaid.config.json'))
+            ? 'mcpaid.config.json'
+            : 'toolpay.config.json';
+        const fullPath = resolve(process.cwd(), configPath || defaultPath);
+        const { config, upstreamUrl } = loadConfigFile(fullPath);
+        console.log(`✅ Configuration valid!`);
+        console.log(`- Server ID: ${config.serverId}`);
+        console.log(`- Upstream Target: ${upstreamUrl}`);
+        console.log(`- Payout Wallet: ${config.payoutWallet}`);
+        console.log(`- Tools Configured: ${config.tools.length}`);
+        for (const tool of config.tools) {
+            const pricingStr = tool.type === 'free' ? 'FREE' : `$${tool.priceUsd} / call`;
+            console.log(`   • ${tool.toolName.padEnd(25)} -> ${pricingStr}`);
+        }
+    }
+    catch (err) {
+        console.error(`❌ Validation failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function handleStart(configPath) {
+    const defaultPath = existsSync(resolve(process.cwd(), 'mcpaid.config.json'))
+        ? 'mcpaid.config.json'
+        : 'toolpay.config.json';
+    const fullPath = resolve(process.cwd(), configPath || defaultPath);
+    const { config, upstreamUrl } = loadConfigFile(fullPath);
+    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 8080;
+    const registry = new ServerRegistry();
+    registry.registerServer(config);
+    const treasuryWallet = config.platformFee?.platformTreasuryWallet || '0x1001001001001001001001001001001001001001';
+    const feeLedger = new FeeLedger(treasuryWallet);
+    const feeCalculator = new FeeCalculator(treasuryWallet, config.platformFee?.platformFeeBasisPoints ?? 300);
+    const orchestrator = new PaymentOrchestrator({
+        nonceStore: new NonceStore(),
+        permitVerifier: new PermitVerifier(),
+        onChainVerifier: new OnChainVerifier({ getTransaction: async () => null }),
+        sessionWalletManager: new SessionWalletManager(),
+        feeCalculator,
+        feeLedger,
+    });
+    const circuitBreaker = new CircuitBreaker();
+    // Forwarding handler to upstream MCP HTTP endpoint
+    const upstreamHandler = async (req) => {
+        try {
+            const res = await fetch(upstreamUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(req),
+            });
+            return (await res.json());
+        }
+        catch (err) {
+            return {
+                jsonrpc: '2.0',
+                id: req.id ?? null,
+                error: { code: -32000, message: `Upstream error at ${upstreamUrl}: ${err.message}` },
+            };
+        }
+    };
+    const gateway = new ToolPayGateway({
+        registry,
+        orchestrator,
+        circuitBreaker,
+        upstreamHandler,
+    });
+    const server = createServer(async (req, res) => {
+        if (req.method !== 'POST') {
+            res.writeHead(405, { 'Content-Type': 'text/plain' });
+            res.end('Method Not Allowed. ToolPay accepts MCP JSON-RPC POST requests.');
+            return;
+        }
+        let bodyRaw = '';
+        req.on('data', (chunk) => {
+            bodyRaw += chunk;
+        });
+        req.on('end', async () => {
+            try {
+                const jsonRpcReq = JSON.parse(bodyRaw);
+                // Extract payment authorization headers if present
+                let paymentProof;
+                const authHeader = req.headers['authorization'] || req.headers['x-payment-proof'];
+                if (typeof authHeader === 'string') {
+                    const raw = authHeader.replace(/^Bearer\s+/i, '').trim();
+                    if (raw.startsWith('{')) {
+                        try {
+                            paymentProof = JSON.parse(raw);
+                        }
+                        catch { }
+                    }
+                    else {
+                        try {
+                            const decoded = Buffer.from(raw, 'base64').toString('utf8');
+                            if (decoded.startsWith('{')) {
+                                paymentProof = JSON.parse(decoded);
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                const agentWallet = req.headers['x-agent-wallet'] || paymentProof?.signerWallet;
+                const idempotencyKey = req.headers['idempotency-key'];
+                const gatewayRes = await gateway.handleRequest(jsonRpcReq, {
+                    serverId: config.serverId,
+                    agentWallet,
+                    paymentProof,
+                    idempotencyKey,
+                });
+                res.writeHead(gatewayRes.statusCode, gatewayRes.headers);
+                res.end(JSON.stringify(gatewayRes.body));
+            }
+            catch (err) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+        });
+    });
+    server.listen(port, () => {
+        console.log(`\n======================================================`);
+        console.log(`🚀 MCPaid Gateway running on http://localhost:${port}`);
+        console.log(`• Monitored Server: ${config.serverId} (${config.serverName})`);
+        console.log(`• Upstream Target:  ${upstreamUrl}`);
+        console.log(`• Payout Wallet:    ${config.payoutWallet}`);
+        console.log(`• Settlement Rail:  ${config.network.toUpperCase()} (${config.currency})`);
+        console.log(`• Platform Cut:     ${(config.platformFee?.platformFeeBasisPoints ?? 300) / 100}%`);
+        console.log(`======================================================\n`);
+    });
+}
+async function handleBridge() {
+    let gatewayUrl;
+    const gwIdx = process.argv.indexOf('--gateway');
+    const urlIdx = process.argv.indexOf('--url');
+    if (gwIdx !== -1 && process.argv[gwIdx + 1]) {
+        gatewayUrl = process.argv[gwIdx + 1];
+    }
+    else if (urlIdx !== -1 && process.argv[urlIdx + 1]) {
+        gatewayUrl = process.argv[urlIdx + 1];
+    }
+    else if (process.argv[3] && !process.argv[3].startsWith('--')) {
+        gatewayUrl = process.argv[3];
+    }
+    if (!gatewayUrl) {
+        console.error('Error: Missing gateway URL. Usage: mcpaid bridge --gateway <url> (or --url <url>)');
+        process.exit(1);
+    }
+    const walletIndex = process.argv.indexOf('--wallet');
+    const agentWallet = walletIndex !== -1 ? process.argv[walletIndex + 1] : undefined;
+    const noWallet = process.argv.includes('--no-wallet');
+    const keyIndex = process.argv.indexOf('--key');
+    const privateKey = noWallet
+        ? undefined
+        : (keyIndex !== -1
+            ? process.argv[keyIndex + 1]
+            : (process.env.AGENT_PRIVATE_KEY || process.env.DEPLOYER_PRIVATE_KEY));
+    const maxPriceIndex = process.argv.indexOf('--max-price');
+    const autoApproveMaxUsd = maxPriceIndex !== -1
+        ? parseFloat(process.argv[maxPriceIndex + 1])
+        : (process.env.AGENT_MAX_PRICE_USD ? parseFloat(process.env.AGENT_MAX_PRICE_USD) : 1.00);
+    console.error(`[MCPaid Stdio Bridge] Connected to gateway: ${gatewayUrl}`);
+    if (privateKey) {
+        console.error(`[MCPaid Stdio Bridge] Autonomous wallet payment enabled (Auto-approve limit: $${autoApproveMaxUsd}/call)`);
+    }
+    const bridge = new StdioBridge({
+        gatewayUrl,
+        agentWallet,
+        privateKey,
+        autoApproveMaxUsd,
+    });
+    bridge.start();
+}
+async function handleWallet(subcommand) {
+    const walletArgs = process.argv.slice(3);
+    const isNew = !subcommand || subcommand === 'new' || subcommand === 'create' || subcommand === 'generate' || subcommand === 'developer' || subcommand === 'agent';
+    const isDeveloper = walletArgs.some((a) => a === '--developer' || a === '-d' || a === 'developer');
+    const isAgent = walletArgs.some((a) => a === '--agent' || a === '-a' || a === 'agent');
+    if (isNew && subcommand !== 'status' && subcommand !== 'info') {
+        const privateKey = generatePrivateKey();
+        const account = privateKeyToAccount(privateKey);
+        if (isDeveloper) {
+            console.log(`
+======================================================
+🔑 New MCPaid Developer Payout Wallet Generated
+======================================================
+• Payout Address:  ${account.address}
+• Private Key:     ${privateKey}
+======================================================
+
+📋 Developer Setup Instructions:
+1. Payout Wallet Address (Base L2):
+   ${account.address}
+
+2. Configure Your Server:
+   • In mcpaid.config.json, set:
+     "payoutWallet": "${account.address}"
+   • Or paste into the MCPaid Developer Dashboard:
+     https://mcpaid.dev/dashboard
+   • Or publish via CLI:
+     npx @mcpaid/sdk publish
+
+3. On-Chain Revenue Settlement:
+   • 97% net developer revenue from all paid tool calls settles
+     directly to this address on Base L2 in Native USDC.
+   • Native USDC Contract: 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
+
+4. Accessing & Withdrawing Funds:
+   • Import this private key into Coinbase Wallet, MetaMask, or Rabby.
+   • View your address on Basescan:
+     https://basescan.org/address/${account.address}
+======================================================
+`);
+            return;
+        }
+        if (isAgent) {
+            console.log(`
+======================================================
+🔑 New MCPaid Autonomous Agent Wallet Generated
+======================================================
+• Agent Address:   ${account.address}
+• Private Key:     ${privateKey}
+======================================================
+
+📋 Quick Setup:
+1. Add this key to your agent project's .env file:
+   AGENT_PRIVATE_KEY=${privateKey}
+
+2. Funding on Base L2 (USDC):
+   • Production (Base Mainnet - Chain ID 8453):
+     - Native USDC Contract: 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
+     - Coinbase Direct: Withdraw USDC directly to ${account.address} selecting the "Base" network (<$0.01 gas fee).
+     - Official Base Bridge: Bridge USDC/ETH from Ethereum at https://bridge.base.org.
+     - DEX Swap: Swap ETH/tokens to USDC on Aerodrome or Uniswap on Base.
+   • Staging / Testnet (Base Sepolia - Chain ID 84532):
+     - Free USDC: https://faucet.circle.com (select Base Sepolia, paste ${account.address})
+     - Free Gas: https://console.optimism.io/faucet
+
+3. Using Paid MCP Tools:
+   • In your MCP client configuration (Claude Desktop, Cursor, OpenCode), configure the bridge:
+     npx @mcpaid/sdk bridge --gateway <gateway-url>
+   • The bridge automatically signs zero-gas EIP-712 permits using your AGENT_PRIVATE_KEY
+     and executes paid tools with zero manual approval friction.
+======================================================
+`);
+            return;
+        }
+        // Default: Display wallet with sections for both roles
+        console.log(`
+======================================================
+🔑 New MCPaid EVM Keypair Generated
+======================================================
+• Public Address:  ${account.address}
+• Private Key:     ${privateKey}
+======================================================
+
+💡 Tip: Run with --developer or --agent for role-specific guidance:
+   npx @mcpaid/sdk wallet new --developer
+   npx @mcpaid/sdk wallet new --agent
+
+──────────────────────────────────────────────────────
+[ROLE 1: DEVELOPER PAYOUT WALLET]
+──────────────────────────────────────────────────────
+• Set "payoutWallet": "${account.address}" in mcpaid.config.json or in the dashboard (https://mcpaid.dev/dashboard).
+• All 97% developer payouts from agent tool calls settle directly to this Base L2 address in native USDC.
+• Basescan: https://basescan.org/address/${account.address}
+
+──────────────────────────────────────────────────────
+[ROLE 2: AI AGENT SPENDING WALLET]
+──────────────────────────────────────────────────────
+• Set AGENT_PRIVATE_KEY=${privateKey} in your project's .env file.
+• Fund with small USDC on Base (via Coinbase Direct or https://bridge.base.org).
+• Connect via stdio bridge: npx @mcpaid/sdk bridge --gateway <gateway-url>
+======================================================
+`);
+        return;
+    }
+    if (subcommand === 'status' || subcommand === 'info') {
+        const creds = loadCredentials();
+        const key = process.env.AGENT_PRIVATE_KEY || process.env.DEPLOYER_PRIVATE_KEY;
+        if (!key && !creds?.payoutWallet) {
+            console.log(`
+❌ No agent or developer wallet configured in environment.
+Run:
+• For Developers: npx @mcpaid/sdk wallet new --developer
+• For AI Agents:  npx @mcpaid/sdk wallet new --agent
+`);
+            return;
+        }
+        console.log(`
+======================================================
+👛 Configured MCPaid Wallet Status
+======================================================`);
+        if (key) {
+            try {
+                const account = privateKeyToAccount(key.startsWith('0x') ? key : `0x${key}`);
+                console.log(`• Agent / Local Wallet: ${account.address}`);
+                console.log(`• Config Source:        ${process.env.AGENT_PRIVATE_KEY ? 'AGENT_PRIVATE_KEY' : 'DEPLOYER_PRIVATE_KEY'}`);
+            }
+            catch (e) {
+                console.error(`Invalid private key in environment: ${e.message}`);
+            }
+        }
+        if (creds?.payoutWallet) {
+            console.log(`• Account Payout Wallet: ${creds.payoutWallet}`);
+        }
+        console.log(`• Supported Rails:       Base Mainnet (8453) & Base Sepolia (84532)
+• Native USDC Contract:  0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
+======================================================
+`);
+        return;
+    }
+    console.log(`
+Usage: npx @mcpaid/sdk wallet <command> [options]
+
+Commands:
+  new [--developer|--agent] Generate a fresh EVM wallet with tailored instructions
+  status                    Show the public address and settings for configured wallet
+`);
+}
+async function handleLogin() {
+    const args = process.argv.slice(3);
+    const gatewayUrl = getFlagValue(args, 'gateway') || process.env.MCPAID_GATEWAY_URL || 'https://mcpaid.dev';
+    let email = getFlagValue(args, 'email');
+    if (!email) {
+        email = await promptQuestion('Enter your developer email: ');
+    }
+    email = email.toLowerCase().trim();
+    if (!email || !email.includes('@')) {
+        console.error('❌ Error: A valid email address is required.');
+        process.exit(1);
+    }
+    console.log(`\nConnecting to MCPaid Edge Gateway (${gatewayUrl})...`);
+    let authPurpose = 'login_2fa';
+    let loginRes = await fetch(`${gatewayUrl}/v1/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email }),
+    });
+    let loginData = (await loginRes.json().catch(() => ({})));
+    if (loginRes.status === 404) {
+        authPurpose = 'signup_confirmation';
+        console.log(`No existing account found for ${email}. Initiating developer account signup...`);
+        const signupRes = await fetch(`${gatewayUrl}/v1/auth/signup`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email }),
+        });
+        loginData = (await signupRes.json().catch(() => ({})));
+        if (!signupRes.ok) {
+            console.error(`❌ Signup failed: ${loginData.error || JSON.stringify(loginData)}`);
+            process.exit(1);
+        }
+    }
+    else if (!loginRes.ok) {
+        console.error(`❌ Login request failed: ${loginData.error || JSON.stringify(loginData)}`);
+        process.exit(1);
+    }
+    console.log(`\n📧 Verification code sent to ${email}. Check your inbox.`);
+    if (loginData.devCodeHint) {
+        console.log(`[Dev Fallback Code]: ${loginData.devCodeHint}`);
+    }
+    let code = getFlagValue(args, 'code');
+    if (!code) {
+        code = await promptQuestion('Enter 6-digit verification code: ');
+    }
+    code = code.trim();
+    const verifyRes = await fetch(`${gatewayUrl}/v1/auth/verify`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, code, purpose: authPurpose, rememberMe: true }),
+    });
+    const verifyData = (await verifyRes.json().catch(() => ({})));
+    if (!verifyRes.ok || !verifyData.success) {
+        console.error(`❌ Verification failed: ${verifyData.error || 'Invalid or expired code'}`);
+        process.exit(1);
+    }
+    saveCredentials({
+        email: verifyData.user.email,
+        token: verifyData.token,
+        gatewayUrl,
+        payoutWallet: verifyData.user.payout_wallet || undefined,
+    });
+    console.log(`
+======================================================
+✅ Successfully Authenticated with MCPaid!
+======================================================
+• Developer Email: ${verifyData.user.email}
+• Payout Wallet:   ${verifyData.user.payout_wallet || 'None configured yet (set on publish or dashboard)'}
+• Gateway Target:  ${gatewayUrl}
+• Session Saved:   ${getCredentialsPath()}
+======================================================
+`);
+}
+async function handleLogout() {
+    const creds = loadCredentials();
+    if (creds) {
+        try {
+            await fetch(`${creds.gatewayUrl}/v1/auth/logout`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${creds.token}`,
+                },
+            });
+        }
+        catch { }
+    }
+    clearCredentials();
+    console.log('✅ Successfully logged out and removed local credentials.');
+}
+async function handleWhoami() {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.log('❌ Not logged in. Run "npx @mcpaid/sdk login" to sign in.');
+        return;
+    }
+    const gatewayUrl = creds.gatewayUrl || 'https://mcpaid.dev';
+    try {
+        const res = await fetch(`${gatewayUrl}/v1/auth/me`, {
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+        const data = (await res.json());
+        if (data.authenticated && data.user) {
+            console.log(`
+======================================================
+👤 MCPaid Authenticated Developer Profile
+======================================================
+• Email:         ${data.user.email}
+• User ID:       ${data.user.id}
+• Payout Wallet: ${data.user.payout_wallet || 'Not configured yet'}
+• Verified:      ${data.user.email_verified ? 'Yes' : 'No'}
+• Gateway:       ${gatewayUrl}
+======================================================
+`);
+            return;
+        }
+    }
+    catch { }
+    console.log(`\n⚠️ Session expired or invalid for ${creds.email}. Please run "npx @mcpaid/sdk login".\n`);
+}
+export function isLocalOrPrivateHost(urlStr) {
+    try {
+        const parsed = new URL(urlStr);
+        const host = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+        return (host === 'localhost' ||
+            host === '127.0.0.1' ||
+            host === '0.0.0.0' ||
+            host === '::1' ||
+            host === '169.254.169.254' ||
+            host.endsWith('.local') ||
+            host.endsWith('.internal') ||
+            host.startsWith('10.') ||
+            host.startsWith('192.168.') ||
+            /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(host));
+    }
+    catch {
+        return false;
+    }
+}
+async function handleTunnel(portArg) {
+    const port = portArg || '3000';
+    console.log(`\n⚡ Starting zero-config Cloudflare Tunnel to http://127.0.0.1:${port}...`);
+    const child = spawn('cloudflared', ['tunnel', '--url', `http://127.0.0.1:${port}`], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    child.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            console.error(`\n❌ "cloudflared" is not installed on your system.`);
+            console.log(`Install it with:`);
+            console.log(`  macOS:   brew install cloudflared`);
+            console.log(`  Linux:   sudo apt-get install cloudflared`);
+            console.log(`  Windows: winget install Cloudflare.cloudflared\n`);
+            console.log(`Alternatively, you can use ngrok: ngrok http ${port}\n`);
+        }
+        else {
+            console.error(`❌ Failed to start cloudflared: ${err.message}`);
+        }
+        process.exit(1);
+    });
+    let detectedUrl = null;
+    const onData = (data) => {
+        const text = data.toString();
+        const match = text.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i);
+        if (match && !detectedUrl) {
+            detectedUrl = match[0];
+            console.log(`
+======================================================
+🌐 Cloudflare Tunnel Online!
+======================================================
+• Public Tunnel:   ${detectedUrl}
+• Local Forward:   http://127.0.0.1:${port}
+• MCP Target:      ${detectedUrl}/mcp
+
+In another terminal, publish your MCP server to MCPaid Edge:
+  npx @mcpaid/sdk publish --upstream ${detectedUrl}/mcp
+======================================================
+Press Ctrl+C to disconnect tunnel.
+`);
+        }
+    };
+    child.stdout.on('data', onData);
+    child.stderr.on('data', onData);
+    process.on('SIGINT', () => {
+        console.log('\n🛑 Disconnecting tunnel...');
+        child.kill();
+        process.exit(0);
+    });
+}
+async function handleDev(configPathArg) {
+    const args = process.argv.slice(3);
+    const gatewayUrl = getFlagValue(args, 'gateway') || process.env.MCPAID_GATEWAY_URL || 'https://mcpaid.dev';
+    let creds = loadCredentials();
+    let effectiveToken = creds?.token || process.env.MCPAID_TOKEN || process.env.TOOLPAY_ADMIN_KEY;
+    if (!effectiveToken) {
+        console.log(`\n🔒 Authentication required to start a live dev tunnel on MCPaid Edge Gateway.`);
+        const doLogin = await promptQuestion('Would you like to sign in now? (Y/n): ');
+        if (doLogin.toLowerCase() === 'n') {
+            console.log('Dev mode cancelled. Run "npx @mcpaid/sdk login" first.');
+            return;
+        }
+        await handleLogin();
+        creds = loadCredentials();
+        effectiveToken = creds?.token || process.env.MCPAID_TOKEN || process.env.TOOLPAY_ADMIN_KEY;
+    }
+    if (!effectiveToken) {
+        console.error('❌ Authentication failed. Please login first.');
+        process.exit(1);
+    }
+    const candidatePath = configPathArg && !configPathArg.startsWith('-')
+        ? configPathArg
+        : (existsSync(resolve(process.cwd(), 'mcpaid.config.json'))
+            ? 'mcpaid.config.json'
+            : (existsSync(resolve(process.cwd(), 'toolpay.config.json')) ? 'toolpay.config.json' : null));
+    if (!candidatePath || !existsSync(resolve(process.cwd(), candidatePath))) {
+        console.error('❌ No mcpaid.config.json found in current directory. Run "npx @mcpaid/sdk init" first.');
+        process.exit(1);
+    }
+    const fullPath = resolve(process.cwd(), candidatePath);
+    console.log(`\n📄 Loading configuration from: ${candidatePath}`);
+    const loaded = loadConfigFile(fullPath);
+    const config = loaded.config;
+    const localUpstream = loaded.upstreamUrl;
+    // Validate payout wallet
+    if (!config.payoutWallet ||
+        config.payoutWallet.includes('YourBaseEVMWallet') ||
+        !/^0x[a-fA-F0-9]{40}$/.test(config.payoutWallet)) {
+        if (creds?.payoutWallet && /^0x[a-fA-F0-9]{40}$/.test(creds.payoutWallet)) {
+            console.log(`Using your account default payout wallet: ${creds.payoutWallet}`);
+            config.payoutWallet = creds.payoutWallet;
+        }
+        else {
+            const wallet = await promptQuestion('Enter your Base EVM payout wallet address (0x...): ');
+            if (!/^0x[a-fA-F0-9]{40}$/.test(wallet)) {
+                console.error('❌ Invalid Ethereum/Base address format (0x + 40 hex chars).');
+                process.exit(1);
+            }
+            config.payoutWallet = wallet;
+        }
+    }
+    // Parse local upstream target
+    let localPort = 3000;
+    let localPath = '/mcp';
+    try {
+        const parsed = new URL(localUpstream);
+        if (parsed.port)
+            localPort = parseInt(parsed.port, 10);
+        if (parsed.pathname && parsed.pathname !== '/')
+            localPath = parsed.pathname;
+    }
+    catch {
+        console.error(`❌ Invalid upstreamUrl in config: ${localUpstream}`);
+        process.exit(1);
+    }
+    console.log(`\n🛡️  Initializing local MCPaid Security Shield...`);
+    // Start Local Security Shield Proxy
+    // The shield verifies incoming requests have 'X-MCPaid-Gateway: true' to prevent direct tunnel bypass!
+    const shieldPort = localPort === 8089 ? 8091 : 8089;
+    let totalCalls = 0;
+    const shieldServer = createServer(async (req, res) => {
+        const isGateway = req.headers['x-mcpaid-gateway'] === 'true';
+        if (!isGateway) {
+            console.log(`\n⛔ [SECURITY SHIELD] Blocked direct unmonetized tunnel access from ${req.socket.remoteAddress || 'remote'}`);
+            res.writeHead(403, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32001,
+                    message: `Direct tunnel access prohibited. This MCP server is monetized and protected by MCPaid. Call via ${gatewayUrl}/mcp/${config.serverId}`,
+                },
+            }));
+            return;
+        }
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', async () => {
+            const bodyBuffer = Buffer.concat(chunks);
+            const startMs = Date.now();
+            let toolName = 'mcp-call';
+            try {
+                const json = JSON.parse(bodyBuffer.toString('utf-8'));
+                if (json.method === 'tools/call' && json.params?.name) {
+                    toolName = json.params.name;
+                }
+                else if (json.method) {
+                    toolName = json.method;
+                }
+            }
+            catch { }
+            try {
+                const targetUrl = `http://127.0.0.1:${localPort}${req.url || localPath}`;
+                const upstreamResponse = await fetch(targetUrl, {
+                    method: req.method || 'POST',
+                    headers: {
+                        'Content-Type': req.headers['content-type'] || 'application/json',
+                        'X-Agent-Wallet': req.headers['x-agent-wallet'] || '',
+                        'X-MCPaid-Edge': 'true',
+                    },
+                    body: bodyBuffer,
+                });
+                const respBody = await upstreamResponse.arrayBuffer();
+                const duration = Date.now() - startMs;
+                totalCalls++;
+                const agentWallet = req.headers['x-agent-wallet']
+                    ? String(req.headers['x-agent-wallet']).slice(0, 8) + '...'
+                    : 'Agent';
+                console.log(`⚡ [CALL #${totalCalls}] ${toolName.padEnd(18)} | Agent: ${agentWallet} | Status: ${upstreamResponse.status} (${duration}ms)`);
+                res.writeHead(upstreamResponse.status, {
+                    'Content-Type': upstreamResponse.headers.get('content-type') || 'application/json',
+                });
+                res.end(Buffer.from(respBody));
+            }
+            catch (err) {
+                console.error(`❌ [LOCAL UPSTREAM ERROR] Could not connect to http://127.0.0.1:${localPort}: ${err.message}`);
+                res.writeHead(502, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32000,
+                        message: `Failed to connect to local MCP server at http://127.0.0.1:${localPort}: ${err.message}. Ensure your local server is running.`,
+                    },
+                }));
+            }
+        });
+    });
+    await new Promise((resolvePromise) => {
+        shieldServer.listen(shieldPort, '127.0.0.1', () => resolvePromise());
+        shieldServer.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                shieldServer.listen(0, '127.0.0.1', () => resolvePromise());
+            }
+        });
+    });
+    const bound = shieldServer.address();
+    const actualShieldPort = typeof bound === 'object' && bound ? bound.port : shieldPort;
+    console.log(`🔒 Security Shield Active on 127.0.0.1:${actualShieldPort} (Direct bypasses blocked)`);
+    console.log(`⚡ Starting encrypted Cloudflare Tunnel...`);
+    const child = spawn('cloudflared', ['tunnel', '--url', `http://127.0.0.1:${actualShieldPort}`], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    child.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            console.error(`\n❌ "cloudflared" is not installed on your system.`);
+            console.log(`Install it with:`);
+            console.log(`  macOS:   brew install cloudflared`);
+            console.log(`  Linux:   sudo apt-get install cloudflared`);
+            console.log(`  Windows: winget install Cloudflare.cloudflared\n`);
+        }
+        else {
+            console.error(`❌ Failed to start cloudflared: ${err.message}`);
+        }
+        shieldServer.close();
+        process.exit(1);
+    });
+    let published = false;
+    const onData = async (data) => {
+        const text = data.toString();
+        const match = text.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i);
+        if (match && !published) {
+            published = true;
+            const tunnelBaseUrl = match[0];
+            const remoteUpstreamUrl = `${tunnelBaseUrl}${localPath}`;
+            console.log(`🌐 Cloudflare Tunnel Online: ${tunnelBaseUrl}`);
+            console.log(`🚀 Registering tunnel with MCPaid Edge Gateway (${gatewayUrl})...`);
+            try {
+                const res = await fetch(`${gatewayUrl}/v1/servers`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${effectiveToken}`,
+                    },
+                    body: JSON.stringify({ config, upstreamUrl: remoteUpstreamUrl }),
+                });
+                const pubData = (await res.json().catch(() => ({})));
+                if (!res.ok || !pubData.success) {
+                    console.error(`❌ Failed to register tunnel on edge: ${pubData.error || JSON.stringify(pubData)}`);
+                    child.kill();
+                    shieldServer.close();
+                    process.exit(1);
+                }
+                console.log(`
+============================================================
+⚡ MCPaid Live Development Tunnel (Connected & Protected)
+============================================================
+• Local MCP Target:   http://127.0.0.1:${localPort}${localPath}
+• Edge Gateway URL:   ${gatewayUrl}/mcp/${config.serverId}
+• Cloudflare Tunnel:  ${tunnelBaseUrl} [TLS 1.3 Encrypted]
+• Security Shield:    ACTIVE (Direct tunnel bypasses blocked)
+• Payout Wallet:      ${config.payoutWallet} (Base L2)
+• Monitored Tools (${config.tools.length}):
+${config.tools.map((t) => `   • ${t.toolName.padEnd(20)} -> ${t.type === 'free' ? 'FREE' : `$${t.priceUsd} USDC`}`).join('\n')}
+
+📋 Agent / Client Connection:
+  npx @mcpaid/sdk bridge --gateway ${gatewayUrl}/mcp/${config.serverId}
+
+Ready! Agents can now invoke monetized tools. Press Ctrl+C to stop.
+============================================================
+`);
+            }
+            catch (err) {
+                console.error(`❌ Registration error: ${err.message}`);
+                child.kill();
+                shieldServer.close();
+                process.exit(1);
+            }
+        }
+    };
+    child.stdout.on('data', onData);
+    child.stderr.on('data', onData);
+    const cleanup = () => {
+        console.log('\n🛑 Disconnecting tunnel and local security shield...');
+        child.kill();
+        shieldServer.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}
+async function handlePublish(configPathArg) {
+    const args = process.argv.slice(3);
+    const gatewayUrl = getFlagValue(args, 'gateway') || process.env.MCPAID_GATEWAY_URL || 'https://mcpaid.dev';
+    let creds = loadCredentials();
+    let effectiveToken = creds?.token || process.env.MCPAID_TOKEN || process.env.TOOLPAY_ADMIN_KEY;
+    if (!effectiveToken) {
+        console.log(`\n🔒 Authentication required to publish servers to MCPaid Edge Gateway.`);
+        const doLogin = await promptQuestion('Would you like to sign in now? (Y/n): ');
+        if (doLogin.toLowerCase() === 'n') {
+            console.log('Publish cancelled. Run "npx @mcpaid/sdk login" when ready.');
+            return;
+        }
+        await handleLogin();
+        creds = loadCredentials();
+        effectiveToken = creds?.token || process.env.MCPAID_TOKEN || process.env.TOOLPAY_ADMIN_KEY;
+    }
+    if (!effectiveToken) {
+        console.error('❌ Authentication failed. Please login first.');
+        process.exit(1);
+    }
+    let config;
+    let upstreamUrl;
+    const candidatePath = configPathArg && !configPathArg.startsWith('-')
+        ? configPathArg
+        : (existsSync(resolve(process.cwd(), 'mcpaid.config.json'))
+            ? 'mcpaid.config.json'
+            : (existsSync(resolve(process.cwd(), 'toolpay.config.json')) ? 'toolpay.config.json' : null));
+    if (candidatePath && existsSync(resolve(process.cwd(), candidatePath))) {
+        const fullPath = resolve(process.cwd(), candidatePath);
+        console.log(`\n📄 Loading configuration from: ${candidatePath}`);
+        const loaded = loadConfigFile(fullPath);
+        config = loaded.config;
+        upstreamUrl = loaded.upstreamUrl;
+        // Check if payout wallet is placeholder
+        if (!config.payoutWallet ||
+            config.payoutWallet.includes('YourBaseEVMWallet') ||
+            !/^0x[a-fA-F0-9]{40}$/.test(config.payoutWallet)) {
+            if (creds?.payoutWallet && /^0x[a-fA-F0-9]{40}$/.test(creds.payoutWallet)) {
+                console.log(`Using your account default payout wallet: ${creds.payoutWallet}`);
+                config.payoutWallet = creds.payoutWallet;
+            }
+            else {
+                const wallet = await promptQuestion('Enter your Base EVM payout wallet address (0x...): ');
+                if (!/^0x[a-fA-F0-9]{40}$/.test(wallet)) {
+                    console.error('❌ Invalid Ethereum/Base address format (must be 0x followed by 40 hex chars).');
+                    process.exit(1);
+                }
+                config.payoutWallet = wallet;
+            }
+        }
+    }
+    else {
+        // Interactive wizard
+        console.log(`\n⚡ No mcpaid.config.json found. Let's configure your MCP server interactively:\n`);
+        const serverId = await promptQuestion('Server slug ID (e.g. my-awesome-mcp): ');
+        if (!serverId) {
+            console.error('❌ Server ID slug is required.');
+            process.exit(1);
+        }
+        const serverName = (await promptQuestion('Friendly server name: ')) || serverId;
+        upstreamUrl = await promptQuestion('Upstream MCP URL (e.g. https://my-tunnel.trycloudflare.com/mcp or https://api.mycompany.com/mcp): ');
+        if (!upstreamUrl) {
+            console.error('❌ Upstream URL is required.');
+            process.exit(1);
+        }
+        let payoutWallet = creds?.payoutWallet;
+        if (!payoutWallet) {
+            payoutWallet = await promptQuestion('Base EVM payout wallet address (0x...): ');
+        }
+        else {
+            const useSaved = await promptQuestion(`Use your account payout wallet ${payoutWallet}? (Y/n): `);
+            if (useSaved.toLowerCase() === 'n') {
+                payoutWallet = await promptQuestion('Base EVM payout wallet address (0x...): ');
+            }
+        }
+        if (!/^0x[a-fA-F0-9]{40}$/.test(payoutWallet)) {
+            console.error('❌ Invalid Base EVM wallet address.');
+            process.exit(1);
+        }
+        const tools = [];
+        let addingTools = true;
+        console.log('\nConfigure tools:');
+        while (addingTools) {
+            const tName = await promptQuestion('Tool name (e.g. get_intel): ');
+            if (!tName)
+                break;
+            const tType = (await promptQuestion('Pricing type [fixed/free] (default: fixed): ')).toLowerCase() || 'fixed';
+            let tPrice = '0';
+            if (tType === 'fixed') {
+                tPrice = (await promptQuestion('Price in USD per call (default: 0.01): ')) || '0.01';
+            }
+            tools.push({
+                toolName: tName,
+                type: tType === 'free' ? 'free' : 'fixed',
+                priceUsd: tPrice,
+            });
+            const more = await promptQuestion('Add another tool? (y/N): ');
+            if (more.toLowerCase() !== 'y') {
+                addingTools = false;
+            }
+        }
+        if (tools.length === 0) {
+            tools.push({ toolName: 'default_tool', type: 'free', priceUsd: '0' });
+        }
+        config = {
+            serverId,
+            serverName,
+            payoutWallet,
+            network: 'base',
+            currency: 'USDC',
+            tools,
+        };
+        const saveLocal = await promptQuestion('\nSave this configuration to ./mcpaid.config.json? (Y/n): ');
+        if (saveLocal.toLowerCase() !== 'n') {
+            const fileJson = {
+                version: '1.0.0',
+                server: {
+                    id: config.serverId,
+                    name: config.serverName,
+                    upstreamUrl,
+                    payoutWallet: config.payoutWallet,
+                    network: config.network,
+                    currency: config.currency,
+                },
+                tools: config.tools.map((t) => ({
+                    name: t.toolName,
+                    type: t.type,
+                    priceUsd: t.priceUsd,
+                })),
+            };
+            writeFileSync(resolve(process.cwd(), 'mcpaid.config.json'), JSON.stringify(fileJson, null, 2), 'utf-8');
+            console.log('✅ Created mcpaid.config.json in current directory');
+        }
+    }
+    if (hasFlag(args, 'tunnel') || hasFlag(args, 'dev')) {
+        return handleDev(configPathArg);
+    }
+    const flagUpstream = getFlagValue(args, 'upstream') || getFlagValue(args, 'public-url') || getFlagValue(args, 'tunnel-url');
+    if (flagUpstream) {
+        upstreamUrl = flagUpstream;
+    }
+    if (isLocalOrPrivateHost(upstreamUrl)) {
+        console.log(`
+⚠️  Local loopback address detected for upstream MCP: "${upstreamUrl}"
+The MCPaid Edge Gateway (${gatewayUrl}) runs globally on Cloudflare and cannot directly reach "127.0.0.1" on your computer.
+
+Choose how to proceed:
+  [1] Launch MCPaid Live Dev Tunnel (Recommended: zero-config, encrypted, with security shield)
+  [2] Enter an existing public tunnel or domain URL
+  [3] Cancel
+`);
+        const opt = await promptQuestion('Select option (1/2/3, default: 1): ');
+        if (opt === '2') {
+            const tunnelInput = await promptQuestion('Enter your public tunnel URL (e.g. https://xxx.trycloudflare.com/mcp): ');
+            if (!tunnelInput || !tunnelInput.trim()) {
+                console.log('\nPublish cancelled.\n');
+                process.exit(0);
+            }
+            let formatted = tunnelInput.trim();
+            if (!formatted.startsWith('http://') && !formatted.startsWith('https://')) {
+                formatted = 'https://' + formatted;
+            }
+            try {
+                const testUrl = new URL(formatted);
+                if (testUrl.pathname === '/' || !testUrl.pathname) {
+                    try {
+                        const origPath = new URL(upstreamUrl).pathname;
+                        if (origPath && origPath !== '/') {
+                            testUrl.pathname = origPath;
+                            formatted = testUrl.toString();
+                        }
+                    }
+                    catch { }
+                }
+            }
+            catch {
+                console.error('❌ Invalid tunnel URL format.');
+                process.exit(1);
+            }
+            if (isLocalOrPrivateHost(formatted)) {
+                console.error('❌ Address is still a local/private host. A public URL is required for edge publishing.');
+                process.exit(1);
+            }
+            upstreamUrl = formatted;
+            if (candidatePath && existsSync(resolve(process.cwd(), candidatePath))) {
+                const updateLocal = await promptQuestion(`Update upstreamUrl in ${candidatePath} to "${upstreamUrl}"? (Y/n): `);
+                if (updateLocal.toLowerCase() !== 'n') {
+                    try {
+                        const rawJson = JSON.parse(readFileSync(resolve(process.cwd(), candidatePath), 'utf-8'));
+                        if (rawJson.server) {
+                            rawJson.server.upstreamUrl = upstreamUrl;
+                        }
+                        else {
+                            rawJson.upstreamUrl = upstreamUrl;
+                        }
+                        writeFileSync(resolve(process.cwd(), candidatePath), JSON.stringify(rawJson, null, 2), 'utf-8');
+                        console.log(`✅ Updated ${candidatePath} with public tunnel URL.`);
+                    }
+                    catch { }
+                }
+            }
+        }
+        else if (opt === '3') {
+            console.log('\nPublish cancelled.\n');
+            process.exit(0);
+        }
+        else {
+            // Default: Launch MCPaid Live Dev Tunnel
+            return handleDev(configPathArg);
+        }
+    }
+    console.log(`\n🚀 Publishing server "${config.serverId}" to ${gatewayUrl}...`);
+    const res = await fetch(`${gatewayUrl}/v1/servers`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${effectiveToken}`,
+        },
+        body: JSON.stringify({ config, upstreamUrl }),
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok || !data.success) {
+        console.error(`❌ Publish failed: ${data.error || JSON.stringify(data)}`);
+        process.exit(1);
+    }
+    // Update saved credentials payout wallet if not already present
+    if (creds && !creds.payoutWallet && config.payoutWallet) {
+        creds.payoutWallet = config.payoutWallet;
+        saveCredentials(creds);
+    }
+    console.log(`
+======================================================
+🎉 MCP Server Successfully Published to MCPaid!
+======================================================
+• Server ID:    ${config.serverId}
+• Name:         ${config.serverName}
+• Edge Gateway: ${gatewayUrl}/mcp/${config.serverId}
+• Upstream:     ${upstreamUrl}
+• Payout:       ${config.payoutWallet} (Base L2)
+• Configured Tools (${config.tools.length}):
+${config.tools.map((t) => `   • ${t.toolName.padEnd(20)} -> ${t.type === 'free' ? 'FREE' : `$${t.priceUsd} USDC`}`).join('\n')}
+
+📋 Agent / Client Connection:
+  npx @mcpaid/sdk bridge --gateway ${gatewayUrl}/mcp/${config.serverId}
+======================================================
+`);
+}
+async function handleServerList() {
+    const args = process.argv.slice(3);
+    const gatewayUrl = getFlagValue(args, 'gateway') || process.env.MCPAID_GATEWAY_URL || 'https://mcpaid.dev';
+    const creds = loadCredentials();
+    const token = creds?.token || process.env.MCPAID_TOKEN;
+    if (!token) {
+        console.log('❌ You must be logged in to view your registered servers.');
+        console.log('Run: npx @mcpaid/sdk login');
+        return;
+    }
+    console.log(`Fetching registered servers from ${gatewayUrl}...`);
+    const res = await fetch(`${gatewayUrl}/v1/developer/dashboard-data`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok || !data.success) {
+        console.error(`❌ Failed to fetch servers: ${data.error || JSON.stringify(data)}`);
+        return;
+    }
+    const servers = data.servers || [];
+    if (servers.length === 0) {
+        console.log(`\nNo MCP servers registered under this account yet.`);
+        console.log(`Publish your first server using: npx @mcpaid/sdk publish\n`);
+        return;
+    }
+    console.log(`
+======================================================
+🌐 Registered MCPaid Servers (${servers.length})
+======================================================`);
+    for (const s of servers) {
+        console.log(`• ID:       ${s.server_id}`);
+        console.log(`  Name:     ${s.name || s.server_id}`);
+        console.log(`  Gateway:  ${gatewayUrl}/mcp/${s.server_id}`);
+        console.log(`  Upstream: ${s.upstream_url}`);
+        console.log(`  Payout:   ${s.payout_wallet}`);
+        console.log(`  Tools:    ${(s.tools || []).map((t) => `${t.tool_name} (${t.pricing_type === 'free' ? 'FREE' : '$' + t.price_usd})`).join(', ') || 'None'}`);
+        console.log(`  Bridge:   npx @mcpaid/sdk bridge --gateway ${gatewayUrl}/mcp/${s.server_id}`);
+        console.log(`──────────────────────────────────────────────────────`);
+    }
+}
+async function handleServerRemove(targetServerId) {
+    const args = process.argv.slice(3);
+    const gatewayUrl = getFlagValue(args, 'gateway') || process.env.MCPAID_GATEWAY_URL || 'https://mcpaid.dev';
+    const isForce = args.includes('--force') || args.includes('-f') || args.includes('-y') || args.includes('--yes');
+    let serverId = targetServerId;
+    if (serverId && serverId.startsWith('-')) {
+        serverId = undefined;
+    }
+    if (!serverId) {
+        const nonFlags = args.filter(a => !a.startsWith('-') && a !== 'remove' && a !== 'rm' && a !== 'delete' && a !== 'disconnect');
+        if (nonFlags.length > 0) {
+            serverId = nonFlags[0];
+        }
+    }
+    const creds = loadCredentials();
+    const token = creds?.token || process.env.MCPAID_TOKEN;
+    if (!token) {
+        console.log('❌ You must be logged in to disconnect or remove an MCP server.');
+        console.log('Run: npx @mcpaid/sdk login');
+        return;
+    }
+    if (!serverId) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        serverId = await new Promise((res) => {
+            rl.question('Enter the ID of the MCP server to disconnect and remove: ', (ans) => {
+                rl.close();
+                res(ans.trim());
+            });
+        });
+    }
+    if (!serverId) {
+        console.error('❌ Error: Server ID is required. Example: npx @mcpaid/sdk server remove my-custom-mcp');
+        return;
+    }
+    if (!isForce) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((res) => {
+            rl.question(`⚠️  Are you sure you want to disconnect and permanently remove "${serverId}" from the MCPaid network? (y/N): `, (ans) => {
+                rl.close();
+                res(ans.trim().toLowerCase());
+            });
+        });
+        if (answer !== 'y' && answer !== 'yes') {
+            console.log('Operation cancelled.');
+            return;
+        }
+    }
+    console.log(`Disconnecting server "${serverId}" from ${gatewayUrl}...`);
+    const res = await fetch(`${gatewayUrl}/v1/servers/${encodeURIComponent(serverId)}`, {
+        method: 'DELETE',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok || !data.success) {
+        console.error(`❌ Failed to disconnect server: ${data.error || JSON.stringify(data)}`);
+        return;
+    }
+    console.log(`
+======================================================
+🗑️  MCP Server Disconnected & Removed
+======================================================
+• Server ID: ${serverId}
+• Status:    Removed from MCPaid network & account records
+• Gateway:   ${gatewayUrl}/mcp/${serverId} (Deactivated)
+======================================================
+Clean slate achieved. You can republish anytime with:
+npx @mcpaid/sdk publish
+`);
+}
+async function handleServer() {
+    const sub = process.argv[3];
+    if (sub === 'list' || sub === 'ls') {
+        return handleServerList();
+    }
+    if (sub === 'add' || sub === 'register' || sub === 'publish' || sub === 'deploy') {
+        return handlePublish(process.argv[4]);
+    }
+    if (sub === 'remove' || sub === 'rm' || sub === 'delete' || sub === 'disconnect') {
+        return handleServerRemove(process.argv[4]);
+    }
+    console.log(`
+Usage: npx @mcpaid/sdk server <command>
+
+Commands:
+  add [config-path]   Publish and monetize an MCP server on MCPaid Edge Gateway
+  list                List all MCP servers registered under your account
+  remove <server-id>  Disconnect and remove an MCP server from MCPaid network
+`);
+}
+async function handleWithdraw(amountArg) {
+    const flags = process.argv.slice(2);
+    const gatewayUrl = (getFlagValue(flags, '--gateway') || process.env.MCPAID_GATEWAY || 'https://mcpaid.dev').replace(/\/+$/, '');
+    const isYes = flags.includes('-y') || flags.includes('--yes');
+    const creds = loadCredentials();
+    if (!creds || !creds.token) {
+        console.log('\n🔒 Authentication required to withdraw developer earnings.');
+        const shouldLogin = (await promptQuestion('Would you like to sign in now? (Y/n): ')).toLowerCase();
+        if (shouldLogin === 'n' || shouldLogin === 'no') {
+            console.log('Aborted. Sign in anytime with: npx @mcpaid/sdk login');
+            return;
+        }
+        await handleLogin();
+    }
+    const updatedCreds = loadCredentials();
+    if (!updatedCreds || !updatedCreds.token) {
+        console.error('❌ You must be authenticated to request withdrawals.');
+        return;
+    }
+    console.log(`\nConnecting to MCPaid Edge Gateway (${gatewayUrl})...`);
+    const sessionRes = await fetch(`${gatewayUrl}/v1/developer/dashboard-data`, {
+        headers: { Authorization: `Bearer ${updatedCreds.token}` },
+    });
+    const sessionData = (await sessionRes.json().catch(() => ({})));
+    if (!sessionRes.ok || !sessionData.success) {
+        console.error(`❌ Failed to retrieve balance: ${sessionData.error || 'Unauthorized'}`);
+        return;
+    }
+    const user = sessionData.user;
+    const balance = sessionData.balance || { availableBalanceMicro: 0 };
+    const availMicro = Number(balance.availableBalanceMicro || 0);
+    const availUsdc = (availMicro / 1_000_000).toFixed(4);
+    if (!user.payoutWallet) {
+        console.error('❌ No Base L2 payout wallet configured on your account.');
+        console.log('Please configure your payout wallet in the dashboard (https://mcpaid.dev/dashboard).');
+        return;
+    }
+    if (availMicro <= 0) {
+        console.log(`\nℹ️  No available balance to withdraw.`);
+        console.log(`• Available Balance:   $${availUsdc} USDC`);
+        console.log(`• Total Gross Volume:  $${((balance.totalGrossMicro || 0) / 1_000_000).toFixed(4)} USDC`);
+        console.log(`• Payout Wallet:       ${user.payoutWallet}`);
+        console.log(`\nInvocations from remote AI agents will credit your balance automatically.\n`);
+        return;
+    }
+    let toWithdrawMicro = availMicro;
+    if (amountArg && !amountArg.startsWith('-')) {
+        const parsedUsd = parseFloat(amountArg);
+        if (isNaN(parsedUsd) || parsedUsd <= 0) {
+            console.error(`❌ Invalid withdrawal amount: "${amountArg}". Example: npx @mcpaid/sdk withdraw 10.00`);
+            return;
+        }
+        toWithdrawMicro = Math.round(parsedUsd * 1_000_000);
+        if (toWithdrawMicro > availMicro) {
+            console.error(`❌ Requested withdrawal ($${parsedUsd.toFixed(4)}) exceeds available balance ($${availUsdc}).`);
+            return;
+        }
+    }
+    const withdrawAmountUsdc = (toWithdrawMicro / 1_000_000).toFixed(4);
+    console.log(`
+======================================================
+💸 MCPaid Payout Withdrawal
+======================================================
+• Available Balance:   $${availUsdc} USDC
+• Amount to Withdraw:  $${withdrawAmountUsdc} USDC
+• Network:             Base Mainnet (Chain ID 8453)
+• Destination Wallet:  ${user.payoutWallet}
+• Protocol Fee:        0.00% (Free)
+======================================================
+`);
+    if (!isYes) {
+        const confirmAns = (await promptQuestion(`Proceed with withdrawal of $${withdrawAmountUsdc} USDC to Base L2? (Y/n): `)).toLowerCase();
+        if (confirmAns === 'n' || confirmAns === 'no') {
+            console.log('Withdrawal cancelled.');
+            return;
+        }
+    }
+    console.log(`Submitting withdrawal request to Base L2 settlement pipeline...`);
+    const res = await fetch(`${gatewayUrl}/v1/developer/withdraw`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${updatedCreds.token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ amountMicro: toWithdrawMicro }),
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok || !data.success) {
+        console.error(`❌ Withdrawal failed: ${data.error || JSON.stringify(data)}`);
+        return;
+    }
+    const w = data.withdrawal;
+    console.log(`
+======================================================
+✅ Withdrawal Successfully Dispatched!
+======================================================
+• Withdrawal ID:   ${w.id}
+• Amount:          $${(w.amountMicro / 1_000_000).toFixed(4)} USDC
+• Status:          ${w.status.toUpperCase()} (Queued for Settlement Batch)
+• Destination:     ${w.developerWallet}
+• BaseScan:        https://basescan.org/address/${w.developerWallet}
+======================================================
+Your available balance has been updated. View past withdrawals with:
+npx @mcpaid/sdk withdrawals
+`);
+}
+async function handleWithdrawals() {
+    const flags = process.argv.slice(2);
+    const gatewayUrl = (getFlagValue(flags, '--gateway') || process.env.MCPAID_GATEWAY || 'https://mcpaid.dev').replace(/\/+$/, '');
+    const creds = loadCredentials();
+    if (!creds || !creds.token) {
+        console.error('❌ You must be authenticated to view withdrawals. Run: npx @mcpaid/sdk login');
+        return;
+    }
+    const res = await fetch(`${gatewayUrl}/v1/developer/withdrawals`, {
+        headers: { Authorization: `Bearer ${creds.token}` },
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok || !data.success) {
+        console.error(`❌ Failed to retrieve withdrawals: ${data.error || 'Error'}`);
+        return;
+    }
+    const list = data.withdrawals || [];
+    console.log(`
+======================================================
+📋 Base L2 Payout & Withdrawal History (${list.length})
+======================================================`);
+    if (list.length === 0) {
+        console.log('No withdrawal requests recorded yet. Withdraw anytime with:');
+        console.log('npx @mcpaid/sdk withdraw');
+        console.log('======================================================\n');
+        return;
+    }
+    for (const w of list) {
+        const date = new Date(w.createdAt || w.created_at).toLocaleString();
+        const amount = `$${(w.amountMicro / 1_000_000).toFixed(4)} USDC`;
+        const status = (w.status || 'processing').toUpperCase();
+        console.log(`• [${status}] ${amount} -> ${w.developerWallet}`);
+        console.log(`  ID: ${w.id} | Date: ${date}`);
+        if (w.txHash) {
+            console.log(`  TxHash:  https://basescan.org/tx/${w.txHash}`);
+        }
+        else {
+            console.log(`  Address: https://basescan.org/address/${w.developerWallet}`);
+        }
+        console.log('');
+    }
+    console.log('======================================================\n');
+}
+async function handleRelayer() {
+    const flags = process.argv.slice(2);
+    const isRunLocal = flags.includes('--run') || flags.includes('-r');
+    if (isRunLocal && process.env.MCPAID_OPERATOR !== '1') {
+        console.log(`
+======================================================
+⛔ Operator-only command
+======================================================
+Manual settlement runs disburse real on-chain funds and are
+reserved for gateway operators under OPERATOR-LICENSE.md.
+
+The hosted mcpaid.dev relayer settles automatically every
+60 seconds — developers do not need this command. If you
+operate your own gateway under an operator agreement, re-run
+with MCPAID_OPERATOR=1.
+======================================================
+`);
+        process.exit(1);
+    }
+    if (!isRunLocal) {
+        console.log(`
+======================================================
+⏱️  MCPaid Automated Base L2 Settlement Relayer
+======================================================
+• Schedule:       Runs automatically EVERY 1 MINUTE (* * * * *)
+• Execution:      Isolated Cloudflare Edge Cron Trigger
+• Security:       HTTP triggers are disabled. Only internal cron
+                  triggers or verified local operator scripts can
+                  disburse on-chain funds.
+• Operator Mode:  To run a manual settlement cycle directly using
+                  your local relayer credentials:
+                  npx @mcpaid/sdk relayer --run
+======================================================
+`);
+        return;
+    }
+    console.log(`\nExecuting local Base L2 settlement relayer...`);
+    const scriptPath = resolve(fileURLToPath(import.meta.url), '../../scripts/settle-withdrawals.ts');
+    if (existsSync(scriptPath)) {
+        const child = spawn('npx', ['tsx', scriptPath], { stdio: 'inherit' });
+        child.on('exit', (code) => {
+            if (code !== 0)
+                process.exit(code || 1);
+        });
+    }
+    else {
+        console.log(`Error: Settlement script not found at ${scriptPath}`);
+    }
+}
+export async function runCli() {
+    const command = process.argv[2];
+    switch (command) {
+        case 'init':
+            await handleInit();
+            break;
+        case 'validate':
+            await handleValidate(process.argv[3]);
+            break;
+        case 'start':
+            await handleStart(process.argv[3]);
+            break;
+        case 'dev':
+            await handleDev(process.argv[3]);
+            break;
+        case 'agent-proxy':
+        case 'bridge':
+            await handleBridge();
+            break;
+        case 'wallet':
+            await handleWallet(process.argv[3]);
+            break;
+        case 'login':
+        case 'auth':
+        case 'signin':
+            await handleLogin();
+            break;
+        case 'logout':
+        case 'signout':
+            await handleLogout();
+            break;
+        case 'whoami':
+            await handleWhoami();
+            break;
+        case 'publish':
+        case 'deploy':
+            await handlePublish(process.argv[3]);
+            break;
+        case 'tunnel':
+            await handleTunnel(process.argv[3]);
+            break;
+        case 'remove':
+        case 'disconnect':
+        case 'rm':
+            await handleServerRemove(process.argv[3]);
+            break;
+        case 'server':
+        case 'servers':
+            await handleServer();
+            break;
+        case 'withdraw':
+        case 'payout':
+            await handleWithdraw(process.argv[3]);
+            break;
+        case 'withdrawals':
+        case 'payouts':
+            await handleWithdrawals();
+            break;
+        case 'relayer':
+        case 'settle':
+            await handleRelayer();
+            break;
+        default:
+            printHelp();
+            break;
+    }
+}
+if (process.argv[1]) {
+    try {
+        const realArgv1 = existsSync(process.argv[1]) ? realpathSync(process.argv[1]) : resolve(process.argv[1]);
+        if (realArgv1 === fileURLToPath(import.meta.url)) {
+            runCli().catch((err) => {
+                console.error(`Fatal error: ${err.message}`);
+                process.exit(1);
+            });
+        }
+    }
+    catch {
+        if (resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+            runCli().catch((err) => {
+                console.error(`Fatal error: ${err.message}`);
+                process.exit(1);
+            });
+        }
+    }
+}
+//# sourceMappingURL=cli.js.map