@agentwonderland/mcp 0.1.40 → 0.1.42

package/dist/core/__tests__/api-client.test.js

@@ -46,7 +46,7 @@ describe("api-client headers", () => {
                 "X-AW-Consumer-Principal": "did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
                 "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/dist/core/__tests__/setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/setup.test.js

@@ -0,0 +1,72 @@
+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, } from "../../setup.js";
+let tempDirs = [];
+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 = {
+            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/dist/core/api-client.js

@@ -12,7 +12,7 @@ export class ApiError extends Error {
         this.name = "ApiError";
     }
 }
-const MCP_VERSION = "0.1.37";
+const MCP_VERSION = "0.1.42";
 function inferToolHeaders(path, method) {
     if (path === "/solve") {
         return { "X-AW-MCP-Tool": "solve", "X-AW-MCP-Action": method === "POST" ? "execute" : "view" };

package/dist/core/ows-adapter.js

@@ -7,6 +7,9 @@
  * The OWS SDK (`@open-wallet-standard/core`) is a NAPI native module.
  * ALL imports are dynamic so the MCP server works without OWS installed.
  */
+import { createHmac } from "node:crypto";
+import { mnemonicToSeedSync, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
 // ── Helpers ──────────────────────────────────────────────────────
 const OWS_INSTALL_HINT = "OWS is not installed. Install with: npm install -g @open-wallet-standard/core";
 async function loadOws() {
@@ -58,6 +61,51 @@ function keypairFromEd25519Hex(privateKeyHex, KeypairCtor) {
     }
     throw new Error(`Unsupported ed25519 key length: ${bytes.length} bytes.`);
 }
+function parseExportedSecret(exported) {
+    const secret = exported.trim();
+    try {
+        const parsed = JSON.parse(secret);
+        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, path = "m/44'/501'/0'/0'") {
+    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 ───────────────────────────────────────────────────
 /**
  * Check whether the OWS native module can be loaded.
@@ -160,7 +208,11 @@ export async function owsAccountFromWalletId(walletId, _chain) {
     // (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);
+    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.`);
     }
@@ -172,11 +224,14 @@ export async function owsSolanaKeypairFromWalletId(walletId) {
     const wallet = ows.getWallet(walletId);
     findSolanaAccount(wallet);
     const exported = ows.exportWallet(walletId);
-    const keys = JSON.parse(exported);
+    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);
 }
 export async function getOwsWalletAddress(walletId, chain = "evm") {

package/dist/core/payments.js

@@ -53,52 +53,42 @@ function clearStaleCardCache(activeKey) {
 }
 // ── Per-protocol initializers ───────────────────────────────────
 async function initEvmMppForChain(wallet, chain) {
-    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 = Mppx.create({ methods: methods, polyfill: false });
-        return mppx.fetch.bind(mppx);
+    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);
     }
-    catch {
+    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, polyfill: false });
+    return mppx.fetch.bind(mppx);
 }
 async function initSolanaMpp(wallet) {
-    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 })],
-            polyfill: false,
-        });
-        return mppx.fetch.bind(mppx);
-    }
-    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 })],
+        polyfill: false,
+    });
+    return mppx.fetch.bind(mppx);
 }
 async function initCard() {
     const cardConfig = getCardConfig();
@@ -149,6 +139,10 @@ async function initForChain(wallet, chain) {
     }
     return null;
 }
+function initFailureMessage(method, wallet, chain, err) {
+    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 ──────────────────────────────────────────────────
 /**
  * Returns a payment-aware fetch for a specific method, or the best
@@ -185,7 +179,13 @@ export async function getPaymentFetch(method) {
         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;
+        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;
@@ -234,7 +234,18 @@ export async function getPaymentFetch(method) {
         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;
+        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/dist/index.js

@@ -21,7 +21,8 @@ import { registerWalletResources } from "./resources/wallet.js";
 import { registerJobResources } from "./resources/jobs.js";
 // ── Prompts ──────────────────────────────────────────────────────
 import { registerPrompts } from "./prompts/index.js";
-const PACKAGE_VERSION = "0.1.40";
+import { runSetupCli } from "./setup.js";
+const PACKAGE_VERSION = "0.1.42";
 export async function startMcpServer() {
     const server = new McpServer({
         name: "agentwonderland",
@@ -95,19 +96,26 @@ const isCli = process.argv[1]?.endsWith("agentwonderland-mcp") ||
     process.argv[1]?.includes("packages/mcp");
 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",
@@ -115,20 +123,22 @@ if (isCli) {
         ].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);
     }
-    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"));
+    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);
+        });
     }
-    startMcpServer().catch((err) => {
-        console.error("MCP server error:", err);
-        process.exit(1);
-    });
 }

package/dist/setup.d.ts

@@ -0,0 +1,36 @@
+export declare const SERVER_NAME = "agentwonderland";
+export declare const SERVER_CONFIG: {
+    command: string;
+    args: string[];
+};
+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;
+};
+export declare function runSetupCli(args?: string[]): Promise<void>;
+export declare function parseSetupArgs(args: string[]): SetupOptions & {
+    help?: boolean;
+};
+export declare function getSetupClients(home?: string, env?: NodeJS.ProcessEnv): SetupClient[];
+export declare function installClient(client: SetupClient, options?: SetupOptions): Promise<InstallResult>;
+export declare function mergeJsonMcpConfig(existing: string): string;
+export declare function mergeCodexTomlConfig(existing: string): string;
+export {};