@agentwonderland/mcp 0.1.40 → 0.1.42

package/dist/setup.js

@@ -0,0 +1,346 @@
+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"],
+};
+const CLIENT_ORDER = [
+    "codex",
+    "claude-code",
+    "claude-desktop",
+    "cursor",
+    "antigravity",
+];
+const CLIENT_LABELS = {
+    codex: "Codex",
+    "claude-code": "Claude Code",
+    "claude-desktop": "Claude Desktop",
+    cursor: "Cursor",
+    antigravity: "Google Antigravity",
+};
+export async function runSetupCli(args = process.argv.slice(2)) {
+    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 = [];
+    for (const client of selected) {
+        results.push(await installClient(client, options));
+    }
+    printResults(results, options);
+}
+export function parseSetupArgs(args) {
+    const options = {};
+    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) {
+    const selected = value
+        .split(",")
+        .map((item) => item.trim().toLowerCase())
+        .filter(Boolean);
+    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) {
+    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 = [
+        {
+            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, options) {
+    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 = [];
+        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, options = {}) {
+    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, options) {
+    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) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "";
+        throw error;
+    }
+}
+export function mergeJsonMcpConfig(existing) {
+    const parsed = existing.trim()
+        ? JSON.parse(existing)
+        : {};
+    const mcpServers = typeof parsed.mcpServers === "object" && parsed.mcpServers !== null && !Array.isArray(parsed.mcpServers)
+        ? parsed.mcpServers
+        : {};
+    const next = {
+        ...parsed,
+        mcpServers: {
+            ...mcpServers,
+            [SERVER_NAME]: SERVER_CONFIG,
+        },
+    };
+    return `${JSON.stringify(next, null, 2)}\n`;
+}
+export function mergeCodexTomlConfig(existing) {
+    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, options) {
+    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() {
+    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() {
+    console.log("");
+    console.log("Manual MCP config:");
+    console.log(JSON.stringify({ mcpServers: { [SERVER_NAME]: SERVER_CONFIG } }, null, 2));
+}
+function timestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+function commandExists(command) {
+    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) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/dist/tools/wallet.js

@@ -213,6 +213,8 @@ export function registerWalletTools(server) {
                         "",
                         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"));
                 }
@@ -244,6 +246,8 @@ export function registerWalletTools(server) {
                         `  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);
                 }
@@ -269,6 +273,8 @@ export function registerWalletTools(server) {
                     `  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);
             }
@@ -293,6 +299,8 @@ export function registerWalletTools(server) {
                 `  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"));
@@ -317,6 +325,8 @@ export function registerWalletTools(server) {
                 `  Name: ${walletName}`,
                 `  Chains: ${selectedChains.join(", ")}`,
                 `  Consumer principal: ${principal}`,
+                "",
+                "No MCP restart is required for wallet changes.",
             ].join("\n"));
         }
         if (defaultCh === "solana") {
@@ -345,6 +355,8 @@ export function registerWalletTools(server) {
                     `  Name: ${walletName}`,
                     `  Chains: solana`,
                     `  Consumer principal: ${principal}`,
+                    "",
+                    "No MCP restart is required for wallet changes.",
                 ].join("\n") + owsNudge);
             }
             catch (err) {
@@ -376,6 +388,8 @@ export function registerWalletTools(server) {
                 `  Name: ${walletName}`,
                 `  Chains: ${selectedChains.join(", ")}`,
                 `  Consumer principal: ${principal}`,
+                "",
+                "No MCP restart is required for wallet changes.",
             ].join("\n") + owsNudge);
         }
         catch {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@agentwonderland/mcp",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "type": "module",
   "description": "MCP server for the Agent Wonderland AI agent marketplace",
   "bin": {
-    "agentwonderland-mcp": "./dist/index.js"
+    "agentwonderland-mcp": "dist/index.js"
   },
   "exports": {
     ".": {
@@ -23,6 +23,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "@scure/bip39": "^1.6.0",
     "@solana/spl-token": "^0.4.14",
     "@solana/web3.js": "1.95.8",
     "qrcode": "^1.5.4",

package/src/core/__tests__/api-client.test.ts

@@ -72,7 +72,7 @@ describe("api-client headers", () => {
           "X-AW-Rebate-Principal":
             "did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
           "X-AW-Surface": "mcp",
-          "X-AW-MCP-Version": "0.1.37",
+          "X-AW-MCP-Version": "0.1.42",
           "X-AW-MCP-Tool": "run_agent",
           "X-AW-MCP-Action": "execute",
         }),

package/src/core/__tests__/setup.test.ts

@@ -0,0 +1,88 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  installClient,
+  mergeCodexTomlConfig,
+  mergeJsonMcpConfig,
+  parseSetupArgs,
+  type SetupClient,
+} from "../../setup.js";
+
+let tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.map((dir) => rm(dir, { recursive: true, force: true })));
+  tempDirs = [];
+});
+
+describe("MCP setup", () => {
+  it("merges the server into existing JSON MCP config", () => {
+    const next = JSON.parse(mergeJsonMcpConfig(JSON.stringify({
+      mcpServers: {
+        existing: { command: "node", args: ["server.js"] },
+      },
+      otherSetting: true,
+    })));
+
+    expect(next.otherSetting).toBe(true);
+    expect(next.mcpServers.existing.command).toBe("node");
+    expect(next.mcpServers.agentwonderland).toEqual({
+      command: "npx",
+      args: ["-y", "@agentwonderland/mcp"],
+    });
+  });
+
+  it("replaces an existing Codex TOML block without disturbing other servers", () => {
+    const next = mergeCodexTomlConfig([
+      "[mcp_servers.other]",
+      'command = "node"',
+      'args = ["other.js"]',
+      "",
+      "[mcp_servers.agentwonderland]",
+      'command = "old"',
+      'args = ["old"]',
+      "",
+      "[model_provider.openai]",
+      'name = "OpenAI"',
+      "",
+    ].join("\n"));
+
+    expect(next).toContain("[mcp_servers.other]");
+    expect(next).toContain("[mcp_servers.agentwonderland]");
+    expect(next).toContain('command = "npx"');
+    expect(next).toContain('args = ["-y", "@agentwonderland/mcp"]');
+    expect(next).not.toContain('command = "old"');
+    expect(next).toContain("[model_provider.openai]");
+  });
+
+  it("writes config and creates a backup when updating", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "aw-mcp-setup-"));
+    tempDirs.push(dir);
+    const configPath = path.join(dir, "mcp.json");
+    await writeFile(configPath, JSON.stringify({ mcpServers: { old: { command: "node" } } }), "utf8");
+    const client: SetupClient = {
+      id: "cursor",
+      name: "Cursor",
+      path: configPath,
+      format: "json",
+      detected: true,
+      note: "test",
+    };
+
+    const result = await installClient(client);
+    const written = JSON.parse(await readFile(configPath, "utf8"));
+
+    expect(result.status).toBe("updated");
+    expect(result.backupPath).toBeTruthy();
+    expect(written.mcpServers.agentwonderland.args).toEqual(["-y", "@agentwonderland/mcp"]);
+  });
+
+  it("parses client selection flags", () => {
+    expect(parseSetupArgs(["--clients", "codex,cursor", "--yes"])).toEqual({
+      clients: ["codex", "cursor"],
+      yes: true,
+    });
+  });
+});

package/src/core/api-client.ts

@@ -29,7 +29,7 @@ interface RequestOptions {
   extraHeaders?: Record<string, string>;
 }
 
-const MCP_VERSION = "0.1.37";
+const MCP_VERSION = "0.1.42";
 
 function inferToolHeaders(path: string, method: string): Record<string, string> {
   if (path === "/solve") {

package/src/core/ows-adapter.ts

@@ -11,6 +11,9 @@
 import type { LocalAccount } from "viem/accounts";
 import type { Hex } from "viem";
 import type { Keypair } from "@solana/web3.js";
+import { createHmac } from "node:crypto";
+import { mnemonicToSeedSync, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
 
 // Note: OWS provides encrypted key storage at rest (~/.ows/, AES-256-GCM).
 // For EVM signing, we export the secp256k1 key and use viem's native
@@ -155,6 +158,56 @@ function keypairFromEd25519Hex(privateKeyHex: string, KeypairCtor: typeof import
   throw new Error(`Unsupported ed25519 key length: ${bytes.length} bytes.`);
 }
 
+function parseExportedSecret(exported: string): { secp256k1?: string; ed25519?: string; mnemonic?: string } {
+  const secret = exported.trim();
+  try {
+    const parsed = JSON.parse(secret) as { secp256k1?: string; ed25519?: string; mnemonic?: string };
+    if (parsed.secp256k1 || parsed.ed25519 || parsed.mnemonic) return parsed;
+  } catch {
+    // OWS-created wallets export a BIP-39 mnemonic, not a JSON key object.
+  }
+
+  const hex = secret.startsWith("0x") ? secret.slice(2) : secret;
+  if (/^[0-9a-fA-F]+$/.test(hex)) {
+    if (hex.length === 64) return { secp256k1: hex, ed25519: hex };
+    if (hex.length === 128) return { ed25519: hex };
+  }
+
+  if (validateMnemonic(secret, wordlist)) {
+    return { mnemonic: secret };
+  }
+
+  return {};
+}
+
+function deriveSolanaSeedFromMnemonic(mnemonic: string, path = "m/44'/501'/0'/0'"): Uint8Array {
+  const seed = mnemonicToSeedSync(mnemonic);
+  let digest = createHmac("sha512", "ed25519 seed").update(seed).digest();
+  let key = digest.subarray(0, 32);
+  let chainCode = digest.subarray(32);
+
+  for (const part of path.split("/").slice(1)) {
+    if (!part.endsWith("'")) {
+      throw new Error(`Unsupported non-hardened ed25519 path segment: ${part}`);
+    }
+    const index = Number(part.slice(0, -1));
+    if (!Number.isInteger(index) || index < 0) {
+      throw new Error(`Unsupported ed25519 path segment: ${part}`);
+    }
+
+    const data = Buffer.alloc(37);
+    data[0] = 0;
+    Buffer.from(key).copy(data, 1);
+    data.writeUInt32BE(index + 0x80000000, 33);
+
+    digest = createHmac("sha512", chainCode).update(data).digest();
+    key = digest.subarray(0, 32);
+    chainCode = digest.subarray(32);
+  }
+
+  return Uint8Array.from(key);
+}
+
 // ── Public API ───────────────────────────────────────────────────
 
 /**
@@ -278,7 +331,13 @@ export async function owsAccountFromWalletId(
   // (EIP-5806 delegate calls) which OWS's native signing can't serialize.
   // OWS provides encrypted storage at rest; viem handles signing in memory.
   const exported = ows.exportWallet(walletId);
-  const keys = JSON.parse(exported) as { secp256k1?: string; ed25519?: string };
+  const keys = parseExportedSecret(exported);
+
+  if (keys.mnemonic) {
+    const { mnemonicToAccount } = await import("viem/accounts");
+    return mnemonicToAccount(keys.mnemonic);
+  }
+
   if (!keys.secp256k1) {
     throw new Error(`Wallet "${wallet.name}" has no secp256k1 key for EVM signing.`);
   }
@@ -295,12 +354,17 @@ export async function owsSolanaKeypairFromWalletId(
   findSolanaAccount(wallet);
 
   const exported = ows.exportWallet(walletId);
-  const keys = JSON.parse(exported) as { secp256k1?: string; ed25519?: string };
+  const keys = parseExportedSecret(exported);
+  const { Keypair } = await import("@solana/web3.js");
+
+  if (keys.mnemonic) {
+    return Keypair.fromSeed(deriveSolanaSeedFromMnemonic(keys.mnemonic));
+  }
+
   if (!keys.ed25519) {
     throw new Error(`Wallet "${wallet.name}" has no ed25519 key for Solana signing.`);
   }
 
-  const { Keypair } = await import("@solana/web3.js");
   return keypairFromEd25519Hex(keys.ed25519, Keypair);
 }