@agentwonderland/mcp 0.1.40 → 0.1.42

package/src/core/payments.ts

@@ -76,52 +76,44 @@ async function initEvmMppForChain(
   wallet: WalletEntry,
   chain: "tempo" | "base",
 ): Promise<typeof fetch | null> {
-  try {
-    const { Mppx } = await import("./mpp-client.js");
-    let account;
-
-    if (wallet.keyType === "ows" && wallet.owsWalletId) {
-      const { owsAccountFromWalletId } = await import("./ows-adapter.js");
-      account = await owsAccountFromWalletId(wallet.owsWalletId);
-    } else if (wallet.key) {
-      const { privateKeyToAccount } = await import("viem/accounts");
-      account = privateKeyToAccount(normalizeKey(wallet.key));
-    } else {
-      return null;
-    }
-
-    const methods = [];
-    if (chain === "tempo") {
-      const { tempoChargeClient } = await import("./tempo-charge.js");
-      methods.push(tempoChargeClient({ account }));
-    } else {
-      const { baseChargeClient } = await import("./base-charge.js");
-      methods.push(baseChargeClient({ account }));
-    }
+  const { Mppx } = await import("./mpp-client.js");
+  let account;
 
-    const mppx = Mppx.create({ methods: methods as any, polyfill: false });
-    return mppx.fetch.bind(mppx) as typeof fetch;
-  } catch {
+  if (wallet.keyType === "ows" && wallet.owsWalletId) {
+    const { owsAccountFromWalletId } = await import("./ows-adapter.js");
+    account = await owsAccountFromWalletId(wallet.owsWalletId);
+  } else if (wallet.key) {
+    const { privateKeyToAccount } = await import("viem/accounts");
+    account = privateKeyToAccount(normalizeKey(wallet.key));
+  } else {
     return null;
   }
+
+  const methods = [];
+  if (chain === "tempo") {
+    const { tempoChargeClient } = await import("./tempo-charge.js");
+    methods.push(tempoChargeClient({ account }));
+  } else {
+    const { baseChargeClient } = await import("./base-charge.js");
+    methods.push(baseChargeClient({ account }));
+  }
+
+  const mppx = Mppx.create({ methods: methods as any, polyfill: false });
+  return mppx.fetch.bind(mppx) as typeof fetch;
 }
 
 async function initSolanaMpp(wallet: WalletEntry): Promise<typeof fetch | null> {
-  try {
-    if (wallet.keyType !== "ows" && !wallet.key) {
-      return null;
-    }
-
-    const { Mppx } = await import("./mpp-client.js");
-    const { solanaChargeClient } = await import("./solana-charge.js");
-    const mppx = Mppx.create({
-      methods: [solanaChargeClient({ wallet })] as any,
-      polyfill: false,
-    });
-    return mppx.fetch.bind(mppx) as typeof fetch;
-  } catch {
+  if (wallet.keyType !== "ows" && !wallet.key) {
     return null;
   }
+
+  const { Mppx } = await import("./mpp-client.js");
+  const { solanaChargeClient } = await import("./solana-charge.js");
+  const mppx = Mppx.create({
+    methods: [solanaChargeClient({ wallet })] as any,
+    polyfill: false,
+  });
+  return mppx.fetch.bind(mppx) as typeof fetch;
 }
 
 async function initCard(): Promise<typeof fetch | null> {
@@ -178,6 +170,11 @@ async function initForChain(wallet: WalletEntry, chain: string): Promise<typeof
   return null;
 }
 
+function initFailureMessage(method: string, wallet: WalletEntry, chain: string, err: unknown): string {
+  const reason = err instanceof Error ? err.message : String(err);
+  return `Payment method "${method}" is configured as ${chain} on wallet "${wallet.id}", but the signer could not initialize: ${reason}`;
+}
+
 // ── Public API ──────────────────────────────────────────────────
 
 /**
@@ -214,7 +211,12 @@ export async function getPaymentFetch(method?: string): Promise<typeof fetch> {
     }
     const ck = cacheKey(resolved.wallet.id, resolved.chain);
     if (fetchCache.has(ck)) return fetchCache.get(ck)!;
-    const pf = await initForChain(resolved.wallet, resolved.chain);
+    let pf: typeof fetch | null;
+    try {
+      pf = await initForChain(resolved.wallet, resolved.chain);
+    } catch (err) {
+      throw new Error(initFailureMessage(method, resolved.wallet, resolved.chain, err));
+    }
     if (pf) {
       fetchCache.set(ck, pf);
       return pf;
@@ -264,7 +266,17 @@ export async function getPaymentFetch(method?: string): Promise<typeof fetch> {
     }
     const ck = cacheKey(resolved.wallet.id, resolved.chain);
     if (fetchCache.has(ck)) return fetchCache.get(ck)!;
-    const pf = await initForChain(resolved.wallet, resolved.chain);
+    let pf: typeof fetch | null;
+    try {
+      pf = await initForChain(resolved.wallet, resolved.chain);
+    } catch (err) {
+      if (m === defaultMethod) {
+        const others = configured.filter((x) => x !== m);
+        const altText = others.length > 0 ? ` Alternatives: ${others.join(", ")}` : "";
+        throw new Error(`${initFailureMessage(m, resolved.wallet, resolved.chain, err)}.${altText}`);
+      }
+      continue;
+    }
     if (pf) {
       fetchCache.set(ck, pf);
       return pf;

package/src/index.ts

@@ -25,8 +25,9 @@ import { registerJobResources } from "./resources/jobs.js";
 
 // ── Prompts ──────────────────────────────────────────────────────
 import { registerPrompts } from "./prompts/index.js";
+import { runSetupCli } from "./setup.js";
 
-const PACKAGE_VERSION = "0.1.40";
+const PACKAGE_VERSION = "0.1.42";
 
 export async function startMcpServer(): Promise<void> {
   const server = new McpServer(
@@ -112,43 +113,47 @@ const isCli =
 if (isCli) {
   const args = process.argv.slice(2);
 
-  if (args.includes("--help") || args.includes("-h")) {
+  if (args[0] === "setup" || args[0] === "install" || args[0] === "configure") {
+    runSetupCli(args.slice(1)).catch((err) => {
+      console.error("Setup failed:", err instanceof Error ? err.message : err);
+      process.exit(1);
+    });
+  } else if (args.includes("--help") || args.includes("-h")) {
     console.log([
       "Agent Wonderland MCP server",
       "",
       "Usage:",
-      "  npx @agentwonderland/mcp",
+      "  npx @agentwonderland/mcp setup      Configure MCP clients",
+      "  npx @agentwonderland/mcp            Start the stdio MCP server",
       "",
-      "This command starts a stdio MCP server. It is meant to be launched by",
+      "The bare command starts a stdio MCP server. It is meant to be launched by",
       "Codex, Cursor, Claude Desktop, or another MCP client. When run directly",
       "in a terminal it waits silently for MCP JSON-RPC messages on stdin.",
       "",
       "MCP client config:",
-      '  { "mcpServers": { "agentwonderland": { "command": "npx", "args": ["@agentwonderland/mcp"] } } }',
+      '  { "mcpServers": { "agentwonderland": { "command": "npx", "args": ["-y", "@agentwonderland/mcp"] } } }',
       "",
       "Options:",
       "  -h, --help     Show this help",
       "  -v, --version  Show package version",
     ].join("\n"));
     process.exit(0);
-  }
-
-  if (args.includes("--version") || args.includes("-v")) {
+  } else if (args.includes("--version") || args.includes("-v")) {
     console.log(PACKAGE_VERSION);
     process.exit(0);
+  } else {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      console.error([
+        "Agent Wonderland MCP server is running.",
+        "This process speaks MCP over stdio, so it waits for a client instead of printing a prompt.",
+        "Add it to an MCP client config, or press Ctrl+C to stop.",
+        "Run `npx @agentwonderland/mcp setup` to configure your MCP clients.",
+      ].join("\n"));
+    }
+
+    startMcpServer().catch((err) => {
+      console.error("MCP server error:", err);
+      process.exit(1);
+    });
   }
-
-  if (process.stdin.isTTY && process.stdout.isTTY) {
-    console.error([
-      "Agent Wonderland MCP server is running.",
-      "This process speaks MCP over stdio, so it waits for a client instead of printing a prompt.",
-      "Add it to an MCP client config, or press Ctrl+C to stop.",
-      "Run `npx @agentwonderland/mcp --help` for setup details.",
-    ].join("\n"));
-  }
-
-  startMcpServer().catch((err) => {
-    console.error("MCP server error:", err);
-    process.exit(1);
-  });
 }

package/src/setup.ts

@@ -0,0 +1,411 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { execFileSync } from "node:child_process";
+
+export const SERVER_NAME = "agentwonderland";
+export const SERVER_CONFIG = {
+  command: "npx",
+  args: ["-y", "@agentwonderland/mcp"],
+};
+
+export type SetupClientId =
+  | "codex"
+  | "claude-code"
+  | "claude-desktop"
+  | "cursor"
+  | "antigravity";
+
+type ConfigFormat = "json" | "toml" | "claude-code-cli";
+
+export type SetupClient = {
+  id: SetupClientId;
+  name: string;
+  path: string;
+  format: ConfigFormat;
+  detected: boolean;
+  note: string;
+};
+
+export type SetupOptions = {
+  all?: boolean;
+  yes?: boolean;
+  clients?: SetupClientId[];
+  dryRun?: boolean;
+};
+
+export type InstallResult = {
+  client: SetupClient;
+  status: "created" | "updated" | "unchanged" | "skipped" | "failed";
+  backupPath?: string;
+  message?: string;
+};
+
+const CLIENT_ORDER: SetupClientId[] = [
+  "codex",
+  "claude-code",
+  "claude-desktop",
+  "cursor",
+  "antigravity",
+];
+
+const CLIENT_LABELS: Record<SetupClientId, string> = {
+  codex: "Codex",
+  "claude-code": "Claude Code",
+  "claude-desktop": "Claude Desktop",
+  cursor: "Cursor",
+  antigravity: "Google Antigravity",
+};
+
+export async function runSetupCli(args: string[] = process.argv.slice(2)): Promise<void> {
+  const options = parseSetupArgs(args);
+  if (options.help) {
+    printSetupHelp();
+    return;
+  }
+
+  const clients = getSetupClients();
+  const selected = await chooseClients(clients, options);
+
+  if (selected.length === 0) {
+    console.log("No MCP clients selected. Nothing changed.");
+    printManualConfig();
+    return;
+  }
+
+  console.log("");
+  console.log("Agent Wonderland will add this MCP server entry:");
+  console.log(JSON.stringify({ mcpServers: { [SERVER_NAME]: SERVER_CONFIG } }, null, 2));
+  console.log("");
+
+  const results: InstallResult[] = [];
+  for (const client of selected) {
+    results.push(await installClient(client, options));
+  }
+
+  printResults(results, options);
+}
+
+export function parseSetupArgs(args: string[]): SetupOptions & { help?: boolean } {
+  const options: SetupOptions & { help?: boolean } = {};
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--all") {
+      options.all = true;
+    } else if (arg === "--yes" || arg === "-y") {
+      options.yes = true;
+    } else if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else if (arg === "--clients") {
+      const value = args[index + 1];
+      if (!value) throw new Error("--clients requires a comma-separated value");
+      options.clients = parseClientList(value);
+      index++;
+    } else if (arg.startsWith("--clients=")) {
+      options.clients = parseClientList(arg.slice("--clients=".length));
+    } else {
+      throw new Error(`Unknown setup option: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+function parseClientList(value: string): SetupClientId[] {
+  const selected = value
+    .split(",")
+    .map((item) => item.trim().toLowerCase())
+    .filter(Boolean) as SetupClientId[];
+  const invalid = selected.filter((item) => !CLIENT_ORDER.includes(item));
+  if (invalid.length > 0) {
+    throw new Error(`Unknown client(s): ${invalid.join(", ")}`);
+  }
+  return selected;
+}
+
+export function getSetupClients(home = homedir(), env = process.env): SetupClient[] {
+  const appData = env.APPDATA ?? path.join(home, "AppData", "Roaming");
+  const isWindows = platform() === "win32";
+  const isMac = platform() === "darwin";
+  const claudeDesktopPath = isMac
+    ? path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+    : isWindows
+      ? path.join(appData, "Claude", "claude_desktop_config.json")
+      : path.join(home, ".config", "Claude", "claude_desktop_config.json");
+
+  const clients: SetupClient[] = [
+    {
+      id: "codex",
+      name: CLIENT_LABELS.codex,
+      path: path.join(home, ".codex", "config.toml"),
+      format: "toml",
+      detected: existsSync(path.join(home, ".codex")) || commandExists("codex"),
+      note: "Global Codex CLI/Desktop config",
+    },
+    {
+      id: "claude-code",
+      name: CLIENT_LABELS["claude-code"],
+      path: "claude mcp add-json --scope user",
+      format: "claude-code-cli",
+      detected: commandExists("claude"),
+      note: "Claude Code user-scope MCP config via the Claude CLI",
+    },
+    {
+      id: "claude-desktop",
+      name: CLIENT_LABELS["claude-desktop"],
+      path: claudeDesktopPath,
+      format: "json",
+      detected: existsSync(claudeDesktopPath) || existsSync(path.dirname(claudeDesktopPath)),
+      note: "Claude Desktop developer config",
+    },
+    {
+      id: "cursor",
+      name: CLIENT_LABELS.cursor,
+      path: path.join(home, ".cursor", "mcp.json"),
+      format: "json",
+      detected: existsSync(path.join(home, ".cursor")),
+      note: "Global Cursor MCP config",
+    },
+    {
+      id: "antigravity",
+      name: CLIENT_LABELS.antigravity,
+      path: path.join(home, ".gemini", "antigravity", "mcp_config.json"),
+      format: "json",
+      detected: existsSync(path.join(home, ".gemini", "antigravity")),
+      note: "Antigravity raw MCP config",
+    },
+  ];
+
+  return clients;
+}
+
+async function chooseClients(
+  clients: SetupClient[],
+  options: SetupOptions,
+): Promise<SetupClient[]> {
+  if (options.clients?.length) {
+    return clients.filter((client) => options.clients?.includes(client.id));
+  }
+
+  if (options.all) {
+    return clients;
+  }
+
+  const detected = clients.filter((client) => client.detected);
+  if (options.yes) {
+    return detected.length > 0 ? detected : clients.filter((client) => client.id === "codex");
+  }
+
+  console.log("Agent Wonderland MCP setup");
+  console.log("");
+  console.log("Detected clients:");
+  for (const client of clients) {
+    const marker = client.detected ? "found" : "not found";
+    console.log(`  ${client.id.padEnd(15)} ${marker.padEnd(9)} ${client.path}`);
+  }
+  console.log("");
+
+  const rl = createInterface({ input, output });
+  try {
+    const selected: SetupClient[] = [];
+    for (const client of clients) {
+      const defaultAnswer = client.detected ? "Y/n" : "y/N";
+      const answer = (await rl.question(`Install for ${client.name}? (${defaultAnswer}) `)).trim().toLowerCase();
+      const yes = answer === ""
+        ? client.detected
+        : answer === "y" || answer === "yes";
+      if (yes) selected.push(client);
+    }
+    return selected;
+  } finally {
+    rl.close();
+  }
+}
+
+export async function installClient(client: SetupClient, options: SetupOptions = {}): Promise<InstallResult> {
+  try {
+    if (client.format === "claude-code-cli") {
+      return installClaudeCode(client, options);
+    }
+
+    const existing = await readExisting(client.path);
+    const next = client.format === "json"
+      ? mergeJsonMcpConfig(existing)
+      : mergeCodexTomlConfig(existing);
+
+    if (next === existing) {
+      return { client, status: "unchanged", message: "already configured" };
+    }
+
+    const backupPath = existing ? `${client.path}.bak-${timestamp()}` : undefined;
+    if (!options.dryRun) {
+      await mkdir(path.dirname(client.path), { recursive: true });
+      if (backupPath) {
+        await writeFile(backupPath, existing, "utf8");
+      }
+      await writeFile(client.path, next, "utf8");
+    }
+
+    return {
+      client,
+      status: existing ? "updated" : "created",
+      backupPath,
+    };
+  } catch (error) {
+    return {
+      client,
+      status: "failed",
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function installClaudeCode(client: SetupClient, options: SetupOptions): InstallResult {
+  if (!commandExists("claude")) {
+    return {
+      client,
+      status: "failed",
+      message: [
+        "Claude Code CLI was not found on PATH.",
+        "Run manually after installing Claude Code:",
+        `claude mcp add-json ${SERVER_NAME} '${JSON.stringify({ type: "stdio", ...SERVER_CONFIG })}' --scope user`,
+      ].join(" "),
+    };
+  }
+
+  if (!options.dryRun) {
+    execFileSync("claude", [
+      "mcp",
+      "add-json",
+      SERVER_NAME,
+      JSON.stringify({ type: "stdio", ...SERVER_CONFIG }),
+      "--scope",
+      "user",
+    ], { stdio: "pipe" });
+  }
+
+  return {
+    client,
+    status: options.dryRun ? "skipped" : "updated",
+    message: options.dryRun ? "would run Claude Code CLI installer" : "installed with Claude Code CLI",
+  };
+}
+
+async function readExisting(filePath: string): Promise<string> {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return "";
+    throw error;
+  }
+}
+
+export function mergeJsonMcpConfig(existing: string): string {
+  const parsed = existing.trim()
+    ? JSON.parse(existing) as Record<string, unknown>
+    : {};
+
+  const mcpServers = typeof parsed.mcpServers === "object" && parsed.mcpServers !== null && !Array.isArray(parsed.mcpServers)
+    ? parsed.mcpServers as Record<string, unknown>
+    : {};
+
+  const next = {
+    ...parsed,
+    mcpServers: {
+      ...mcpServers,
+      [SERVER_NAME]: SERVER_CONFIG,
+    },
+  };
+
+  return `${JSON.stringify(next, null, 2)}\n`;
+}
+
+export function mergeCodexTomlConfig(existing: string): string {
+  const block = [
+    `[mcp_servers.${SERVER_NAME}]`,
+    `command = "npx"`,
+    `args = ["-y", "@agentwonderland/mcp"]`,
+    "",
+  ].join("\n");
+
+  const pattern = new RegExp(
+    `\\n?\\[mcp_servers\\.${SERVER_NAME.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\][\\s\\S]*?(?=\\n\\[[^\\]]+\\]|$)`,
+  );
+
+  const trimmed = existing.trimEnd();
+  if (!trimmed) return block;
+  if (pattern.test(trimmed)) {
+    const next = trimmed.replace(pattern, `\n${block.trimEnd()}`);
+    return `${next.trimEnd()}\n`;
+  }
+  return `${trimmed}\n\n${block}`;
+}
+
+function printResults(results: InstallResult[], options: SetupOptions): void {
+  console.log(options.dryRun ? "Dry run complete:" : "Setup complete:");
+  for (const result of results) {
+    const suffix = result.backupPath ? ` (backup: ${result.backupPath})` : "";
+    const detail = result.message ? ` - ${result.message}` : "";
+    console.log(`  ${result.status.padEnd(9)} ${result.client.name}: ${result.client.path}${suffix}${detail}`);
+  }
+  console.log("");
+  console.log("Restart any clients you updated, then ask your coding agent:");
+  console.log('  "Check my Agent Wonderland wallet status."');
+  console.log("");
+  console.log("If no wallet is configured yet, ask:");
+  console.log('  "Set up payment for Agent Wonderland."');
+}
+
+function printSetupHelp(): void {
+  console.log([
+    "Agent Wonderland MCP setup",
+    "",
+    "Usage:",
+    "  npx @agentwonderland/mcp setup",
+    "  npx @agentwonderland/mcp setup --clients codex,claude-code",
+    "  npx @agentwonderland/mcp setup --all --yes",
+    "",
+    "Supported clients:",
+    `  ${CLIENT_ORDER.join(", ")}`,
+    "",
+    "Options:",
+    "  --clients <list>  Comma-separated client ids",
+    "  --all             Offer/install every supported config target",
+    "  -y, --yes         Accept defaults without prompts",
+    "  --dry-run         Show what would be changed without writing files",
+    "  -h, --help        Show this help",
+  ].join("\n"));
+}
+
+function printManualConfig(): void {
+  console.log("");
+  console.log("Manual MCP config:");
+  console.log(JSON.stringify({ mcpServers: { [SERVER_NAME]: SERVER_CONFIG } }, null, 2));
+}
+
+function timestamp(): string {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+function commandExists(command: string): boolean {
+  try {
+    if (platform() === "win32") {
+      execFileSync("where", [command], { stdio: "ignore" });
+    } else {
+      execFileSync("sh", ["-lc", `command -v ${shellQuote(command)}`], { stdio: "ignore" });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/src/tools/wallet.ts

@@ -280,6 +280,8 @@ export function registerWalletTools(server: McpServer): void {
               "",
               chainStatus,
               "",
+              "No MCP restart is required for wallet changes.",
+              "",
               `Fund this address with USDC on ${defaultCh === "solana" ? "Solana" : "Tempo"} to start using agents.`,
             ].join("\n"));
           }
@@ -313,6 +315,8 @@ export function registerWalletTools(server: McpServer): void {
                 `  Chains: solana`,
                 `  Consumer principal: ${principal}`,
                 "",
+                "No MCP restart is required for wallet changes.",
+                "",
                 "Fund this address with USDC on Solana to start using agents.",
               ].join("\n") + owsNudge,
             );
@@ -340,6 +344,8 @@ export function registerWalletTools(server: McpServer): void {
               `  Chains: tempo, base`,
               `  Consumer principal: ${principal}`,
               "",
+              "No MCP restart is required for wallet changes.",
+              "",
               `Fund this address with USDC on Tempo or Base to start using agents.`,
             ].join("\n") + owsNudge,
           );
@@ -369,6 +375,8 @@ export function registerWalletTools(server: McpServer): void {
             `  Storage: ~/.ows/ (AES-256-GCM encrypted)`,
             `  Consumer principal: ${principal}`,
             "",
+            "No MCP restart is required for wallet changes.",
+            "",
             `Fund this address with USDC on ${defaultCh === "solana" ? "Solana" : "Tempo"} to start using agents.`,
             "For testnet: npx mppx account fund",
           ].join("\n"),
@@ -395,11 +403,13 @@ export function registerWalletTools(server: McpServer): void {
             `Key imported to OWS [encrypted]:`,
             `  ID: ${result.walletId}`,
             `  Address: ${result.address}`,
-            `  Name: ${walletName}`,
-            `  Chains: ${selectedChains.join(", ")}`,
-            `  Consumer principal: ${principal}`,
-          ].join("\n"),
-        );
+          `  Name: ${walletName}`,
+          `  Chains: ${selectedChains.join(", ")}`,
+          `  Consumer principal: ${principal}`,
+          "",
+          "No MCP restart is required for wallet changes.",
+        ].join("\n"),
+      );
       }
 
       if (defaultCh === "solana") {
@@ -429,6 +439,8 @@ export function registerWalletTools(server: McpServer): void {
               `  Name: ${walletName}`,
               `  Chains: solana`,
               `  Consumer principal: ${principal}`,
+              "",
+              "No MCP restart is required for wallet changes.",
             ].join("\n") + owsNudge,
           );
         } catch (err) {
@@ -468,6 +480,8 @@ export function registerWalletTools(server: McpServer): void {
             `  Name: ${walletName}`,
             `  Chains: ${selectedChains.join(", ")}`,
             `  Consumer principal: ${principal}`,
+            "",
+            "No MCP restart is required for wallet changes.",
           ].join("\n") + owsNudge,
         );
       } catch {