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

package/dist/esm/index.js

@@ -1,28 +1,23 @@
 #!/usr/bin/env node
+import { ok, resultFromPromise, err, resultFromThrowable } from '@x402scan/neverthrow';
 import z$1, { z } from 'zod';
-import { getAddress, formatUnits } from 'viem';
+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 * 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 { 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 { 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 { 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';
@@ -40,10 +35,10 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/install/clients.ts
+// src/cli/install/clients.ts
 var Clients, clientMetadata;
 var init_clients = __esm({
-  "src/install/clients.ts"() {
+  "src/cli/install/clients.ts"() {
     Clients = /* @__PURE__ */ ((Clients2) => {
       Clients2["ClaudeCode"] = "claude-code";
       Clients2["Cursor"] = "cursor";
@@ -129,79 +124,389 @@ var init_clients = __esm({
     };
   }
 });
+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/lib/response.ts
-var mcpSuccess, mcpError;
-var init_response = __esm({
-  "src/server/lib/response.ts"() {
-    mcpSuccess = (data) => {
+// 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: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        content,
+        isError: true
       };
     };
-    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;
+    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: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                error: message,
-                ...details && { details },
-                ...context && { context }
-              },
-              null,
-              2
-            )
-          }
-        ],
-        isError: true
+        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 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);
+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")
-    });
-    requestWithHeadersSchema = requestSchema.extend({
+      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/server/types.ts
-var init_types = __esm({
-  "src/server/types.ts"() {
+// 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 BASE_DIRECTORY, configFile;
+var errorType2, fsErr, fsResultFromPromise, safeReadFile, safeWriteFile, safeAppendFile, safeChmod, safeFileExists;
 var init_fs = __esm({
-  "src/lib/fs.ts"() {
+  "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 (!fs.existsSync(BASE_DIRECTORY)) {
-      fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+    if (!fs2.existsSync(BASE_DIRECTORY)) {
+      fs2.mkdirSync(BASE_DIRECTORY, { recursive: true });
     }
-    configFile = (name) => {
-      if (!fs.existsSync(BASE_DIRECTORY)) {
-        fs.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 (!fs.existsSync(filePath)) {
-        fs.writeFileSync(filePath, "{}");
+      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)
@@ -211,19 +516,17 @@ 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 {
-  }
+  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/lib/log.ts"() {
+  "src/shared/log.ts"() {
     init_fs();
-    LOG_FILE = configFile("mcp.log");
+    init_fs2();
+    LOG_FILE = configFile("mcp.log", "");
     DEBUG = process.env.X402_DEBUG === "true";
     log = {
       info: (msg, ...args) => write("INFO", msg, args),
@@ -233,6 +536,53 @@ var init_log = __esm({
     };
   }
 });
+
+// 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;
@@ -245,7 +595,7 @@ function getChainName(network) {
 }
 var CHAIN_CONFIGS, V1_TO_CAIP2, DEFAULT_NETWORK;
 var init_networks = __esm({
-  "src/lib/networks.ts"() {
+  "src/shared/networks.ts"() {
     CHAIN_CONFIGS = {
       "eip155:8453": {
         chain: base,
@@ -304,841 +654,316 @@ var init_networks = __esm({
 });
 var tokenStringToNumber;
 var init_token = __esm({
-  "src/lib/token.ts"() {
+  "src/shared/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";
+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"
+        })
+      );
     };
   }
 });
-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"
+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 (!res.ok) {
-    throw new Error(
-      `Balance API request failed (${res.status} ${res.statusText})`
+    if (probeResult.value.status !== 402) {
+      return probeResult;
+    }
+    const response = probeResult.value;
+    const paymentRequiredResult = await safeGetPaymentRequired(
+      toolName,
+      client,
+      response
     );
-  }
-  let json;
-  try {
-    json = await res.json();
-  } catch {
-    throw new Error(
-      `Failed to parse balance API response as JSON (${res.status} ${res.statusText})`
+    if (paymentRequiredResult.isErr()) {
+      return paymentRequiredResult;
+    }
+    const paymentRequired = paymentRequiredResult.value;
+    const paymentPayloadResult = await safeCreatePaymentPayload(
+      toolName,
+      client,
+      paymentRequired
     );
-  }
-  const result = balanceApiResponseSchema.safeParse(json);
-  if (!result.success) {
-    throw new Error(
-      `Failed to safeParse balance API response (${res.status} ${res.statusText})`
+    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 {
-    balanceFormatted: result.data.balance,
-    balanceRaw: result.data.rawBalance
+    return await safeFetch(toolName, clonedRequest);
   };
 }
-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
-            })
+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
           );
         }
-        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 {};
+
+// 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;
       }
-      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]
-          });
-        }
-      });
+      return bazaar;
     };
-  }
-});
-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 {
+    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 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
-    }) => {
-      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" } : {},
-                ...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"() {
+var toolName2, registerAuthTools;
+var init_auth_fetch = __esm({
+  "src/server/tools/auth-fetch.ts"() {
+    init_fetch();
+    init_x402();
     init_response();
-    init_protocol();
-    init_client();
-    init_encode();
-    init_schemas();
+    init_request();
+    init_x402_extensions();
+    toolName2 = "fetchWithAuth";
     registerAuthTools = ({ server, account }) => {
       server.registerTool(
-        "authed_call",
+        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: requestWithHeadersSchema
+          inputSchema: requestSchema
         },
-        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."
-                }
-              );
+        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 serverInfo = siwxExtension.info;
-            const requiredFields = [
-              "domain",
-              "uri",
-              "version",
-              "chainId",
-              "nonce",
-              "issuedAt"
-            ];
-            const missingFields = requiredFields.filter(
-              (f) => !serverInfo[f]
+            const parseResponseResult2 = await safeParseResponse(
+              toolName2,
+              firstResponse
             );
-            if (missingFields.length > 0) {
-              return mcpError(
-                "Invalid sign-in-with-x extension: missing required fields",
-                {
-                  missingFields,
-                  receivedInfo: serverInfo
-                }
-              );
+            if (parseResponseResult2.isErr()) {
+              return mcpError(parseResponseResult2);
             }
-            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
+            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 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
-              }
+          }
+          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."
             });
-          } catch (err2) {
-            return mcpError(err2, { tool: "authed_call", url });
           }
+          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
+            }
+          });
         }
       );
     };
@@ -1146,138 +971,195 @@ var init_auth = __esm({
 });
 
 // src/server/tools/wallet.ts
-var registerWalletTools;
+var toolName3, registerWalletTools;
 var init_wallet = __esm({
   "src/server/tools/wallet.ts"() {
-    init_response();
     init_balance();
     init_networks();
-    init_deposit();
+    init_utils();
+    init_response();
+    toolName3 = "getWalletInfo";
     registerWalletTools = ({
       server,
       account: { address },
       flags
     }) => {
       server.registerTool(
-        "check_balance",
+        toolName3,
         {
           description: "Check wallet address and USDC balance. Creates wallet if needed."
         },
         async () => {
-          const { balanceFormatted } = await getUSDCBalance(address, flags);
-          return mcpSuccess({
+          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: balanceFormatted,
-            balanceFormatted: balanceFormatted.toString(),
-            isNewWallet: balanceFormatted === 0,
-            depositLink: getDepositLink(address, flags)
+            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(
-        "get_wallet_address",
+        toolName4,
         {
-          description: "Get the wallet address."
+          description: "Check if an endpoint is x402-protected and get pricing options, schema, and auth requirements (if applicable).",
+          inputSchema: requestSchema
         },
-        () => mcpSuccess({ address })
+        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
+              }))
+            }
+          });
+        }
       );
     };
   }
 });
-
-// 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
-        }))
-      };
+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;
     };
-    getSchema = (extensions) => {
-      const { bazaar } = extensions ?? {};
-      if (!bazaar) {
-        return void 0;
+    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 { 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 });
-          }
-        }
+      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 registerRedeemInviteTool;
+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
     }) => {
-      const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
       server.registerTool(
-        "redeem_invite",
+        toolName5,
         {
           description: "Redeem an invite code to receive USDC.",
           inputSchema: z$1.object({
@@ -1285,18 +1167,20 @@ var init_redeem_invite2 = __esm({
           })
         },
         async ({ code }) => {
-          const res = await fetch(`${baseUrl}/api/invite/redeem`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ code, recipientAddr: address })
+          const result = await redeemInviteCode({
+            code,
+            dev: flags.dev,
+            address,
+            surface: toolName5
           });
-          const data = await res.json();
-          if (!data.success) {
-            return mcpError(data.error ?? "Failed to redeem invite code");
+          if (result.isErr()) {
+            return mcpError(result);
           }
-          return mcpSuccess({
-            amount: `${data.amount} USDC`,
-            txHash: data.txHash
+          const { amount, txHash } = result.value;
+          return mcpSuccessJson({
+            redeemed: true,
+            amount: `${amount} USDC`,
+            txHash
           });
         }
       );
@@ -1305,135 +1189,252 @@ var init_redeem_invite2 = __esm({
 });
 function getVersion() {
   {
-    return "0.0.7-beta.0";
+    return "0.0.7-beta.1";
   }
 }
-var MCP_VERSION;
+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 toolName6, registerTelemetryTools;
 var init_telemetry = __esm({
   "src/server/tools/telemetry.ts"() {
+    init_fetch();
     init_log();
-    init_response();
+    init_utils();
     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")
-    });
+    init_response();
+    toolName6 = "reportError";
     registerTelemetryTools = ({
       server,
       account: { address },
       flags
     }) => {
-      const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
       server.registerTool(
-        "report_error",
+        toolName6,
         {
           description: "EMERGENCY ONLY. Report critical MCP tool bugs. Do NOT use for normal errors (balance, network, 4xx) - those are recoverable.",
-          inputSchema: errorReportSchema
+          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) => {
-          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`, {
+          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(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" });
+              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.
 
-// 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;
+        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
+          });
         }
-        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)}`
+      } 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_lib();
-    init_get_route_details();
+    init_lib2();
+    init_x402_extensions();
     origins = ["enrichx402.com"];
     registerOrigins = async ({ server }) => {
       await Promise.all(
         origins.map(async (origin) => {
-          const metadata = await getWebPageMetadata(`https://${origin}`);
+          const metadataResult = await getWebPageMetadata(`https://${origin}`);
+          const metadata = metadataResult.isOk() ? metadataResult.value : null;
           server.registerResource(
             origin,
             `api://${origin}`,
@@ -1483,7 +1484,7 @@ var init_origins = __esm({
                       description: metadata?.description,
                       resources: resources.filter(Boolean).map((resource) => {
                         if (!resource) return null;
-                        const schema = getSchema(
+                        const schema = getInputSchema(
                           resource.paymentRequired?.extensions
                         );
                         return {
@@ -1518,362 +1519,95 @@ var init_origins = __esm({
     };
   }
 });
+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 { 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 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}`
+      });
     }
-    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 });
-      }
+  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`
+      });
     }
-  );
-}
-function getOrigin(urlString) {
-  try {
-    return new URL(urlString).origin;
-  } catch {
-    return urlString;
+    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 });
   }
-}
-function getHostname(origin) {
-  try {
-    return new URL(origin).hostname;
-  } catch {
-    return origin;
+  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 DiscoveryDocumentSchema;
-var init_discover_resources = __esm({
-  "src/server/tools/discover-resources.ts"() {
+var WALLET_FILE, storedWalletSchema, walletSurface;
+var init_wallet2 = __esm({
+  "src/shared/wallet.ts"() {
+    init_fs();
+    init_json();
+    init_parse();
     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()
+    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";
   }
 });
 
@@ -1885,28 +1619,35 @@ __export(server_exports, {
 var startServer;
 var init_server = __esm({
   "src/server/index.ts"() {
-    init_fetch_x402_resource();
-    init_auth();
+    init_x402_fetch();
+    init_auth_fetch();
     init_wallet();
-    init_check_endpoint_schema();
+    init_check_endpoint();
     init_redeem_invite2();
     init_telemetry();
+    init_discover_resources();
     init_origins();
+    init_version();
     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 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
+          address: account.address,
+          surface: "startServer"
         });
       }
       const server = new McpServer(
@@ -1952,7 +1693,7 @@ var init_server = __esm({
 });
 var getClient;
 var init_get_client = __esm({
-  "src/install/1-get-client/index.ts"() {
+  "src/cli/install/1-get-client/index.ts"() {
     init_clients();
     getClient = async ({ client: flagClient, yes }) => {
       if (yes) {
@@ -1991,14 +1732,14 @@ var init_get_client = __esm({
       if (parsedClientSelection.success) {
         return parsedClientSelection.data;
       }
-      outro(chalk.bold.red("No MCP client selected"));
+      outro(chalk2.bold.red("No MCP client selected"));
       process.exit(0);
     };
   }
 });
 var Platforms, getPlatformPath;
 var init_platforms = __esm({
-  "src/install/2-add-server/lib/platforms.ts"() {
+  "src/cli/install/2-add-server/lib/platforms.ts"() {
     Platforms = /* @__PURE__ */ ((Platforms2) => {
       Platforms2["Windows"] = "win32";
       Platforms2["MacOS"] = "darwin";
@@ -2033,25 +1774,68 @@ var init_platforms = __esm({
     };
   }
 });
-var parseClientConfig, serializeClientConfig, stringifyObject;
+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/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
-      };
+  "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 */) {
@@ -2065,24 +1849,13 @@ var init_file_types = __esm({
         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);
+        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);
     };
@@ -2103,7 +1876,7 @@ var init_file_types = __esm({
 });
 var getClientConfigFile;
 var init_client_config_file = __esm({
-  "src/install/2-add-server/lib/client-config-file.ts"() {
+  "src/cli/install/2-add-server/lib/client-config-file.ts"() {
     init_platforms();
     init_log();
     init_clients();
@@ -2214,7 +1987,7 @@ var init_client_config_file = __esm({
             "opencode.json"
           );
           const jsoncPath = jsonPath.replace(".json", ".jsonc");
-          if (fs__default.existsSync(jsoncPath)) {
+          if (fs2__default.existsSync(jsoncPath)) {
             log.info(`Found .jsonc file for OpenCode, using: ${jsoncPath}`);
             return {
               path: jsoncPath,
@@ -2235,10 +2008,10 @@ var init_client_config_file = __esm({
   }
 });
 
-// src/install/2-add-server/lib/nested-values.ts
+// src/cli/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"() {
+  "src/cli/install/2-add-server/lib/nested-values.ts"() {
     getNestedValue = (obj, path3) => {
       const keys = path3.split(".");
       let current = obj;
@@ -2264,193 +2037,34 @@ var init_nested_values = __esm({
   }
 });
 
-// src/install/2-add-server/lib/index.ts
-var init_lib2 = __esm({
-  "src/install/2-add-server/lib/index.ts"() {
+// 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();
   }
 });
-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 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, formatDiffByFormat;
+});
+var getMcpConfig, addServer, formatDiffByFormat;
 var init_add_server = __esm({
-  "src/install/2-add-server/index.ts"() {
+  "src/cli/install/2-add-server/index.ts"() {
+    init_fs();
     init_log();
     init_clients();
-    init_lib2();
+    init_lib3();
+    init_version();
     init_wait();
     getMcpConfig = (globalFlags) => {
       if (globalFlags.dev) {
@@ -2463,9 +2077,191 @@ var init_add_server = __esm({
       return {
         serverName: "x402",
         command: "npx",
-        args: ["-y", "@x402scan/mcp@latest"]
+        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) {
@@ -2475,7 +2271,7 @@ var init_add_server = __esm({
             const diffLines = [0, 1, numLines - 2, numLines - 1];
             const isDiffLine = !diffLines.includes(index);
             if (isDiffLine) {
-              return `${chalk.bold.green(`+ ${line.slice(2)}`)}`;
+              return `${chalk2.bold.green(`+ ${line.slice(2)}`)}`;
             }
             return line;
           }).join("\n");
@@ -2485,14 +2281,14 @@ var init_add_server = __esm({
             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 `${chalk2.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()}`)}`;
+            return `${chalk2.bold.green(`+ ${line.trim()}`)}`;
           }).join("\n");
         }
       }
@@ -2501,7 +2297,7 @@ var init_add_server = __esm({
 });
 var redeemInviteCode2;
 var init_redeem_invite3 = __esm({
-  "src/install/3-redeem-invite/index.ts"() {
+  "src/cli/install/3-redeem-invite/index.ts"() {
     init_wait();
     init_redeem_invite();
     redeemInviteCode2 = async (props, flags) => {
@@ -2511,26 +2307,18 @@ var init_redeem_invite3 = __esm({
       }
       const result = await redeemInviteCode(props);
       return result.match(
-        async ({ data }) => {
+        async ({ amount, txHash }) => {
           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!`
+              stopText: chalk2.green(
+                `${chalk2.bold(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}`)
-          );
+          log$1.info(chalk2.dim(`Transaction: https://basescan.org/tx/${txHash}`));
           return true;
         },
         (error) => {
@@ -2538,7 +2326,7 @@ var init_redeem_invite3 = __esm({
             s.stop("Invite code redemption failed");
           }
           log$1.warning(
-            chalk.yellow(`Failed to redeem invite code: ${error?.message}`)
+            chalk2.yellow(`Failed to redeem invite code: ${error.message}`)
           );
           return false;
         }
@@ -2546,95 +2334,209 @@ var init_redeem_invite3 = __esm({
     };
   }
 });
+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/install/4-add-funds/index.ts"() {
+  "src/cli/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);
+        await promptDeposit({ address, flags, surface: "add-funds" });
       } else {
-        const { balanceFormatted } = await getUSDCBalance(address, flags);
-        if (!flags.yes) {
-          await wait({
-            startText: "Checking balance...",
-            stopText: `Balance: ${chalk.bold(`${balanceFormatted} USDC`)} `,
-            ms: 1e3
-          });
+        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;
         }
-        if (balanceFormatted < 1) {
+        const balance = balanceResult.value;
+        if (balance.balance < 1) {
           log$1.warning(
-            chalk.bold(
-              `Your balance is low (${balanceFormatted} USDC). Consider topping up.`
+            chalk2.bold(
+              `Your balance is low (${balance.balance} USDC). Consider topping up.`
             )
           );
-          await promptDeposit(address, flags);
+          await promptDeposit({ address, flags, surface: "install" });
         }
       }
     };
   }
 });
 
-// src/install/index.ts
+// src/cli/install/index.ts
 var install_exports = {};
 __export(install_exports, {
   installMcpServer: () => installMcpServer
 });
 var installMcpServer;
 var init_install = __esm({
-  "src/install/index.ts"() {
+  "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
-      } = await getWallet();
-      intro(chalk.green.bold(`Install x402scan MCP`));
+      } = walletResult.value;
       const client = await getClient(flags);
       await addServer(client, flags);
       const inviteRedeemed = flags.invite ? await redeemInviteCode2(
         {
           code: flags.invite,
           dev: flags.dev,
-          address
+          address,
+          surface: "install"
         },
         flags
       ) : false;
       if (!inviteRedeemed) {
         await addFunds({ flags, address, isNew });
       }
-      outro(chalk.bold.green("Your x402scan MCP server is ready to use!"));
+      outro(chalk2.bold.green("Your x402scan MCP server is ready to use!"));
     };
   }
 });
 
-// src/fund/index.ts
+// src/cli/fund/index.ts
 var fund_exports = {};
 __export(fund_exports, {
   fundMcpServer: () => fundMcpServer
 });
 var fundMcpServer;
 var init_fund = __esm({
-  "src/fund/index.ts"() {
+  "src/cli/fund/index.ts"() {
     init_wallet2();
     init_deposit();
+    init_log();
     fundMcpServer = async (flags) => {
-      intro(chalk.bold(`Fund ${chalk.hex("#2563eb")("x402scan MCP")}`));
+      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 }
-      } = await getWallet();
-      await promptDeposit(address, flags);
-      outro(chalk.bold.green("Your x402scan MCP server is funded!"));
+      } = walletResult.value;
+      await promptDeposit({ address, flags, surface: "fund" });
+      outro(chalk2.bold.green("Your x402scan MCP server is funded!"));
     };
   }
 });
@@ -2685,8 +2587,8 @@ void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
     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((err2) => {
-  console.error("Fatal:", err2);
+).strict().demandCommand(0, 1, "", "Too many commands provided").help().parseAsync().catch((err9) => {
+  console.error("Fatal:", err9);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map