@x402storage/mcp 1.0.2 → 1.0.4

package/dist/config.d.ts

@@ -1,18 +1,45 @@
 /**
- * Environment validation for x402store MCP server
+ * Environment validation and multi-wallet config for x402store MCP server
  */
-export type WalletType = 'evm' | 'solana';
+export type WalletType = 'evm' | 'sol';
+/**
+ * Config file format for multi-wallet support
+ */
+export interface X402Config {
+    activeWallet: WalletType;
+    wallets: {
+        evm?: string;
+        sol?: string;
+    };
+}
 /**
  * Detects wallet type from private key format
  */
 export declare function detectWalletType(key: string): WalletType;
 /**
- * Validates required environment variables.
- * Returns error message if X402_PRIVATE_KEY is missing, null if valid.
+ * Loads config from ~/.x402-config.json
+ * Returns null if config doesn't exist
+ */
+export declare function loadConfig(): X402Config | null;
+/**
+ * Saves config to ~/.x402-config.json
+ */
+export declare function saveConfig(config: X402Config): void;
+/**
+ * Gets the active wallet's private key
+ * Returns null if no wallet is configured
+ */
+export declare function getActiveWallet(): {
+    type: WalletType;
+    privateKey: string;
+} | null;
+/**
+ * Validates required environment variables or config.
+ * Returns error message if no wallet configured, null if valid.
  */
 export declare function validateEnvironment(): string | null;
 /**
- * Gets the private key from environment.
+ * Gets the private key from environment or config.
  * Should only be called after validateEnvironment() returns null.
  */
 export declare function getPrivateKey(): string;
@@ -23,8 +50,31 @@ export interface WalletInfo {
     address: string;
     balance: string;
     chain: string;
+    type: WalletType;
+    isActive: boolean;
 }
 /**
  * Gets wallet address and balance from the configured private key
  */
 export declare function getWalletInfo(): Promise<WalletInfo>;
+/**
+ * Gets info for all configured wallets
+ */
+export declare function getAllWalletInfo(): Promise<WalletInfo[]>;
+/**
+ * Sets the active wallet type
+ * Returns error message if wallet type not configured, null on success
+ */
+export declare function setActiveWallet(type: WalletType): string | null;
+/**
+ * Checks if legacy wallet file exists and returns migration info
+ */
+export declare function checkLegacyWallet(): {
+    exists: boolean;
+    type?: WalletType;
+    privateKey?: string;
+};
+/**
+ * Gets the config file path (for CLI output)
+ */
+export declare function getConfigPath(): string;

package/dist/config.js

@@ -1,54 +1,202 @@
 /**
- * Environment validation for x402store MCP server
+ * Environment validation and multi-wallet config for x402store MCP server
  */
 import { privateKeyToAccount } from 'viem/accounts';
 import { createPublicClient, http, formatUnits } from 'viem';
 import { base } from 'viem/chains';
 import { Connection, Keypair, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CONFIG_PATH = join(homedir(), '.x402-config.json');
+const LEGACY_WALLET_PATH = join(homedir(), '.x402-wallet');
 /**
  * Detects wallet type from private key format
  */
 export function detectWalletType(key) {
     const trimmed = key.trim();
-    // EVM keys start with 0x
-    if (trimmed.startsWith('0x')) {
-        return 'evm';
-    }
     // Solana keys are JSON arrays
     if (trimmed.startsWith('[')) {
-        return 'solana';
+        return 'sol';
     }
-    // Default to EVM for other formats
+    // Default to EVM for other formats (including 0x prefix)
     return 'evm';
 }
 /**
- * Validates required environment variables.
- * Returns error message if X402_PRIVATE_KEY is missing, null if valid.
+ * Loads config from ~/.x402-config.json
+ * Returns null if config doesn't exist
+ */
+export function loadConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(CONFIG_PATH, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Saves config to ~/.x402-config.json
+ */
+export function saveConfig(config) {
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+/**
+ * Gets the active wallet's private key
+ * Returns null if no wallet is configured
+ */
+export function getActiveWallet() {
+    // First check env var for backward compatibility
+    if (process.env.X402_PRIVATE_KEY) {
+        const type = detectWalletType(process.env.X402_PRIVATE_KEY);
+        return { type, privateKey: process.env.X402_PRIVATE_KEY };
+    }
+    // Then check config file
+    const config = loadConfig();
+    if (!config) {
+        return null;
+    }
+    const activeType = config.activeWallet;
+    const privateKey = config.wallets[activeType];
+    if (!privateKey) {
+        return null;
+    }
+    return { type: activeType, privateKey };
+}
+/**
+ * Validates required environment variables or config.
+ * Returns error message if no wallet configured, null if valid.
  */
 export function validateEnvironment() {
-    if (!process.env.X402_PRIVATE_KEY) {
-        return 'X402_PRIVATE_KEY not set. Run /x402storage:setup to configure.';
+    const wallet = getActiveWallet();
+    if (!wallet) {
+        return 'No wallet configured. Run /x402storage:setup to configure.';
     }
     return null;
 }
 /**
- * Gets the private key from environment.
+ * Gets the private key from environment or config.
  * Should only be called after validateEnvironment() returns null.
  */
 export function getPrivateKey() {
-    return process.env.X402_PRIVATE_KEY;
+    const wallet = getActiveWallet();
+    return wallet.privateKey;
 }
 /**
  * Gets wallet address and balance from the configured private key
  */
 export async function getWalletInfo() {
-    const privateKey = getPrivateKey();
-    const walletType = detectWalletType(privateKey);
-    if (walletType === 'solana') {
-        return getSolanaWalletInfo(privateKey);
+    const wallet = getActiveWallet();
+    if (!wallet) {
+        throw new Error('No wallet configured');
+    }
+    if (wallet.type === 'sol') {
+        const info = await getSolanaWalletInfo(wallet.privateKey);
+        return { ...info, type: 'sol', isActive: true };
     }
     else {
-        return getEvmWalletInfo(privateKey);
+        const info = await getEvmWalletInfo(wallet.privateKey);
+        return { ...info, type: 'evm', isActive: true };
+    }
+}
+/**
+ * Gets info for all configured wallets
+ */
+export async function getAllWalletInfo() {
+    const results = [];
+    // Check env var first
+    if (process.env.X402_PRIVATE_KEY) {
+        const type = detectWalletType(process.env.X402_PRIVATE_KEY);
+        if (type === 'sol') {
+            const info = await getSolanaWalletInfo(process.env.X402_PRIVATE_KEY);
+            results.push({ ...info, type: 'sol', isActive: true });
+        }
+        else {
+            const info = await getEvmWalletInfo(process.env.X402_PRIVATE_KEY);
+            results.push({ ...info, type: 'evm', isActive: true });
+        }
+        return results;
+    }
+    // Check config file
+    const config = loadConfig();
+    if (!config) {
+        return results;
+    }
+    // Get EVM wallet info if configured
+    if (config.wallets.evm) {
+        try {
+            const info = await getEvmWalletInfo(config.wallets.evm);
+            results.push({
+                ...info,
+                type: 'evm',
+                isActive: config.activeWallet === 'evm',
+            });
+        }
+        catch (error) {
+            results.push({
+                address: 'Error loading wallet',
+                balance: 'N/A',
+                chain: 'Base',
+                type: 'evm',
+                isActive: config.activeWallet === 'evm',
+            });
+        }
+    }
+    // Get SOL wallet info if configured
+    if (config.wallets.sol) {
+        try {
+            const info = await getSolanaWalletInfo(config.wallets.sol);
+            results.push({
+                ...info,
+                type: 'sol',
+                isActive: config.activeWallet === 'sol',
+            });
+        }
+        catch (error) {
+            results.push({
+                address: 'Error loading wallet',
+                balance: 'N/A',
+                chain: 'Solana',
+                type: 'sol',
+                isActive: config.activeWallet === 'sol',
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Sets the active wallet type
+ * Returns error message if wallet type not configured, null on success
+ */
+export function setActiveWallet(type) {
+    const config = loadConfig();
+    if (!config) {
+        return 'No config file found. Run /x402storage:setup first.';
+    }
+    if (!config.wallets[type]) {
+        return `No ${type === 'evm' ? 'EVM (Base)' : 'Solana'} wallet configured. Run /x402storage:setup to add one.`;
+    }
+    config.activeWallet = type;
+    saveConfig(config);
+    return null;
+}
+/**
+ * Checks if legacy wallet file exists and returns migration info
+ */
+export function checkLegacyWallet() {
+    if (!existsSync(LEGACY_WALLET_PATH)) {
+        return { exists: false };
+    }
+    try {
+        const privateKey = readFileSync(LEGACY_WALLET_PATH, 'utf-8').trim();
+        const type = detectWalletType(privateKey);
+        return { exists: true, type, privateKey };
+    }
+    catch {
+        return { exists: false };
     }
 }
 /**
@@ -101,3 +249,9 @@ async function getEvmWalletInfo(privateKey) {
         chain: 'Base',
     };
 }
+/**
+ * Gets the config file path (for CLI output)
+ */
+export function getConfigPath() {
+    return CONFIG_PATH;
+}

package/dist/index.js

@@ -4,23 +4,65 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import { resolve } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { privateKeyToAccount } from 'viem/accounts';
-import { validateEnvironment, getPrivateKey, getWalletInfo } from './config.js';
+import { Keypair } from '@solana/web3.js';
+import { validateEnvironment, getPrivateKey, getAllWalletInfo, setActiveWallet, loadConfig, saveConfig, } from './config.js';
 import { uploadFile, FileNotFoundError, UploadError } from './upload.js';
-// Handle --generate-wallet flag before MCP server setup
-if (process.argv.includes('--generate-wallet')) {
+const CONFIG_PATH = join(homedir(), '.x402-config.json');
+// Handle CLI flags before MCP server setup
+const args = process.argv.slice(2);
+// --generate-wallet (legacy, generates EVM wallet)
+if (args.includes('--generate-wallet') || args.includes('--generate-evm-wallet')) {
     const privateKey = `0x${randomBytes(32).toString('hex')}`;
-    const walletPath = `${homedir()}/.x402-wallet`;
-    writeFileSync(walletPath, privateKey, { mode: 0o600 });
     const account = privateKeyToAccount(privateKey);
+    // Add to config file
+    let config = loadConfig();
+    if (!config) {
+        config = { activeWallet: 'evm', wallets: {} };
+    }
+    config.wallets.evm = privateKey;
+    config.activeWallet = 'evm';
+    saveConfig(config);
     console.log(account.address);
     process.exit(0);
 }
+// --generate-sol-wallet
+if (args.includes('--generate-sol-wallet')) {
+    const keypair = Keypair.generate();
+    const privateKey = JSON.stringify(Array.from(keypair.secretKey));
+    const address = keypair.publicKey.toBase58();
+    // Add to config file
+    let config = loadConfig();
+    if (!config) {
+        config = { activeWallet: 'sol', wallets: {} };
+    }
+    config.wallets.sol = privateKey;
+    config.activeWallet = 'sol';
+    saveConfig(config);
+    console.log(address);
+    process.exit(0);
+}
+// --set-active-wallet <type>
+const setActiveIdx = args.indexOf('--set-active-wallet');
+if (setActiveIdx !== -1) {
+    const walletType = args[setActiveIdx + 1];
+    if (!walletType || (walletType !== 'evm' && walletType !== 'sol')) {
+        console.error('Error: --set-active-wallet requires "evm" or "sol" as argument');
+        process.exit(1);
+    }
+    const error = setActiveWallet(walletType);
+    if (error) {
+        console.error(`Error: ${error}`);
+        process.exit(1);
+    }
+    console.log(`Active wallet set to ${walletType === 'evm' ? 'EVM (Base)' : 'Solana'}`);
+    process.exit(0);
+}
 // Create MCP server
 const server = new McpServer({
-    name: 'x402store',
+    name: 'x402storage',
     version: '1.0.0',
 });
 // Register store_file tool
@@ -83,21 +125,34 @@ server.tool('store_file', 'Store a file permanently on IPFS via x402.storage. Re
         };
     }
 });
-// Register wallet tool
+// Register wallet tool - shows ALL configured wallets
 server.tool('wallet', 'Show your x402.storage wallet address and balance', {}, async () => {
-    const envError = validateEnvironment();
-    if (envError) {
-        return {
-            content: [{ type: 'text', text: `Error: ${envError}` }],
-        };
-    }
     try {
-        const info = await getWalletInfo();
+        const wallets = await getAllWalletInfo();
+        if (wallets.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No wallets configured. Run /x402storage:setup to configure.',
+                    },
+                ],
+            };
+        }
+        const lines = [];
+        for (const wallet of wallets) {
+            const activeMarker = wallet.isActive ? ' [ACTIVE]' : '';
+            const chainLabel = wallet.type === 'evm' ? 'EVM (Base)' : 'Solana';
+            lines.push(`${chainLabel}${activeMarker}`);
+            lines.push(`  Address: ${wallet.address}`);
+            lines.push(`  Balance: ${wallet.balance}`);
+            lines.push('');
+        }
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Address: ${info.address}\nBalance: ${info.balance}`,
+                    text: lines.join('\n').trim(),
                 },
             ],
         };
@@ -109,13 +164,35 @@ server.tool('wallet', 'Show your x402.storage wallet address and balance', {}, a
         };
     }
 });
+// Register set_active_wallet tool
+server.tool('set_active_wallet', 'Set which wallet (evm or sol) to use for payments. Note: Claude Code restart required for changes to take effect.', {
+    wallet_type: z
+        .enum(['evm', 'sol'])
+        .describe('Wallet type to set as active: "evm" for Base/USDC or "sol" for Solana'),
+}, async ({ wallet_type }) => {
+    const error = setActiveWallet(wallet_type);
+    if (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+        };
+    }
+    const chainLabel = wallet_type === 'evm' ? 'EVM (Base)' : 'Solana';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Active wallet set to ${chainLabel}.\n\nNote: Restart Claude Code for the change to take effect.`,
+            },
+        ],
+    };
+});
 // Run server with stdio transport
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // Note: MCP servers must not write to stdout (breaks JSON-RPC)
     // Use console.error for any debugging
-    console.error('x402store MCP server running on stdio');
+    console.error('x402storage MCP server running on stdio');
 }
 main().catch((error) => {
     console.error('Fatal error:', error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x402storage/mcp",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "MCP server for x402.storage file uploads",
   "type": "module",
   "license": "MIT",
@@ -9,6 +9,7 @@
     "url": "https://github.com/rawgroundbeef/x402.storage"
   },
   "bin": {
+    "mcp": "./dist/index.js",
     "x402-mcp": "./dist/index.js"
   },
   "files": [