@x402scan/mcp 0.1.2 → 0.2.1-beta.0

package/dist/esm/server-GJU7QTN5.js

@@ -1,1105 +0,0 @@
-import {
-  MCP_VERSION,
-  getBalance
-} from "./chunk-WEP7L2WM.js";
-import {
-  DEFAULT_NETWORK,
-  err,
-  fetchErr,
-  fetchHttpErr,
-  fetchOk,
-  getBaseUrl,
-  getChainName,
-  getDepositLink,
-  getWallet,
-  isFetchError,
-  log,
-  ok,
-  openDepositLink,
-  redeemInviteCode,
-  resultFromPromise,
-  resultFromThrowable,
-  safeFetch,
-  safeFetchJson,
-  safeParseResponse,
-  safeStringifyJson
-} from "./chunk-IBB75UHN.js";
-
-// src/server/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { randomBytes } from "crypto";
-
-// src/server/tools/x402-fetch.ts
-import { x402Client, x402HTTPClient } from "@x402/core/client";
-import { ExactEvmScheme } from "@x402/evm/exact/client";
-
-// src/server/tools/response/lib.ts
-var parsedResponseToToolContentPart = (data) => {
-  switch (data.type) {
-    case "json":
-      return {
-        type: "text",
-        text: JSON.stringify(data.data, null, 2)
-      };
-    case "image":
-      return {
-        type: "image",
-        mimeType: data.mimeType,
-        data: Buffer.from(data.data).toString("base64")
-      };
-    case "audio":
-      return {
-        type: "audio",
-        mimeType: data.mimeType,
-        data: Buffer.from(data.data).toString("base64")
-      };
-    case "text":
-      return { type: "text", text: data.data };
-    default:
-      return {
-        type: "text",
-        text: `Unsupported response type: ${data.type}`
-      };
-  }
-};
-
-// src/server/tools/response/error.ts
-var buildMcpError = (content) => {
-  return {
-    content,
-    isError: true
-  };
-};
-var 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) }
-    ])
-  );
-};
-var mcpError = async (err2) => {
-  const { error } = err2;
-  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 });
-};
-var mcpErrorFetch = async (surface3, response) => {
-  return mcpError(fetchHttpErr(surface3, response));
-};
-
-// src/server/tools/response/success.ts
-var buildMcpSuccess = (content) => {
-  return {
-    content
-  };
-};
-var mcpSuccessJson = (data) => {
-  return safeStringifyJson("mcp-success-text", data).match(
-    (success) => buildMcpSuccess([{ type: "text", text: success }]),
-    (error) => mcpErrorJson(error)
-  );
-};
-var 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/lib/request.ts
-import z from "zod";
-var requestSchema = z.object({
-  url: z.url().describe("The endpoint URL"),
-  method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).default("GET").describe("HTTP method"),
-  body: z.unknown().optional().describe("Request body for POST/PUT/PATCH methods"),
-  headers: z.record(z.string(), z.string()).optional().describe("Additional headers to include").default({})
-});
-var buildRequest = ({
-  input,
-  address,
-  sessionId
-}) => {
-  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,
-      ...address ? { "X-Wallet-Address": address, "X-Client-ID": address } : {},
-      ...sessionId ? { "X-Session-ID": sessionId } : {}
-    }
-  });
-};
-
-// src/server/tools/lib/check-balance.ts
-var 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;
-};
-
-// src/shared/token.ts
-import { formatUnits } from "viem";
-var tokenStringToNumber = (amount, decimals = 6) => {
-  return Number(formatUnits(BigInt(amount), decimals));
-};
-
-// src/shared/neverthrow/x402/index.ts
-import { createSIWxPayload } from "@x402scan/siwx";
-var errorType = "x402";
-var x402Ok = (value) => ok(value);
-var x402Err = (cause, error) => err(errorType, cause, error);
-var x402ResultFromPromise = (surface3, promise, error) => resultFromPromise(errorType, surface3, promise, error);
-var x402ResultFromThrowable = (surface3, fn, error) => resultFromThrowable(errorType, surface3, fn, error);
-var 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"
-    })
-  );
-};
-var 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"
-    })
-  );
-};
-var 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"
-    })
-  );
-};
-var 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"
-    })
-  );
-};
-
-// src/server/tools/x402-fetch.ts
-var toolName = "fetch";
-var registerFetchX402ResourceTool = ({
-  server,
-  account,
-  flags,
-  sessionId
-}) => {
-  server.registerTool(
-    toolName,
-    {
-      title: "Fetch",
-      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, address: account.address, sessionId })
-      );
-      if (fetchResult.isErr()) {
-        return mcpError(fetchResult);
-      }
-      const { response, paymentPayload } = 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() || paymentPayload !== void 0 ? {
-          ...paymentPayload !== void 0 ? {
-            price: tokenStringToNumber(
-              paymentPayload.accepted.amount
-            ).toLocaleString("en-US", {
-              style: "currency",
-              currency: "USD"
-            })
-          } : {},
-          ...settlementResult.isOk() ? {
-            payment: {
-              success: settlementResult.value.success,
-              transactionHash: settlementResult.value.transaction
-            }
-          } : {}
-        } : void 0
-      );
-    }
-  );
-};
-function safeWrapFetchWithPayment(client) {
-  return async (request) => {
-    const clonedRequest = request.clone();
-    const probeResult = await safeFetch(toolName, request);
-    if (probeResult.isErr()) {
-      return fetchErr(toolName, probeResult.error);
-    }
-    if (probeResult.value.status !== 402) {
-      return probeResult.andThen(
-        (response2) => fetchOk({
-          response: response2,
-          paymentPayload: void 0
-        })
-      );
-    }
-    const response = probeResult.value;
-    const paymentRequiredResult = await safeGetPaymentRequired(
-      toolName,
-      client,
-      response
-    );
-    if (paymentRequiredResult.isErr()) {
-      return paymentRequiredResult;
-    }
-    const paymentRequired = paymentRequiredResult.value;
-    const paymentPayloadResult = await safeCreatePaymentPayload(
-      toolName,
-      client,
-      paymentRequired
-    );
-    if (paymentPayloadResult.isErr()) {
-      return paymentPayloadResult;
-    }
-    const paymentPayload = paymentPayloadResult.value;
-    const paymentHeaders = client.encodePaymentSignatureHeader(paymentPayload);
-    if (clonedRequest.headers.has("PAYMENT-SIGNATURE") || clonedRequest.headers.has("X-PAYMENT")) {
-      return x402Err(toolName, {
-        cause: "payment_already_attempted",
-        message: "Payment already attempted"
-      });
-    }
-    for (const [key, value] of Object.entries(paymentHeaders)) {
-      clonedRequest.headers.set(key, value);
-    }
-    clonedRequest.headers.set(
-      "Access-Control-Expose-Headers",
-      "PAYMENT-RESPONSE,X-PAYMENT-RESPONSE"
-    );
-    return await safeFetch(toolName, clonedRequest).andThen(
-      (response2) => x402Ok({
-        response: response2,
-        paymentPayload
-      })
-    );
-  };
-}
-
-// src/server/tools/auth-fetch.ts
-import { x402Client as x402Client2, x402HTTPClient as x402HTTPClient2 } from "@x402/core/client";
-import { encodeSIWxHeader } from "@x402scan/siwx";
-
-// src/server/lib/x402-extensions.ts
-var getBazaarExtension = (extensions) => {
-  const { bazaar } = extensions ?? {};
-  if (!bazaar) {
-    return void 0;
-  }
-  return bazaar;
-};
-var getInputSchema = (extensions) => getBazaarExtension(extensions)?.schema.properties.input;
-var getSiwxExtension = (extensions) => {
-  const siwx = extensions?.["sign-in-with-x"];
-  if (!siwx?.info) {
-    return void 0;
-  }
-  return siwx.info;
-};
-
-// src/server/tools/auth-fetch.ts
-var toolName2 = "fetch_with_auth";
-var registerAuthTools = ({
-  server,
-  account,
-  sessionId
-}) => {
-  server.registerTool(
-    toolName2,
-    {
-      title: "Fetch with Authentication",
-      description: "Make a request to a SIWX-protected endpoint. Handles auth flow automatically: detects SIWX requirement from 402 response, signs proof with server-provided challenge, retries.",
-      inputSchema: requestSchema
-    },
-    async (input) => {
-      const httpClient = new x402HTTPClient2(new x402Client2());
-      const firstResult = await safeFetch(
-        toolName2,
-        buildRequest({ input, address: account.address, sessionId })
-      );
-      if (firstResult.isErr()) {
-        return mcpError(firstResult);
-      }
-      const firstResponse = firstResult.value;
-      if (firstResponse.status !== 402) {
-        if (!firstResponse.ok) {
-          return mcpErrorFetch(toolName2, firstResponse);
-        }
-        const parseResponseResult2 = await safeParseResponse(
-          toolName2,
-          firstResponse
-        );
-        if (parseResponseResult2.isErr()) {
-          return mcpError(parseResponseResult2);
-        }
-        return mcpSuccessResponse(parseResponseResult2.value);
-      }
-      const getPaymentRequiredResult = await safeGetPaymentRequired(
-        toolName2,
-        httpClient,
-        firstResponse
-      );
-      if (getPaymentRequiredResult.isErr()) {
-        return mcpError(getPaymentRequiredResult);
-      }
-      const paymentRequired = getPaymentRequiredResult.value;
-      const siwxExtension = getSiwxExtension(paymentRequired.extensions);
-      if (!siwxExtension) {
-        return mcpErrorJson({
-          message: "Endpoint returned 402 but no sign-in-with-x extension found",
-          statusCode: 402,
-          extensions: Object.keys(paymentRequired.extensions ?? {}),
-          hint: "This endpoint may require payment instead of authentication. Use execute_call for paid requests."
-        });
-      }
-      const serverInfo = siwxExtension;
-      const requiredFields = [
-        "domain",
-        "uri",
-        "version",
-        "chainId",
-        "nonce",
-        "issuedAt"
-      ];
-      const missingFields = requiredFields.filter(
-        (f) => !serverInfo[f]
-      );
-      if (missingFields.length > 0) {
-        return mcpErrorJson({
-          message: "Invalid sign-in-with-x extension: missing required fields",
-          missingFields,
-          receivedInfo: { ...serverInfo }
-        });
-      }
-      if (serverInfo.chainId.startsWith("solana:")) {
-        return mcpErrorJson({
-          message: "Solana authentication not supported",
-          chainId: serverInfo.chainId,
-          hint: "This endpoint requires a Solana wallet. The MCP server currently only supports EVM wallets."
-        });
-      }
-      const payloadResult = await safeCreateSIWxPayload(
-        toolName2,
-        serverInfo,
-        account
-      );
-      if (payloadResult.isErr()) {
-        return mcpError(payloadResult);
-      }
-      const siwxHeader = encodeSIWxHeader(payloadResult.value);
-      const authedRequest = buildRequest({
-        input,
-        address: account.address,
-        sessionId
-      });
-      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);
-    }
-  );
-};
-
-// src/server/tools/wallet.ts
-var toolName3 = "get_wallet_info";
-var registerWalletTools = ({
-  server,
-  account: { address },
-  flags
-}) => {
-  server.registerTool(
-    toolName3,
-    {
-      title: "Get Wallet Info",
-      description: "Check wallet address and USDC balance. Creates wallet if needed."
-    },
-    async () => {
-      const balanceResult = await getBalance({
-        address,
-        flags,
-        surface: toolName3
-      });
-      if (balanceResult.isErr()) {
-        return mcpError(balanceResult);
-      }
-      const { balance } = balanceResult.value;
-      return mcpSuccessJson({
-        address,
-        network: DEFAULT_NETWORK,
-        networkName: getChainName(DEFAULT_NETWORK),
-        usdcBalance: balance,
-        isNewWallet: balance === 0,
-        depositLink: getDepositLink(address, flags),
-        ...balance < 2.5 ? {
-          message: `Your balance is low. Consider topping it up`
-        } : {}
-      });
-    }
-  );
-};
-
-// src/server/tools/check-endpoint.ts
-import { x402Client as x402Client3, x402HTTPClient as x402HTTPClient3 } from "@x402/core/client";
-var toolName4 = "check_endpoint_schema";
-var registerCheckX402EndpointTool = ({
-  server,
-  account,
-  sessionId
-}) => {
-  server.registerTool(
-    toolName4,
-    {
-      title: "Check Endpoint Schema",
-      description: "Check if an endpoint is x402-protected and get pricing options, schema, and auth requirements (if applicable).",
-      inputSchema: requestSchema
-    },
-    async (input) => {
-      log.info("Querying endpoint", input);
-      const responseResult = await safeFetch(
-        toolName4,
-        buildRequest({ input, address: account.address, sessionId })
-      );
-      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 x402HTTPClient3(new x402Client3());
-      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/tools/redeem-invite.ts
-import z2 from "zod";
-var toolName5 = "redeem_invite";
-var registerRedeemInviteTool = ({
-  server,
-  account: { address },
-  flags
-}) => {
-  server.registerTool(
-    toolName5,
-    {
-      title: "Redeem Invite",
-      description: "Redeem an invite code to receive USDC.",
-      inputSchema: z2.object({
-        code: z2.string().min(1).describe("The invite code")
-      })
-    },
-    async ({ code }) => {
-      const result = await redeemInviteCode({
-        code,
-        dev: flags.dev,
-        address,
-        surface: toolName5
-      });
-      if (result.isErr()) {
-        return mcpError(result);
-      }
-      const { amount, txHash } = result.value;
-      return mcpSuccessJson({
-        redeemed: true,
-        amount: `${amount} USDC`,
-        txHash
-      });
-    }
-  );
-};
-
-// src/server/tools/telemetry.ts
-import z3 from "zod";
-var toolName6 = "report_error";
-var registerTelemetryTools = ({
-  server,
-  account: { address },
-  flags
-}) => {
-  server.registerTool(
-    toolName6,
-    {
-      title: "Report Error",
-      description: "EMERGENCY ONLY. Report critical MCP tool bugs. Do NOT use for normal errors (balance, network, 4xx) - those are recoverable.",
-      inputSchema: z3.object({
-        tool: z3.string().describe("MCP tool name"),
-        resource: z3.string().optional().describe("x402 resource URL"),
-        summary: z3.string().describe("1-2 sentence summary"),
-        errorMessage: z3.string().describe("Error message"),
-        stack: z3.string().optional().describe("Stack trace"),
-        fullReport: z3.string().optional().describe("Detailed report with context, logs, repro steps")
-      })
-    },
-    async (input) => {
-      log.info("Submitting error report", {
-        tool: input.tool,
-        resource: input.resource,
-        summary: input.summary
-      });
-      const telemetryResult = await safeFetchJson(
-        toolName6,
-        new Request(`${getBaseUrl(flags.dev)}/api/telemetry`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            ...input,
-            walletAddress: address,
-            mcpVersion: MCP_VERSION,
-            reportedAt: (/* @__PURE__ */ new Date()).toISOString()
-          })
-        }),
-        z3.object({
-          reportId: z3.string()
-        })
-      );
-      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."
-      });
-    }
-  );
-};
-
-// src/server/tools/discover-resources.ts
-import { z as z4 } from "zod";
-var discoveryDocumentSchema = z4.object({
-  version: z4.number().refine((v) => v === 1, { message: "version must be 1" }),
-  resources: z4.array(z4.string()),
-  ownershipProofs: z4.array(z4.string()).optional(),
-  instructions: z4.string().optional()
-});
-var toolName7 = "discover_api_endpoints";
-function registerDiscoveryTools(server) {
-  server.registerTool(
-    toolName7,
-    {
-      title: "Discover API Endpoints",
-      description: `Discover x402-protected resources on an origin. Returns a list of resource URLs.
-        Use check_x402_endpoint separately to get detailed pricing/schema info for specific resources.
-
-        Known default origins with resource packs. Discover if more needed:
-        - https://enrichx402.com ->
-            People + Org search
-            Google Maps (places + locations)
-            Grok twitter search
-            Exa web search
-            Clado linkedin data
-            Firecrawl web scrape
-            WhitePages (business directory)
-            Email enrichment
-        - https://stablestudio.io -> generate images / videos
-        `,
-      inputSchema: {
-        url: z4.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" } }),
-        discoveryDocumentSchema
-      );
-      if (wellKnownResult.isOk()) {
-        return mcpSuccessJson({
-          found: true,
-          origin,
-          source: "well-known",
-          data: wellKnownResult.value
-        });
-      } 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" } }
-        ),
-        z4.object({
-          Answer: z4.array(
-            z4.object({
-              data: z4.string()
-            })
-          ).optional()
-        })
-      );
-      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" } }),
-            discoveryDocumentSchema
-          );
-          if (dnsDocResult.isOk()) {
-            return mcpSuccessJson({
-              found: true,
-              origin,
-              source: "dns-txt",
-              data: dnsDocResult.value
-            });
-          }
-        } 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"
-      });
-    }
-  );
-}
-
-// src/server/resources/origins.ts
-import z5 from "zod";
-import { x402HTTPClient as x402HTTPClient4 } from "@x402/core/client";
-import { x402Client as x402Client4 } from "@x402/core/client";
-
-// src/server/resources/_lib.ts
-var surface = "getWebPageMetadata";
-var 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"
-    });
-  });
-};
-var 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
-  };
-};
-
-// src/server/resources/origins.ts
-var surface2 = "registerOrigins";
-var origins = ["enrichx402.com", "stablestudio.io"];
-var wellKnownSchema = z5.object({
-  resources: z5.array(z5.string())
-});
-var registerOrigins = async ({ server }) => {
-  await Promise.all(
-    origins.map(async (origin) => {
-      const metadataResult = await getWebPageMetadata(`https://${origin}`);
-      const metadata = metadataResult.isOk() ? metadataResult.value : null;
-      server.registerResource(
-        origin,
-        `api://${origin}`,
-        {
-          title: metadata?.title ?? origin,
-          description: metadata?.description ?? "",
-          mimeType: "application/json"
-        },
-        async (uri) => {
-          const wellKnownUrl = `${uri.toString().replace("api://", "https://")}/.well-known/x402`;
-          const wellKnownResult = await safeFetchJson(
-            surface2,
-            new Request(wellKnownUrl),
-            wellKnownSchema
-          );
-          if (wellKnownResult.isErr()) {
-            console.error(
-              `Failed to fetch well-known for ${origin}:`,
-              wellKnownResult.error
-            );
-            return {
-              contents: [
-                {
-                  uri: origin,
-                  text: JSON.stringify(
-                    { error: "Failed to fetch well-known resources" },
-                    null,
-                    2
-                  ),
-                  mimeType: "application/json"
-                }
-              ]
-            };
-          }
-          const resources = await Promise.all(
-            wellKnownResult.value.resources.map(async (resource) => {
-              const postResult = await getResourceResponse(
-                resource,
-                new Request(resource, {
-                  method: "POST",
-                  headers: {
-                    "Content-Type": "application/json"
-                  }
-                })
-              );
-              if (postResult.isOk()) {
-                return postResult.value;
-              }
-              const getResult = await getResourceResponse(
-                resource,
-                new Request(resource, { method: "GET" })
-              );
-              if (getResult.isOk()) {
-                return getResult.value;
-              }
-              console.error(`Failed to get resource response for ${resource}`);
-              return null;
-            })
-          );
-          const payload = {
-            server: origin,
-            name: metadata?.title,
-            description: metadata?.description,
-            resources: resources.filter(Boolean).map((resource) => {
-              if (!resource) return null;
-              const schema = getInputSchema(
-                resource.paymentRequired?.extensions
-              );
-              return {
-                url: resource.resource,
-                schema,
-                mimeType: resource.paymentRequired.resource.mimeType
-              };
-            })
-          };
-          const stringifyResult = safeStringifyJson(
-            surface2,
-            payload
-          );
-          if (stringifyResult.isErr()) {
-            console.error(
-              `Failed to stringify response for ${origin}:`,
-              stringifyResult.error
-            );
-            return {
-              contents: [
-                {
-                  uri: origin,
-                  text: JSON.stringify({
-                    error: "Failed to stringify response"
-                  }),
-                  mimeType: "application/json"
-                }
-              ]
-            };
-          }
-          return {
-            contents: [
-              {
-                uri: origin,
-                text: stringifyResult.value,
-                mimeType: "application/json"
-              }
-            ]
-          };
-        }
-      );
-    })
-  );
-};
-var getResourceResponse = async (resource, request) => {
-  const client = new x402HTTPClient4(new x402Client4());
-  const fetchResult = await safeFetch(surface2, request);
-  if (fetchResult.isErr()) {
-    return err("fetch", surface2, {
-      cause: "network",
-      message: `Failed to fetch resource: ${resource}`
-    });
-  }
-  const response = fetchResult.value;
-  if (response.status !== 402) {
-    return err("fetch", surface2, {
-      cause: "not_402",
-      message: `Resource did not return 402: ${resource}`
-    });
-  }
-  const paymentRequiredResult = await safeGetPaymentRequired(
-    surface2,
-    client,
-    response
-  );
-  if (paymentRequiredResult.isErr()) {
-    return err("x402", surface2, {
-      cause: "parse_payment_required",
-      message: `Failed to parse payment required for: ${resource}`
-    });
-  }
-  return ok({
-    paymentRequired: paymentRequiredResult.value,
-    resource
-  });
-};
-
-// src/server/index.ts
-var startServer = async (flags) => {
-  log.info("Starting x402scan-mcp...");
-  const { dev, invite } = flags;
-  const walletResult = await getWallet();
-  if (walletResult.isErr()) {
-    log.error(JSON.stringify(walletResult.error, null, 2));
-    console.error(walletResult.error);
-    process.exit(1);
-  }
-  const { account } = walletResult.value;
-  const code = invite ?? process.env.INVITE_CODE;
-  const sessionId = randomBytes(16).toString("hex");
-  if (code) {
-    await redeemInviteCode({
-      code,
-      dev,
-      address: account.address,
-      surface: "startServer"
-    });
-  }
-  const server = new McpServer(
-    {
-      name: "@x402scan/mcp",
-      version: MCP_VERSION,
-      websiteUrl: "https://x402scan.com/mcp",
-      icons: [{ src: "https://x402scan.com/logo.svg" }]
-    },
-    {
-      capabilities: {
-        resources: {
-          subscribe: true,
-          listChanged: true
-        }
-      }
-    }
-  );
-  const props = {
-    server,
-    account,
-    flags,
-    sessionId
-  };
-  registerFetchX402ResourceTool(props);
-  registerAuthTools(props);
-  registerWalletTools(props);
-  registerCheckX402EndpointTool(props);
-  registerRedeemInviteTool(props);
-  registerDiscoveryTools(server);
-  registerTelemetryTools(props);
-  await registerOrigins({ server, flags });
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  const shutdown = async () => {
-    log.info("Shutting down...");
-    await server.close();
-    process.exit(0);
-  };
-  process.on("SIGINT", () => void shutdown());
-  process.on("SIGTERM", () => void shutdown());
-};
-export {
-  startServer
-};
-//# sourceMappingURL=server-GJU7QTN5.js.map