@x402scan/mcp 0.0.7-beta.1 → 0.0.7-beta.3

package/dist/esm/index.js

@@ -1,2548 +1,9 @@
 #!/usr/bin/env node
-import { ok, resultFromPromise, err, resultFromThrowable } from '@x402scan/neverthrow';
-import z$1, { z } from 'zod';
-import open from 'open';
-import * as fs from 'fs/promises';
-import * as fs2 from 'fs';
-import fs2__default, { existsSync } from 'fs';
-import path2, { join } from 'path';
-import os, { homedir } from 'os';
-import { polygon, arbitrum, optimism, sepolia, mainnet, baseSepolia, base } from 'viem/chains';
-import { getAddress, formatUnits } from 'viem';
-import { encodeSIWxHeader, createSIWxPayload } from '@x402scan/siwx';
-import { x402Client, x402HTTPClient } from '@x402/core/client';
-import { ExactEvmScheme } from '@x402/evm/exact/client';
-import 'url';
-import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { intro, outro, log as log$1, select, confirm, stream, spinner, text } from '@clack/prompts';
-import chalk2 from 'chalk';
-import process2 from 'process';
-import * as TOML from '@iarna/toml';
-import yaml from 'js-yaml';
-import * as jsonc from 'jsonc-parser';
+import './chunk-47GMMJYJ.js';
+import './chunk-PLDDJCW6.js';
 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/cli/install/clients.ts
-var Clients, clientMetadata;
-var init_clients = __esm({
-  "src/cli/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",
-        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"
-      }
-    };
-  }
-});
-var errorType, fetchErr, fetchHttpErr, safeFetch, safeFetchJson, safeParseResponse, isFetchError;
-var init_fetch = __esm({
-  "src/shared/neverthrow/fetch/index.ts"() {
-    errorType = "fetch";
-    fetchErr = (surface3, error) => err(errorType, surface3, error);
-    fetchHttpErr = (surface3, response) => fetchErr(surface3, {
-      cause: "http",
-      statusCode: response.status,
-      message: response.statusText,
-      response
-    });
-    safeFetch = (surface3, request) => {
-      return resultFromPromise(
-        errorType,
-        surface3,
-        fetch(request),
-        (error) => ({
-          cause: "network",
-          message: error instanceof Error ? error.message : "Network error"
-        })
-      );
-    };
-    safeFetchJson = (surface3, request) => {
-      return safeFetch(surface3, request).andThen((response) => {
-        if (!response.ok) {
-          return fetchHttpErr(surface3, response);
-        }
-        return resultFromPromise(
-          errorType,
-          surface3,
-          response.json(),
-          () => ({
-            cause: "parse",
-            message: "Could not parse JSON from response",
-            statusCode: response.status,
-            contentType: response.headers.get("content-type") ?? "Not specified"
-          })
-        );
-      });
-    };
-    safeParseResponse = (surface3, response) => {
-      return resultFromPromise(
-        errorType,
-        surface3,
-        (async () => {
-          const contentType = response.headers.get("content-type") ?? "";
-          switch (contentType) {
-            case "application/json":
-              return {
-                type: "json",
-                data: await response.json()
-              };
-            case "image/png":
-            case "image/jpeg":
-            case "image/gif":
-            case "image/webp":
-            case "image/svg+xml":
-            case "image/tiff":
-            case "image/bmp":
-            case "image/ico":
-              return {
-                type: "image",
-                mimeType: contentType,
-                data: await response.arrayBuffer()
-              };
-            case "audio/":
-              return {
-                type: "audio",
-                mimeType: contentType,
-                data: await response.arrayBuffer()
-              };
-            case "video/":
-              return {
-                type: "video",
-                mimeType: contentType,
-                data: await response.arrayBuffer()
-              };
-            case "application/pdf":
-              return {
-                type: "pdf",
-                mimeType: contentType,
-                data: await response.arrayBuffer()
-              };
-            case "application/octet-stream":
-              return {
-                type: "octet-stream",
-                mimeType: contentType,
-                data: await response.arrayBuffer()
-              };
-            case "multipart/form-data":
-              return { type: "formData", data: await response.formData() };
-            case "text/":
-              return { type: "text", data: await response.text() };
-            default:
-              throw new Error(`Unsupported content type: ${contentType}`);
-          }
-        })(),
-        (e) => ({
-          cause: "parse",
-          message: e instanceof Error ? e.message : "Could not parse response",
-          statusCode: response.status,
-          contentType: response.headers.get("content-type") ?? "Not specified"
-        })
-      );
-    };
-    isFetchError = (error) => {
-      return error.type === errorType;
-    };
-  }
-});
-var type, jsonErr, safeStringifyJson, safeParseJson;
-var init_json = __esm({
-  "src/shared/neverthrow/json/index.ts"() {
-    type = "json";
-    jsonErr = (surface3, error) => {
-      return err(type, surface3, error);
-    };
-    safeStringifyJson = (surface3, value) => {
-      return resultFromThrowable(
-        type,
-        surface3,
-        () => JSON.stringify(value),
-        () => ({
-          cause: "stringify",
-          message: "Could not stringify JSON"
-        })
-      );
-    };
-    safeParseJson = (surface3, value) => {
-      return resultFromThrowable(
-        type,
-        surface3,
-        () => JSON.parse(value),
-        (e) => ({
-          cause: "parse",
-          message: e instanceof Error ? e.message : "Could not parse JSON"
-        })
-      );
-    };
-  }
-});
-
-// src/server/tools/response/lib.ts
-var parsedResponseToToolContentPart;
-var init_lib = __esm({
-  "src/server/tools/response/lib.ts"() {
-    parsedResponseToToolContentPart = (data) => {
-      switch (data.type) {
-        case "json":
-          return {
-            type: "text",
-            text: JSON.stringify(data.data, null, 2)
-          };
-        case "image":
-          return {
-            type: "image",
-            mimeType: data.mimeType,
-            data: Buffer.from(data.data).toString("base64")
-          };
-        case "audio":
-          return {
-            type: "audio",
-            mimeType: data.mimeType,
-            data: Buffer.from(data.data).toString("base64")
-          };
-        case "text":
-          return { type: "text", text: data.data };
-        default:
-          return {
-            type: "text",
-            text: `Unsupported response type: ${data.type}`
-          };
-      }
-    };
-  }
-});
-
-// src/server/tools/response/error.ts
-var buildMcpError, mcpErrorJson, mcpError, mcpErrorFetch;
-var init_error = __esm({
-  "src/server/tools/response/error.ts"() {
-    init_json();
-    init_lib();
-    init_fetch();
-    buildMcpError = (content) => {
-      return {
-        content,
-        isError: true
-      };
-    };
-    mcpErrorJson = (error) => {
-      return safeStringifyJson("mcp-error-json", error).match(
-        (success) => buildMcpError([{ type: "text", text: success }]),
-        (error2) => buildMcpError([
-          { type: "text", text: JSON.stringify(error2, null, 2) }
-        ])
-      );
-    };
-    mcpError = async (err9) => {
-      const { error } = err9;
-      if (isFetchError(error)) {
-        switch (error.cause) {
-          case "network":
-          case "parse":
-            return mcpErrorJson({ ...error });
-          case "http":
-            const { response, ...rest } = error;
-            const parseResponseResult = await safeParseResponse(
-              "mcp-error-fetch-parse-response",
-              response
-            );
-            return buildMcpError([
-              { type: "text", text: JSON.stringify(rest, null, 2) },
-              ...parseResponseResult.match(
-                (success) => [parsedResponseToToolContentPart(success)],
-                () => []
-              )
-            ]);
-        }
-      }
-      return mcpErrorJson({ ...error });
-    };
-    mcpErrorFetch = async (surface3, response) => {
-      return mcpError(fetchHttpErr(surface3, response));
-    };
-  }
-});
-
-// src/server/tools/response/success.ts
-var buildMcpSuccess, mcpSuccessJson, mcpSuccessResponse;
-var init_success = __esm({
-  "src/server/tools/response/success.ts"() {
-    init_json();
-    init_error();
-    init_lib();
-    buildMcpSuccess = (content) => {
-      return {
-        content
-      };
-    };
-    mcpSuccessJson = (data) => {
-      return safeStringifyJson("mcp-success-text", data).match(
-        (success) => buildMcpSuccess([{ type: "text", text: success }]),
-        (error) => mcpErrorJson(error)
-      );
-    };
-    mcpSuccessResponse = (data, extra) => {
-      const parsedExtra = extra ? safeStringifyJson("mcp-success-extra", extra).match(
-        (success) => success,
-        () => void 0
-      ) : void 0;
-      return buildMcpSuccess([
-        parsedResponseToToolContentPart(data),
-        ...parsedExtra ? [{ type: "text", text: parsedExtra }] : []
-      ]);
-    };
-  }
-});
-
-// src/server/tools/response/index.ts
-var init_response = __esm({
-  "src/server/tools/response/index.ts"() {
-    init_success();
-    init_error();
-  }
-});
-var requestSchema, buildRequest;
-var init_request = __esm({
-  "src/server/tools/lib/request.ts"() {
-    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"),
-      headers: z$1.record(z$1.string(), z$1.string()).optional().describe("Additional headers to include").default({})
-    });
-    buildRequest = (input) => {
-      return new Request(input.url, {
-        method: input.method,
-        body: input.body ? typeof input.body === "string" ? input.body : JSON.stringify(input.body) : void 0,
-        headers: {
-          ...input.body ? { "Content-Type": "application/json" } : {},
-          ...input.headers
-        }
-      });
-    };
-  }
-});
-var getBaseUrl, getDepositLink, openDepositLink;
-var init_utils = __esm({
-  "src/shared/utils.ts"() {
-    getBaseUrl = (dev) => {
-      return dev ? "http://localhost:3000" : "https://x402scan.com";
-    };
-    getDepositLink = (address, flags) => {
-      return `${getBaseUrl(flags.dev)}/mcp/deposit/${address}`;
-    };
-    openDepositLink = async (address, flags) => {
-      const depositLink = getDepositLink(address, flags);
-      await open(depositLink);
-    };
-  }
-});
-
-// src/shared/balance.ts
-var getBalance;
-var init_balance = __esm({
-  "src/shared/balance.ts"() {
-    init_utils();
-    init_fetch();
-    getBalance = async ({
-      address,
-      flags,
-      surface: surface3
-    }) => {
-      const url = `${getBaseUrl(flags.dev)}/api/rpc/balance/${address}`;
-      const res = await safeFetchJson(
-        surface3,
-        new Request(url, {
-          method: "GET",
-          headers: {
-            accept: "application/json"
-          }
-        })
-      );
-      return res;
-    };
-  }
-});
-var errorType2, fsErr, fsResultFromPromise, safeReadFile, safeWriteFile, safeAppendFile, safeChmod, safeFileExists;
-var init_fs = __esm({
-  "src/shared/neverthrow/fs/index.ts"() {
-    errorType2 = "fs";
-    fsErr = (surface3, error) => err(errorType2, surface3, error);
-    fsResultFromPromise = (surface3, promise, error) => resultFromPromise(errorType2, surface3, promise, error);
-    safeReadFile = (surface3, path3) => fsResultFromPromise(surface3, fs.readFile(path3, "utf-8"), () => ({
-      cause: "file_not_readable",
-      message: "Failed to read file"
-    }));
-    safeWriteFile = (surface3, path3, data) => fsResultFromPromise(surface3, fs.writeFile(path3, data), () => ({
-      cause: "file_not_writable",
-      message: "Failed to write file"
-    }));
-    safeAppendFile = (surface3, path3, data) => fsResultFromPromise(surface3, fs.appendFile(path3, data), () => ({
-      cause: "file_not_writable",
-      message: "Failed to append file"
-    }));
-    safeChmod = (surface3, path3, mode) => fsResultFromPromise(surface3, fs.chmod(path3, mode), () => ({
-      cause: "file_not_chmodable",
-      message: "Failed to chmod file"
-    }));
-    safeFileExists = (surface3, path3) => {
-      const fileExists = existsSync(path3);
-      if (fileExists) {
-        return ok(true);
-      }
-      return err(errorType2, surface3, {
-        cause: "file_not_found",
-        message: "File not found"
-      });
-    };
-  }
-});
-var BASE_DIRECTORY, configFile;
-var init_fs2 = __esm({
-  "src/shared/fs.ts"() {
-    BASE_DIRECTORY = join(homedir(), ".x402scan-mcp");
-    if (!fs2.existsSync(BASE_DIRECTORY)) {
-      fs2.mkdirSync(BASE_DIRECTORY, { recursive: true });
-    }
-    configFile = (name, defaultValue) => {
-      if (!fs2.existsSync(BASE_DIRECTORY)) {
-        fs2.mkdirSync(BASE_DIRECTORY, { recursive: true });
-      }
-      const filePath = join(BASE_DIRECTORY, name);
-      if (!fs2.existsSync(filePath)) {
-        fs2.writeFileSync(filePath, defaultValue);
-      }
-      return filePath;
-    };
-  }
-});
-
-// src/shared/log.ts
-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}
-`;
-  safeAppendFile("log", LOG_FILE, line);
-  if (process.env.X402_DEBUG === "true") {
-    console.error(`[x402scan] ${formatted}`);
-  }
-}
-var LOG_FILE, DEBUG, log;
-var init_log = __esm({
-  "src/shared/log.ts"() {
-    init_fs();
-    init_fs2();
-    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
-    };
-  }
-});
-
-// src/server/tools/lib/check-balance.ts
-var checkBalance;
-var init_check_balance = __esm({
-  "src/server/tools/lib/check-balance.ts"() {
-    init_balance();
-    init_utils();
-    init_log();
-    checkBalance = async ({
-      server,
-      address,
-      amountNeeded,
-      message,
-      flags,
-      surface: surface3
-    }) => {
-      const balanceResult = await getBalance({ address, flags, surface: surface3 });
-      if (balanceResult.isErr()) {
-        log.error(JSON.stringify(balanceResult.error, null, 2));
-        return;
-      }
-      const balance = balanceResult.value;
-      if (balance.balance < amountNeeded) {
-        const capabilities = server.server.getClientCapabilities();
-        if (!capabilities?.elicitation) {
-          throw new Error(
-            `${message(balance.balance)}
-
-You can deposit USDC at ${getDepositLink(address, flags)}`
-          );
-        }
-        const result = await server.server.elicitInput({
-          mode: "form",
-          message: message(balance.balance),
-          requestedSchema: {
-            type: "object",
-            properties: {}
-          }
-        });
-        if (result.action === "accept") {
-          await openDepositLink(address, flags);
-        }
-      }
-      return balance.balance;
-    };
-  }
-});
-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/shared/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/shared/token.ts"() {
-    tokenStringToNumber = (amount, decimals = 6) => {
-      return Number(formatUnits(BigInt(amount), decimals));
-    };
-  }
-});
-var errorType3, x402Err, x402ResultFromPromise, x402ResultFromThrowable, safeGetPaymentRequired, safeCreatePaymentPayload, safeGetPaymentSettlement, safeCreateSIWxPayload;
-var init_x402 = __esm({
-  "src/shared/neverthrow/x402/index.ts"() {
-    errorType3 = "x402";
-    x402Err = (cause, error) => err(errorType3, cause, error);
-    x402ResultFromPromise = (surface3, promise, error) => resultFromPromise(errorType3, surface3, promise, error);
-    x402ResultFromThrowable = (surface3, fn, error) => resultFromThrowable(errorType3, surface3, fn, error);
-    safeGetPaymentRequired = (surface3, client, response) => {
-      return x402ResultFromPromise(
-        surface3,
-        response.json().then(
-          (json) => client.getPaymentRequiredResponse(
-            (name) => response.headers.get(name),
-            json
-          ),
-          () => client.getPaymentRequiredResponse((name) => response.headers.get(name))
-        ),
-        (error) => ({
-          cause: "parse_payment_required",
-          message: error instanceof Error ? error.message : "Failed to parse payment required"
-        })
-      );
-    };
-    safeCreatePaymentPayload = (surface3, client, paymentRequired) => {
-      return x402ResultFromPromise(
-        surface3,
-        client.createPaymentPayload(paymentRequired),
-        (error) => ({
-          cause: "create_payment_payload",
-          message: error instanceof Error ? error.message : "Failed to create payment payload"
-        })
-      );
-    };
-    safeGetPaymentSettlement = (surface3, client, response) => {
-      return x402ResultFromThrowable(
-        surface3,
-        () => client.getPaymentSettleResponse((name) => response.headers.get(name)),
-        (error) => ({
-          cause: "get_payment_settlement",
-          message: error instanceof Error ? error.message : "Failed to get payment settlement"
-        })
-      );
-    };
-    safeCreateSIWxPayload = (surface3, serverInfo, signer) => {
-      return x402ResultFromPromise(
-        surface3,
-        createSIWxPayload(serverInfo, signer),
-        (error) => ({
-          cause: "create_siwx_payload",
-          message: error instanceof Error ? error.message : "Failed to create SIWX payload"
-        })
-      );
-    };
-  }
-});
-function safeWrapFetchWithPayment(client) {
-  return async (input, init) => {
-    const request = new Request(input, init);
-    const clonedRequest = request.clone();
-    const probeResult = await safeFetch(toolName, request);
-    if (probeResult.isErr()) {
-      return probeResult;
-    }
-    if (probeResult.value.status !== 402) {
-      return probeResult;
-    }
-    const response = probeResult.value;
-    const paymentRequiredResult = await safeGetPaymentRequired(
-      toolName,
-      client,
-      response
-    );
-    if (paymentRequiredResult.isErr()) {
-      return paymentRequiredResult;
-    }
-    const paymentRequired = paymentRequiredResult.value;
-    const paymentPayloadResult = await safeCreatePaymentPayload(
-      toolName,
-      client,
-      paymentRequired
-    );
-    if (paymentPayloadResult.isErr()) {
-      return paymentPayloadResult;
-    }
-    const paymentPayload = paymentPayloadResult.value;
-    const paymentHeaders = client.encodePaymentSignatureHeader(paymentPayload);
-    if (clonedRequest.headers.has("PAYMENT-SIGNATURE") || clonedRequest.headers.has("X-PAYMENT")) {
-      return x402Err(toolName, {
-        cause: "payment_already_attempted",
-        message: "Payment already attempted"
-      });
-    }
-    for (const [key, value] of Object.entries(paymentHeaders)) {
-      clonedRequest.headers.set(key, value);
-    }
-    clonedRequest.headers.set(
-      "Access-Control-Expose-Headers",
-      "PAYMENT-RESPONSE,X-PAYMENT-RESPONSE"
-    );
-    return await safeFetch(toolName, clonedRequest);
-  };
-}
-var toolName, registerFetchX402ResourceTool;
-var init_x402_fetch = __esm({
-  "src/server/tools/x402-fetch.ts"() {
-    init_fetch();
-    init_response();
-    init_request();
-    init_check_balance();
-    init_networks();
-    init_token();
-    init_x402();
-    toolName = "fetch";
-    registerFetchX402ResourceTool = ({
-      server,
-      account,
-      flags
-    }) => {
-      server.registerTool(
-        toolName,
-        {
-          description: "Makes an http fetch request. If the request is to an x402-protected resource, it will handle payment automatically.",
-          inputSchema: requestSchema
-        },
-        async (input) => {
-          const coreClient = x402Client.fromConfig({
-            schemes: [
-              { network: DEFAULT_NETWORK, client: new ExactEvmScheme(account) }
-            ]
-          });
-          coreClient.onBeforePaymentCreation(async ({ selectedRequirements }) => {
-            const amount = tokenStringToNumber(selectedRequirements.amount);
-            await checkBalance({
-              surface: toolName,
-              server,
-              address: account.address,
-              amountNeeded: amount,
-              message: (balance) => `This request costs ${amount} USDC. Your current balance is ${balance} USDC.`,
-              flags
-            });
-          });
-          const client = new x402HTTPClient(coreClient);
-          const fetchWithPay = safeWrapFetchWithPayment(client);
-          const fetchResult = await fetchWithPay(buildRequest(input));
-          if (fetchResult.isErr()) {
-            return mcpError(fetchResult);
-          }
-          const response = fetchResult.value;
-          if (!response.ok) {
-            return mcpErrorFetch(toolName, response);
-          }
-          const parseResponseResult = await safeParseResponse(toolName, response);
-          if (parseResponseResult.isErr()) {
-            return mcpError(parseResponseResult);
-          }
-          const settlementResult = safeGetPaymentSettlement(
-            toolName,
-            client,
-            response
-          );
-          return mcpSuccessResponse(
-            parseResponseResult.value,
-            settlementResult.isOk() ? { payment: settlementResult.value } : void 0
-          );
-        }
-      );
-    };
-  }
-});
-
-// src/server/lib/x402-extensions.ts
-var getBazaarExtension, getInputSchema, getSiwxExtension;
-var init_x402_extensions = __esm({
-  "src/server/lib/x402-extensions.ts"() {
-    getBazaarExtension = (extensions) => {
-      const { bazaar } = extensions ?? {};
-      if (!bazaar) {
-        return void 0;
-      }
-      return bazaar;
-    };
-    getInputSchema = (extensions) => getBazaarExtension(extensions)?.schema.properties.input;
-    getSiwxExtension = (extensions) => {
-      const siwx = extensions?.["sign-in-with-x"];
-      if (!siwx?.info) {
-        return void 0;
-      }
-      return siwx.info;
-    };
-  }
-});
-var toolName2, registerAuthTools;
-var init_auth_fetch = __esm({
-  "src/server/tools/auth-fetch.ts"() {
-    init_fetch();
-    init_x402();
-    init_response();
-    init_request();
-    init_x402_extensions();
-    toolName2 = "fetchWithAuth";
-    registerAuthTools = ({ server, account }) => {
-      server.registerTool(
-        toolName2,
-        {
-          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: requestSchema
-        },
-        async (input) => {
-          const httpClient = new x402HTTPClient(new x402Client());
-          const firstResult = await safeFetch(toolName2, buildRequest(input));
-          if (firstResult.isErr()) {
-            return mcpError(firstResult);
-          }
-          const firstResponse = firstResult.value;
-          if (firstResponse.status !== 402) {
-            if (!firstResponse.ok) {
-              return mcpErrorFetch(toolName2, firstResponse);
-            }
-            const parseResponseResult2 = await safeParseResponse(
-              toolName2,
-              firstResponse
-            );
-            if (parseResponseResult2.isErr()) {
-              return mcpError(parseResponseResult2);
-            }
-            return mcpSuccessResponse(parseResponseResult2.value);
-          }
-          const getPaymentRequiredResult = await safeGetPaymentRequired(
-            toolName2,
-            httpClient,
-            firstResponse
-          );
-          if (getPaymentRequiredResult.isErr()) {
-            return mcpError(getPaymentRequiredResult);
-          }
-          const paymentRequired = getPaymentRequiredResult.value;
-          const siwxExtension = getSiwxExtension(paymentRequired.extensions);
-          if (!siwxExtension) {
-            return mcpErrorJson({
-              message: "Endpoint returned 402 but no sign-in-with-x extension found",
-              statusCode: 402,
-              extensions: Object.keys(paymentRequired.extensions ?? {}),
-              hint: "This endpoint may require payment instead of authentication. Use execute_call for paid requests."
-            });
-          }
-          const serverInfo = siwxExtension;
-          const requiredFields = [
-            "domain",
-            "uri",
-            "version",
-            "chainId",
-            "nonce",
-            "issuedAt"
-          ];
-          const missingFields = requiredFields.filter(
-            (f) => !serverInfo[f]
-          );
-          if (missingFields.length > 0) {
-            return mcpErrorJson({
-              message: "Invalid sign-in-with-x extension: missing required fields",
-              missingFields,
-              receivedInfo: { ...serverInfo }
-            });
-          }
-          if (serverInfo.chainId.startsWith("solana:")) {
-            return mcpErrorJson({
-              message: "Solana authentication not supported",
-              chainId: serverInfo.chainId,
-              hint: "This endpoint requires a Solana wallet. The MCP server currently only supports EVM wallets."
-            });
-          }
-          const payloadResult = await safeCreateSIWxPayload(
-            toolName2,
-            serverInfo,
-            account
-          );
-          if (payloadResult.isErr()) {
-            return mcpError(payloadResult);
-          }
-          const siwxHeader = encodeSIWxHeader(payloadResult.value);
-          const authedRequest = buildRequest(input);
-          authedRequest.headers.set("SIGN-IN-WITH-X", siwxHeader);
-          const authedResult = await safeFetch(toolName2, authedRequest);
-          if (authedResult.isErr()) {
-            return mcpError(authedResult);
-          }
-          const authedResponse = authedResult.value;
-          if (!authedResponse.ok) {
-            return mcpErrorFetch(toolName2, authedResponse);
-          }
-          const parseResponseResult = await safeParseResponse(
-            toolName2,
-            authedResponse
-          );
-          if (parseResponseResult.isErr()) {
-            return mcpError(parseResponseResult);
-          }
-          return mcpSuccessResponse(parseResponseResult.value, {
-            authentication: {
-              address: account.address,
-              domain: serverInfo.domain,
-              chainId: serverInfo.chainId
-            }
-          });
-        }
-      );
-    };
-  }
-});
-
-// src/server/tools/wallet.ts
-var toolName3, registerWalletTools;
-var init_wallet = __esm({
-  "src/server/tools/wallet.ts"() {
-    init_balance();
-    init_networks();
-    init_utils();
-    init_response();
-    toolName3 = "getWalletInfo";
-    registerWalletTools = ({
-      server,
-      account: { address },
-      flags
-    }) => {
-      server.registerTool(
-        toolName3,
-        {
-          description: "Check wallet address and USDC balance. Creates wallet if needed."
-        },
-        async () => {
-          const balanceResult = await getBalance({
-            address,
-            flags,
-            surface: toolName3
-          });
-          if (balanceResult.isErr()) {
-            return mcpError(balanceResult);
-          }
-          const { balance } = balanceResult.value;
-          return mcpSuccessJson({
-            address,
-            network: DEFAULT_NETWORK,
-            networkName: getChainName(DEFAULT_NETWORK),
-            usdcBalance: balance,
-            isNewWallet: balance === 0,
-            depositLink: getDepositLink(address, flags),
-            ...balance < 2.5 ? {
-              message: `Your balance is low. Consider topping it up`
-            } : {}
-          });
-        }
-      );
-    };
-  }
-});
-var toolName4, registerCheckX402EndpointTool;
-var init_check_endpoint = __esm({
-  "src/server/tools/check-endpoint.ts"() {
-    init_fetch();
-    init_response();
-    init_log();
-    init_token();
-    init_x402();
-    init_x402_extensions();
-    init_request();
-    toolName4 = "checkEndpointSchema";
-    registerCheckX402EndpointTool = ({ server }) => {
-      server.registerTool(
-        toolName4,
-        {
-          description: "Check if an endpoint is x402-protected and get pricing options, schema, and auth requirements (if applicable).",
-          inputSchema: requestSchema
-        },
-        async (input) => {
-          log.info("Querying endpoint", input);
-          const responseResult = await safeFetch(toolName4, buildRequest(input));
-          if (responseResult.isErr()) {
-            return mcpError(responseResult);
-          }
-          const response = responseResult.value;
-          if (response.status !== 402) {
-            if (!response.ok) {
-              return mcpErrorFetch(toolName4, response);
-            }
-            const parseResponseResult = await safeParseResponse(toolName4, response);
-            if (parseResponseResult.isErr()) {
-              return mcpError(parseResponseResult);
-            }
-            return mcpSuccessResponse(parseResponseResult.value, {
-              requiresPayment: false
-            });
-          }
-          const client = new x402HTTPClient(new x402Client());
-          const paymentRequiredResult = await safeGetPaymentRequired(
-            toolName4,
-            client,
-            response
-          );
-          if (paymentRequiredResult.isErr()) {
-            return mcpError(paymentRequiredResult);
-          }
-          const { resource, extensions, accepts } = paymentRequiredResult.value;
-          return mcpSuccessJson({
-            requiresPayment: true,
-            statusCode: response.status,
-            routeDetails: {
-              ...resource,
-              schema: getInputSchema(extensions),
-              paymentMethods: accepts.map((accept) => ({
-                price: tokenStringToNumber(accept.amount),
-                network: accept.network,
-                asset: accept.asset
-              }))
-            }
-          });
-        }
-      );
-    };
-  }
-});
-var STATE_FILE, stateSchema, getState, setState;
-var init_state = __esm({
-  "src/shared/state.ts"() {
-    init_fs2();
-    init_log();
-    STATE_FILE = configFile("state.json", "{}");
-    stateSchema = z$1.looseObject({
-      redeemedCodes: z$1.array(z$1.string())
-    }).partial();
-    getState = () => {
-      const result = stateSchema.safeParse(
-        JSON.parse(fs2__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 });
-      fs2__default.writeFileSync(STATE_FILE, JSON.stringify(newState, null, 2));
-    };
-  }
-});
-var redeemInviteCode;
-var init_redeem_invite = __esm({
-  "src/shared/redeem-invite.ts"() {
-    init_fetch();
-    init_utils();
-    init_state();
-    redeemInviteCode = async ({
-      code,
-      dev,
-      address,
-      surface: surface3
-    }) => {
-      const state = getState();
-      if (state.redeemedCodes?.includes(code)) {
-        return err("user", surface3, {
-          cause: "conflict",
-          message: "This invite code has already been redeemed"
-        });
-      }
-      const result = await safeFetchJson(
-        surface3,
-        new Request(`${getBaseUrl(dev)}/api/invite/redeem`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            code,
-            recipientAddr: address
-          })
-        })
-      );
-      if (result.isOk()) {
-        setState({
-          redeemedCodes: [...state.redeemedCodes ?? [], code]
-        });
-      }
-      return result;
-    };
-  }
-});
-var toolName5, registerRedeemInviteTool;
-var init_redeem_invite2 = __esm({
-  "src/server/tools/redeem-invite.ts"() {
-    init_response();
-    init_redeem_invite();
-    toolName5 = "redeemInvite";
-    registerRedeemInviteTool = ({
-      server,
-      account: { address },
-      flags
-    }) => {
-      server.registerTool(
-        toolName5,
-        {
-          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 result = await redeemInviteCode({
-            code,
-            dev: flags.dev,
-            address,
-            surface: toolName5
-          });
-          if (result.isErr()) {
-            return mcpError(result);
-          }
-          const { amount, txHash } = result.value;
-          return mcpSuccessJson({
-            redeemed: true,
-            amount: `${amount} USDC`,
-            txHash
-          });
-        }
-      );
-    };
-  }
-});
-function getVersion() {
-  {
-    return "0.0.7-beta.1";
-  }
-}
-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 toolName6, registerTelemetryTools;
-var init_telemetry = __esm({
-  "src/server/tools/telemetry.ts"() {
-    init_fetch();
-    init_log();
-    init_utils();
-    init_version();
-    init_response();
-    toolName6 = "reportError";
-    registerTelemetryTools = ({
-      server,
-      account: { address },
-      flags
-    }) => {
-      server.registerTool(
-        toolName6,
-        {
-          description: "EMERGENCY ONLY. Report critical MCP tool bugs. Do NOT use for normal errors (balance, network, 4xx) - those are recoverable.",
-          inputSchema: z$1.object({
-            tool: z$1.string().describe("MCP tool name"),
-            resource: z$1.string().optional().describe("x402 resource URL"),
-            summary: z$1.string().describe("1-2 sentence summary"),
-            errorMessage: z$1.string().describe("Error message"),
-            stack: z$1.string().optional().describe("Stack trace"),
-            fullReport: z$1.string().optional().describe("Detailed report with context, logs, repro steps")
-          })
-        },
-        async (input) => {
-          log.info("Submitting error report", {
-            tool: input.tool,
-            resource: input.resource,
-            summary: input.summary
-          });
-          const telemetryResult = await safeFetchJson(
-            toolName6,
-            new Request(`${getBaseUrl(flags.dev)}/api/telemetry`, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json"
-              },
-              body: JSON.stringify({
-                ...input,
-                walletAddress: address,
-                mcpVersion: MCP_VERSION,
-                reportedAt: (/* @__PURE__ */ new Date()).toISOString()
-              })
-            })
-          );
-          if (telemetryResult.isErr()) {
-            log.error("Failed to submit error report", telemetryResult.error);
-            return mcpError(telemetryResult);
-          }
-          const { reportId } = telemetryResult.value;
-          log.info("Error report submitted successfully", {
-            reportId
-          });
-          return mcpSuccessJson({
-            submitted: true,
-            reportId,
-            message: "Error report submitted successfully. The x402scan team will investigate."
-          });
-        }
-      );
-    };
-  }
-});
-function registerDiscoveryTools(server) {
-  server.registerTool(
-    "discover_resources",
-    {
-      description: `Discover x402-protected resources on an origin. Returns a list of resource URLs.
-        Use check_x402_endpoint separately to get detailed pricing/schema info for specific 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"
-        )
-      }
-    },
-    async ({ url }) => {
-      const origin = URL.canParse(url) ? new URL(url).origin : url;
-      const hostname = URL.canParse(origin) ? new URL(origin).hostname : origin;
-      log.info(`Discovering resources for origin: ${origin}`);
-      const wellKnownUrl = `${origin}/.well-known/x402`;
-      log.debug(`Fetching discovery document from: ${wellKnownUrl}`);
-      const wellKnownResult = await safeFetchJson(
-        toolName7,
-        new Request(wellKnownUrl, { headers: { Accept: "application/json" } })
-      );
-      if (wellKnownResult.isOk()) {
-        const parsed = discoveryDocumentSchema.safeParse(wellKnownResult.value);
-        if (parsed.success) {
-          return mcpSuccessJson({
-            found: true,
-            origin,
-            source: "well-known",
-            data: parsed.data
-          });
-        }
-      } else {
-        log.info(
-          `No well-known x402 discovery document found at ${wellKnownUrl}`
-        );
-      }
-      const dnsQuery = `_x402.${hostname}`;
-      log.debug(`Looking up DNS TXT record: ${dnsQuery}`);
-      const dnsResult = await safeFetchJson(
-        toolName7,
-        new Request(
-          `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(dnsQuery)}&type=TXT`,
-          { headers: { Accept: "application/dns-json" } }
-        )
-      );
-      if (dnsResult.isOk() && dnsResult.value.Answer && dnsResult.value.Answer.length > 0) {
-        const dnsUrl = dnsResult.value.Answer[0].data.replace(/^"|"$/g, "");
-        if (URL.canParse(dnsUrl)) {
-          const dnsDocResult = await safeFetchJson(
-            toolName7,
-            new Request(dnsUrl, { headers: { Accept: "application/json" } })
-          );
-          if (dnsDocResult.isOk()) {
-            const parsed = discoveryDocumentSchema.safeParse(
-              dnsDocResult.value
-            );
-            if (parsed.success) {
-              return mcpSuccessJson({
-                found: true,
-                origin,
-                source: "dns-txt",
-                data: parsed.data
-              });
-            }
-          }
-        } else {
-          log.debug(`DNS TXT value is not a valid URL: ${dnsUrl}`);
-        }
-      } else {
-        log.info(`No DNS TXT record found for ${dnsQuery}`);
-      }
-      const llmsTxtUrl = `${origin}/llms.txt`;
-      log.debug(`Fetching llms.txt from: ${llmsTxtUrl}`);
-      const llmsResult = await safeFetch(
-        toolName7,
-        new Request(llmsTxtUrl, { headers: { Accept: "text/plain" } })
-      );
-      if (llmsResult.isOk()) {
-        const parseResult = await safeParseResponse(toolName7, llmsResult.value);
-        if (parseResult.isOk() && parseResult.value.type === "text") {
-          return mcpSuccessJson({
-            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.",
-            data: parseResult.value
-          });
-        }
-      }
-      return mcpErrorJson({
-        found: false,
-        origin,
-        error: "No discovery document found. Tried: .well-known/x402, DNS TXT record, llms.txt"
-      });
-    }
-  );
-}
-var toolName7, discoveryDocumentSchema;
-var init_discover_resources = __esm({
-  "src/server/tools/discover-resources.ts"() {
-    init_log();
-    init_fetch();
-    init_response();
-    toolName7 = "discoverResources";
-    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()
-    });
-  }
-});
-var surface, getWebPageMetadata, parseMetadataFromResponse;
-var init_lib2 = __esm({
-  "src/server/resources/_lib.ts"() {
-    init_fetch();
-    surface = "getWebPageMetadata";
-    getWebPageMetadata = (url) => {
-      return safeFetch(surface, new Request(url)).andThen((response) => safeParseResponse(surface, response)).andThen((parsedResponse) => {
-        if (parsedResponse.type === "text") {
-          return ok(parseMetadataFromResponse(parsedResponse.data));
-        }
-        return err("user", surface, {
-          cause: "invalid_response_type",
-          message: "Invalid response type"
-        });
-      });
-    };
-    parseMetadataFromResponse = (html) => {
-      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
-      };
-    };
-  }
-});
-var origins, registerOrigins, getResourceResponse;
-var init_origins = __esm({
-  "src/server/resources/origins.ts"() {
-    init_lib2();
-    init_x402_extensions();
-    origins = ["enrichx402.com"];
-    registerOrigins = async ({ server }) => {
-      await Promise.all(
-        origins.map(async (origin) => {
-          const metadataResult = await getWebPageMetadata(`https://${origin}`);
-          const metadata = metadataResult.isOk() ? metadataResult.value : null;
-          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 = getInputSchema(
-                          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;
-    };
-  }
-});
-var type2, parseErr, safeParse;
-var init_parse = __esm({
-  "src/shared/neverthrow/parse/index.ts"() {
-    type2 = "json";
-    parseErr = (surface3, error) => err(type2, surface3, error);
-    safeParse = (surface3, schema, value) => {
-      const parseResult = schema.safeParse(value);
-      if (!parseResult.success) {
-        return parseErr(surface3, {
-          cause: "invalid_data",
-          message: JSON.stringify(z$1.treeifyError(parseResult.error), null, 2),
-          error: parseResult.error
-        });
-      }
-      return ok(parseResult.data);
-    };
-  }
-});
-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 ok({ account: account2, isNew: false });
-  }
-  const readFileResult = await safeReadFile(walletSurface, WALLET_FILE);
-  if (!readFileResult.isOk()) {
-    const fileExistsResult = safeFileExists(walletSurface, WALLET_FILE);
-    if (fileExistsResult.isOk()) {
-      return fsErr(walletSurface, {
-        cause: "file_not_readable",
-        message: `The file exists but is not readable. Fix corrupted state file: ${WALLET_FILE}`
-      });
-    }
-  }
-  if (readFileResult.isOk()) {
-    const data = readFileResult.value;
-    const jsonParseResult = safeParseJson(walletSurface, data);
-    if (jsonParseResult.isErr()) {
-      return jsonErr(walletSurface, {
-        cause: "parse",
-        message: `The data in ${WALLET_FILE} is not valid JSON`
-      });
-    }
-    const parseResult = safeParse(
-      walletSurface,
-      storedWalletSchema,
-      jsonParseResult.value
-    );
-    if (parseResult.isErr()) {
-      return parseResult;
-    }
-    const account2 = privateKeyToAccount(parseResult.value.privateKey);
-    log.info(`Loaded wallet: ${account2.address}`);
-    return ok({ account: account2, isNew: false });
-  }
-  const privateKey = generatePrivateKey();
-  const account = privateKeyToAccount(privateKey);
-  const stored = {
-    privateKey,
-    address: account.address,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const saveResult = await safeWriteFile(
-    walletSurface,
-    WALLET_FILE,
-    JSON.stringify(stored, null, 2)
-  ).andThen(() => safeChmod(walletSurface, WALLET_FILE, 384));
-  if (saveResult.isErr()) {
-    return saveResult;
-  }
-  log.info(`Created wallet: ${account.address}`);
-  log.info(`Saved to: ${WALLET_FILE}`);
-  return ok({ account, isNew: true });
-}
-var WALLET_FILE, storedWalletSchema, walletSurface;
-var init_wallet2 = __esm({
-  "src/shared/wallet.ts"() {
-    init_fs();
-    init_json();
-    init_parse();
-    init_log();
-    init_fs2();
-    WALLET_FILE = configFile("wallet.json", "");
-    storedWalletSchema = z$1.object({
-      privateKey: z$1.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid Ethereum private key").transform((privateKey) => privateKey),
-      address: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address").transform((address) => getAddress(address)),
-      createdAt: z$1.string()
-    });
-    walletSurface = "wallet";
-  }
-});
-
-// src/server/index.ts
-var server_exports = {};
-__export(server_exports, {
-  startServer: () => startServer
-});
-var startServer;
-var init_server = __esm({
-  "src/server/index.ts"() {
-    init_x402_fetch();
-    init_auth_fetch();
-    init_wallet();
-    init_check_endpoint();
-    init_redeem_invite2();
-    init_telemetry();
-    init_discover_resources();
-    init_origins();
-    init_version();
-    init_log();
-    init_wallet2();
-    init_redeem_invite();
-    startServer = async (flags) => {
-      log.info("Starting x402scan-mcp...");
-      const { dev, invite } = flags;
-      const walletResult = await getWallet();
-      if (walletResult.isErr()) {
-        log.error(JSON.stringify(walletResult.error, null, 2));
-        console.error(walletResult.error);
-        process.exit(1);
-      }
-      const { account } = walletResult.value;
-      const code = invite ?? process.env.INVITE_CODE;
-      if (code) {
-        await redeemInviteCode({
-          code,
-          dev,
-          address: account.address,
-          surface: "startServer"
-        });
-      }
-      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
-      };
-      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/cli/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(chalk2.bold.red("No MCP client selected"));
-      process.exit(0);
-    };
-  }
-});
-var Platforms, getPlatformPath;
-var init_platforms = __esm({
-  "src/cli/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 errorType4, surface2, configResultFromThrowable;
-var init_result = __esm({
-  "src/cli/install/2-add-server/lib/result.ts"() {
-    errorType4 = "config";
-    surface2 = "config_file";
-    configResultFromThrowable = (fn, error) => resultFromThrowable(errorType4, surface2, fn, error);
-  }
-});
-var parseContent, parseClientConfig, serializeJsonc, serializeClientConfig, stringifyObject;
-var init_file_types = __esm({
-  "src/cli/install/2-add-server/lib/file-types.ts"() {
-    init_fs();
-    init_result();
-    parseContent = (fileContent, format2, path3) => {
-      return configResultFromThrowable(
-        () => {
-          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
-          };
-        },
-        (e) => ({
-          cause: "parse_config",
-          message: e instanceof Error ? e.message : "Failed to parse config file"
-        })
-      );
-    };
-    parseClientConfig = async ({ format: format2, path: path3 }) => {
-      const readResult = await safeReadFile("config_file", path3);
-      if (readResult.isErr()) return readResult;
-      const parseResult = parseContent(readResult.value, format2, path3);
-      if (parseResult.isErr()) return parseResult;
-      return parseResult;
-    };
-    serializeJsonc = (config, originalContent) => {
-      return configResultFromThrowable(
-        () => {
-          const modifications = [];
-          for (const key of Object.keys(config)) {
-            const keyPath = [key];
-            const edits = jsonc.modify(originalContent, keyPath, config[key], {
-              formattingOptions: { tabSize: 2, insertSpaces: true }
-            });
-            modifications.push(...edits);
-          }
-          return jsonc.applyEdits(originalContent, modifications);
-        },
-        (e) => ({
-          cause: "serialize_config",
-          message: e instanceof Error ? e.message : "Failed to serialize JSONC"
-        })
-      );
-    };
-    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) {
-        const result = serializeJsonc(config, originalContent);
-        if (result.isOk()) {
-          return result.value;
-        }
-        console.log(`Error applying JSONC edits: ${result.error.message}`);
-        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/cli/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 (fs2__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/cli/install/2-add-server/lib/nested-values.ts
-var getNestedValue, setNestedValue;
-var init_nested_values = __esm({
-  "src/cli/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/cli/install/2-add-server/lib/index.ts
-var init_lib3 = __esm({
-  "src/cli/install/2-add-server/lib/index.ts"() {
-    init_client_config_file();
-    init_file_types();
-    init_nested_values();
-    init_platforms();
-  }
-});
-var wait;
-var init_wait = __esm({
-  "src/cli/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);
-    };
-  }
-});
-var getMcpConfig, addServer, formatDiffByFormat;
-var init_add_server = __esm({
-  "src/cli/install/2-add-server/index.ts"() {
-    init_fs();
-    init_log();
-    init_clients();
-    init_lib3();
-    init_version();
-    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}`]
-      };
-    };
-    addServer = async (client, globalFlags) => {
-      const { serverName, command, args } = getMcpConfig(globalFlags);
-      if (client === "warp" /* Warp */) {
-        log$1.info(
-          chalk2.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) {
-          return err("user", "install", {
-            cause: "warp_mcp_server_not_added",
-            message: "Warp MCP server not added"
-          });
-        }
-      }
-      const clientFileTarget = getClientConfigFile(client);
-      const { name } = clientMetadata[client];
-      let config = {};
-      let content = void 0;
-      log.info(`Checking if config file exists at: ${clientFileTarget.path}`);
-      if (!fs2__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 parseResult = await parseClientConfig(clientFileTarget);
-        if (parseResult.isErr()) {
-          log$1.error(
-            chalk2.bold.red(`Error reading config: ${parseResult.error.message}`)
-          );
-          outro(chalk2.bold.red(`Error adding x402scan MCP to ${name}`));
-          process.exit(1);
-        }
-        const { config: rawConfig, fileContent } = parseResult.value;
-        config = rawConfig;
-        content = fileContent;
-        const existingValue = getNestedValue(rawConfig, clientFileTarget.configKey);
-        if (!existingValue) {
-          setNestedValue(rawConfig, clientFileTarget.configKey, {});
-        }
-        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(
-          chalk2.bold.red(
-            `Invalid ${clientFileTarget.configKey} structure in config`
-          )
-        );
-        outro(chalk2.bold.red(`Error adding x402scan MCP to ${name}`));
-        process.exit(1);
-      }
-      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));
-        log$1.step(
-          `The following will be added to ${chalk2.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(chalk2.bold.red("Installation cancelled"));
-        process.exit(0);
-      }
-      const configContent = serializeClientConfig(
-        clientFileTarget,
-        config,
-        content
-      );
-      const writeResult = await safeWriteFile(
-        "config_file",
-        clientFileTarget.path,
-        configContent
-      );
-      if (writeResult.isErr()) {
-        log$1.error(
-          chalk2.bold.red(`Error writing config: ${writeResult.error.message}`)
-        );
-        outro(chalk2.bold.red(`Error adding x402scan MCP to ${name}`));
-        process.exit(1);
-      }
-      log$1.success(chalk2.bold.green(`Added x402scan MCP to ${name}`));
-    };
-    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 `${chalk2.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 `${chalk2.bold.green(`+ ${line.slice(2)}`)}`;
-            }
-            return line;
-          }).join("\n");
-        }
-        case "toml" /* TOML */: {
-          return str.split("\n").filter((line) => line.trim() !== "").map((line) => {
-            return `${chalk2.bold.green(`+ ${line.trim()}`)}`;
-          }).join("\n");
-        }
-      }
-    };
-  }
-});
-var redeemInviteCode2;
-var init_redeem_invite3 = __esm({
-  "src/cli/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 ({ amount, txHash }) => {
-          if (!flags.yes) {
-            s.stop("Invite code redeemed successfully!");
-            await wait({
-              startText: "Processing...",
-              stopText: chalk2.green(
-                `${chalk2.bold(amount)} USDC has been sent to your wallet!`
-              ),
-              ms: 1e3
-            });
-          }
-          log$1.info(chalk2.dim(`Transaction: https://basescan.org/tx/${txHash}`));
-          return true;
-        },
-        (error) => {
-          if (!flags.yes) {
-            s.stop("Invite code redemption failed");
-          }
-          log$1.warning(
-            chalk2.yellow(`Failed to redeem invite code: ${error.message}`)
-          );
-          return false;
-        }
-      );
-    };
-  }
-});
-var promptDeposit;
-var init_deposit = __esm({
-  "src/cli/lib/deposit.ts"() {
-    init_networks();
-    init_wait();
-    init_utils();
-    init_redeem_invite();
-    promptDeposit = async (props) => {
-      const { address, flags, surface: surface3 } = props;
-      const depositLink = getDepositLink(address, flags);
-      const depositChoice = flags.yes || surface3 === "guided" ? "manual" : await select({
-        message: chalk2.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 ${chalk2.underline.hex("#2563eb")(depositLink)}`,
-          ms: 1e3
-        });
-        await open(depositLink);
-      } else if (depositChoice === "manual") {
-        log$1.step(chalk2.bold("Account Information"));
-        log$1.message(`Address: ${address}`);
-        log$1.message(`Network: ${getChainName(DEFAULT_NETWORK)}`);
-        log$1.step(chalk2.bold("Online Portal"));
-        log$1.message(`${chalk2.underline(depositLink)}`);
-      } else if (depositChoice === "invite") {
-        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 promptDeposit({ address, flags, surface: surface3 });
-        }
-        const s = spinner();
-        s.start("Redeeming invite code...");
-        const redeemResult = await redeemInviteCode({
-          code,
-          dev: flags.dev,
-          address,
-          surface: "redeemInvite"
-        });
-        if (redeemResult.isErr()) {
-          s.stop("Invite code redemption failed");
-          log$1.error("Failed to redeem invite code");
-          return promptDeposit({ address, flags, surface: surface3 });
-        }
-        s.stop("Invite code redeemed successfully!");
-        const { amount, txHash } = redeemResult.value;
-        await wait({
-          startText: "Processing...",
-          stopText: chalk2.green(
-            `${chalk2.bold(amount)} USDC has been sent to your wallet!`
-          ),
-          ms: 1500
-        });
-        log$1.success(chalk2.bold(`Your wallet has been funded with ${amount} USDC`));
-        if (txHash) {
-          log$1.info(chalk2.dim(`Transaction: https://basescan.org/tx/${txHash}`));
-        }
-        return;
-      }
-    };
-  }
-});
-var addFunds;
-var init_add_funds = __esm({
-  "src/cli/install/4-add-funds/index.ts"() {
-    init_balance();
-    init_deposit();
-    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, surface: "add-funds" });
-      } else {
-        const { start, stop } = spinner();
-        start("Checking balance...");
-        const balanceResult = await getBalance({
-          address,
-          flags,
-          surface: "add-funds"
-        });
-        if (balanceResult.isOk()) {
-          stop(`Balance: ${chalk2.bold(`${balanceResult.value.balance} USDC`)} `);
-        } else {
-          stop(`Error: ${balanceResult.error.message}`);
-          return;
-        }
-        const balance = balanceResult.value;
-        if (balance.balance < 1) {
-          log$1.warning(
-            chalk2.bold(
-              `Your balance is low (${balance.balance} USDC). Consider topping up.`
-            )
-          );
-          await promptDeposit({ address, flags, surface: "install" });
-        }
-      }
-    };
-  }
-});
-
-// src/cli/install/index.ts
-var install_exports = {};
-__export(install_exports, {
-  installMcpServer: () => installMcpServer
-});
-var installMcpServer;
-var init_install = __esm({
-  "src/cli/install/index.ts"() {
-    init_wallet2();
-    init_log();
-    init_get_client();
-    init_add_server();
-    init_redeem_invite3();
-    init_add_funds();
-    installMcpServer = async (flags) => {
-      intro(chalk2.green.bold(`Install x402scan MCP`));
-      const walletResult = await getWallet();
-      if (walletResult.isErr()) {
-        log.error(JSON.stringify(walletResult.error, null, 2));
-        outro(chalk2.bold.red("Failed to get wallet"));
-        process.exit(1);
-      }
-      const {
-        account: { address },
-        isNew
-      } = walletResult.value;
-      const client = await getClient(flags);
-      await addServer(client, flags);
-      const inviteRedeemed = flags.invite ? await redeemInviteCode2(
-        {
-          code: flags.invite,
-          dev: flags.dev,
-          address,
-          surface: "install"
-        },
-        flags
-      ) : false;
-      if (!inviteRedeemed) {
-        await addFunds({ flags, address, isNew });
-      }
-      outro(chalk2.bold.green("Your x402scan MCP server is ready to use!"));
-    };
-  }
-});
-
-// src/cli/fund/index.ts
-var fund_exports = {};
-__export(fund_exports, {
-  fundMcpServer: () => fundMcpServer
-});
-var fundMcpServer;
-var init_fund = __esm({
-  "src/cli/fund/index.ts"() {
-    init_wallet2();
-    init_deposit();
-    init_log();
-    fundMcpServer = async (flags) => {
-      intro(chalk2.bold(`Fund ${chalk2.hex("#2563eb")("x402scan MCP")}`));
-      const walletResult = await getWallet();
-      if (walletResult.isErr()) {
-        log.error(walletResult.error.message);
-        log$1.error(walletResult.error.message);
-        outro(chalk2.bold.red("Failed to get wallet"));
-        process.exit(1);
-      }
-      const {
-        account: { address }
-      } = walletResult.value;
-      await promptDeposit({ address, flags, surface: "fund" });
-      outro(chalk2.bold.green("Your x402scan MCP server is funded!"));
-    };
-  }
-});
-
-// src/index.ts
-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", {
@@ -2563,8 +24,8 @@ void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
   "Start the MCP server",
   (yargs2) => yargs2,
   async (args) => {
-    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-    await startServer2(args);
+    const { startServer } = await import('./server-P6JS4DSU.js');
+    await startServer(args);
   }
 ).command(
   "install",
@@ -2576,19 +37,19 @@ void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
     default: isClaudeCode ? "claude-code" /* ClaudeCode */ : void 0
   }),
   async (args) => {
-    const { installMcpServer: installMcpServer2 } = await Promise.resolve().then(() => (init_install(), install_exports));
-    await installMcpServer2(args);
+    const { installMcpServer } = await import('./install-F5WF4NGY.js');
+    await installMcpServer(args);
   }
 ).command(
   "fund",
   "Open the funding page",
   (yargs2) => yargs2,
   async (args) => {
-    const { fundMcpServer: fundMcpServer2 } = await Promise.resolve().then(() => (init_fund(), fund_exports));
-    await fundMcpServer2(args);
+    const { fundMcpServer } = await import('./fund-DSYKNOMK.js');
+    await fundMcpServer(args);
   }
-).strict().demandCommand(0, 1, "", "Too many commands provided").help().parseAsync().catch((err9) => {
-  console.error("Fatal:", err9);
+).strict().demandCommand(0, 1, "", "Too many commands provided").help().parseAsync().catch((err) => {
+  console.error("Fatal:", err);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map