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

package/dist/esm/server-IOVNYPTB.js

@@ -0,0 +1,976 @@
+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