@x402scan/mcp 0.0.7-beta.4 → 0.0.7

package/dist/esm/index.js

@@ -1,9 +1,2654 @@
 #!/usr/bin/env node
-import "./chunk-Q2QVXJFE.js";
+import z$1, { z } from 'zod';
+import { getAddress, formatUnits } from 'viem';
+import path2, { join } from 'path';
+import os, { homedir } from 'os';
+import * as fs from 'fs';
+import fs__default, { appendFileSync } from 'fs';
+import { polygon, arbitrum, optimism, sepolia, mainnet, baseSepolia, base } from 'viem/chains';
+import { intro, outro, log as log$1, confirm, stream, spinner, select, text } from '@clack/prompts';
+import { errAsync, ResultAsync, err } from 'neverthrow';
+import chalk from 'chalk';
+import open from 'open';
+import { x402HTTPClient, x402Client } from '@x402/core/client';
+import { ExactEvmScheme } from '@x402/evm/exact/client';
+import { wrapFetchWithPayment } from '@x402/fetch';
+import { base58 } from '@scure/base';
+import 'tweetnacl';
+import { SiweMessage } from 'siwe';
+import { safeBase64Encode } from '@x402/core/utils';
+import 'url';
+import { randomBytes } from 'crypto';
+import * as fs3 from 'fs/promises';
+import { privateKeyToAccount } from 'viem/accounts';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import process2 from 'process';
+import * as TOML from '@iarna/toml';
+import yaml from 'js-yaml';
+import * as jsonc from 'jsonc-parser';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/install/clients.ts
+var Clients, clientMetadata;
+var init_clients = __esm({
+  "src/install/clients.ts"() {
+    Clients = /* @__PURE__ */ ((Clients2) => {
+      Clients2["ClaudeCode"] = "claude-code";
+      Clients2["Cursor"] = "cursor";
+      Clients2["Claude"] = "claude";
+      Clients2["Codex"] = "codex";
+      Clients2["Vscode"] = "vscode";
+      Clients2["Cline"] = "cline";
+      Clients2["RooCline"] = "roo-cline";
+      Clients2["Windsurf"] = "windsurf";
+      Clients2["Warp"] = "warp";
+      Clients2["GeminiCli"] = "gemini-cli";
+      Clients2["Goose"] = "goose";
+      Clients2["Zed"] = "zed";
+      Clients2["Opencode"] = "opencode";
+      return Clients2;
+    })(Clients || {});
+    clientMetadata = {
+      ["claude-code" /* ClaudeCode */]: {
+        name: "Claude Code",
+        description: "Claude Code is a code editor that uses the Claude API.",
+        website: "https://claude.com"
+      },
+      ["cursor" /* Cursor */]: {
+        name: "Cursor",
+        description: "Cursor is a code editor that uses the Cursor API.",
+        website: "https://cursor.com"
+      },
+      ["claude" /* Claude */]: {
+        name: "Claude Desktop",
+        description: "Claude is a code editor that uses the Claude API.",
+        website: "https://claude.com"
+      },
+      ["codex" /* Codex */]: {
+        name: "Codex",
+        description: "Codex is a code editor that uses the Codex API.",
+        website: "https://codex.com"
+      },
+      ["vscode" /* Vscode */]: {
+        name: "VSCode",
+        description: "VSCode is a code editor that uses the VSCode API.",
+        website: "https://vscode.com"
+      },
+      ["cline" /* Cline */]: {
+        name: "Cline",
+        description: "Cline is a code editor that uses the Cline API.",
+        website: "https://cline.com"
+      },
+      ["roo-cline" /* RooCline */]: {
+        name: "RooCline",
+        description: "RooCline is a code editor that uses the RooCline API.",
+        website: "https://roo-cline.com"
+      },
+      ["windsurf" /* Windsurf */]: {
+        name: "Windsurf",
+        description: "Windsurf is a code editor that uses the Windsurf API.",
+        website: "https://windsurf.com"
+      },
+      ["warp" /* Warp */]: {
+        name: "Warp",
+        description: "Warp is a code editor that uses the Warp API.",
+        website: "https://warp.com"
+      },
+      ["gemini-cli" /* GeminiCli */]: {
+        name: "Gemini CLI",
+        description: "Gemini CLI is a code editor that uses the Gemini CLI API.",
+        website: "https://gemini-cli.com"
+      },
+      ["goose" /* Goose */]: {
+        name: "Goose",
+        description: "Goose is a code editor that uses the Goose API.",
+        website: "https://goose.com"
+      },
+      ["zed" /* Zed */]: {
+        name: "Zed",
+        description: "Zed is a code editor that uses the Zed API.",
+        website: "https://zed.com"
+      },
+      ["opencode" /* Opencode */]: {
+        name: "Opencode",
+        description: "Opencode is a code editor that uses the Opencode API.",
+        website: "https://opencode.com"
+      }
+    };
+  }
+});
+
+// src/server/lib/response.ts
+var mcpSuccess, mcpError;
+var init_response = __esm({
+  "src/server/lib/response.ts"() {
+    mcpSuccess = (data) => {
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    };
+    mcpError = (error, context) => {
+      const message = error instanceof Error ? error.message : typeof error === "string" ? error : String(error);
+      const details = error instanceof Error && error.cause ? { cause: JSON.stringify(error.cause) } : void 0;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                error: message,
+                ...details && { details },
+                ...context && { context }
+              },
+              null,
+              2
+            )
+          }
+        ],
+        isError: true
+      };
+    };
+  }
+});
+var ethereumAddressSchema, ethereumPrivateKeySchema, requestSchema, requestWithHeadersSchema;
+var init_schemas = __esm({
+  "src/server/lib/schemas.ts"() {
+    ethereumAddressSchema = z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address").transform((address) => getAddress(address));
+    ethereumPrivateKeySchema = z$1.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid Ethereum private key").transform((privateKey) => privateKey);
+    requestSchema = z$1.object({
+      url: z$1.url().describe("The endpoint URL"),
+      method: z$1.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).default("GET").describe("HTTP method"),
+      body: z$1.unknown().optional().describe("Request body for POST/PUT/PATCH methods")
+    });
+    requestWithHeadersSchema = requestSchema.extend({
+      headers: z$1.record(z$1.string(), z$1.string()).optional().describe("Additional headers to include").default({})
+    });
+  }
+});
+
+// src/server/types.ts
+var init_types = __esm({
+  "src/server/types.ts"() {
+  }
+});
+var BASE_DIRECTORY, configFile;
+var init_fs = __esm({
+  "src/lib/fs.ts"() {
+    BASE_DIRECTORY = join(homedir(), ".x402scan-mcp");
+    if (!fs.existsSync(BASE_DIRECTORY)) {
+      fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+    }
+    configFile = (name) => {
+      if (!fs.existsSync(BASE_DIRECTORY)) {
+        fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+      }
+      const filePath = join(BASE_DIRECTORY, name);
+      if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, "{}");
+      }
+      return filePath;
+    };
+  }
+});
+function format(args) {
+  return args.map(
+    (a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)
+  ).join(" ");
+}
+function write(level, msg, args) {
+  const formatted = args.length ? `${msg} ${format(args)}` : msg;
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${formatted}
+`;
+  try {
+    appendFileSync(LOG_FILE, line);
+  } catch {
+  }
+  if (process.env.X402_DEBUG === "true") {
+    console.error(`[x402scan] ${formatted}`);
+  }
+}
+var LOG_FILE, DEBUG, log;
+var init_log = __esm({
+  "src/lib/log.ts"() {
+    init_fs();
+    LOG_FILE = configFile("mcp.log");
+    DEBUG = process.env.X402_DEBUG === "true";
+    log = {
+      info: (msg, ...args) => write("INFO", msg, args),
+      error: (msg, ...args) => write("ERROR", msg, args),
+      debug: (msg, ...args) => DEBUG && write("DEBUG", msg, args),
+      path: LOG_FILE
+    };
+  }
+});
+function toCaip2(network) {
+  if (network.startsWith("eip155:")) return network;
+  return V1_TO_CAIP2[network.toLowerCase()] ?? network;
+}
+function getChainConfig(network) {
+  return CHAIN_CONFIGS[toCaip2(network)];
+}
+function getChainName(network) {
+  return getChainConfig(network)?.chain.name ?? network;
+}
+var CHAIN_CONFIGS, V1_TO_CAIP2, DEFAULT_NETWORK;
+var init_networks = __esm({
+  "src/lib/networks.ts"() {
+    CHAIN_CONFIGS = {
+      "eip155:8453": {
+        chain: base,
+        caip2: "eip155:8453",
+        v1Name: "base",
+        usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+      },
+      "eip155:84532": {
+        chain: baseSepolia,
+        caip2: "eip155:84532",
+        v1Name: "base-sepolia",
+        usdcAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+      },
+      "eip155:1": {
+        chain: mainnet,
+        caip2: "eip155:1",
+        v1Name: "ethereum",
+        usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+      },
+      "eip155:11155111": {
+        chain: sepolia,
+        caip2: "eip155:11155111",
+        v1Name: "ethereum-sepolia",
+        usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+      },
+      "eip155:10": {
+        chain: optimism,
+        caip2: "eip155:10",
+        v1Name: "optimism",
+        usdcAddress: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85"
+      },
+      "eip155:42161": {
+        chain: arbitrum,
+        caip2: "eip155:42161",
+        v1Name: "arbitrum",
+        usdcAddress: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+      },
+      "eip155:137": {
+        chain: polygon,
+        caip2: "eip155:137",
+        v1Name: "polygon",
+        usdcAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+      }
+    };
+    V1_TO_CAIP2 = {
+      base: "eip155:8453",
+      "base-sepolia": "eip155:84532",
+      ethereum: "eip155:1",
+      "ethereum-sepolia": "eip155:11155111",
+      optimism: "eip155:10",
+      arbitrum: "eip155:42161",
+      polygon: "eip155:137"
+    };
+    DEFAULT_NETWORK = "eip155:8453";
+  }
+});
+var tokenStringToNumber;
+var init_token = __esm({
+  "src/lib/token.ts"() {
+    tokenStringToNumber = (amount, decimals = 6) => {
+      return Number(formatUnits(BigInt(amount), decimals));
+    };
+  }
+});
+
+// src/lib/utils.ts
+var getBaseUrl;
+var init_utils = __esm({
+  "src/lib/utils.ts"() {
+    getBaseUrl = (dev) => {
+      return dev ? "http://localhost:3000" : "https://x402scan.com";
+    };
+  }
+});
+async function getUSDCBalance(address, flags) {
+  const url = `${getBaseUrl(flags.dev)}/api/rpc/balance/${address}`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      accept: "application/json"
+    }
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Balance API request failed (${res.status} ${res.statusText})`
+    );
+  }
+  let json;
+  try {
+    json = await res.json();
+  } catch {
+    throw new Error(
+      `Failed to parse balance API response as JSON (${res.status} ${res.statusText})`
+    );
+  }
+  const result = balanceApiResponseSchema.safeParse(json);
+  if (!result.success) {
+    throw new Error(
+      `Failed to safeParse balance API response (${res.status} ${res.statusText})`
+    );
+  }
+  return {
+    balanceFormatted: result.data.balance,
+    balanceRaw: result.data.rawBalance
+  };
+}
+var balanceApiResponseSchema;
+var init_balance = __esm({
+  "src/lib/balance.ts"() {
+    init_utils();
+    balanceApiResponseSchema = z.object({
+      address: z.string(),
+      chain: z.number().int(),
+      balance: z.coerce.number(),
+      rawBalance: z.string()
+    });
+  }
+});
+var wait;
+var init_wait = __esm({
+  "src/lib/wait.ts"() {
+    wait = async ({ startText, stopText, ms }) => {
+      const { start: startSpinner, stop: stopSpinner } = spinner();
+      startSpinner(startText);
+      await new Promise((resolve) => setTimeout(resolve, ms));
+      stopSpinner(stopText);
+    };
+  }
+});
+function safeFetch(input, init) {
+  return ResultAsync.fromPromise(
+    fetch(input, init),
+    (error) => ({
+      type: "network",
+      message: "Network error",
+      error: error instanceof Error ? error : new Error(String(error))
+    })
+  );
+}
+var safeFetchJson;
+var init_safe_fetch = __esm({
+  "src/lib/safe-fetch.ts"() {
+    safeFetchJson = (input, init, errorMessage) => {
+      return safeFetch(input, init).andThen((response) => {
+        if (!response.ok) {
+          return ResultAsync.fromSafePromise(
+            response.json().catch(() => void 0)
+          ).andThen(
+            (json) => err({
+              type: "http",
+              message: json !== void 0 && errorMessage ? errorMessage(json) : response.statusText,
+              status: response.status,
+              headers: response.headers,
+              json
+            })
+          );
+        }
+        return ResultAsync.fromPromise(
+          response.json(),
+          (error) => ({
+            type: "parse",
+            message: "Could not parse JSON from response",
+            error: error instanceof Error ? error : new Error(String(error))
+          })
+        );
+      });
+    };
+  }
+});
+var STATE_FILE, stateSchema, getState, setState;
+var init_state = __esm({
+  "src/lib/state.ts"() {
+    init_fs();
+    init_log();
+    STATE_FILE = configFile("state.json");
+    stateSchema = z$1.looseObject({
+      redeemedCodes: z$1.array(z$1.string())
+    }).partial();
+    getState = () => {
+      if (!fs__default.existsSync(STATE_FILE)) {
+        fs__default.writeFileSync(STATE_FILE, JSON.stringify({}));
+        return {};
+      }
+      const result = stateSchema.safeParse(
+        JSON.parse(fs__default.readFileSync(STATE_FILE, "utf-8"))
+      );
+      if (!result.success) {
+        log.error("Failed to parse state", { error: result.error });
+        return {};
+      }
+      return result.data;
+    };
+    setState = (state) => {
+      const existing = getState();
+      const newState = stateSchema.parse({ ...existing, ...state });
+      fs__default.writeFileSync(STATE_FILE, JSON.stringify(newState, null, 2));
+    };
+  }
+});
+var redeemInviteCode;
+var init_redeem_invite = __esm({
+  "src/lib/redeem-invite.ts"() {
+    init_safe_fetch();
+    init_utils();
+    init_state();
+    redeemInviteCode = async ({
+      code,
+      dev,
+      address
+    }) => {
+      const state = getState();
+      if (state.redeemedCodes?.includes(code)) {
+        return Promise.resolve(
+          errAsync({
+            success: false,
+            message: "This invite code has already been redeemed"
+          })
+        );
+      }
+      return await safeFetchJson(
+        `${getBaseUrl(dev)}/api/invite/redeem`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            code,
+            recipientAddr: address
+          })
+        },
+        ({ message }) => message
+      ).andTee((result) => {
+        if (result.success) {
+          setState({
+            redeemedCodes: [...state.redeemedCodes ?? [], code]
+          });
+        }
+      });
+    };
+  }
+});
+var getDepositLink, openDepositLink, redeemInviteCodePrompt, promptDeposit;
+var init_deposit = __esm({
+  "src/lib/deposit.ts"() {
+    init_networks();
+    init_wait();
+    init_redeem_invite();
+    init_utils();
+    getDepositLink = (address, flags) => {
+      return `${getBaseUrl(flags.dev)}/mcp/deposit/${address}`;
+    };
+    openDepositLink = async (address, flags) => {
+      const depositLink = getDepositLink(address, flags);
+      await open(depositLink);
+    };
+    redeemInviteCodePrompt = async (address, flags) => {
+      const code = await text({
+        message: "Enter your invite code",
+        placeholder: "MRT-XXXXX",
+        validate: (value) => {
+          if (!value || value.trim().length === 0) {
+            return "Please enter an invite code";
+          }
+        }
+      });
+      if (typeof code !== "string") {
+        return false;
+      }
+      const s = spinner();
+      s.start("Redeeming invite code...");
+      const result = await redeemInviteCode({ code, dev: flags.dev, address });
+      return result.match(
+        async ({ data: { amount, txHash } }) => {
+          s.stop("Invite code redeemed successfully!");
+          await wait({
+            startText: "Processing...",
+            stopText: chalk.green(
+              `${chalk.bold(amount)} USDC has been sent to your wallet!`
+            ),
+            ms: 1500
+          });
+          log$1.success(
+            chalk.bold(`Your wallet has been funded with ${amount} USDC`)
+          );
+          if (txHash) {
+            log$1.info(chalk.dim(`Transaction: https://basescan.org/tx/${txHash}`));
+          }
+          return true;
+        },
+        (error) => {
+          s.stop("Invite code redemption failed");
+          log$1.warning(
+            chalk.yellow(`Failed to redeem invite code: ${error?.message}`)
+          );
+          return false;
+        }
+      );
+    };
+    promptDeposit = async (address, flags) => {
+      const depositLink = getDepositLink(address, flags);
+      const depositChoice = flags.yes ? "manual" : await select({
+        message: chalk.bold("How would you like to deposit?"),
+        initialValue: "guided",
+        options: [
+          {
+            label: "Guided - Recommended",
+            value: "guided",
+            hint: "Online portal in x402scan"
+          },
+          {
+            label: "Manual",
+            value: "manual",
+            hint: "Print deposit instructions"
+          },
+          {
+            label: "Redeem Invite Code",
+            value: "invite",
+            hint: "Enter an invite code for starter money"
+          },
+          {
+            label: "Skip",
+            value: void 0,
+            hint: "Skip deposit process - functionality limited"
+          }
+        ]
+      });
+      if (depositChoice === "guided") {
+        await wait({
+          startText: "Opening deposit page...",
+          stopText: `Opening ${chalk.underline.hex("#2563eb")(depositLink)}`,
+          ms: 1e3
+        });
+        await open(depositLink);
+      } else if (depositChoice === "manual") {
+        log$1.step(chalk.bold("Account Information"));
+        log$1.message(`Address: ${address}`);
+        log$1.message(`Network: ${getChainName(DEFAULT_NETWORK)}`);
+        log$1.step(chalk.bold("Online Portal"));
+        log$1.message(`${chalk.underline(depositLink)}`);
+      } else if (depositChoice === "invite") {
+        const redeemed = await redeemInviteCodePrompt(address, flags);
+        if (!redeemed) {
+          await promptDeposit(address, flags);
+        }
+      }
+    };
+  }
+});
+
+// src/server/lib/check-balance.ts
+var checkBalance;
+var init_check_balance = __esm({
+  "src/server/lib/check-balance.ts"() {
+    init_balance();
+    init_deposit();
+    checkBalance = async ({
+      server,
+      address,
+      amountNeeded,
+      message,
+      flags
+    }) => {
+      const { balanceFormatted } = await getUSDCBalance(address, flags);
+      if (balanceFormatted < amountNeeded) {
+        const capabilities = server.server.getClientCapabilities();
+        if (!capabilities?.elicitation) {
+          throw new Error(
+            `${message(balanceFormatted)}
+
+You can deposit USDC at ${getDepositLink(address, flags)}`
+          );
+        }
+        const result = await server.server.elicitInput({
+          mode: "form",
+          message: message(balanceFormatted),
+          requestedSchema: {
+            type: "object",
+            properties: {}
+          }
+        });
+        if (result.action === "accept") {
+          await openDepositLink(address, flags);
+        }
+      }
+      return balanceFormatted;
+    };
+  }
+});
+
+// src/server/lib/parse-response.ts
+var parseResponse;
+var init_parse_response = __esm({
+  "src/server/lib/parse-response.ts"() {
+    parseResponse = async (response) => {
+      try {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+          return await response.json();
+        } else if (contentType.includes("image/")) {
+          return await response.arrayBuffer();
+        } else {
+          return await response.text();
+        }
+      } catch {
+        return void 0;
+      }
+    };
+  }
+});
+var registerFetchX402ResourceTool;
+var init_fetch_x402_resource = __esm({
+  "src/server/tools/fetch-x402-resource.ts"() {
+    init_response();
+    init_schemas();
+    init_types();
+    init_log();
+    init_networks();
+    init_token();
+    init_check_balance();
+    init_parse_response();
+    registerFetchX402ResourceTool = ({
+      server,
+      account,
+      flags,
+      sessionId
+    }) => {
+      server.registerTool(
+        "fetch",
+        {
+          description: "Fetches an x402-protected resource and handles payment automatically. If the resource is not x402-protected, it will return the raw response.",
+          inputSchema: requestWithHeadersSchema
+        },
+        async ({ url, method, body, headers }) => {
+          const coreClient = x402Client.fromConfig({
+            schemes: [
+              { network: DEFAULT_NETWORK, client: new ExactEvmScheme(account) }
+            ]
+          });
+          let state = "initial_request" /* INITIAL_REQUEST */;
+          coreClient.onBeforePaymentCreation(async ({ selectedRequirements }) => {
+            const amount = tokenStringToNumber(selectedRequirements.amount);
+            await checkBalance({
+              server,
+              address: account.address,
+              amountNeeded: amount,
+              message: (balance) => `This request costs ${amount} USDC. Your current balance is ${balance} USDC.`,
+              flags
+            });
+            state = "payment_required" /* PAYMENT_REQUIRED */;
+          });
+          coreClient.onAfterPaymentCreation(async (ctx) => {
+            state = "payment_created" /* PAYMENT_CREATED */;
+            log.info("After payment creation", ctx);
+            return Promise.resolve();
+          });
+          coreClient.onPaymentCreationFailure(async (ctx) => {
+            state = "payment_failed" /* PAYMENT_FAILED */;
+            log.info("Payment creation failure", ctx);
+            return Promise.resolve();
+          });
+          const client = new x402HTTPClient(coreClient);
+          const fetchWithPay = wrapFetchWithPayment(fetch, client);
+          try {
+            const response = await fetchWithPay(url, {
+              method,
+              body: typeof body === "string" ? body : body ? JSON.stringify(body) : void 0,
+              headers: {
+                ...body ? { "Content-Type": "application/json" } : {},
+                "X-Wallet-Address": account.address,
+                "X-Client-ID": account.address,
+                "X-Session-ID": sessionId,
+                ...headers
+              }
+            });
+            if (!response.ok) {
+              const errorResponse = {
+                data: await parseResponse(response),
+                statusCode: response.status,
+                state
+              };
+              if (response.status === 402) {
+                return mcpError("Payment required", errorResponse);
+              }
+              return mcpError(
+                response.statusText ?? "Request failed",
+                errorResponse
+              );
+            }
+            const getSettlement = () => {
+              try {
+                return client.getPaymentSettleResponse(
+                  (name) => response.headers.get(name)
+                );
+              } catch {
+                return void 0;
+              }
+            };
+            const settlement = getSettlement();
+            return mcpSuccess({
+              data: await parseResponse(response),
+              payment: settlement
+            });
+          } catch (err2) {
+            return mcpError(err2, { state });
+          }
+        }
+      );
+    };
+  }
+});
+
+// src/server/lib/x402/protocol.ts
+function isV1Response(pr) {
+  if (!pr || typeof pr !== "object") return false;
+  const obj = pr;
+  if (obj.x402Version === 1) return true;
+  const accepts = obj.accepts;
+  if (Array.isArray(accepts) && accepts.length > 0) {
+    return "maxAmountRequired" in accepts[0];
+  }
+  return false;
+}
+function normalizeV1Requirement(req) {
+  if (!req.maxAmountRequired) {
+    throw new Error("v1 requirement missing maxAmountRequired field");
+  }
+  return {
+    scheme: req.scheme,
+    network: req.network,
+    amount: req.maxAmountRequired,
+    asset: req.asset,
+    payTo: req.payTo,
+    maxTimeoutSeconds: req.maxTimeoutSeconds,
+    extra: req.extra,
+    resource: req.resource,
+    description: req.description,
+    mimeType: req.mimeType
+  };
+}
+function normalizeV2Requirement(req) {
+  if (!req.amount) {
+    throw new Error("v2 requirement missing amount field");
+  }
+  return {
+    scheme: req.scheme,
+    network: req.network,
+    amount: req.amount,
+    asset: req.asset,
+    payTo: req.payTo,
+    maxTimeoutSeconds: req.maxTimeoutSeconds,
+    extra: req.extra
+  };
+}
+function normalizePaymentRequired(pr) {
+  const version = pr.x402Version ?? 1;
+  if (isV1Response(pr)) {
+    const v1 = pr;
+    return {
+      x402Version: 1,
+      error: v1.error,
+      accepts: v1.accepts.map(normalizeV1Requirement)
+    };
+  }
+  const v2 = pr;
+  return {
+    x402Version: version,
+    error: v2.error,
+    accepts: v2.accepts.map(normalizeV2Requirement),
+    resource: v2.resource,
+    extensions: v2.extensions
+  };
+}
+var init_protocol = __esm({
+  "src/server/lib/x402/protocol.ts"() {
+  }
+});
+function extractSolanaChainReference(chainId) {
+  const [, reference] = chainId.split(":");
+  return reference;
+}
+function formatSIWSMessage(info, address) {
+  const lines = [
+    `${info.domain} wants you to sign in with your Solana account:`,
+    address,
+    ""
+  ];
+  if (info.statement) {
+    lines.push(info.statement, "");
+  }
+  lines.push(
+    `URI: ${info.uri}`,
+    `Version: ${info.version}`,
+    `Chain ID: ${extractSolanaChainReference(info.chainId)}`,
+    `Nonce: ${info.nonce}`,
+    `Issued At: ${info.issuedAt}`
+  );
+  if (info.expirationTime) {
+    lines.push(`Expiration Time: ${info.expirationTime}`);
+  }
+  if (info.notBefore) {
+    lines.push(`Not Before: ${info.notBefore}`);
+  }
+  if (info.requestId) {
+    lines.push(`Request ID: ${info.requestId}`);
+  }
+  if (info.resources && info.resources.length > 0) {
+    lines.push("Resources:");
+    for (const resource of info.resources) {
+      lines.push(`- ${resource}`);
+    }
+  }
+  return lines.join("\n");
+}
+function encodeBase58(bytes) {
+  return base58.encode(bytes);
+}
+var init_solana = __esm({
+  "src/server/vendor/sign-in-with-x/solana.ts"() {
+  }
+});
+
+// src/server/vendor/sign-in-with-x/sign.ts
+function getEVMAddress(signer) {
+  if (signer.account?.address) {
+    return signer.account.address;
+  }
+  if (signer.address) {
+    return signer.address;
+  }
+  throw new Error("EVM signer missing address");
+}
+function getSolanaAddress(signer) {
+  const pk = signer.publicKey;
+  return typeof pk === "string" ? pk : pk.toBase58();
+}
+async function signEVMMessage(message, signer) {
+  if (signer.account) {
+    return signer.signMessage({ message, account: signer.account });
+  }
+  return signer.signMessage({ message });
+}
+async function signSolanaMessage(message, signer) {
+  const messageBytes = new TextEncoder().encode(message);
+  const signatureBytes = await signer.signMessage(messageBytes);
+  return encodeBase58(signatureBytes);
+}
+var init_sign = __esm({
+  "src/server/vendor/sign-in-with-x/sign.ts"() {
+    init_solana();
+  }
+});
+function extractEVMChainId(chainId) {
+  const match = /^eip155:(\d+)$/.exec(chainId);
+  if (!match) {
+    throw new Error(
+      `Invalid EVM chainId format: ${chainId}. Expected eip155:<number>`
+    );
+  }
+  return parseInt(match[1], 10);
+}
+function formatSIWEMessage(info, address) {
+  const numericChainId = extractEVMChainId(info.chainId);
+  const siweMessage = new SiweMessage({
+    domain: info.domain,
+    address,
+    statement: info.statement,
+    uri: info.uri,
+    version: info.version,
+    chainId: numericChainId,
+    nonce: info.nonce,
+    issuedAt: info.issuedAt,
+    expirationTime: info.expirationTime,
+    notBefore: info.notBefore,
+    requestId: info.requestId,
+    resources: info.resources
+  });
+  return siweMessage.prepareMessage();
+}
+var init_evm = __esm({
+  "src/server/vendor/sign-in-with-x/evm.ts"() {
+  }
+});
+
+// src/server/vendor/sign-in-with-x/message.ts
+function createSIWxMessage(serverInfo, address) {
+  if (serverInfo.chainId.startsWith("eip155:")) {
+    return formatSIWEMessage(serverInfo, address);
+  }
+  if (serverInfo.chainId.startsWith("solana:")) {
+    return formatSIWSMessage(serverInfo, address);
+  }
+  throw new Error(
+    `Unsupported chain namespace: ${serverInfo.chainId}. Supported: eip155:* (EVM), solana:* (Solana)`
+  );
+}
+var init_message = __esm({
+  "src/server/vendor/sign-in-with-x/message.ts"() {
+    init_evm();
+    init_solana();
+  }
+});
+
+// src/server/vendor/sign-in-with-x/client.ts
+async function createSIWxPayload(serverExtension, signer) {
+  const isSolana = serverExtension.chainId.startsWith("solana:");
+  const address = isSolana ? getSolanaAddress(signer) : getEVMAddress(signer);
+  const message = createSIWxMessage(serverExtension, address);
+  const signature = isSolana ? await signSolanaMessage(message, signer) : await signEVMMessage(message, signer);
+  return {
+    domain: serverExtension.domain,
+    address,
+    statement: serverExtension.statement,
+    uri: serverExtension.uri,
+    version: serverExtension.version,
+    chainId: serverExtension.chainId,
+    type: serverExtension.type,
+    nonce: serverExtension.nonce,
+    issuedAt: serverExtension.issuedAt,
+    expirationTime: serverExtension.expirationTime,
+    notBefore: serverExtension.notBefore,
+    requestId: serverExtension.requestId,
+    resources: serverExtension.resources,
+    signatureScheme: serverExtension.signatureScheme,
+    signature
+  };
+}
+var init_client = __esm({
+  "src/server/vendor/sign-in-with-x/client.ts"() {
+    init_sign();
+    init_message();
+  }
+});
+function encodeSIWxHeader(payload) {
+  return safeBase64Encode(JSON.stringify(payload));
+}
+var init_encode = __esm({
+  "src/server/vendor/sign-in-with-x/encode.ts"() {
+  }
+});
+var registerAuthTools;
+var init_auth = __esm({
+  "src/server/tools/auth.ts"() {
+    init_response();
+    init_protocol();
+    init_client();
+    init_encode();
+    init_schemas();
+    registerAuthTools = ({ server, account }) => {
+      server.registerTool(
+        "authed_call",
+        {
+          description: "Make a request to a SIWX-protected endpoint. Handles auth flow automatically: detects SIWX requirement from 402 response, signs proof with server-provided challenge, retries.",
+          inputSchema: requestWithHeadersSchema
+        },
+        async ({ url, method, body, headers }) => {
+          try {
+            const httpClient = new x402HTTPClient(new x402Client());
+            const firstResponse = await fetch(url, {
+              method,
+              headers: {
+                "Content-Type": "application/json",
+                ...headers
+              },
+              body: body ? JSON.stringify(body) : void 0
+            });
+            if (firstResponse.status !== 402) {
+              const responseHeaders2 = Object.fromEntries(
+                firstResponse.headers.entries()
+              );
+              if (firstResponse.ok) {
+                let data2;
+                const contentType2 = firstResponse.headers.get("content-type");
+                if (contentType2?.includes("application/json")) {
+                  data2 = await firstResponse.json();
+                } else {
+                  data2 = await firstResponse.text();
+                }
+                return mcpSuccess({
+                  statusCode: firstResponse.status,
+                  headers: responseHeaders2,
+                  data: data2
+                });
+              }
+              let errorBody;
+              try {
+                errorBody = await firstResponse.json();
+              } catch {
+                errorBody = await firstResponse.text();
+              }
+              return mcpError(`HTTP ${firstResponse.status}`, {
+                statusCode: firstResponse.status,
+                headers: responseHeaders2,
+                body: errorBody
+              });
+            }
+            let rawBody;
+            try {
+              rawBody = await firstResponse.clone().json();
+            } catch {
+              rawBody = void 0;
+            }
+            const rawPaymentRequired = httpClient.getPaymentRequiredResponse(
+              (name) => firstResponse.headers.get(name),
+              rawBody
+            );
+            const paymentRequired = normalizePaymentRequired(rawPaymentRequired);
+            const siwxExtension = paymentRequired.extensions?.["sign-in-with-x"];
+            if (!siwxExtension?.info) {
+              return mcpError(
+                "Endpoint returned 402 but no sign-in-with-x extension found",
+                {
+                  statusCode: 402,
+                  x402Version: paymentRequired.x402Version,
+                  extensions: Object.keys(paymentRequired.extensions ?? {}),
+                  hint: "This endpoint may require payment instead of authentication. Use execute_call for paid requests."
+                }
+              );
+            }
+            const serverInfo = siwxExtension.info;
+            const requiredFields = [
+              "domain",
+              "uri",
+              "version",
+              "chainId",
+              "nonce",
+              "issuedAt"
+            ];
+            const missingFields = requiredFields.filter(
+              (f) => !serverInfo[f]
+            );
+            if (missingFields.length > 0) {
+              return mcpError(
+                "Invalid sign-in-with-x extension: missing required fields",
+                {
+                  missingFields,
+                  receivedInfo: serverInfo
+                }
+              );
+            }
+            if (serverInfo.chainId.startsWith("solana:")) {
+              return mcpError("Solana authentication not supported", {
+                chainId: serverInfo.chainId,
+                hint: "This endpoint requires a Solana wallet. The MCP server currently only supports EVM wallets."
+              });
+            }
+            const payload = await createSIWxPayload(serverInfo, account);
+            const siwxHeader = encodeSIWxHeader(payload);
+            const authedResponse = await fetch(url, {
+              method,
+              headers: {
+                "Content-Type": "application/json",
+                "SIGN-IN-WITH-X": siwxHeader,
+                ...headers
+              },
+              body: body ? JSON.stringify(body) : void 0
+            });
+            const responseHeaders = Object.fromEntries(
+              authedResponse.headers.entries()
+            );
+            if (!authedResponse.ok) {
+              let errorBody;
+              try {
+                errorBody = await authedResponse.json();
+              } catch {
+                errorBody = await authedResponse.text();
+              }
+              return mcpError(
+                `HTTP ${authedResponse.status} after authentication`,
+                {
+                  statusCode: authedResponse.status,
+                  headers: responseHeaders,
+                  body: errorBody,
+                  authAddress: account.address
+                }
+              );
+            }
+            let data;
+            const contentType = authedResponse.headers.get("content-type");
+            if (contentType?.includes("application/json")) {
+              data = await authedResponse.json();
+            } else {
+              data = await authedResponse.text();
+            }
+            return mcpSuccess({
+              statusCode: authedResponse.status,
+              headers: responseHeaders,
+              data,
+              authentication: {
+                address: account.address,
+                domain: serverInfo.domain,
+                chainId: serverInfo.chainId
+              }
+            });
+          } catch (err2) {
+            return mcpError(err2, { tool: "authed_call", url });
+          }
+        }
+      );
+    };
+  }
+});
+
+// src/server/tools/wallet.ts
+var registerWalletTools;
+var init_wallet = __esm({
+  "src/server/tools/wallet.ts"() {
+    init_response();
+    init_balance();
+    init_networks();
+    init_deposit();
+    registerWalletTools = ({
+      server,
+      account: { address },
+      flags
+    }) => {
+      server.registerTool(
+        "check_balance",
+        {
+          description: "Check wallet address and USDC balance. Creates wallet if needed."
+        },
+        async () => {
+          const { balanceFormatted } = await getUSDCBalance(address, flags);
+          return mcpSuccess({
+            address,
+            network: DEFAULT_NETWORK,
+            networkName: getChainName(DEFAULT_NETWORK),
+            usdcBalance: balanceFormatted,
+            balanceFormatted: balanceFormatted.toString(),
+            isNewWallet: balanceFormatted === 0,
+            depositLink: getDepositLink(address, flags)
+          });
+        }
+      );
+      server.registerTool(
+        "get_wallet_address",
+        {
+          description: "Get the wallet address."
+        },
+        () => mcpSuccess({ address })
+      );
+    };
+  }
+});
+
+// src/server/lib/x402/get-route-details.ts
+var getRouteDetails, getSchema;
+var init_get_route_details = __esm({
+  "src/server/lib/x402/get-route-details.ts"() {
+    init_token();
+    getRouteDetails = (paymentRequired) => {
+      const { accepts, extensions, resource } = paymentRequired;
+      return {
+        ...resource,
+        schema: getSchema(extensions),
+        paymentMethods: accepts.map((accept) => ({
+          price: tokenStringToNumber(accept.amount),
+          network: accept.network,
+          asset: accept.asset
+        }))
+      };
+    };
+    getSchema = (extensions) => {
+      const { bazaar } = extensions ?? {};
+      if (!bazaar) {
+        return void 0;
+      }
+      const { schema } = bazaar;
+      return schema.properties.input;
+    };
+  }
+});
+var registerCheckX402EndpointTool;
+var init_check_endpoint_schema = __esm({
+  "src/server/tools/check-endpoint-schema.ts"() {
+    init_response();
+    init_schemas();
+    init_log();
+    init_get_route_details();
+    registerCheckX402EndpointTool = ({ server }) => {
+      server.registerTool(
+        "check_x402_endpoint",
+        {
+          description: "Check if an endpoint is x402-protected and get pricing options, schema, and auth requirements (if applicable).",
+          inputSchema: requestSchema
+        },
+        async ({ url, method, body }) => {
+          try {
+            log.info("Querying endpoint", { url, method, body });
+            const response = await fetch(url, {
+              method,
+              body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+              headers: {
+                "Content-Type": "application/json"
+              }
+            });
+            const bodyText = await response.text().catch(() => void 0);
+            if (response.status !== 402) {
+              return mcpSuccess({
+                data: bodyText,
+                statusCode: response.status,
+                requiresPayment: false
+              });
+            }
+            const paymentRequired = new x402HTTPClient(
+              new x402Client()
+            ).getPaymentRequiredResponse(
+              (name) => response.headers.get(name),
+              JSON.parse(bodyText ?? "{}")
+            );
+            const routeDetails = getRouteDetails(paymentRequired);
+            return mcpSuccess({
+              requiresPayment: true,
+              statusCode: response.status,
+              routeDetails
+            });
+          } catch (err2) {
+            return mcpError(err2, { tool: "query_endpoint", url });
+          }
+        }
+      );
+    };
+  }
+});
+var registerRedeemInviteTool;
+var init_redeem_invite2 = __esm({
+  "src/server/tools/redeem-invite.ts"() {
+    init_response();
+    registerRedeemInviteTool = ({
+      server,
+      account: { address },
+      flags
+    }) => {
+      const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
+      server.registerTool(
+        "redeem_invite",
+        {
+          description: "Redeem an invite code to receive USDC.",
+          inputSchema: z$1.object({
+            code: z$1.string().min(1).describe("The invite code")
+          })
+        },
+        async ({ code }) => {
+          const res = await fetch(`${baseUrl}/api/invite/redeem`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code, recipientAddr: address })
+          });
+          const data = await res.json();
+          if (!data.success) {
+            return mcpError(data.error ?? "Failed to redeem invite code");
+          }
+          return mcpSuccess({
+            amount: `${data.amount} USDC`,
+            txHash: data.txHash
+          });
+        }
+      );
+    };
+  }
+});
+function getVersion() {
+  {
+    return "0.0.7";
+  }
+}
+var MCP_VERSION, DIST_TAG;
+var init_version = __esm({
+  "src/server/lib/version.ts"() {
+    MCP_VERSION = getVersion();
+    DIST_TAG = MCP_VERSION.includes("-beta") ? "beta" : "latest";
+  }
+});
+var errorReportSchema, registerTelemetryTools;
+var init_telemetry = __esm({
+  "src/server/tools/telemetry.ts"() {
+    init_log();
+    init_response();
+    init_version();
+    errorReportSchema = z.object({
+      tool: z.string().describe("MCP tool name"),
+      resource: z.string().optional().describe("x402 resource URL"),
+      summary: z.string().describe("1-2 sentence summary"),
+      errorMessage: z.string().describe("Error message"),
+      stack: z.string().optional().describe("Stack trace"),
+      fullReport: z.string().optional().describe("Detailed report with context, logs, repro steps")
+    });
+    registerTelemetryTools = ({
+      server,
+      account: { address },
+      flags
+    }) => {
+      const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
+      server.registerTool(
+        "report_error",
+        {
+          description: "EMERGENCY ONLY. Report critical MCP tool bugs. Do NOT use for normal errors (balance, network, 4xx) - those are recoverable.",
+          inputSchema: errorReportSchema
+        },
+        async (input) => {
+          try {
+            log.info("Submitting error report", {
+              tool: input.tool,
+              resource: input.resource,
+              summary: input.summary
+            });
+            const report = {
+              ...input,
+              walletAddress: address,
+              mcpVersion: MCP_VERSION,
+              reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            const response = await fetch(`${baseUrl}/api/telemetry`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify(report)
+            });
+            if (!response.ok) {
+              const errorText = await response.text().catch(() => "Unknown error");
+              log.error("Failed to submit error report", {
+                status: response.status,
+                error: errorText
+              });
+              return mcpError(
+                `Failed to submit error report: ${response.status} ${errorText}`,
+                { tool: "report_error" }
+              );
+            }
+            const result = await response.json();
+            log.info("Error report submitted successfully", {
+              reportId: result.reportId
+            });
+            return mcpSuccess({
+              submitted: true,
+              reportId: result.reportId,
+              message: "Error report submitted successfully. The x402scan team will investigate."
+            });
+          } catch (err2) {
+            log.error("Failed to submit error report", { error: err2 });
+            return mcpError(err2, { tool: "report_error" });
+          }
+        }
+      );
+    };
+  }
+});
+
+// src/server/resources/_lib.ts
+var getWebPageMetadata;
+var init_lib = __esm({
+  "src/server/resources/_lib.ts"() {
+    getWebPageMetadata = async (url) => {
+      try {
+        const response = await fetch(url);
+        if (!response.ok) {
+          return null;
+        }
+        const html = await response.text();
+        const titleMatch = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+        const title = titleMatch ? titleMatch[1].trim().replace(/\s+/g, " ") : null;
+        let descriptionMatch = /<meta\s+name=["']description["']\s+content=["']([^"']*)["']/i.exec(html);
+        descriptionMatch ??= /<meta\s+property=["']og:description["']\s+content=["']([^"']*)["']/i.exec(
+          html
+        );
+        descriptionMatch ??= /<meta\s+content=["']([^"']*)["']\s+name=["']description["']/i.exec(html);
+        descriptionMatch ??= /<meta\s+content=["']([^"']*)["']\s+property=["']og:description["']/i.exec(
+          html
+        );
+        const description = descriptionMatch ? descriptionMatch[1].trim().replace(/\s+/g, " ") : null;
+        return {
+          title,
+          description
+        };
+      } catch (error) {
+        throw new Error(
+          `Failed to fetch web page metadata: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    };
+  }
+});
+var origins, registerOrigins, getResourceResponse;
+var init_origins = __esm({
+  "src/server/resources/origins.ts"() {
+    init_lib();
+    init_get_route_details();
+    origins = ["enrichx402.com"];
+    registerOrigins = async ({ server }) => {
+      await Promise.all(
+        origins.map(async (origin) => {
+          const metadata = await getWebPageMetadata(`https://${origin}`);
+          server.registerResource(
+            origin,
+            `api://${origin}`,
+            {
+              title: metadata?.title ?? origin,
+              description: metadata?.description ?? "",
+              mimeType: "application/json"
+            },
+            async (uri) => {
+              const response = await fetch(
+                `${uri.toString().replace("api://", "https://")}/.well-known/x402`
+              ).then((response2) => response2.json());
+              const resources = await Promise.all(
+                response.resources.map(async (resource) => {
+                  const resourceResponse = await getResourceResponse(
+                    resource,
+                    await fetch(resource, {
+                      method: "POST",
+                      headers: {
+                        "Content-Type": "application/json"
+                      }
+                    })
+                  );
+                  if (resourceResponse) {
+                    return resourceResponse;
+                  }
+                  const getResponse = await getResourceResponse(
+                    resource,
+                    await fetch(resource, {
+                      method: "GET"
+                    })
+                  );
+                  if (getResponse) {
+                    return getResponse;
+                  }
+                  console.error(`Failed to get resource response for ${resource}`);
+                  return null;
+                })
+              );
+              return {
+                contents: [
+                  {
+                    uri: origin,
+                    text: JSON.stringify({
+                      server: origin,
+                      name: metadata?.title,
+                      description: metadata?.description,
+                      resources: resources.filter(Boolean).map((resource) => {
+                        if (!resource) return null;
+                        const schema = getSchema(
+                          resource.paymentRequired?.extensions
+                        );
+                        return {
+                          url: resource.resource,
+                          schema,
+                          mimeType: resource.paymentRequired.resource.mimeType
+                        };
+                      })
+                    }),
+                    mimeType: "application/json"
+                  }
+                ]
+              };
+            }
+          );
+        })
+      );
+    };
+    getResourceResponse = async (resource, response) => {
+      const client = new x402HTTPClient(new x402Client());
+      if (response.status === 402) {
+        const paymentRequired = client.getPaymentRequiredResponse(
+          (name) => response.headers.get(name),
+          JSON.parse(await response.text())
+        );
+        return {
+          paymentRequired,
+          resource
+        };
+      }
+      return null;
+    };
+  }
+});
+async function getWallet() {
+  if (process.env.X402_PRIVATE_KEY) {
+    const account2 = privateKeyToAccount(process.env.X402_PRIVATE_KEY);
+    log.info(`Using wallet from env: ${account2.address}`);
+    return { account: account2, isNew: false };
+  }
+  try {
+    const data = await fs3.readFile(WALLET_FILE, "utf-8");
+    const stored2 = storedWalletSchema.parse(JSON.parse(data));
+    const account2 = privateKeyToAccount(stored2.privateKey);
+    log.info(`Loaded wallet: ${account2.address}`);
+    return { account: account2, isNew: false };
+  } catch {
+  }
+  const privateKey = `0x${randomBytes(32).toString("hex")}`;
+  const account = privateKeyToAccount(privateKey);
+  const stored = {
+    privateKey,
+    address: account.address,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await fs3.writeFile(WALLET_FILE, JSON.stringify(stored, null, 2));
+  try {
+    await fs3.chmod(WALLET_FILE, 384);
+  } catch {
+  }
+  log.info(`Created wallet: ${account.address}`);
+  log.info(`Saved to: ${WALLET_FILE}`);
+  return { account, isNew: true };
+}
+var WALLET_FILE, storedWalletSchema;
+var init_wallet2 = __esm({
+  "src/lib/wallet.ts"() {
+    init_log();
+    init_schemas();
+    init_fs();
+    WALLET_FILE = configFile("wallet.json");
+    storedWalletSchema = z$1.object({
+      privateKey: ethereumPrivateKeySchema,
+      address: ethereumAddressSchema,
+      createdAt: z$1.string()
+    });
+  }
+});
+async function lookupDnsTxtRecord(hostname) {
+  const dnsQuery = `_x402.${hostname}`;
+  log.debug(`Looking up DNS TXT record: ${dnsQuery}`);
+  try {
+    const response = await fetch(
+      `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(
+        dnsQuery
+      )}&type=TXT`,
+      {
+        headers: { Accept: "application/dns-json" }
+      }
+    );
+    if (!response.ok) {
+      log.debug(`DNS lookup failed: HTTP ${response.status}`);
+      return null;
+    }
+    const data = await response.json();
+    if (!data.Answer || data.Answer.length === 0) {
+      log.debug("No DNS TXT record found");
+      return null;
+    }
+    const txtValue = data.Answer[0].data.replace(/^"|"$/g, "");
+    log.debug(`Found DNS TXT record: ${txtValue}`);
+    try {
+      new URL(txtValue);
+      return txtValue;
+    } catch {
+      log.debug(`DNS TXT value is not a valid URL: ${txtValue}`);
+      return null;
+    }
+  } catch (err2) {
+    log.debug(
+      `DNS lookup error: ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    return null;
+  }
+}
+async function fetchLlmsTxt(origin) {
+  const llmsTxtUrl = `${origin}/llms.txt`;
+  log.debug(`Fetching llms.txt from: ${llmsTxtUrl}`);
+  try {
+    const response = await fetch(llmsTxtUrl, {
+      headers: { Accept: "text/plain" }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        return { found: false, error: "No llms.txt found" };
+      }
+      return { found: false, error: `HTTP ${response.status}` };
+    }
+    const content = await response.text();
+    if (!content || content.trim().length === 0) {
+      return { found: false, error: "llms.txt is empty" };
+    }
+    return { found: true, content };
+  } catch (err2) {
+    return {
+      found: false,
+      error: `Network error: ${err2 instanceof Error ? err2.message : String(err2)}`
+    };
+  }
+}
+async function fetchDiscoveryFromUrl(url) {
+  log.debug(`Fetching discovery document from: ${url}`);
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: "application/json" }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        return { found: false, error: `Not found at ${url}` };
+      }
+      return {
+        found: false,
+        error: `HTTP ${response.status}: ${await response.text()}`
+      };
+    }
+    let rawData;
+    try {
+      rawData = await response.json();
+    } catch {
+      return {
+        found: false,
+        error: "Failed to parse discovery document as JSON"
+      };
+    }
+    const parsed = DiscoveryDocumentSchema.safeParse(rawData);
+    if (!parsed.success) {
+      return {
+        found: false,
+        error: `Invalid discovery document: ${parsed.error.issues.map((e) => e.message).join(", ")}`,
+        rawResponse: rawData
+      };
+    }
+    return { found: true, document: parsed.data };
+  } catch (err2) {
+    return {
+      found: false,
+      error: `Network error: ${err2 instanceof Error ? err2.message : String(err2)}`
+    };
+  }
+}
+async function fetchDiscoveryDocument(origin) {
+  const attemptedSources = [];
+  const hostname = getHostname(origin);
+  const wellKnownUrl = `${origin}/.well-known/x402`;
+  attemptedSources.push(wellKnownUrl);
+  const wellKnownResult = await fetchDiscoveryFromUrl(wellKnownUrl);
+  if (wellKnownResult.found && wellKnownResult.document) {
+    return {
+      found: true,
+      source: "well-known",
+      document: wellKnownResult.document,
+      attemptedSources
+    };
+  }
+  attemptedSources.push(`DNS TXT _x402.${hostname}`);
+  const dnsUrl = await lookupDnsTxtRecord(hostname);
+  if (dnsUrl) {
+    attemptedSources.push(dnsUrl);
+    const dnsResult = await fetchDiscoveryFromUrl(dnsUrl);
+    if (dnsResult.found && dnsResult.document) {
+      return {
+        found: true,
+        source: "dns-txt",
+        document: dnsResult.document,
+        attemptedSources
+      };
+    }
+  }
+  attemptedSources.push(`${origin}/llms.txt`);
+  const llmsResult = await fetchLlmsTxt(origin);
+  if (llmsResult.found && llmsResult.content) {
+    return {
+      found: true,
+      source: "llms-txt",
+      llmsTxtContent: llmsResult.content,
+      attemptedSources
+    };
+  }
+  return {
+    found: false,
+    error: "No discovery document found. Tried: .well-known/x402, DNS TXT record, llms.txt",
+    attemptedSources
+  };
+}
+async function queryResource(url) {
+  log.debug(`Querying resource: ${url}`);
+  try {
+    const result = await fetch(url, { method: "GET" });
+    if (!result.ok) {
+      return {
+        url,
+        isX402Endpoint: false,
+        error: result.statusText ?? "Failed to query endpoint"
+      };
+    }
+    if (result.status !== 402) {
+      return {
+        url,
+        isX402Endpoint: false
+      };
+    }
+    const pr = new x402HTTPClient(new x402Client()).getPaymentRequiredResponse(
+      (name) => result.headers.get(name),
+      JSON.parse(await result.text())
+    );
+    const firstReq = pr.accepts[0];
+    const resource = {
+      url,
+      isX402Endpoint: true,
+      x402Version: pr.x402Version,
+      price: tokenStringToNumber(firstReq.amount),
+      priceRaw: firstReq.amount,
+      network: firstReq.network,
+      networkName: getChainName(firstReq.network)
+    };
+    if (pr.extensions?.bazaar) {
+      const bazaar = pr.extensions.bazaar;
+      resource.bazaar = { info: bazaar.info, schema: bazaar.schema };
+      const info = bazaar.info;
+      if (info?.description) {
+        resource.description = info.description;
+      }
+    }
+    if (pr.extensions?.["sign-in-with-x"]) {
+      const siwx = pr.extensions["sign-in-with-x"];
+      resource.signInWithX = { required: true, info: siwx.info };
+    }
+    return resource;
+  } catch (err2) {
+    return {
+      url,
+      isX402Endpoint: false,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    };
+  }
+}
+function registerDiscoveryTools(server) {
+  server.registerTool(
+    "discover_resources",
+    {
+      description: `Discover x402-protected resources on an origin.
+         NEVER use 'fanOut = true' on the first try.
+         NEVER use 'fanOut = true' when there are more than 8 resources.
+
+        Known default origins with resource packs. Discover if more needed:
+        - https://enrichx402.com ->
+            People + Org search
+            Google Maps (places + locations)
+            Grok twitter search
+            Exa web search
+            Clado linkedin data
+            Firecrawl web scrape
+        - https://stablestudio.io -> generate images / videos
+        `,
+      inputSchema: {
+        url: z.url().describe(
+          "The origin URL or any URL on the origin to discover resources from"
+        ),
+        fanOut: z.boolean().default(false).describe(
+          "Whether to query each discovered resource for full pricing/schema info. NEVER use on first try."
+        ),
+        concurrency: z.number().int().min(1).max(10).default(5).describe(
+          "Max concurrent requests when querying resources (default: 5)"
+        )
+      }
+    },
+    async ({ url, fanOut, concurrency }) => {
+      try {
+        const origin = getOrigin(url);
+        log.info(`Discovering resources for origin: ${origin}`);
+        const discoveryResult = await fetchDiscoveryDocument(origin);
+        if (discoveryResult.found && discoveryResult.source === "llms-txt") {
+          return mcpSuccess({
+            found: true,
+            origin,
+            source: "llms-txt",
+            usage: "Found llms.txt but no structured x402 discovery document. The content below may contain information about x402 resources. Parse it to find relevant endpoints.",
+            llmsTxtContent: discoveryResult.llmsTxtContent,
+            attemptedSources: discoveryResult.attemptedSources,
+            resources: []
+          });
+        }
+        if (!discoveryResult.found || !discoveryResult.document) {
+          return mcpSuccess({
+            found: false,
+            origin,
+            error: discoveryResult.error,
+            attemptedSources: discoveryResult.attemptedSources,
+            rawResponse: discoveryResult.rawResponse
+          });
+        }
+        const doc = discoveryResult.document;
+        const result = {
+          found: true,
+          origin,
+          source: discoveryResult.source,
+          instructions: doc.instructions,
+          usage: "Use query_endpoint to get full pricing/requirements for a resource. Use execute_call (for payment) or authed_call (for SIWX auth) to call it.",
+          resources: []
+        };
+        if (!fanOut) {
+          result.resources = doc.resources.map((resourceUrl) => ({
+            url: resourceUrl
+          }));
+          return mcpSuccess(result);
+        }
+        const resourceUrls = doc.resources;
+        const allResources = [];
+        for (let i = 0; i < resourceUrls.length; i += concurrency) {
+          const batch = resourceUrls.slice(i, i + concurrency);
+          const batchResults = await Promise.all(
+            batch.map((resourceUrl) => queryResource(resourceUrl))
+          );
+          allResources.push(...batchResults);
+        }
+        result.resources = allResources;
+        return mcpSuccess(result);
+      } catch (err2) {
+        return mcpError(err2, { tool: "discover_resources", url });
+      }
+    }
+  );
+}
+function getOrigin(urlString) {
+  try {
+    return new URL(urlString).origin;
+  } catch {
+    return urlString;
+  }
+}
+function getHostname(origin) {
+  try {
+    return new URL(origin).hostname;
+  } catch {
+    return origin;
+  }
+}
+var DiscoveryDocumentSchema;
+var init_discover_resources = __esm({
+  "src/server/tools/discover-resources.ts"() {
+    init_log();
+    init_response();
+    init_token();
+    init_networks();
+    DiscoveryDocumentSchema = z.object({
+      version: z.number().refine((v) => v === 1, { message: "version must be 1" }),
+      resources: z.array(z.url()),
+      ownershipProofs: z.array(z.string()).optional(),
+      instructions: z.string().optional()
+    });
+  }
+});
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+var startServer;
+var init_server = __esm({
+  "src/server/index.ts"() {
+    init_fetch_x402_resource();
+    init_auth();
+    init_wallet();
+    init_check_endpoint_schema();
+    init_redeem_invite2();
+    init_telemetry();
+    init_origins();
+    init_log();
+    init_wallet2();
+    init_discover_resources();
+    init_redeem_invite();
+    init_version();
+    startServer = async (flags) => {
+      log.info("Starting x402scan-mcp...");
+      const { dev, invite } = flags;
+      const { account } = await getWallet();
+      const code = invite ?? process.env.INVITE_CODE;
+      const sessionId = randomBytes(16).toString("hex");
+      if (code) {
+        await redeemInviteCode({
+          code,
+          dev,
+          address: account.address
+        });
+      }
+      const server = new McpServer(
+        {
+          name: "@x402scan/mcp",
+          version: MCP_VERSION,
+          websiteUrl: "https://x402scan.com/mcp",
+          icons: [{ src: "https://x402scan.com/logo.svg" }]
+        },
+        {
+          capabilities: {
+            resources: {
+              subscribe: true,
+              listChanged: true
+            }
+          }
+        }
+      );
+      const props = {
+        server,
+        account,
+        flags,
+        sessionId
+      };
+      registerFetchX402ResourceTool(props);
+      registerAuthTools(props);
+      registerWalletTools(props);
+      registerCheckX402EndpointTool(props);
+      registerRedeemInviteTool(props);
+      registerDiscoveryTools(server);
+      registerTelemetryTools(props);
+      await registerOrigins({ server, flags });
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+      const shutdown = async () => {
+        log.info("Shutting down...");
+        await server.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", () => void shutdown());
+      process.on("SIGTERM", () => void shutdown());
+    };
+  }
+});
+var getClient;
+var init_get_client = __esm({
+  "src/install/1-get-client/index.ts"() {
+    init_clients();
+    getClient = async ({ client: flagClient, yes }) => {
+      if (yes) {
+        if (!flagClient) {
+          throw new Error(
+            `Client is required when yes is true. Pass --client as one of these values: ${Object.values(Clients).join(", ")}`
+          );
+        }
+        const parsedClient2 = z$1.enum(Clients).safeParse(flagClient);
+        if (!parsedClient2.success) {
+          throw new Error(
+            `${flagClient} is not a valid client. Valid options are: ${Object.values(Clients).join(", ")}`
+          );
+        }
+        return parsedClient2.data;
+      }
+      const parsedClient = z$1.enum(Clients).safeParse(flagClient);
+      if (parsedClient.success) {
+        return parsedClient.data;
+      }
+      if (flagClient) {
+        log$1.error(`${flagClient} is not a valid client. Please select a client`);
+      }
+      const client = await select({
+        message: "Where would you like to install the x402scan MCP server?",
+        options: Object.values(Clients).map((client2) => {
+          const metadata = clientMetadata[client2];
+          return {
+            label: metadata.name,
+            value: client2
+          };
+        }),
+        maxItems: 7
+      });
+      const parsedClientSelection = z$1.enum(Clients).safeParse(client);
+      if (parsedClientSelection.success) {
+        return parsedClientSelection.data;
+      }
+      outro(chalk.bold.red("No MCP client selected"));
+      process.exit(0);
+    };
+  }
+});
+var Platforms, getPlatformPath;
+var init_platforms = __esm({
+  "src/install/2-add-server/lib/platforms.ts"() {
+    Platforms = /* @__PURE__ */ ((Platforms2) => {
+      Platforms2["Windows"] = "win32";
+      Platforms2["MacOS"] = "darwin";
+      Platforms2["Linux"] = "linux";
+      return Platforms2;
+    })(Platforms || {});
+    getPlatformPath = () => {
+      const platform = z$1.enum(Platforms).safeParse(process2.platform);
+      if (!platform.success) {
+        throw new Error(`Invalid platform: ${process2.platform}`);
+      }
+      const homeDir = os.homedir();
+      switch (platform.data) {
+        case "win32" /* Windows */:
+          return {
+            baseDir: process2.env.APPDATA ?? path2.join(homeDir, "AppData", "Roaming"),
+            vscodePath: path2.join("Code", "User")
+          };
+        case "darwin" /* MacOS */:
+          return {
+            baseDir: path2.join(homeDir, "Library", "Application Support"),
+            vscodePath: path2.join("Code", "User")
+          };
+        case "linux" /* Linux */:
+          return {
+            baseDir: process2.env.XDG_CONFIG_HOME ?? path2.join(homeDir, ".config"),
+            vscodePath: path2.join("Code/User")
+          };
+        default:
+          throw new Error(`Invalid platform: ${process2.platform}`);
+      }
+    };
+  }
+});
+var parseClientConfig, serializeClientConfig, stringifyObject;
+var init_file_types = __esm({
+  "src/install/2-add-server/lib/file-types.ts"() {
+    parseClientConfig = ({ format: format2, path: path3 }) => {
+      const fileContent = fs__default.readFileSync(path3, "utf8");
+      let config = {};
+      if (format2 === "yaml" /* YAML */) {
+        config = yaml.load(fileContent);
+      } else if (format2 === "toml" /* TOML */) {
+        config = TOML.parse(fileContent);
+      } else if (path3.endsWith(".jsonc")) {
+        config = jsonc.parse(fileContent);
+      } else {
+        config = JSON.parse(fileContent);
+      }
+      return {
+        config,
+        fileContent
+      };
+    };
+    serializeClientConfig = ({ format: format2, path: path3 }, config, originalContent) => {
+      if (format2 === "yaml" /* YAML */) {
+        return yaml.dump(config, {
+          indent: 2,
+          lineWidth: -1,
+          noRefs: true
+        });
+      }
+      if (format2 === "toml" /* TOML */) {
+        return TOML.stringify(config);
+      }
+      if (path3.endsWith(".jsonc") && originalContent) {
+        try {
+          const editedContent = originalContent;
+          const modifications = [];
+          for (const key of Object.keys(config)) {
+            const path4 = [key];
+            const edits = jsonc.modify(editedContent, path4, config[key], {
+              formattingOptions: { tabSize: 2, insertSpaces: true }
+            });
+            modifications.push(...edits);
+          }
+          return jsonc.applyEdits(originalContent, modifications);
+        } catch (error) {
+          console.log(
+            `Error applying JSONC edits: ${error instanceof Error ? error.message : String(error)}`
+          );
+          console.log("Falling back to JSON.stringify (comments will be lost)");
+          return JSON.stringify(config, null, 2);
+        }
+      }
+      return JSON.stringify(config, null, 2);
+    };
+    stringifyObject = (config, format2) => {
+      if (format2 === "yaml" /* YAML */) {
+        return yaml.dump(config, {
+          indent: 2,
+          lineWidth: -1,
+          noRefs: true
+        });
+      }
+      if (format2 === "toml" /* TOML */) {
+        return TOML.stringify(config);
+      }
+      return JSON.stringify(config, null, 2);
+    };
+  }
+});
+var getClientConfigFile;
+var init_client_config_file = __esm({
+  "src/install/2-add-server/lib/client-config-file.ts"() {
+    init_platforms();
+    init_log();
+    init_clients();
+    init_file_types();
+    getClientConfigFile = (client) => {
+      const homeDir = os.homedir();
+      const { baseDir, vscodePath } = getPlatformPath();
+      switch (client) {
+        case "claude" /* Claude */:
+          return {
+            path: path2.join(baseDir, "Claude", "claude_desktop_config.json"),
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "cline" /* Cline */:
+          return {
+            path: path2.join(
+              baseDir,
+              vscodePath,
+              "globalStorage",
+              "saoudrizwan.claude-dev",
+              "settings",
+              "cline_mcp_settings.json"
+            ),
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "roo-cline" /* RooCline */:
+          return {
+            path: path2.join(
+              baseDir,
+              vscodePath,
+              "globalStorage",
+              "rooveterinaryinc.roo-cline",
+              "settings",
+              "mcp_settings.json"
+            ),
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "windsurf" /* Windsurf */:
+          return {
+            path: path2.join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "cursor" /* Cursor */:
+          return {
+            path: path2.join(homeDir, ".cursor", "mcp.json"),
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "warp" /* Warp */:
+          return {
+            path: "no-local-config",
+            // it's okay this isn't a real path, we never use it
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "gemini-cli" /* GeminiCli */:
+          return {
+            path: path2.join(homeDir, ".gemini", "settings.json"),
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "vscode" /* Vscode */:
+          return {
+            path: path2.join(baseDir, vscodePath, "mcp.json"),
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "claude-code" /* ClaudeCode */:
+          return {
+            path: path2.join(homeDir, ".claude.json"),
+            configKey: "mcpServers",
+            format: "json" /* JSON */
+          };
+        case "goose" /* Goose */:
+          return {
+            path: path2.join(homeDir, ".config", "goose", "config.yaml"),
+            configKey: "extensions",
+            format: "yaml" /* YAML */
+          };
+        case "zed" /* Zed */:
+          return {
+            path: process2.platform === "win32" ? path2.join(
+              process2.env.APPDATA ?? path2.join(homeDir, "AppData", "Roaming"),
+              "Zed",
+              "settings.json"
+            ) : path2.join(homeDir, ".config", "zed", "settings.json"),
+            configKey: "context_servers",
+            format: "json" /* JSON */
+          };
+        case "codex" /* Codex */:
+          return {
+            path: path2.join(
+              process2.env.CODEX_HOME ?? path2.join(homeDir, ".codex"),
+              "config.toml"
+            ),
+            configKey: "mcp_servers",
+            format: "toml" /* TOML */
+          };
+        case "opencode" /* Opencode */: {
+          const jsonPath = path2.join(
+            homeDir,
+            ".config",
+            "opencode",
+            "opencode.json"
+          );
+          const jsoncPath = jsonPath.replace(".json", ".jsonc");
+          if (fs__default.existsSync(jsoncPath)) {
+            log.info(`Found .jsonc file for OpenCode, using: ${jsoncPath}`);
+            return {
+              path: jsoncPath,
+              configKey: "mcp",
+              format: "json" /* JSON */
+            };
+          }
+          return {
+            path: jsonPath,
+            configKey: "mcp",
+            format: "json" /* JSON */
+          };
+        }
+        default:
+          throw new Error(`Unknown client: ${String(client)}`);
+      }
+    };
+  }
+});
+
+// src/install/2-add-server/lib/nested-values.ts
+var getNestedValue, setNestedValue;
+var init_nested_values = __esm({
+  "src/install/2-add-server/lib/nested-values.ts"() {
+    getNestedValue = (obj, path3) => {
+      const keys = path3.split(".");
+      let current = obj;
+      for (const key of keys) {
+        if (current && typeof current === "object" && key in current) {
+          current = current[key];
+        } else {
+          return void 0;
+        }
+      }
+      return current;
+    };
+    setNestedValue = (obj, path3, value) => {
+      const keys = path3.split(".");
+      const lastKey = keys.pop();
+      if (!lastKey) return;
+      const target = keys.reduce((current, key) => {
+        current[key] ??= {};
+        return current[key];
+      }, obj);
+      target[lastKey] = value;
+    };
+  }
+});
+
+// src/install/2-add-server/lib/index.ts
+var init_lib2 = __esm({
+  "src/install/2-add-server/lib/index.ts"() {
+    init_client_config_file();
+    init_file_types();
+    init_nested_values();
+    init_platforms();
+  }
+});
+async function addServer(client, globalFlags) {
+  const { serverName, command, args } = getMcpConfig(globalFlags);
+  if (client === "warp" /* Warp */) {
+    log$1.info(
+      chalk.bold.yellow("Warp requires a manual installation through their UI.")
+    );
+    log$1.message(
+      "Please copy the following configuration object and add it to your Warp MCP config:"
+    );
+    console.log();
+    console.log(
+      JSON.stringify(
+        {
+          [serverName]: {
+            command,
+            args,
+            working_directory: null,
+            start_on_launch: true
+          }
+        },
+        null,
+        2
+      )
+    );
+    console.log();
+    log$1.message(
+      `Read Warp's documentation at https://docs.warp.dev/knowledge-and-collaboration/mcp`
+    );
+    const addedToWarp = await confirm({
+      message: "Did you add the MCP server to your Warp config?"
+    });
+    if (!addedToWarp) {
+      throw new Error("Warp MCP server not added");
+    }
+  }
+  const clientFileTarget = getClientConfigFile(client);
+  const { name } = clientMetadata[client];
+  try {
+    let config = {};
+    let content = void 0;
+    log.info(`Checking if config file exists at: ${clientFileTarget.path}`);
+    if (!fs__default.existsSync(clientFileTarget.path)) {
+      log.info("Config file not found, creating default empty config");
+      setNestedValue(config, clientFileTarget.configKey, {});
+      log.info("Config created successfully");
+      if (!globalFlags.yes) {
+        await wait({
+          startText: "Locating config file",
+          stopText: `No config found, creating default empty config`,
+          ms: 1e3
+        });
+      }
+    } else {
+      log.info("Config file found, reading config file content");
+      const { config: rawConfig, fileContent } = parseClientConfig(clientFileTarget);
+      config = rawConfig;
+      content = fileContent;
+      const existingValue = getNestedValue(
+        rawConfig,
+        clientFileTarget.configKey
+      );
+      if (!existingValue) {
+        setNestedValue(rawConfig, clientFileTarget.configKey, {});
+      }
+      log.info(
+        `Config loaded successfully: ${JSON.stringify(rawConfig, null, 2)}`
+      );
+      if (!globalFlags.yes) {
+        await wait({
+          startText: `Locating config file`,
+          stopText: `Config loaded from ${clientFileTarget.path}`,
+          ms: 1e3
+        });
+      }
+    }
+    const servers = getNestedValue(config, clientFileTarget.configKey);
+    if (!servers || typeof servers !== "object") {
+      log.error(`Invalid ${clientFileTarget.configKey} structure in config`);
+      log$1.error(
+        chalk.bold.red(
+          `Invalid ${clientFileTarget.configKey} structure in config`
+        )
+      );
+      throw new Error(`Invalid ${clientFileTarget.configKey} structure`);
+    }
+    if (client === "goose" /* Goose */) {
+      servers[serverName] = {
+        name: serverName,
+        cmd: command,
+        args,
+        enabled: true,
+        envs: {},
+        type: "stdio",
+        timeout: 300
+      };
+    } else if (client === "zed" /* Zed */) {
+      servers[serverName] = {
+        source: "custom",
+        command,
+        args,
+        env: {}
+      };
+    } else if (client === "opencode" /* Opencode */) {
+      servers[serverName] = {
+        type: "local",
+        command,
+        args,
+        enabled: true,
+        environment: {}
+      };
+    } else {
+      servers[serverName] = {
+        command,
+        args
+      };
+    }
+    if (!globalFlags.yes) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+    if (!globalFlags.yes) {
+      log$1.step(
+        `The following will be added to ${chalk.bold.underline(clientFileTarget.path)}`
+      );
+    }
+    const configStr = formatDiffByFormat(
+      {
+        [clientFileTarget.configKey]: {
+          [serverName]: servers[serverName]
+        }
+      },
+      clientFileTarget.format
+    );
+    if (!globalFlags.yes) {
+      await stream.message(
+        (async function* () {
+          for (const num of Array.from(
+            { length: configStr.length },
+            (_, i) => i
+          )) {
+            const char = configStr[num];
+            yield char;
+            if (!["\n", " ", "\u2500", "\u256E", "\u256D", "\u2570", "\u256F", "\u2502"].includes(char)) {
+              await new Promise((resolve) => setTimeout(resolve, 5));
+            } else {
+              await new Promise((resolve) => setTimeout(resolve, 2));
+            }
+          }
+        })()
+      );
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+    const isConfirmed = globalFlags.yes ? true : await confirm({
+      message: `Would you like to proceed?`,
+      active: "Install MCP",
+      inactive: "Cancel"
+    });
+    if (isConfirmed !== true) {
+      outro(chalk.bold.red("Installation cancelled"));
+      process.exit(0);
+    }
+    const configContent = serializeClientConfig(
+      clientFileTarget,
+      config,
+      content
+    );
+    fs__default.writeFileSync(clientFileTarget.path, configContent);
+    log$1.success(chalk.bold.green(`Added x402scan MCP to ${name}`));
+  } catch (e) {
+    log$1.error(chalk.bold.red(`Error adding x402scan MCP to ${name}`));
+    throw e;
+  }
+}
+var getMcpConfig, formatDiffByFormat;
+var init_add_server = __esm({
+  "src/install/2-add-server/index.ts"() {
+    init_version();
+    init_clients();
+    init_lib2();
+    init_log();
+    init_wait();
+    getMcpConfig = (globalFlags) => {
+      if (globalFlags.dev) {
+        return {
+          serverName: "x402",
+          command: "node",
+          args: [`${process.cwd()}/dist/esm/index.js`, "--dev"]
+        };
+      }
+      return {
+        serverName: "x402",
+        command: "npx",
+        args: ["-y", `@x402scan/mcp@${DIST_TAG}`]
+      };
+    };
+    formatDiffByFormat = (obj, format2) => {
+      const str = stringifyObject(obj, format2);
+      switch (format2) {
+        case "json" /* JSON */: {
+          const numLines = str.split("\n").length;
+          return str.split("\n").map((line, index) => {
+            const diffLines = [0, 1, numLines - 2, numLines - 1];
+            const isDiffLine = !diffLines.includes(index);
+            if (isDiffLine) {
+              return `${chalk.bold.green(`+ ${line.slice(2)}`)}`;
+            }
+            return line;
+          }).join("\n");
+        }
+        case "yaml" /* YAML */: {
+          return str.split("\n").map((line, index) => {
+            const diffLines = [0, 1, str.length - 2, str.length - 1];
+            const isDiffLine = !diffLines.includes(index);
+            if (isDiffLine) {
+              return `${chalk.bold.green(`+ ${line.slice(2)}`)}`;
+            }
+            return line;
+          }).join("\n");
+        }
+        case "toml" /* TOML */: {
+          return str.split("\n").filter((line) => line.trim() !== "").map((line) => {
+            return `${chalk.bold.green(`+ ${line.trim()}`)}`;
+          }).join("\n");
+        }
+      }
+    };
+  }
+});
+var redeemInviteCode2;
+var init_redeem_invite3 = __esm({
+  "src/install/3-redeem-invite/index.ts"() {
+    init_wait();
+    init_redeem_invite();
+    redeemInviteCode2 = async (props, flags) => {
+      const s = spinner();
+      if (!flags.yes) {
+        s.start("Redeeming invite code...");
+      }
+      const result = await redeemInviteCode(props);
+      return result.match(
+        async ({ data }) => {
+          if (!flags.yes) {
+            s.stop("Invite code redeemed successfully!");
+            await wait({
+              startText: "Processing...",
+              stopText: chalk.green(
+                `${chalk.bold(data.amount)} USDC has been sent to your wallet!`
+              ),
+              ms: 1e3
+            });
+          } else {
+            log$1.success(
+              chalk.green(
+                `${chalk.bold(data.amount)} USDC has been sent to your wallet!`
+              )
+            );
+          }
+          log$1.info(
+            chalk.dim(`Transaction: https://basescan.org/tx/${data.txHash}`)
+          );
+          return true;
+        },
+        (error) => {
+          if (!flags.yes) {
+            s.stop("Invite code redemption failed");
+          }
+          log$1.warning(
+            chalk.yellow(`Failed to redeem invite code: ${error?.message}`)
+          );
+          return false;
+        }
+      );
+    };
+  }
+});
+var addFunds;
+var init_add_funds = __esm({
+  "src/install/4-add-funds/index.ts"() {
+    init_balance();
+    init_deposit();
+    init_wait();
+    addFunds = async ({ flags, address, isNew }) => {
+      if (isNew) {
+        if (!flags.yes) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+        log$1.info("To use paid API tools, you will need USDC in your wallet.");
+        await promptDeposit(address, flags);
+      } else {
+        const { balanceFormatted } = await getUSDCBalance(address, flags);
+        if (!flags.yes) {
+          await wait({
+            startText: "Checking balance...",
+            stopText: `Balance: ${chalk.bold(`${balanceFormatted} USDC`)} `,
+            ms: 1e3
+          });
+        }
+        if (balanceFormatted < 1) {
+          log$1.warning(
+            chalk.bold(
+              `Your balance is low (${balanceFormatted} USDC). Consider topping up.`
+            )
+          );
+          await promptDeposit(address, flags);
+        }
+      }
+    };
+  }
+});
+
+// src/install/index.ts
+var install_exports = {};
+__export(install_exports, {
+  installMcpServer: () => installMcpServer
+});
+var installMcpServer;
+var init_install = __esm({
+  "src/install/index.ts"() {
+    init_wallet2();
+    init_get_client();
+    init_add_server();
+    init_redeem_invite3();
+    init_add_funds();
+    installMcpServer = async (flags) => {
+      const {
+        account: { address },
+        isNew
+      } = await getWallet();
+      intro(chalk.green.bold(`Install x402scan MCP`));
+      const client = await getClient(flags);
+      await addServer(client, flags);
+      const inviteRedeemed = flags.invite ? await redeemInviteCode2(
+        {
+          code: flags.invite,
+          dev: flags.dev,
+          address
+        },
+        flags
+      ) : false;
+      if (!inviteRedeemed) {
+        await addFunds({ flags, address, isNew });
+      }
+      outro(chalk.bold.green("Your x402scan MCP server is ready to use!"));
+    };
+  }
+});
+
+// src/fund/index.ts
+var fund_exports = {};
+__export(fund_exports, {
+  fundMcpServer: () => fundMcpServer
+});
+var fundMcpServer;
+var init_fund = __esm({
+  "src/fund/index.ts"() {
+    init_wallet2();
+    init_deposit();
+    fundMcpServer = async (flags) => {
+      intro(chalk.bold(`Fund ${chalk.hex("#2563eb")("x402scan MCP")}`));
+      const {
+        account: { address }
+      } = await getWallet();
+      await promptDeposit(address, flags);
+      outro(chalk.bold.green("Your x402scan MCP server is funded!"));
+    };
+  }
+});
 
 // src/index.ts
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
+init_clients();
 var isClaudeCode = Boolean(process.env.CLAUDECODE);
 var defaultYes = isClaudeCode || Boolean(process.env.CI);
 void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
@@ -24,8 +2669,8 @@ void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
   "Start the MCP server",
   (yargs2) => yargs2,
   async (args) => {
-    const { startServer } = await import("./server-IOVNYPTB.js");
-    await startServer(args);
+    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    await startServer2(args);
   }
 ).command(
   "install",
@@ -37,19 +2682,20 @@ void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
     default: isClaudeCode ? "claude-code" /* ClaudeCode */ : void 0
   }),
   async (args) => {
-    const { installMcpServer } = await import("./install-BBOI4D6I.js");
-    await installMcpServer(args);
+    const { installMcpServer: installMcpServer2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+    await installMcpServer2(args);
   }
 ).command(
   "fund",
   "Open the funding page",
   (yargs2) => yargs2,
   async (args) => {
-    const { fundMcpServer } = await import("./fund-ANZCZU5C.js");
-    await fundMcpServer(args);
+    const { fundMcpServer: fundMcpServer2 } = await Promise.resolve().then(() => (init_fund(), fund_exports));
+    await fundMcpServer2(args);
   }
-).strict().demandCommand(0, 1, "", "Too many commands provided").help().parseAsync().catch((err) => {
-  console.error("Fatal:", err);
+).strict().demandCommand(0, 1, "", "Too many commands provided").help().parseAsync().catch((err2) => {
+  console.error("Fatal:", err2);
   process.exit(1);
 });
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map