@x402scan/mcp 0.0.1

package/dist/install-QDUD2KOS.js

@@ -0,0 +1,646 @@
+import {
+  getUSDCBalance
+} from "./chunk-KD3GRRAV.js";
+import {
+  getWallet,
+  log,
+  promptDeposit,
+  wait
+} from "./chunk-FFXFOKKF.js";
+
+// src/install/1-get-client/index.ts
+import z from "zod";
+import { select, log as log2, outro } from "@clack/prompts";
+import chalk from "chalk";
+
+// src/install/clients.ts
+var Clients = /* @__PURE__ */ ((Clients2) => {
+  Clients2["ClaudeCode"] = "claude-code";
+  Clients2["Cursor"] = "cursor";
+  Clients2["Claude"] = "claude";
+  Clients2["Codex"] = "codex";
+  Clients2["Vscode"] = "vscode";
+  Clients2["Cline"] = "cline";
+  Clients2["RooCline"] = "roo-cline";
+  Clients2["Windsurf"] = "windsurf";
+  Clients2["Warp"] = "warp";
+  Clients2["GeminiCli"] = "gemini-cli";
+  Clients2["Goose"] = "goose";
+  Clients2["Zed"] = "zed";
+  Clients2["Opencode"] = "opencode";
+  return Clients2;
+})(Clients || {});
+var clientMetadata = {
+  ["claude-code" /* ClaudeCode */]: {
+    name: "Claude Code",
+    description: "Claude Code is a code editor that uses the Claude API.",
+    website: "https://claude.com"
+  },
+  ["cursor" /* Cursor */]: {
+    name: "Cursor",
+    description: "Cursor is a code editor that uses the Cursor API.",
+    website: "https://cursor.com"
+  },
+  ["claude" /* Claude */]: {
+    name: "Claude",
+    description: "Claude is a code editor that uses the Claude API.",
+    website: "https://claude.com"
+  },
+  ["codex" /* Codex */]: {
+    name: "Codex",
+    description: "Codex is a code editor that uses the Codex API.",
+    website: "https://codex.com"
+  },
+  ["vscode" /* Vscode */]: {
+    name: "VSCode",
+    description: "VSCode is a code editor that uses the VSCode API.",
+    website: "https://vscode.com"
+  },
+  ["cline" /* Cline */]: {
+    name: "Cline",
+    description: "Cline is a code editor that uses the Cline API.",
+    website: "https://cline.com"
+  },
+  ["roo-cline" /* RooCline */]: {
+    name: "RooCline",
+    description: "RooCline is a code editor that uses the RooCline API.",
+    website: "https://roo-cline.com"
+  },
+  ["windsurf" /* Windsurf */]: {
+    name: "Windsurf",
+    description: "Windsurf is a code editor that uses the Windsurf API.",
+    website: "https://windsurf.com"
+  },
+  ["warp" /* Warp */]: {
+    name: "Warp",
+    description: "Warp is a code editor that uses the Warp API.",
+    website: "https://warp.com"
+  },
+  ["gemini-cli" /* GeminiCli */]: {
+    name: "Gemini CLI",
+    description: "Gemini CLI is a code editor that uses the Gemini CLI API.",
+    website: "https://gemini-cli.com"
+  },
+  ["goose" /* Goose */]: {
+    name: "Goose",
+    description: "Goose is a code editor that uses the Goose API.",
+    website: "https://goose.com"
+  },
+  ["zed" /* Zed */]: {
+    name: "Zed",
+    description: "Zed is a code editor that uses the Zed API.",
+    website: "https://zed.com"
+  },
+  ["opencode" /* Opencode */]: {
+    name: "Opencode",
+    description: "Opencode is a code editor that uses the Opencode API.",
+    website: "https://opencode.com"
+  }
+};
+
+// src/install/1-get-client/index.ts
+var getClient = async ({ client: flagClient }) => {
+  const parsedClient = z.enum(Clients).safeParse(flagClient);
+  if (parsedClient.success) {
+    return parsedClient.data;
+  }
+  if (flagClient) {
+    log2.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(chalk.bold.red("No MCP client selected"));
+  process.exit(0);
+};
+
+// src/install/2-add-server/index.ts
+import fs3 from "fs";
+import chalk2 from "chalk";
+import { log as clackLog, confirm, outro as outro2, stream } from "@clack/prompts";
+
+// src/install/2-add-server/lib/client-config-file.ts
+import os2 from "os";
+import path2 from "path";
+import process3 from "process";
+import fs2 from "fs";
+
+// src/install/2-add-server/lib/platforms.ts
+import os from "os";
+import path from "path";
+import process2 from "process";
+import z2 from "zod";
+var Platforms = /* @__PURE__ */ ((Platforms2) => {
+  Platforms2["Windows"] = "win32";
+  Platforms2["MacOS"] = "darwin";
+  Platforms2["Linux"] = "linux";
+  return Platforms2;
+})(Platforms || {});
+var getPlatformPath = () => {
+  const platform = z2.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 ?? path.join(homeDir, "AppData", "Roaming"),
+        vscodePath: path.join("Code", "User")
+      };
+    case "darwin" /* MacOS */:
+      return {
+        baseDir: path.join(homeDir, "Library", "Application Support"),
+        vscodePath: path.join("Code", "User")
+      };
+    case "linux" /* Linux */:
+      return {
+        baseDir: process2.env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config"),
+        vscodePath: path.join("Code/User")
+      };
+    default:
+      throw new Error(`Invalid platform: ${process2.platform}`);
+  }
+};
+
+// src/install/2-add-server/lib/file-types.ts
+import fs from "fs";
+import * as TOML from "@iarna/toml";
+import yaml from "js-yaml";
+import * as jsonc from "jsonc-parser";
+var parseClientConfig = ({ format, path: path3 }) => {
+  const fileContent = fs.readFileSync(path3, "utf8");
+  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
+  };
+};
+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) {
+    try {
+      const editedContent = originalContent;
+      const modifications = [];
+      for (const key of Object.keys(config)) {
+        const path4 = [key];
+        const edits = jsonc.modify(editedContent, path4, config[key], {
+          formattingOptions: { tabSize: 2, insertSpaces: true }
+        });
+        modifications.push(...edits);
+      }
+      return jsonc.applyEdits(originalContent, modifications);
+    } catch (error) {
+      console.log(
+        `Error applying JSONC edits: ${error instanceof Error ? error.message : String(error)}`
+      );
+      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/install/2-add-server/lib/client-config-file.ts
+var getClientConfigFile = (client) => {
+  const homeDir = os2.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: process3.platform === "win32" ? path2.join(
+          process3.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(
+          process3.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 (fs2.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/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/install/2-add-server/index.ts
+var getMcpConfig = (globalFlags) => {
+  if (globalFlags.dev) {
+    return {
+      serverName: "x402",
+      command: "node",
+      args: [`${process.cwd()}/dist/index.js`, "--dev"]
+    };
+  }
+  return {
+    serverName: "x402",
+    command: "npx",
+    args: ["-y", "@x402scan/mcp@latest"]
+  };
+};
+async function addServer(client, globalFlags) {
+  const { serverName, command, args } = getMcpConfig(globalFlags);
+  if (client === "warp" /* Warp */) {
+    clackLog.info(
+      chalk2.bold.yellow("Warp requires a manual installation through their UI.")
+    );
+    clackLog.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();
+    clackLog.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) {
+      throw new Error("Warp MCP server not added");
+    }
+  }
+  const clientFileTarget = getClientConfigFile(client);
+  const { name } = clientMetadata[client];
+  try {
+    let config = {};
+    let content = void 0;
+    log.info(`Checking if config file exists at: ${clientFileTarget.path}`);
+    if (!fs3.existsSync(clientFileTarget.path)) {
+      log.info("Config file not found, creating default empty config");
+      setNestedValue(config, clientFileTarget.configKey, {});
+      log.info("Config created successfully");
+      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 { config: rawConfig, fileContent } = parseClientConfig(clientFileTarget);
+      config = rawConfig;
+      content = fileContent;
+      const existingValue = getNestedValue(
+        rawConfig,
+        clientFileTarget.configKey
+      );
+      if (!existingValue) {
+        setNestedValue(rawConfig, clientFileTarget.configKey, {});
+      }
+      log.info(
+        `Config loaded successfully: ${JSON.stringify(rawConfig, null, 2)}`
+      );
+      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`);
+      clackLog.error(
+        chalk2.bold.red(
+          `Invalid ${clientFileTarget.configKey} structure in config`
+        )
+      );
+      throw new Error(`Invalid ${clientFileTarget.configKey} structure`);
+    }
+    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
+      };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    clackLog.step(`The following will be added to ${chalk2.bold.underline(clientFileTarget.path)}`);
+    const configStr = formatDiffByFormat(
+      {
+        [clientFileTarget.configKey]: {
+          [serverName]: servers[serverName]
+        }
+      },
+      clientFileTarget.format
+    );
+    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 = await confirm({
+      message: `Would you like to proceed?`,
+      active: "Install MCP",
+      inactive: "Cancel"
+    });
+    if (isConfirmed !== true) {
+      outro2(chalk2.bold.red("Installation cancelled"));
+      process.exit(0);
+    }
+    const configContent = serializeClientConfig(
+      clientFileTarget,
+      config,
+      content
+    );
+    fs3.writeFileSync(clientFileTarget.path, configContent);
+    clackLog.success(chalk2.bold.green(`Added x402scan MCP to ${name}`));
+  } catch (e) {
+    clackLog.error(chalk2.bold.red(`Error adding x402scan MCP to ${name}`));
+    throw e;
+  }
+}
+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");
+    }
+  }
+};
+
+// src/install/3-add-funds/index.ts
+import chalk3 from "chalk";
+import { log as log3 } from "@clack/prompts";
+var addFunds = async ({ flags, address, isNew }) => {
+  if (isNew) {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    log3.info("To use paid API tools, you will need USDC in your wallet.");
+    await promptDeposit(address, flags);
+  } else {
+    const balance = await getUSDCBalance({ address });
+    await wait({
+      startText: "Checking balance...",
+      stopText: `Balance: ${chalk3.bold(`${balance} USDC`)} `,
+      ms: 1e3
+    });
+    if (balance < 1) {
+      log3.warning(
+        chalk3.bold(
+          `Your balance is low (${balance} USDC). Consider topping up.`
+        )
+      );
+      await promptDeposit(address, flags);
+    }
+  }
+};
+
+// src/install/index.ts
+import { intro, outro as outro3 } from "@clack/prompts";
+import chalk4 from "chalk";
+var installMcpServer = async (flags) => {
+  const {
+    account: { address },
+    isNew
+  } = await getWallet();
+  intro(chalk4.green.bold(`Install x402scan MCP`));
+  const client = await getClient(flags);
+  await addServer(client, flags);
+  await addFunds({ flags, address, isNew });
+  outro3(chalk4.bold.green("Your x402scan MCP server is ready to use!"));
+};
+export {
+  installMcpServer
+};