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

package/dist/esm/install-F5WF4NGY.js

@@ -0,0 +1,657 @@
+import { Clients, clientMetadata } from './chunk-47GMMJYJ.js';
+import { getBalance, DIST_TAG } from './chunk-BGSCKUEG.js';
+import { wait, promptDeposit } from './chunk-NV5QXA6N.js';
+import { getWallet, log, err, safeWriteFile, redeemInviteCode, safeReadFile, resultFromThrowable } from './chunk-4ESXGYV6.js';
+import './chunk-PLDDJCW6.js';
+import chalk2 from 'chalk';
+import { intro, outro, log as log$1, select, confirm, stream, spinner } from '@clack/prompts';
+import z from 'zod';
+import fs from 'fs';
+import os from 'os';
+import path2 from 'path';
+import process2 from 'process';
+import * as TOML from '@iarna/toml';
+import yaml from 'js-yaml';
+import * as jsonc from 'jsonc-parser';
+
+var getClient = async ({ client: flagClient, yes }) => {
+  if (yes) {
+    if (!flagClient) {
+      throw new Error(
+        `Client is required when yes is true. Pass --client as one of these values: ${Object.values(Clients).join(", ")}`
+      );
+    }
+    const parsedClient2 = z.enum(Clients).safeParse(flagClient);
+    if (!parsedClient2.success) {
+      throw new Error(
+        `${flagClient} is not a valid client. Valid options are: ${Object.values(Clients).join(", ")}`
+      );
+    }
+    return parsedClient2.data;
+  }
+  const parsedClient = z.enum(Clients).safeParse(flagClient);
+  if (parsedClient.success) {
+    return parsedClient.data;
+  }
+  if (flagClient) {
+    log$1.error(`${flagClient} is not a valid client. Please select a client`);
+  }
+  const client = await select({
+    message: "Where would you like to install the x402scan MCP server?",
+    options: Object.values(Clients).map((client2) => {
+      const metadata = clientMetadata[client2];
+      return {
+        label: metadata.name,
+        value: client2
+      };
+    }),
+    maxItems: 7
+  });
+  const parsedClientSelection = z.enum(Clients).safeParse(client);
+  if (parsedClientSelection.success) {
+    return parsedClientSelection.data;
+  }
+  outro(chalk2.bold.red("No MCP client selected"));
+  process.exit(0);
+};
+var Platforms = /* @__PURE__ */ ((Platforms2) => {
+  Platforms2["Windows"] = "win32";
+  Platforms2["MacOS"] = "darwin";
+  Platforms2["Linux"] = "linux";
+  return Platforms2;
+})(Platforms || {});
+var getPlatformPath = () => {
+  const platform = z.enum(Platforms).safeParse(process2.platform);
+  if (!platform.success) {
+    throw new Error(`Invalid platform: ${process2.platform}`);
+  }
+  const homeDir = os.homedir();
+  switch (platform.data) {
+    case "win32" /* Windows */:
+      return {
+        baseDir: process2.env.APPDATA ?? path2.join(homeDir, "AppData", "Roaming"),
+        vscodePath: path2.join("Code", "User")
+      };
+    case "darwin" /* MacOS */:
+      return {
+        baseDir: path2.join(homeDir, "Library", "Application Support"),
+        vscodePath: path2.join("Code", "User")
+      };
+    case "linux" /* Linux */:
+      return {
+        baseDir: process2.env.XDG_CONFIG_HOME ?? path2.join(homeDir, ".config"),
+        vscodePath: path2.join("Code/User")
+      };
+    default:
+      throw new Error(`Invalid platform: ${process2.platform}`);
+  }
+};
+
+// src/cli/install/2-add-server/lib/result.ts
+var errorType = "config";
+var surface = "config_file";
+var configResultFromThrowable = (fn, error) => resultFromThrowable(errorType, surface, fn, error);
+
+// src/cli/install/2-add-server/lib/file-types.ts
+var parseContent = (fileContent, format, path3) => {
+  return configResultFromThrowable(
+    () => {
+      let config;
+      if (format === "yaml" /* YAML */) {
+        config = yaml.load(fileContent);
+      } else if (format === "toml" /* TOML */) {
+        config = TOML.parse(fileContent);
+      } else if (path3.endsWith(".jsonc")) {
+        config = jsonc.parse(fileContent);
+      } else {
+        config = JSON.parse(fileContent);
+      }
+      return {
+        config,
+        fileContent
+      };
+    },
+    (e) => ({
+      cause: "parse_config",
+      message: e instanceof Error ? e.message : "Failed to parse config file"
+    })
+  );
+};
+var parseClientConfig = async ({ format, path: path3 }) => {
+  const readResult = await safeReadFile("config_file", path3);
+  if (readResult.isErr()) return readResult;
+  const parseResult = parseContent(readResult.value, format, path3);
+  if (parseResult.isErr()) return parseResult;
+  return parseResult;
+};
+var serializeJsonc = (config, originalContent) => {
+  return configResultFromThrowable(
+    () => {
+      const modifications = [];
+      for (const key of Object.keys(config)) {
+        const keyPath = [key];
+        const edits = jsonc.modify(originalContent, keyPath, config[key], {
+          formattingOptions: { tabSize: 2, insertSpaces: true }
+        });
+        modifications.push(...edits);
+      }
+      return jsonc.applyEdits(originalContent, modifications);
+    },
+    (e) => ({
+      cause: "serialize_config",
+      message: e instanceof Error ? e.message : "Failed to serialize JSONC"
+    })
+  );
+};
+var serializeClientConfig = ({ format, path: path3 }, config, originalContent) => {
+  if (format === "yaml" /* YAML */) {
+    return yaml.dump(config, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true
+    });
+  }
+  if (format === "toml" /* TOML */) {
+    return TOML.stringify(config);
+  }
+  if (path3.endsWith(".jsonc") && originalContent) {
+    const result = serializeJsonc(config, originalContent);
+    if (result.isOk()) {
+      return result.value;
+    }
+    console.log(`Error applying JSONC edits: ${result.error.message}`);
+    console.log("Falling back to JSON.stringify (comments will be lost)");
+    return JSON.stringify(config, null, 2);
+  }
+  return JSON.stringify(config, null, 2);
+};
+var stringifyObject = (config, format) => {
+  if (format === "yaml" /* YAML */) {
+    return yaml.dump(config, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true
+    });
+  }
+  if (format === "toml" /* TOML */) {
+    return TOML.stringify(config);
+  }
+  return JSON.stringify(config, null, 2);
+};
+
+// src/cli/install/2-add-server/lib/client-config-file.ts
+var getClientConfigFile = (client) => {
+  const homeDir = os.homedir();
+  const { baseDir, vscodePath } = getPlatformPath();
+  switch (client) {
+    case "claude" /* Claude */:
+      return {
+        path: path2.join(baseDir, "Claude", "claude_desktop_config.json"),
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "cline" /* Cline */:
+      return {
+        path: path2.join(
+          baseDir,
+          vscodePath,
+          "globalStorage",
+          "saoudrizwan.claude-dev",
+          "settings",
+          "cline_mcp_settings.json"
+        ),
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "roo-cline" /* RooCline */:
+      return {
+        path: path2.join(
+          baseDir,
+          vscodePath,
+          "globalStorage",
+          "rooveterinaryinc.roo-cline",
+          "settings",
+          "mcp_settings.json"
+        ),
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "windsurf" /* Windsurf */:
+      return {
+        path: path2.join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "cursor" /* Cursor */:
+      return {
+        path: path2.join(homeDir, ".cursor", "mcp.json"),
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "warp" /* Warp */:
+      return {
+        path: "no-local-config",
+        // it's okay this isn't a real path, we never use it
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "gemini-cli" /* GeminiCli */:
+      return {
+        path: path2.join(homeDir, ".gemini", "settings.json"),
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "vscode" /* Vscode */:
+      return {
+        path: path2.join(baseDir, vscodePath, "mcp.json"),
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "claude-code" /* ClaudeCode */:
+      return {
+        path: path2.join(homeDir, ".claude.json"),
+        configKey: "mcpServers",
+        format: "json" /* JSON */
+      };
+    case "goose" /* Goose */:
+      return {
+        path: path2.join(homeDir, ".config", "goose", "config.yaml"),
+        configKey: "extensions",
+        format: "yaml" /* YAML */
+      };
+    case "zed" /* Zed */:
+      return {
+        path: process2.platform === "win32" ? path2.join(
+          process2.env.APPDATA ?? path2.join(homeDir, "AppData", "Roaming"),
+          "Zed",
+          "settings.json"
+        ) : path2.join(homeDir, ".config", "zed", "settings.json"),
+        configKey: "context_servers",
+        format: "json" /* JSON */
+      };
+    case "codex" /* Codex */:
+      return {
+        path: path2.join(
+          process2.env.CODEX_HOME ?? path2.join(homeDir, ".codex"),
+          "config.toml"
+        ),
+        configKey: "mcp_servers",
+        format: "toml" /* TOML */
+      };
+    case "opencode" /* Opencode */: {
+      const jsonPath = path2.join(
+        homeDir,
+        ".config",
+        "opencode",
+        "opencode.json"
+      );
+      const jsoncPath = jsonPath.replace(".json", ".jsonc");
+      if (fs.existsSync(jsoncPath)) {
+        log.info(`Found .jsonc file for OpenCode, using: ${jsoncPath}`);
+        return {
+          path: jsoncPath,
+          configKey: "mcp",
+          format: "json" /* JSON */
+        };
+      }
+      return {
+        path: jsonPath,
+        configKey: "mcp",
+        format: "json" /* JSON */
+      };
+    }
+    default:
+      throw new Error(`Unknown client: ${String(client)}`);
+  }
+};
+
+// src/cli/install/2-add-server/lib/nested-values.ts
+var getNestedValue = (obj, path3) => {
+  const keys = path3.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current && typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+};
+var setNestedValue = (obj, path3, value) => {
+  const keys = path3.split(".");
+  const lastKey = keys.pop();
+  if (!lastKey) return;
+  const target = keys.reduce((current, key) => {
+    current[key] ??= {};
+    return current[key];
+  }, obj);
+  target[lastKey] = value;
+};
+
+// src/cli/install/2-add-server/index.ts
+var getMcpConfig = (globalFlags) => {
+  if (globalFlags.dev) {
+    return {
+      serverName: "x402",
+      command: "node",
+      args: [`${process.cwd()}/dist/esm/index.js`, "--dev"]
+    };
+  }
+  return {
+    serverName: "x402",
+    command: "npx",
+    args: ["-y", `@x402scan/mcp@${DIST_TAG}`]
+  };
+};
+var addServer = async (client, globalFlags) => {
+  const { serverName, command, args } = getMcpConfig(globalFlags);
+  if (client === "warp" /* Warp */) {
+    log$1.info(
+      chalk2.bold.yellow("Warp requires a manual installation through their UI.")
+    );
+    log$1.message(
+      "Please copy the following configuration object and add it to your Warp MCP config:"
+    );
+    console.log();
+    console.log(
+      JSON.stringify(
+        {
+          [serverName]: {
+            command,
+            args,
+            working_directory: null,
+            start_on_launch: true
+          }
+        },
+        null,
+        2
+      )
+    );
+    console.log();
+    log$1.message(
+      `Read Warp's documentation at https://docs.warp.dev/knowledge-and-collaboration/mcp`
+    );
+    const addedToWarp = await confirm({
+      message: "Did you add the MCP server to your Warp config?"
+    });
+    if (!addedToWarp) {
+      return err("user", "install", {
+        cause: "warp_mcp_server_not_added",
+        message: "Warp MCP server not added"
+      });
+    }
+  }
+  const clientFileTarget = getClientConfigFile(client);
+  const { name } = clientMetadata[client];
+  let config = {};
+  let content = void 0;
+  log.info(`Checking if config file exists at: ${clientFileTarget.path}`);
+  if (!fs.existsSync(clientFileTarget.path)) {
+    log.info("Config file not found, creating default empty config");
+    setNestedValue(config, clientFileTarget.configKey, {});
+    log.info("Config created successfully");
+    if (!globalFlags.yes) {
+      await wait({
+        startText: "Locating config file",
+        stopText: `No config found, creating default empty config`,
+        ms: 1e3
+      });
+    }
+  } else {
+    log.info("Config file found, reading config file content");
+    const parseResult = await parseClientConfig(clientFileTarget);
+    if (parseResult.isErr()) {
+      log$1.error(
+        chalk2.bold.red(`Error reading config: ${parseResult.error.message}`)
+      );
+      outro(chalk2.bold.red(`Error adding x402scan MCP to ${name}`));
+      process.exit(1);
+    }
+    const { config: rawConfig, fileContent } = parseResult.value;
+    config = rawConfig;
+    content = fileContent;
+    const existingValue = getNestedValue(rawConfig, clientFileTarget.configKey);
+    if (!existingValue) {
+      setNestedValue(rawConfig, clientFileTarget.configKey, {});
+    }
+    if (!globalFlags.yes) {
+      await wait({
+        startText: `Locating config file`,
+        stopText: `Config loaded from ${clientFileTarget.path}`,
+        ms: 1e3
+      });
+    }
+  }
+  const servers = getNestedValue(config, clientFileTarget.configKey);
+  if (!servers || typeof servers !== "object") {
+    log.error(`Invalid ${clientFileTarget.configKey} structure in config`);
+    log$1.error(
+      chalk2.bold.red(
+        `Invalid ${clientFileTarget.configKey} structure in config`
+      )
+    );
+    outro(chalk2.bold.red(`Error adding x402scan MCP to ${name}`));
+    process.exit(1);
+  }
+  if (client === "goose" /* Goose */) {
+    servers[serverName] = {
+      name: serverName,
+      cmd: command,
+      args,
+      enabled: true,
+      envs: {},
+      type: "stdio",
+      timeout: 300
+    };
+  } else if (client === "zed" /* Zed */) {
+    servers[serverName] = {
+      source: "custom",
+      command,
+      args,
+      env: {}
+    };
+  } else if (client === "opencode" /* Opencode */) {
+    servers[serverName] = {
+      type: "local",
+      command,
+      args,
+      enabled: true,
+      environment: {}
+    };
+  } else {
+    servers[serverName] = {
+      command,
+      args
+    };
+  }
+  if (!globalFlags.yes) {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    log$1.step(
+      `The following will be added to ${chalk2.bold.underline(clientFileTarget.path)}`
+    );
+  }
+  const configStr = formatDiffByFormat(
+    {
+      [clientFileTarget.configKey]: {
+        [serverName]: servers[serverName]
+      }
+    },
+    clientFileTarget.format
+  );
+  if (!globalFlags.yes) {
+    await stream.message(
+      (async function* () {
+        for (const num of Array.from(
+          { length: configStr.length },
+          (_, i) => i
+        )) {
+          const char = configStr[num];
+          yield char;
+          if (!["\n", " ", "\u2500", "\u256E", "\u256D", "\u2570", "\u256F", "\u2502"].includes(char)) {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+          } else {
+            await new Promise((resolve) => setTimeout(resolve, 2));
+          }
+        }
+      })()
+    );
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  }
+  const isConfirmed = globalFlags.yes ? true : await confirm({
+    message: `Would you like to proceed?`,
+    active: "Install MCP",
+    inactive: "Cancel"
+  });
+  if (isConfirmed !== true) {
+    outro(chalk2.bold.red("Installation cancelled"));
+    process.exit(0);
+  }
+  const configContent = serializeClientConfig(
+    clientFileTarget,
+    config,
+    content
+  );
+  const writeResult = await safeWriteFile(
+    "config_file",
+    clientFileTarget.path,
+    configContent
+  );
+  if (writeResult.isErr()) {
+    log$1.error(
+      chalk2.bold.red(`Error writing config: ${writeResult.error.message}`)
+    );
+    outro(chalk2.bold.red(`Error adding x402scan MCP to ${name}`));
+    process.exit(1);
+  }
+  log$1.success(chalk2.bold.green(`Added x402scan MCP to ${name}`));
+};
+var formatDiffByFormat = (obj, format) => {
+  const str = stringifyObject(obj, format);
+  switch (format) {
+    case "json" /* JSON */: {
+      const numLines = str.split("\n").length;
+      return str.split("\n").map((line, index) => {
+        const diffLines = [0, 1, numLines - 2, numLines - 1];
+        const isDiffLine = !diffLines.includes(index);
+        if (isDiffLine) {
+          return `${chalk2.bold.green(`+ ${line.slice(2)}`)}`;
+        }
+        return line;
+      }).join("\n");
+    }
+    case "yaml" /* YAML */: {
+      return str.split("\n").map((line, index) => {
+        const diffLines = [0, 1, str.length - 2, str.length - 1];
+        const isDiffLine = !diffLines.includes(index);
+        if (isDiffLine) {
+          return `${chalk2.bold.green(`+ ${line.slice(2)}`)}`;
+        }
+        return line;
+      }).join("\n");
+    }
+    case "toml" /* TOML */: {
+      return str.split("\n").filter((line) => line.trim() !== "").map((line) => {
+        return `${chalk2.bold.green(`+ ${line.trim()}`)}`;
+      }).join("\n");
+    }
+  }
+};
+var redeemInviteCode2 = async (props, flags) => {
+  const s = spinner();
+  if (!flags.yes) {
+    s.start("Redeeming invite code...");
+  }
+  const result = await redeemInviteCode(props);
+  return result.match(
+    async ({ amount, txHash }) => {
+      if (!flags.yes) {
+        s.stop("Invite code redeemed successfully!");
+        await wait({
+          startText: "Processing...",
+          stopText: chalk2.green(
+            `${chalk2.bold(amount)} USDC has been sent to your wallet!`
+          ),
+          ms: 1e3
+        });
+      }
+      log$1.info(chalk2.dim(`Transaction: https://basescan.org/tx/${txHash}`));
+      return true;
+    },
+    (error) => {
+      if (!flags.yes) {
+        s.stop("Invite code redemption failed");
+      }
+      log$1.warning(
+        chalk2.yellow(`Failed to redeem invite code: ${error.message}`)
+      );
+      return false;
+    }
+  );
+};
+var addFunds = async ({ flags, address, isNew }) => {
+  if (isNew) {
+    if (!flags.yes) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+    log$1.info("To use paid API tools, you will need USDC in your wallet.");
+    await promptDeposit({ address, flags, surface: "add-funds" });
+  } else {
+    const { start, stop } = spinner();
+    start("Checking balance...");
+    const balanceResult = await getBalance({
+      address,
+      flags,
+      surface: "add-funds"
+    });
+    if (balanceResult.isOk()) {
+      stop(`Balance: ${chalk2.bold(`${balanceResult.value.balance} USDC`)} `);
+    } else {
+      stop(`Error: ${balanceResult.error.message}`);
+      return;
+    }
+    const balance = balanceResult.value;
+    if (balance.balance < 1) {
+      log$1.warning(
+        chalk2.bold(
+          `Your balance is low (${balance.balance} USDC). Consider topping up.`
+        )
+      );
+      await promptDeposit({ address, flags, surface: "install" });
+    }
+  }
+};
+
+// src/cli/install/index.ts
+var installMcpServer = async (flags) => {
+  intro(chalk2.green.bold(`Install x402scan MCP`));
+  const walletResult = await getWallet();
+  if (walletResult.isErr()) {
+    log.error(JSON.stringify(walletResult.error, null, 2));
+    outro(chalk2.bold.red("Failed to get wallet"));
+    process.exit(1);
+  }
+  const {
+    account: { address },
+    isNew
+  } = walletResult.value;
+  const client = await getClient(flags);
+  await addServer(client, flags);
+  const inviteRedeemed = flags.invite ? await redeemInviteCode2(
+    {
+      code: flags.invite,
+      dev: flags.dev,
+      address,
+      surface: "install"
+    },
+    flags
+  ) : false;
+  if (!inviteRedeemed) {
+    await addFunds({ flags, address, isNew });
+  }
+  outro(chalk2.bold.green("Your x402scan MCP server is ready to use!"));
+};
+
+export { installMcpServer };
+//# sourceMappingURL=install-F5WF4NGY.js.map
+//# sourceMappingURL=install-F5WF4NGY.js.map