@x402scan/mcp 0.0.7-beta.4 → 0.0.7

package/dist/esm/server-IOVNYPTB.js

@@ -1,976 +0,0 @@
-import {
-  MCP_VERSION,
-  getBalance
-} from "./chunk-2UP5W5MC.js";
-import {
-  DEFAULT_NETWORK,
-  err,
-  fetchHttpErr,
-  getBaseUrl,
-  getChainName,
-  getDepositLink,
-  getWallet,
-  isFetchError,
-  log,
-  ok,
-  openDepositLink,
-  redeemInviteCode,
-  resultFromPromise,
-  resultFromThrowable,
-  safeFetch,
-  safeFetchJson,
-  safeParseResponse,
-  safeStringifyJson
-} from "./chunk-JXXC6FYE.js";
-
-// src/server/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// 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 (surface2, response) => {
-  return mcpError(fetchHttpErr(surface2, 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) => {
-  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
-    }
-  });
-};
-
-// src/server/tools/lib/check-balance.ts
-var checkBalance = async ({
-  server,
-  address,
-  amountNeeded,
-  message,
-  flags,
-  surface: surface2
-}) => {
-  const balanceResult = await getBalance({ address, flags, surface: surface2 });
-  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 x402Err = (cause, error) => err(errorType, cause, error);
-var x402ResultFromPromise = (surface2, promise, error) => resultFromPromise(errorType, surface2, promise, error);
-var x402ResultFromThrowable = (surface2, fn, error) => resultFromThrowable(errorType, surface2, fn, error);
-var safeGetPaymentRequired = (surface2, client, response) => {
-  return x402ResultFromPromise(
-    surface2,
-    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 = (surface2, client, paymentRequired) => {
-  return x402ResultFromPromise(
-    surface2,
-    client.createPaymentPayload(paymentRequired),
-    (error) => ({
-      cause: "create_payment_payload",
-      message: error instanceof Error ? error.message : "Failed to create payment payload"
-    })
-  );
-};
-var safeGetPaymentSettlement = (surface2, client, response) => {
-  return x402ResultFromThrowable(
-    surface2,
-    () => 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 = (surface2, serverInfo, signer) => {
-  return x402ResultFromPromise(
-    surface2,
-    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
-}) => {
-  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
-      );
-    }
-  );
-};
-function safeWrapFetchWithPayment(client) {
-  return async (input, init) => {
-    const request = new Request(input, init);
-    const clonedRequest = request.clone();
-    const probeResult = await safeFetch(toolName, request);
-    if (probeResult.isErr()) {
-      return probeResult;
-    }
-    if (probeResult.value.status !== 402) {
-      return probeResult;
-    }
-    const response = probeResult.value;
-    const paymentRequiredResult = await safeGetPaymentRequired(
-      toolName,
-      client,
-      response
-    );
-    if (paymentRequiredResult.isErr()) {
-      return paymentRequiredResult;
-    }
-    const paymentRequired = paymentRequiredResult.value;
-    const paymentPayloadResult = await safeCreatePaymentPayload(
-      toolName,
-      client,
-      paymentRequired
-    );
-    if (paymentPayloadResult.isErr()) {
-      return paymentPayloadResult;
-    }
-    const paymentPayload = paymentPayloadResult.value;
-    const paymentHeaders = client.encodePaymentSignatureHeader(paymentPayload);
-    if (clonedRequest.headers.has("PAYMENT-SIGNATURE") || clonedRequest.headers.has("X-PAYMENT")) {
-      return x402Err(toolName, {
-        cause: "payment_already_attempted",
-        message: "Payment already attempted"
-      });
-    }
-    for (const [key, value] of Object.entries(paymentHeaders)) {
-      clonedRequest.headers.set(key, value);
-    }
-    clonedRequest.headers.set(
-      "Access-Control-Expose-Headers",
-      "PAYMENT-RESPONSE,X-PAYMENT-RESPONSE"
-    );
-    return await safeFetch(toolName, clonedRequest);
-  };
-}
-
-// 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 = "fetchWithAuth";
-var registerAuthTools = ({ server, account }) => {
-  server.registerTool(
-    toolName2,
-    {
-      description: "Make a request to a SIWX-protected endpoint. Handles auth flow automatically: detects SIWX requirement from 402 response, signs proof with server-provided challenge, retries.",
-      inputSchema: requestSchema
-    },
-    async (input) => {
-      const httpClient = new x402HTTPClient2(new x402Client2());
-      const firstResult = await safeFetch(toolName2, buildRequest(input));
-      if (firstResult.isErr()) {
-        return mcpError(firstResult);
-      }
-      const firstResponse = firstResult.value;
-      if (firstResponse.status !== 402) {
-        if (!firstResponse.ok) {
-          return mcpErrorFetch(toolName2, firstResponse);
-        }
-        const parseResponseResult2 = await safeParseResponse(
-          toolName2,
-          firstResponse
-        );
-        if (parseResponseResult2.isErr()) {
-          return mcpError(parseResponseResult2);
-        }
-        return mcpSuccessResponse(parseResponseResult2.value);
-      }
-      const getPaymentRequiredResult = await safeGetPaymentRequired(
-        toolName2,
-        httpClient,
-        firstResponse
-      );
-      if (getPaymentRequiredResult.isErr()) {
-        return mcpError(getPaymentRequiredResult);
-      }
-      const paymentRequired = getPaymentRequiredResult.value;
-      const siwxExtension = getSiwxExtension(paymentRequired.extensions);
-      if (!siwxExtension) {
-        return mcpErrorJson({
-          message: "Endpoint returned 402 but no sign-in-with-x extension found",
-          statusCode: 402,
-          extensions: Object.keys(paymentRequired.extensions ?? {}),
-          hint: "This endpoint may require payment instead of authentication. Use execute_call for paid requests."
-        });
-      }
-      const serverInfo = siwxExtension;
-      const requiredFields = [
-        "domain",
-        "uri",
-        "version",
-        "chainId",
-        "nonce",
-        "issuedAt"
-      ];
-      const missingFields = requiredFields.filter(
-        (f) => !serverInfo[f]
-      );
-      if (missingFields.length > 0) {
-        return mcpErrorJson({
-          message: "Invalid sign-in-with-x extension: missing required fields",
-          missingFields,
-          receivedInfo: { ...serverInfo }
-        });
-      }
-      if (serverInfo.chainId.startsWith("solana:")) {
-        return mcpErrorJson({
-          message: "Solana authentication not supported",
-          chainId: serverInfo.chainId,
-          hint: "This endpoint requires a Solana wallet. The MCP server currently only supports EVM wallets."
-        });
-      }
-      const payloadResult = await safeCreateSIWxPayload(
-        toolName2,
-        serverInfo,
-        account
-      );
-      if (payloadResult.isErr()) {
-        return mcpError(payloadResult);
-      }
-      const siwxHeader = encodeSIWxHeader(payloadResult.value);
-      const authedRequest = buildRequest(input);
-      authedRequest.headers.set("SIGN-IN-WITH-X", siwxHeader);
-      const authedResult = await safeFetch(toolName2, authedRequest);
-      if (authedResult.isErr()) {
-        return mcpError(authedResult);
-      }
-      const authedResponse = authedResult.value;
-      if (!authedResponse.ok) {
-        return mcpErrorFetch(toolName2, authedResponse);
-      }
-      const parseResponseResult = await safeParseResponse(
-        toolName2,
-        authedResponse
-      );
-      if (parseResponseResult.isErr()) {
-        return mcpError(parseResponseResult);
-      }
-      return mcpSuccessResponse(parseResponseResult.value, {
-        authentication: {
-          address: account.address,
-          domain: serverInfo.domain,
-          chainId: serverInfo.chainId
-        }
-      });
-    }
-  );
-};
-
-// src/server/tools/wallet.ts
-var toolName3 = "getWalletInfo";
-var registerWalletTools = ({
-  server,
-  account: { address },
-  flags
-}) => {
-  server.registerTool(
-    toolName3,
-    {
-      description: "Check wallet address and USDC balance. Creates wallet if needed."
-    },
-    async () => {
-      const balanceResult = await getBalance({
-        address,
-        flags,
-        surface: toolName3
-      });
-      if (balanceResult.isErr()) {
-        return mcpError(balanceResult);
-      }
-      const { balance } = balanceResult.value;
-      return mcpSuccessJson({
-        address,
-        network: DEFAULT_NETWORK,
-        networkName: getChainName(DEFAULT_NETWORK),
-        usdcBalance: balance,
-        isNewWallet: balance === 0,
-        depositLink: getDepositLink(address, flags),
-        ...balance < 2.5 ? {
-          message: `Your balance is low. Consider topping it up`
-        } : {}
-      });
-    }
-  );
-};
-
-// src/server/tools/check-endpoint.ts
-import { x402Client as x402Client3, x402HTTPClient as x402HTTPClient3 } from "@x402/core/client";
-var toolName4 = "checkEndpointSchema";
-var registerCheckX402EndpointTool = ({ server }) => {
-  server.registerTool(
-    toolName4,
-    {
-      description: "Check if an endpoint is x402-protected and get pricing options, schema, and auth requirements (if applicable).",
-      inputSchema: requestSchema
-    },
-    async (input) => {
-      log.info("Querying endpoint", input);
-      const responseResult = await safeFetch(toolName4, buildRequest(input));
-      if (responseResult.isErr()) {
-        return mcpError(responseResult);
-      }
-      const response = responseResult.value;
-      if (response.status !== 402) {
-        if (!response.ok) {
-          return mcpErrorFetch(toolName4, response);
-        }
-        const parseResponseResult = await safeParseResponse(toolName4, response);
-        if (parseResponseResult.isErr()) {
-          return mcpError(parseResponseResult);
-        }
-        return mcpSuccessResponse(parseResponseResult.value, {
-          requiresPayment: false
-        });
-      }
-      const client = new 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 = "redeemInvite";
-var registerRedeemInviteTool = ({
-  server,
-  account: { address },
-  flags
-}) => {
-  server.registerTool(
-    toolName5,
-    {
-      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 = "reportError";
-var registerTelemetryTools = ({
-  server,
-  account: { address },
-  flags
-}) => {
-  server.registerTool(
-    toolName6,
-    {
-      description: "EMERGENCY ONLY. Report critical MCP tool bugs. Do NOT use for normal errors (balance, network, 4xx) - those are recoverable.",
-      inputSchema: 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()
-          })
-        })
-      );
-      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 toolName7 = "discoverResources";
-var discoveryDocumentSchema = z4.object({
-  version: z4.number().refine((v) => v === 1, { message: "version must be 1" }),
-  resources: z4.array(z4.url()),
-  ownershipProofs: z4.array(z4.string()).optional(),
-  instructions: z4.string().optional()
-});
-function registerDiscoveryTools(server) {
-  server.registerTool(
-    "discover_resources",
-    {
-      description: `Discover x402-protected resources on an origin. Returns a list of resource URLs.
-        Use check_x402_endpoint separately to get detailed pricing/schema info for specific resources.
-
-        Known default origins with resource packs. Discover if more needed:
-        - https://enrichx402.com ->
-            People + Org search
-            Google Maps (places + locations)
-            Grok twitter search
-            Exa web search
-            Clado linkedin data
-            Firecrawl web scrape
-        - https://stablestudio.io -> generate images / videos
-        `,
-      inputSchema: {
-        url: 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" } })
-      );
-      if (wellKnownResult.isOk()) {
-        const parsed = discoveryDocumentSchema.safeParse(wellKnownResult.value);
-        if (parsed.success) {
-          return mcpSuccessJson({
-            found: true,
-            origin,
-            source: "well-known",
-            data: parsed.data
-          });
-        }
-      } else {
-        log.info(
-          `No well-known x402 discovery document found at ${wellKnownUrl}`
-        );
-      }
-      const dnsQuery = `_x402.${hostname}`;
-      log.debug(`Looking up DNS TXT record: ${dnsQuery}`);
-      const dnsResult = await safeFetchJson(
-        toolName7,
-        new Request(
-          `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(dnsQuery)}&type=TXT`,
-          { headers: { Accept: "application/dns-json" } }
-        )
-      );
-      if (dnsResult.isOk() && dnsResult.value.Answer && dnsResult.value.Answer.length > 0) {
-        const dnsUrl = dnsResult.value.Answer[0].data.replace(/^"|"$/g, "");
-        if (URL.canParse(dnsUrl)) {
-          const dnsDocResult = await safeFetchJson(
-            toolName7,
-            new Request(dnsUrl, { headers: { Accept: "application/json" } })
-          );
-          if (dnsDocResult.isOk()) {
-            const parsed = discoveryDocumentSchema.safeParse(
-              dnsDocResult.value
-            );
-            if (parsed.success) {
-              return mcpSuccessJson({
-                found: true,
-                origin,
-                source: "dns-txt",
-                data: parsed.data
-              });
-            }
-          }
-        } else {
-          log.debug(`DNS TXT value is not a valid URL: ${dnsUrl}`);
-        }
-      } else {
-        log.info(`No DNS TXT record found for ${dnsQuery}`);
-      }
-      const llmsTxtUrl = `${origin}/llms.txt`;
-      log.debug(`Fetching llms.txt from: ${llmsTxtUrl}`);
-      const llmsResult = await safeFetch(
-        toolName7,
-        new Request(llmsTxtUrl, { headers: { Accept: "text/plain" } })
-      );
-      if (llmsResult.isOk()) {
-        const parseResult = await safeParseResponse(toolName7, llmsResult.value);
-        if (parseResult.isOk() && parseResult.value.type === "text") {
-          return mcpSuccessJson({
-            found: true,
-            origin,
-            source: "llms-txt",
-            usage: "Found llms.txt but no structured x402 discovery document. The content below may contain information about x402 resources. Parse it to find relevant endpoints.",
-            data: parseResult.value
-          });
-        }
-      }
-      return mcpErrorJson({
-        found: false,
-        origin,
-        error: "No discovery document found. Tried: .well-known/x402, DNS TXT record, llms.txt"
-      });
-    }
-  );
-}
-
-// src/server/resources/origins.ts
-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 origins = ["enrichx402.com"];
-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 response = await fetch(
-            `${uri.toString().replace("api://", "https://")}/.well-known/x402`
-          ).then((response2) => response2.json());
-          const resources = await Promise.all(
-            response.resources.map(async (resource) => {
-              const resourceResponse = await getResourceResponse(
-                resource,
-                await fetch(resource, {
-                  method: "POST",
-                  headers: {
-                    "Content-Type": "application/json"
-                  }
-                })
-              );
-              if (resourceResponse) {
-                return resourceResponse;
-              }
-              const getResponse = await getResourceResponse(
-                resource,
-                await fetch(resource, {
-                  method: "GET"
-                })
-              );
-              if (getResponse) {
-                return getResponse;
-              }
-              console.error(`Failed to get resource response for ${resource}`);
-              return null;
-            })
-          );
-          return {
-            contents: [
-              {
-                uri: origin,
-                text: JSON.stringify({
-                  server: origin,
-                  name: metadata?.title,
-                  description: metadata?.description,
-                  resources: resources.filter(Boolean).map((resource) => {
-                    if (!resource) return null;
-                    const schema = getInputSchema(
-                      resource.paymentRequired?.extensions
-                    );
-                    return {
-                      url: resource.resource,
-                      schema,
-                      mimeType: resource.paymentRequired.resource.mimeType
-                    };
-                  })
-                }),
-                mimeType: "application/json"
-              }
-            ]
-          };
-        }
-      );
-    })
-  );
-};
-var getResourceResponse = async (resource, response) => {
-  const client = new x402HTTPClient4(new x402Client4());
-  if (response.status === 402) {
-    const paymentRequired = client.getPaymentRequiredResponse(
-      (name) => response.headers.get(name),
-      JSON.parse(await response.text())
-    );
-    return {
-      paymentRequired,
-      resource
-    };
-  }
-  return null;
-};
-
-// 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;
-  if (code) {
-    await redeemInviteCode({
-      code,
-      dev,
-      address: account.address,
-      surface: "startServer"
-    });
-  }
-  const server = new McpServer(
-    {
-      name: "@x402scan/mcp",
-      version: MCP_VERSION,
-      websiteUrl: "https://x402scan.com/mcp",
-      icons: [{ src: "https://x402scan.com/logo.svg" }]
-    },
-    {
-      capabilities: {
-        resources: {
-          subscribe: true,
-          listChanged: true
-        }
-      }
-    }
-  );
-  const props = {
-    server,
-    account,
-    flags
-  };
-  registerFetchX402ResourceTool(props);
-  registerAuthTools(props);
-  registerWalletTools(props);
-  registerCheckX402EndpointTool(props);
-  registerRedeemInviteTool(props);
-  registerDiscoveryTools(server);
-  registerTelemetryTools(props);
-  await registerOrigins({ server, flags });
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  const shutdown = async () => {
-    log.info("Shutting down...");
-    await server.close();
-    process.exit(0);
-  };
-  process.on("SIGINT", () => void shutdown());
-  process.on("SIGTERM", () => void shutdown());
-};
-export {
-  startServer
-};
-//# sourceMappingURL=server-IOVNYPTB.js.map