@x402scan/mcp 0.0.3 → 0.0.4

package/dist/esm/index.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import z, { z as z$1 } from 'zod';
 import { getAddress, createPublicClient, http, erc20Abi, formatUnits } from 'viem';
-import fs4, { mkdirSync, appendFileSync } from 'fs';
 import path2, { join } from 'path';
 import os, { homedir } from 'os';
+import * as fs from 'fs';
+import fs__default, { appendFileSync } from 'fs';
 import { polygon, arbitrum, optimism, sepolia, mainnet, baseSepolia, base } from 'viem/chains';
-import { intro, outro, log as log$1, confirm, stream, spinner, select } from '@clack/prompts';
-import boxen from 'boxen';
-import chalk3 from 'chalk';
+import { intro, outro, log as log$1, confirm, stream, spinner, select, text } from '@clack/prompts';
+import { errAsync, ResultAsync, err } from 'neverthrow';
+import chalk from 'chalk';
 import open from 'open';
 import { x402Client, x402HTTPClient } from '@x402/core/client';
 import { ExactEvmScheme } from '@x402/evm/exact/client';
@@ -16,8 +17,9 @@ import { base58 } from '@scure/base';
 import 'tweetnacl';
 import { SiweMessage } from 'siwe';
 import { safeBase64Encode } from '@x402/core/utils';
+import 'url';
 import { randomBytes } from 'crypto';
-import * as fs from 'fs/promises';
+import * as fs3 from 'fs/promises';
 import { privateKeyToAccount } from 'viem/accounts';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -91,6 +93,25 @@ var init_types = __esm({
   "src/server/types.ts"() {
   }
 });
+var BASE_DIRECTORY, configFile;
+var init_fs = __esm({
+  "src/lib/fs.ts"() {
+    BASE_DIRECTORY = join(homedir(), ".x402scan-mcp");
+    if (!fs.existsSync(BASE_DIRECTORY)) {
+      fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+    }
+    configFile = (name) => {
+      if (!fs.existsSync(BASE_DIRECTORY)) {
+        fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+      }
+      const filePath = join(BASE_DIRECTORY, name);
+      if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, "{}");
+      }
+      return filePath;
+    };
+  }
+});
 function format(args) {
   return args.map(
     (a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)
@@ -108,16 +129,12 @@ function write(level, msg, args) {
     console.error(`[x402scan] ${formatted}`);
   }
 }
-var LOG_DIR, LOG_FILE, DEBUG, log;
+var LOG_FILE, DEBUG, log;
 var init_log = __esm({
   "src/lib/log.ts"() {
-    LOG_DIR = join(homedir(), ".x402scan-mcp");
-    LOG_FILE = join(LOG_DIR, "mcp.log");
+    init_fs();
+    LOG_FILE = configFile("mcp.log");
     DEBUG = process.env.X402_DEBUG === "true";
-    try {
-      mkdirSync(LOG_DIR, { recursive: true });
-    } catch {
-    }
     log = {
       info: (msg, ...args) => write("INFO", msg, args),
       error: (msg, ...args) => write("ERROR", msg, args),
@@ -249,35 +266,207 @@ var init_wait = __esm({
     };
   }
 });
-var getDepositLink, openDepositLink, promptDeposit;
+function safeFetch(input, init) {
+  return ResultAsync.fromPromise(
+    fetch(input, init),
+    (error) => ({
+      type: "network",
+      message: "Network error",
+      error: error instanceof Error ? error : new Error(String(error))
+    })
+  );
+}
+var safeFetchJson;
+var init_safe_fetch = __esm({
+  "src/lib/safe-fetch.ts"() {
+    safeFetchJson = (input, init, errorMessage) => {
+      return safeFetch(input, init).andThen((response) => {
+        if (!response.ok) {
+          return ResultAsync.fromSafePromise(
+            response.json().catch(() => void 0)
+          ).andThen(
+            (json) => err({
+              type: "http",
+              message: json !== void 0 && errorMessage ? errorMessage(json) : response.statusText,
+              status: response.status,
+              headers: response.headers,
+              json
+            })
+          );
+        }
+        return ResultAsync.fromPromise(
+          response.json(),
+          (error) => ({
+            type: "parse",
+            message: "Could not parse JSON from response",
+            error: error instanceof Error ? error : new Error(String(error))
+          })
+        );
+      });
+    };
+  }
+});
+
+// src/lib/utils.ts
+var getBaseUrl;
+var init_utils = __esm({
+  "src/lib/utils.ts"() {
+    getBaseUrl = (dev) => {
+      return dev ? "http://localhost:3000" : "https://x402scan.com";
+    };
+  }
+});
+var STATE_FILE, stateSchema, getState, setState;
+var init_state = __esm({
+  "src/lib/state.ts"() {
+    init_fs();
+    init_log();
+    STATE_FILE = configFile("state.json");
+    stateSchema = z.looseObject({
+      redeemedCodes: z.array(z.string())
+    }).partial();
+    getState = () => {
+      if (!fs__default.existsSync(STATE_FILE)) {
+        fs__default.writeFileSync(STATE_FILE, JSON.stringify({}));
+        return {};
+      }
+      const result = stateSchema.safeParse(
+        JSON.parse(fs__default.readFileSync(STATE_FILE, "utf-8"))
+      );
+      if (!result.success) {
+        log.error("Failed to parse state", { error: result.error });
+        return {};
+      }
+      return result.data;
+    };
+    setState = (state) => {
+      const existing = getState();
+      const newState = stateSchema.parse({ ...existing, ...state });
+      fs__default.writeFileSync(STATE_FILE, JSON.stringify(newState, null, 2));
+    };
+  }
+});
+var redeemInviteCode;
+var init_redeem_invite = __esm({
+  "src/lib/redeem-invite.ts"() {
+    init_safe_fetch();
+    init_utils();
+    init_state();
+    redeemInviteCode = async ({
+      code,
+      dev,
+      address
+    }) => {
+      const state = getState();
+      if (state.redeemedCodes?.includes(code)) {
+        return Promise.resolve(
+          errAsync({
+            success: false,
+            message: "This invite code has already been redeemed"
+          })
+        );
+      }
+      return await safeFetchJson(
+        `${getBaseUrl(dev)}/api/invite/redeem`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            code,
+            recipientAddr: address
+          })
+        },
+        ({ message }) => message
+      ).andTee((result) => {
+        if (result.success) {
+          setState({
+            redeemedCodes: [...state.redeemedCodes ?? [], code]
+          });
+        }
+      });
+    };
+  }
+});
+var getDepositLink, openDepositLink, redeemInviteCodePrompt, promptDeposit;
 var init_deposit = __esm({
   "src/lib/deposit.ts"() {
     init_networks();
     init_wait();
+    init_redeem_invite();
+    init_utils();
     getDepositLink = (address, flags) => {
-      const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
-      return `${baseUrl}/deposit/${address}`;
+      return `${getBaseUrl(flags.dev)}/deposit/${address}`;
     };
     openDepositLink = async (address, flags) => {
       const depositLink = getDepositLink(address, flags);
       await open(depositLink);
     };
+    redeemInviteCodePrompt = async (address, flags) => {
+      const code = await text({
+        message: "Enter your invite code",
+        placeholder: "MRT-XXXXX",
+        validate: (value) => {
+          if (!value || value.trim().length === 0) {
+            return "Please enter an invite code";
+          }
+        }
+      });
+      if (typeof code !== "string") {
+        return false;
+      }
+      const s = spinner();
+      s.start("Redeeming invite code...");
+      const result = await redeemInviteCode({ code, dev: flags.dev, address });
+      return result.match(
+        async ({ data: { amount, txHash } }) => {
+          s.stop("Invite code redeemed successfully!");
+          await wait({
+            startText: "Processing...",
+            stopText: chalk.green(
+              `${chalk.bold(amount)} USDC has been sent to your wallet!`
+            ),
+            ms: 1500
+          });
+          log$1.success(
+            chalk.bold(`Your wallet has been funded with ${amount} USDC`)
+          );
+          if (txHash) {
+            log$1.info(chalk.dim(`Transaction: https://basescan.org/tx/${txHash}`));
+          }
+          return true;
+        },
+        (error) => {
+          s.stop("Invite code redemption failed");
+          log$1.warning(
+            chalk.yellow(`Failed to redeem invite code: ${error?.message}`)
+          );
+          return false;
+        }
+      );
+    };
     promptDeposit = async (address, flags) => {
       const depositLink = getDepositLink(address, flags);
-      const guidedDeposit = await select({
-        message: chalk3.bold("How would you like to deposit?"),
-        initialValue: true,
+      const depositChoice = await select({
+        message: chalk.bold("How would you like to deposit?"),
+        initialValue: "guided",
         options: [
           {
-            label: `Guided - Recommended`,
-            value: true,
+            label: "Guided - Recommended",
+            value: "guided",
             hint: "Online portal in x402scan"
           },
           {
             label: "Manual",
-            value: false,
+            value: "manual",
             hint: "Print deposit instructions"
           },
+          {
+            label: "Redeem Invite Code",
+            value: "invite",
+            hint: "Enter an invite code for starter money"
+          },
           {
             label: "Skip",
             value: void 0,
@@ -285,30 +474,24 @@ var init_deposit = __esm({
           }
         ]
       });
-      if (guidedDeposit === true) {
+      if (depositChoice === "guided") {
         await wait({
           startText: "Opening deposit page...",
-          stopText: `Opening ${chalk3.underline.hex("#2563eb")(depositLink)}`,
+          stopText: `Opening ${chalk.underline.hex("#2563eb")(depositLink)}`,
           ms: 1e3
         });
         await open(depositLink);
-      } else if (guidedDeposit === false) {
-        log$1.message(
-          boxen(
-            `${chalk3.bold("Account Information")}
-Address: ${address}
-Network: ${getChainName(DEFAULT_NETWORK)}
-
-${chalk3.bold("Online Portal")}
-${chalk3.underline(depositLink)}`,
-            {
-              borderStyle: "round",
-              borderColor: "#2563eb",
-              title: "Deposit Instructions",
-              padding: 1
-            }
-          )
-        );
+      } else if (depositChoice === "manual") {
+        log$1.step(chalk.bold("Account Information"));
+        log$1.message(`Address: ${address}`);
+        log$1.message(`Network: ${getChainName(DEFAULT_NETWORK)}`);
+        log$1.step(chalk.bold("Online Portal"));
+        log$1.message(`${chalk.underline(depositLink)}`);
+      } else if (depositChoice === "invite") {
+        const redeemed = await redeemInviteCodePrompt(address, flags);
+        if (!redeemed) {
+          await promptDeposit(address, flags);
+        }
       }
     };
   }
@@ -355,6 +538,27 @@ You can deposit USDC at ${getDepositLink(address, flags)}`
     };
   }
 });
+
+// src/server/lib/parse-response.ts
+var parseResponse;
+var init_parse_response = __esm({
+  "src/server/lib/parse-response.ts"() {
+    parseResponse = async (response) => {
+      try {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+          return await response.json();
+        } else if (contentType.includes("image/")) {
+          return await response.arrayBuffer();
+        } else {
+          return await response.text();
+        }
+      } catch {
+        return void 0;
+      }
+    };
+  }
+});
 var registerFetchX402ResourceTool;
 var init_fetch_x402_resource = __esm({
   "src/server/tools/fetch-x402-resource.ts"() {
@@ -365,6 +569,7 @@ var init_fetch_x402_resource = __esm({
     init_networks();
     init_token();
     init_check_balance();
+    init_parse_response();
     registerFetchX402ResourceTool = ({
       server,
       account,
@@ -416,9 +621,8 @@ var init_fetch_x402_resource = __esm({
               }
             });
             if (!response.ok) {
-              const errorData = await response.text();
               const errorResponse = {
-                data: errorData,
+                data: await parseResponse(response),
                 statusCode: response.status,
                 state
               };
@@ -441,11 +645,11 @@ var init_fetch_x402_resource = __esm({
             };
             const settlement = getSettlement();
             return mcpSuccess({
-              data: await response.text().catch(() => void 0),
+              data: await parseResponse(response),
               payment: settlement
             });
-          } catch (err) {
-            return mcpError(err, { state });
+          } catch (err2) {
+            return mcpError(err2, { state });
           }
         }
       );
@@ -835,8 +1039,8 @@ var init_auth = __esm({
                 chainId: serverInfo.chainId
               }
             });
-          } catch (err) {
-            return mcpError(err, { tool: "authed_call", url });
+          } catch (err2) {
+            return mcpError(err2, { tool: "authed_call", url });
           }
         }
       );
@@ -956,8 +1160,131 @@ var init_check_endpoint_schema = __esm({
               statusCode: response.status,
               routeDetails
             });
-          } catch (err) {
-            return mcpError(err, { tool: "query_endpoint", url });
+          } catch (err2) {
+            return mcpError(err2, { tool: "query_endpoint", url });
+          }
+        }
+      );
+    };
+  }
+});
+var registerRedeemInviteTool;
+var init_redeem_invite2 = __esm({
+  "src/server/tools/redeem-invite.ts"() {
+    init_response();
+    registerRedeemInviteTool = ({
+      server,
+      account: { address },
+      flags
+    }) => {
+      const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
+      server.registerTool(
+        "redeem_invite",
+        {
+          description: "Redeem an invite code to receive USDC.",
+          inputSchema: z.object({
+            code: z.string().min(1).describe("The invite code")
+          })
+        },
+        async ({ code }) => {
+          const res = await fetch(`${baseUrl}/api/invite/redeem`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code, recipientAddr: address })
+          });
+          const data = await res.json();
+          if (!data.success) {
+            return mcpError(data.error ?? "Failed to redeem invite code");
+          }
+          return mcpSuccess({
+            amount: `${data.amount} USDC`,
+            txHash: data.txHash
+          });
+        }
+      );
+    };
+  }
+});
+function getVersion() {
+  {
+    return "0.0.4";
+  }
+}
+var MCP_VERSION;
+var init_version = __esm({
+  "src/server/lib/version.ts"() {
+    MCP_VERSION = getVersion();
+  }
+});
+var errorReportSchema, registerTelemetryTools;
+var init_telemetry = __esm({
+  "src/server/tools/telemetry.ts"() {
+    init_log();
+    init_response();
+    init_version();
+    errorReportSchema = z$1.object({
+      tool: z$1.string().describe("MCP tool name"),
+      resource: z$1.string().optional().describe("x402 resource URL"),
+      summary: z$1.string().describe("1-2 sentence summary"),
+      errorMessage: z$1.string().describe("Error message"),
+      stack: z$1.string().optional().describe("Stack trace"),
+      fullReport: z$1.string().optional().describe("Detailed report with context, logs, repro steps")
+    });
+    registerTelemetryTools = ({
+      server,
+      account: { address },
+      flags
+    }) => {
+      const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
+      server.registerTool(
+        "report_error",
+        {
+          description: "EMERGENCY ONLY. Report critical MCP tool bugs. Do NOT use for normal errors (balance, network, 4xx) - those are recoverable.",
+          inputSchema: errorReportSchema
+        },
+        async (input) => {
+          try {
+            log.info("Submitting error report", {
+              tool: input.tool,
+              resource: input.resource,
+              summary: input.summary
+            });
+            const report = {
+              ...input,
+              walletAddress: address,
+              mcpVersion: MCP_VERSION,
+              reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            const response = await fetch(`${baseUrl}/api/telemetry`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify(report)
+            });
+            if (!response.ok) {
+              const errorText = await response.text().catch(() => "Unknown error");
+              log.error("Failed to submit error report", {
+                status: response.status,
+                error: errorText
+              });
+              return mcpError(
+                `Failed to submit error report: ${response.status} ${errorText}`,
+                { tool: "report_error" }
+              );
+            }
+            const result = await response.json();
+            log.info("Error report submitted successfully", {
+              reportId: result.reportId
+            });
+            return mcpSuccess({
+              submitted: true,
+              reportId: result.reportId,
+              message: "Error report submitted successfully. The x402scan team will investigate."
+            });
+          } catch (err2) {
+            log.error("Failed to submit error report", { error: err2 });
+            return mcpError(err2, { tool: "report_error" });
           }
         }
       );
@@ -1100,7 +1427,7 @@ async function getWallet() {
     return { account: account2, isNew: false };
   }
   try {
-    const data = await fs.readFile(KEYSTORE_FILE, "utf-8");
+    const data = await fs3.readFile(WALLET_FILE, "utf-8");
     const stored2 = storedWalletSchema.parse(JSON.parse(data));
     const account2 = privateKeyToAccount(stored2.privateKey);
     log.info(`Loaded wallet: ${account2.address}`);
@@ -1114,23 +1441,22 @@ async function getWallet() {
     address: account.address,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs.mkdir(KEYSTORE_DIR, { recursive: true });
-  await fs.writeFile(KEYSTORE_FILE, JSON.stringify(stored, null, 2));
+  await fs3.writeFile(WALLET_FILE, JSON.stringify(stored, null, 2));
   try {
-    await fs.chmod(KEYSTORE_FILE, 384);
+    await fs3.chmod(WALLET_FILE, 384);
   } catch {
   }
   log.info(`Created wallet: ${account.address}`);
-  log.info(`Saved to: ${KEYSTORE_FILE}`);
+  log.info(`Saved to: ${WALLET_FILE}`);
   return { account, isNew: true };
 }
-var KEYSTORE_DIR, KEYSTORE_FILE, storedWalletSchema;
+var WALLET_FILE, storedWalletSchema;
 var init_wallet2 = __esm({
   "src/lib/wallet.ts"() {
     init_log();
     init_schemas();
-    KEYSTORE_DIR = join(homedir(), ".x402scan-mcp");
-    KEYSTORE_FILE = join(KEYSTORE_DIR, "wallet.json");
+    init_fs();
+    WALLET_FILE = configFile("wallet.json");
     storedWalletSchema = z.object({
       privateKey: ethereumPrivateKeySchema,
       address: ethereumAddressSchema,
@@ -1168,9 +1494,9 @@ async function lookupDnsTxtRecord(hostname) {
       log.debug(`DNS TXT value is not a valid URL: ${txtValue}`);
       return null;
     }
-  } catch (err) {
+  } catch (err2) {
     log.debug(
-      `DNS lookup error: ${err instanceof Error ? err.message : String(err)}`
+      `DNS lookup error: ${err2 instanceof Error ? err2.message : String(err2)}`
     );
     return null;
   }
@@ -1193,10 +1519,10 @@ async function fetchLlmsTxt(origin) {
       return { found: false, error: "llms.txt is empty" };
     }
     return { found: true, content };
-  } catch (err) {
+  } catch (err2) {
     return {
       found: false,
-      error: `Network error: ${err instanceof Error ? err.message : String(err)}`
+      error: `Network error: ${err2 instanceof Error ? err2.message : String(err2)}`
     };
   }
 }
@@ -1233,10 +1559,10 @@ async function fetchDiscoveryFromUrl(url) {
       };
     }
     return { found: true, document: parsed.data };
-  } catch (err) {
+  } catch (err2) {
     return {
       found: false,
-      error: `Network error: ${err instanceof Error ? err.message : String(err)}`
+      error: `Network error: ${err2 instanceof Error ? err2.message : String(err2)}`
     };
   }
 }
@@ -1328,11 +1654,11 @@ async function queryResource(url) {
       resource.signInWithX = { required: true, info: siwx.info };
     }
     return resource;
-  } catch (err) {
+  } catch (err2) {
     return {
       url,
       isX402Endpoint: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: err2 instanceof Error ? err2.message : String(err2)
     };
   }
 }
@@ -1366,7 +1692,7 @@ function registerDiscoveryTools(server) {
         )
       }
     },
-    async ({ url, testResources, concurrency }) => {
+    async ({ url, fanOut, concurrency }) => {
       try {
         const origin = getOrigin(url);
         log.info(`Discovering resources for origin: ${origin}`);
@@ -1400,7 +1726,7 @@ function registerDiscoveryTools(server) {
           usage: "Use query_endpoint to get full pricing/requirements for a resource. Use execute_call (for payment) or authed_call (for SIWX auth) to call it.",
           resources: []
         };
-        if (!testResources) {
+        if (!fanOut) {
           result.resources = doc.resources.map((resourceUrl) => ({
             url: resourceUrl
           }));
@@ -1417,8 +1743,8 @@ function registerDiscoveryTools(server) {
         }
         result.resources = allResources;
         return mcpSuccess(result);
-      } catch (err) {
-        return mcpError(err, { tool: "discover_resources", url });
+      } catch (err2) {
+        return mcpError(err2, { tool: "discover_resources", url });
       }
     }
   );
@@ -1465,17 +1791,30 @@ var init_server = __esm({
     init_auth();
     init_wallet();
     init_check_endpoint_schema();
+    init_redeem_invite2();
+    init_telemetry();
     init_origins();
     init_log();
     init_wallet2();
     init_discover_resources();
+    init_redeem_invite();
+    init_version();
     startServer = async (flags) => {
       log.info("Starting x402scan-mcp...");
+      const { dev, invite } = flags;
       const { account } = await getWallet();
+      const code = invite ?? process.env.INVITE_CODE;
+      if (code) {
+        await redeemInviteCode({
+          code,
+          dev,
+          address: account.address
+        });
+      }
       const server = new McpServer(
         {
           name: "@x402scan/mcp",
-          version: "0.0.1",
+          version: MCP_VERSION,
           websiteUrl: "https://x402scan.com/mcp",
           icons: [{ src: "https://x402scan.com/logo.svg" }]
         },
@@ -1497,7 +1836,9 @@ var init_server = __esm({
       registerAuthTools(props);
       registerWalletTools(props);
       registerCheckX402EndpointTool(props);
+      registerRedeemInviteTool(props);
       registerDiscoveryTools(server);
+      registerTelemetryTools(props);
       await registerOrigins({ server, flags });
       const transport = new StdioServerTransport();
       await server.connect(transport);
@@ -1628,7 +1969,7 @@ var init_get_client = __esm({
       if (parsedClientSelection.success) {
         return parsedClientSelection.data;
       }
-      outro(chalk3.bold.red("No MCP client selected"));
+      outro(chalk.bold.red("No MCP client selected"));
       process.exit(0);
     };
   }
@@ -1674,7 +2015,7 @@ var parseClientConfig, serializeClientConfig, stringifyObject;
 var init_file_types = __esm({
   "src/install/2-add-server/lib/file-types.ts"() {
     parseClientConfig = ({ format: format2, path: path3 }) => {
-      const fileContent = fs4.readFileSync(path3, "utf8");
+      const fileContent = fs__default.readFileSync(path3, "utf8");
       let config = {};
       if (format2 === "yaml" /* YAML */) {
         config = yaml.load(fileContent);
@@ -1851,7 +2192,7 @@ var init_client_config_file = __esm({
             "opencode.json"
           );
           const jsoncPath = jsonPath.replace(".json", ".jsonc");
-          if (fs4.existsSync(jsoncPath)) {
+          if (fs__default.existsSync(jsoncPath)) {
             log.info(`Found .jsonc file for OpenCode, using: ${jsoncPath}`);
             return {
               path: jsoncPath,
@@ -1914,7 +2255,7 @@ async function addServer(client, globalFlags) {
   const { serverName, command, args } = getMcpConfig(globalFlags);
   if (client === "warp" /* Warp */) {
     log$1.info(
-      chalk3.bold.yellow("Warp requires a manual installation through their UI.")
+      chalk.bold.yellow("Warp requires a manual installation through their UI.")
     );
     log$1.message(
       "Please copy the following configuration object and add it to your Warp MCP config:"
@@ -1951,7 +2292,7 @@ async function addServer(client, globalFlags) {
     let config = {};
     let content = void 0;
     log.info(`Checking if config file exists at: ${clientFileTarget.path}`);
-    if (!fs4.existsSync(clientFileTarget.path)) {
+    if (!fs__default.existsSync(clientFileTarget.path)) {
       log.info("Config file not found, creating default empty config");
       setNestedValue(config, clientFileTarget.configKey, {});
       log.info("Config created successfully");
@@ -1985,7 +2326,7 @@ async function addServer(client, globalFlags) {
     if (!servers || typeof servers !== "object") {
       log.error(`Invalid ${clientFileTarget.configKey} structure in config`);
       log$1.error(
-        chalk3.bold.red(
+        chalk.bold.red(
           `Invalid ${clientFileTarget.configKey} structure in config`
         )
       );
@@ -2023,7 +2364,9 @@ async function addServer(client, globalFlags) {
       };
     }
     await new Promise((resolve) => setTimeout(resolve, 1e3));
-    log$1.step(`The following will be added to ${chalk3.bold.underline(clientFileTarget.path)}`);
+    log$1.step(
+      `The following will be added to ${chalk.bold.underline(clientFileTarget.path)}`
+    );
     const configStr = formatDiffByFormat(
       {
         [clientFileTarget.configKey]: {
@@ -2055,7 +2398,7 @@ async function addServer(client, globalFlags) {
       inactive: "Cancel"
     });
     if (isConfirmed !== true) {
-      outro(chalk3.bold.red("Installation cancelled"));
+      outro(chalk.bold.red("Installation cancelled"));
       process.exit(0);
     }
     const configContent = serializeClientConfig(
@@ -2063,10 +2406,10 @@ async function addServer(client, globalFlags) {
       config,
       content
     );
-    fs4.writeFileSync(clientFileTarget.path, configContent);
-    log$1.success(chalk3.bold.green(`Added x402scan MCP to ${name}`));
+    fs__default.writeFileSync(clientFileTarget.path, configContent);
+    log$1.success(chalk.bold.green(`Added x402scan MCP to ${name}`));
   } catch (e) {
-    log$1.error(chalk3.bold.red(`Error adding x402scan MCP to ${name}`));
+    log$1.error(chalk.bold.red(`Error adding x402scan MCP to ${name}`));
     throw e;
   }
 }
@@ -2100,7 +2443,7 @@ var init_add_server = __esm({
             const diffLines = [0, 1, numLines - 2, numLines - 1];
             const isDiffLine = !diffLines.includes(index);
             if (isDiffLine) {
-              return `${chalk3.bold.green(`+ ${line.slice(2)}`)}`;
+              return `${chalk.bold.green(`+ ${line.slice(2)}`)}`;
             }
             return line;
           }).join("\n");
@@ -2110,14 +2453,14 @@ var init_add_server = __esm({
             const diffLines = [0, 1, str.length - 2, str.length - 1];
             const isDiffLine = !diffLines.includes(index);
             if (isDiffLine) {
-              return `${chalk3.bold.green(`+ ${line.slice(2)}`)}`;
+              return `${chalk.bold.green(`+ ${line.slice(2)}`)}`;
             }
             return line;
           }).join("\n");
         }
         case "toml" /* TOML */: {
           return str.split("\n").filter((line) => line.trim() !== "").map((line) => {
-            return `${chalk3.bold.green(`+ ${line.trim()}`)}`;
+            return `${chalk.bold.green(`+ ${line.trim()}`)}`;
           }).join("\n");
         }
       }
@@ -2139,12 +2482,12 @@ var init_add_funds = __esm({
         const balance = await getUSDCBalance({ address });
         await wait({
           startText: "Checking balance...",
-          stopText: `Balance: ${chalk3.bold(`${balance} USDC`)} `,
+          stopText: `Balance: ${chalk.bold(`${balance} USDC`)} `,
           ms: 1e3
         });
         if (balance < 1) {
           log$1.warning(
-            chalk3.bold(
+            chalk.bold(
               `Your balance is low (${balance} USDC). Consider topping up.`
             )
           );
@@ -2154,6 +2497,41 @@ var init_add_funds = __esm({
     };
   }
 });
+var redeemInviteCode2;
+var init_redeem_invite3 = __esm({
+  "src/install/4-redeem-invite/index.ts"() {
+    init_wait();
+    init_redeem_invite();
+    redeemInviteCode2 = async (props) => {
+      const s = spinner();
+      s.start("Redeeming invite code...");
+      const result = await redeemInviteCode(props);
+      return result.match(
+        async ({ data }) => {
+          s.stop("Invite code redeemed successfully!");
+          await wait({
+            startText: "Processing...",
+            stopText: chalk.green(
+              `${chalk.bold(data.amount)} USDC has been sent to your wallet!`
+            ),
+            ms: 1e3
+          });
+          log$1.info(
+            chalk.dim(`Transaction: https://basescan.org/tx/${data.txHash}`)
+          );
+          return true;
+        },
+        (error) => {
+          s.stop("Invite code redemption failed");
+          log$1.warning(
+            chalk.yellow(`Failed to redeem invite code: ${error?.message}`)
+          );
+          return false;
+        }
+      );
+    };
+  }
+});
 
 // src/install/index.ts
 var install_exports = {};
@@ -2167,16 +2545,24 @@ var init_install = __esm({
     init_get_client();
     init_add_server();
     init_add_funds();
+    init_redeem_invite3();
     installMcpServer = async (flags) => {
       const {
         account: { address },
         isNew
       } = await getWallet();
-      intro(chalk3.green.bold(`Install x402scan MCP`));
+      intro(chalk.green.bold(`Install x402scan MCP`));
       const client = await getClient(flags);
       await addServer(client, flags);
-      await addFunds({ flags, address, isNew });
-      outro(chalk3.bold.green("Your x402scan MCP server is ready to use!"));
+      const inviteRedeemed = flags.invite ? await redeemInviteCode2({
+        code: flags.invite,
+        dev: flags.dev,
+        address
+      }) : false;
+      if (!inviteRedeemed) {
+        await addFunds({ flags, address, isNew });
+      }
+      outro(chalk.bold.green("Your x402scan MCP server is ready to use!"));
     };
   }
 });
@@ -2192,12 +2578,12 @@ var init_fund = __esm({
     init_wallet2();
     init_deposit();
     fundMcpServer = async (flags) => {
-      intro(chalk3.bold(`Fund ${chalk3.hex("#2563eb")("x402scan MCP")}`));
+      intro(chalk.bold(`Fund ${chalk.hex("#2563eb")("x402scan MCP")}`));
       const {
         account: { address }
       } = await getWallet();
       await promptDeposit(address, flags);
-      outro(chalk3.bold.green("Your x402scan MCP server is funded!"));
+      outro(chalk.bold.green("Your x402scan MCP server is funded!"));
     };
   }
 });
@@ -2205,6 +2591,10 @@ void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
   type: "boolean",
   description: "Enable dev mode",
   default: false
+}).option("invite", {
+  type: "string",
+  description: "Invite code to redeem for starter money",
+  required: false
 }).command(
   "$0",
   "Start the MCP server",
@@ -2223,7 +2613,7 @@ void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
   }),
   async (args) => {
     const { installMcpServer: installMcpServer2 } = await Promise.resolve().then(() => (init_install(), install_exports));
-    await installMcpServer2({ ...args });
+    await installMcpServer2(args);
   }
 ).command(
   "fund",
@@ -2233,8 +2623,8 @@ void yargs(hideBin(process.argv)).scriptName("@x402scan/mcp").option("dev", {
     const { fundMcpServer: fundMcpServer2 } = await Promise.resolve().then(() => (init_fund(), fund_exports));
     await fundMcpServer2(args);
   }
-).strict().demandCommand(0, 1, "", "Too many commands provided").help().parseAsync().catch((err) => {
-  console.error("Fatal:", err);
+).strict().demandCommand(0, 1, "", "Too many commands provided").help().parseAsync().catch((err2) => {
+  console.error("Fatal:", err2);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map