@manifest-network/manifest-mcp-browser 0.1.7 → 0.1.8

package/src/index.ts

@@ -1,478 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-  Tool,
-} from '@modelcontextprotocol/sdk/types.js';
-import { CosmosClientManager } from './client.js';
-import { cosmosQuery, cosmosTx } from './cosmos.js';
-import { getAvailableModules, getModuleSubcommands } from './modules.js';
-import {
-  ManifestMCPConfig,
-  WalletProvider,
-  AccountInfo,
-  ManifestMCPError,
-  ManifestMCPErrorCode,
-} from './types.js';
-import { createValidatedConfig } from './config.js';
-
-/**
- * Sensitive field names that should be redacted from error responses
- */
-const SENSITIVE_FIELDS = new Set([
-  'mnemonic',
-  'privatekey',
-  'private_key',
-  'secret',
-  'password',
-  'seed',
-  'key',
-  'token',
-  'apikey',
-  'api_key',
-]);
-
-/**
- * Parse raw args input into string array.
- * Handles both array and space-separated string inputs.
- */
-function parseArgs(rawArgs: unknown): string[] {
-  if (Array.isArray(rawArgs)) {
-    return rawArgs.map(String);
-  }
-  if (typeof rawArgs === 'string' && rawArgs.length > 0) {
-    return rawArgs.split(/\s+/);
-  }
-  return [];
-}
-
-/**
- * Recursively sanitize an object by redacting sensitive fields
- */
-function sanitizeForLogging(obj: unknown, depth = 0): unknown {
-  // Prevent infinite recursion
-  if (depth > 10) {
-    return '[max depth exceeded]';
-  }
-
-  if (obj === null || obj === undefined) {
-    return obj;
-  }
-
-  if (typeof obj === 'string') {
-    // Redact strings that look like mnemonics (12 or 24 words)
-    const wordCount = obj.trim().split(/\s+/).length;
-    if (wordCount === 12 || wordCount === 24) {
-      return '[REDACTED - possible mnemonic]';
-    }
-    return obj;
-  }
-
-  if (Array.isArray(obj)) {
-    return obj.map(item => sanitizeForLogging(item, depth + 1));
-  }
-
-  if (typeof obj === 'object') {
-    const sanitized: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(obj)) {
-      const lowerKey = key.toLowerCase();
-      if (SENSITIVE_FIELDS.has(lowerKey)) {
-        sanitized[key] = '[REDACTED]';
-      } else {
-        sanitized[key] = sanitizeForLogging(value, depth + 1);
-      }
-    }
-    return sanitized;
-  }
-
-  return obj;
-}
-
-// Re-export types and utilities
-export * from './types.js';
-export { createConfig, createValidatedConfig, validateConfig } from './config.js';
-export { CosmosClientManager } from './client.js';
-export { cosmosQuery, cosmosTx } from './cosmos.js';
-export { getAvailableModules, getModuleSubcommands, getSubcommandUsage, getSupportedModules, isSubcommandSupported } from './modules.js';
-export { MnemonicWalletProvider } from './wallet/index.js';
-
-/**
- * Tool definitions for the MCP server
- */
-const tools: Tool[] = [
-  {
-    name: 'get_account_info',
-    description: 'Get account address and key name for the configured key',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-      required: [],
-    },
-  },
-  {
-    name: 'cosmos_query',
-    description:
-      'Execute any Cosmos SDK query command. Use list_modules and list_module_subcommands to discover available options.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        module: {
-          type: 'string',
-          description:
-            'The module name (e.g., "bank", "staking", "distribution", "gov", "auth")',
-        },
-        subcommand: {
-          type: 'string',
-          description:
-            'The subcommand (e.g., "balance", "balances", "delegations", "rewards", "proposals")',
-        },
-        args: {
-          type: 'array',
-          items: { type: 'string' },
-          description:
-            'Additional arguments as an array of strings (e.g., ["<address>", "umfx"] for bank balance). Use array to preserve arguments with spaces.',
-        },
-      },
-      required: ['module', 'subcommand'],
-    },
-  },
-  {
-    name: 'cosmos_tx',
-    description:
-      'Execute any Cosmos SDK transaction. Automatically signs with the configured key and estimates gas. Use list_modules and list_module_subcommands to discover available options.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        module: {
-          type: 'string',
-          description: 'The module name (e.g., "bank", "staking", "gov")',
-        },
-        subcommand: {
-          type: 'string',
-          description: 'The subcommand (e.g., "send", "delegate", "unbond", "vote")',
-        },
-        args: {
-          type: 'array',
-          items: { type: 'string' },
-          description:
-            'Arguments to the transaction as an array of strings (e.g., ["<to_address>", "1000umfx"] for bank send). Use array to preserve arguments with spaces.',
-        },
-        wait_for_confirmation: {
-          type: 'boolean',
-          description:
-            'If true, wait for the transaction to be included in a block before returning. Defaults to false (broadcast only).',
-        },
-      },
-      required: ['module', 'subcommand', 'args'],
-    },
-  },
-  {
-    name: 'list_modules',
-    description:
-      'List all available query and transaction modules supported by the chain',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-      required: [],
-    },
-  },
-  {
-    name: 'list_module_subcommands',
-    description:
-      'List all available subcommands for a specific module (query or tx)',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        type: {
-          type: 'string',
-          enum: ['query', 'tx'],
-          description: 'Whether to list query or transaction subcommands',
-        },
-        module: {
-          type: 'string',
-          description: 'The module name (e.g., "bank", "staking")',
-        },
-      },
-      required: ['type', 'module'],
-    },
-  },
-];
-
-/**
- * Options for creating a ManifestMCPServer
- */
-export interface ManifestMCPServerOptions {
-  config: ManifestMCPConfig;
-  walletProvider: WalletProvider;
-}
-
-/**
- * ManifestMCPServer class for browser-compatible MCP server
- */
-export class ManifestMCPServer {
-  private server: Server;
-  private clientManager: CosmosClientManager;
-  private walletProvider: WalletProvider;
-  private config: ManifestMCPConfig;
-
-  constructor(options: ManifestMCPServerOptions) {
-    this.config = createValidatedConfig(options.config);
-    this.walletProvider = options.walletProvider;
-    this.clientManager = CosmosClientManager.getInstance(this.config, this.walletProvider);
-
-    // Note: Keep version in sync with package.json
-    this.server = new Server(
-      {
-        name: '@manifest-network/manifest-mcp-browser',
-        version: '0.1.1',
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      }
-    );
-
-    this.setupHandlers();
-  }
-
-  /**
-   * Set up the MCP request handlers
-   */
-  private setupHandlers(): void {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools,
-    }));
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const toolName = request.params.name;
-      const toolInput = request.params.arguments || {};
-
-      try {
-        return await this.handleToolCall(toolName, toolInput);
-      } catch (error) {
-        // Build detailed error response with sanitized inputs
-        let errorResponse: Record<string, unknown> = {
-          error: true,
-          tool: toolName,
-          input: sanitizeForLogging(toolInput),
-        };
-
-        if (error instanceof ManifestMCPError) {
-          errorResponse = {
-            ...errorResponse,
-            code: error.code,
-            message: error.message,
-            details: sanitizeForLogging(error.details),
-          };
-        } else {
-          errorResponse = {
-            ...errorResponse,
-            message: error instanceof Error ? error.message : String(error),
-          };
-        }
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(errorResponse, null, 2),
-            },
-          ],
-          isError: true,
-        };
-      }
-    });
-  }
-
-  /**
-   * Handle a tool call
-   */
-  private async handleToolCall(
-    toolName: string,
-    toolInput: Record<string, unknown>
-  ): Promise<{ content: Array<{ type: string; text: string }>; isError?: boolean }> {
-    switch (toolName) {
-      case 'get_account_info': {
-        const address = await this.walletProvider.getAddress();
-        const accountInfo: AccountInfo = {
-          address,
-        };
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(accountInfo, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'cosmos_query': {
-        const module = toolInput.module as string;
-        const subcommand = toolInput.subcommand as string;
-        const args = parseArgs(toolInput.args);
-
-        if (!module || !subcommand) {
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.QUERY_FAILED,
-            'module and subcommand are required'
-          );
-        }
-
-        const result = await cosmosQuery(this.clientManager, module, subcommand, args);
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'cosmos_tx': {
-        const module = toolInput.module as string;
-        const subcommand = toolInput.subcommand as string;
-        const args = parseArgs(toolInput.args);
-        const waitForConfirmation = (toolInput.wait_for_confirmation as boolean) || false;
-
-        if (!module || !subcommand || args.length === 0) {
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.TX_FAILED,
-            'module, subcommand, and args are required'
-          );
-        }
-
-        const result = await cosmosTx(
-          this.clientManager,
-          module,
-          subcommand,
-          args,
-          waitForConfirmation
-        );
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'list_modules': {
-        const modules = getAvailableModules();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(modules, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'list_module_subcommands': {
-        const type = toolInput.type as string;
-        const module = toolInput.module as string;
-
-        if (!type || !module) {
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.QUERY_FAILED,
-            'type and module are required'
-          );
-        }
-
-        if (type !== 'query' && type !== 'tx') {
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.QUERY_FAILED,
-            'type must be either "query" or "tx"'
-          );
-        }
-
-        const subcommands = getModuleSubcommands(type as 'query' | 'tx', module);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(
-                {
-                  type,
-                  module,
-                  subcommands,
-                },
-                null,
-                2
-              ),
-            },
-          ],
-        };
-      }
-
-      default:
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.UNKNOWN_ERROR,
-          `Unknown tool: ${toolName}`
-        );
-    }
-  }
-
-  /**
-   * Get the underlying MCP server instance
-   */
-  getServer(): Server {
-    return this.server;
-  }
-
-  /**
-   * Get the client manager
-   */
-  getClientManager(): CosmosClientManager {
-    return this.clientManager;
-  }
-
-  /**
-   * Disconnect and clean up resources
-   */
-  disconnect(): void {
-    this.clientManager.disconnect();
-  }
-}
-
-/**
- * Create a ManifestMCPServer with mnemonic wallet (for testing or non-interactive use)
- *
- * @example
- * ```typescript
- * import { createMnemonicServer } from '@manifest-network/manifest-mcp-browser';
- *
- * const server = await createMnemonicServer({
- *   chainId: 'manifest-ledger-testnet',
- *   rpcUrl: 'https://nodes.chandrastation.com/rpc/manifest/',
- *   gasPrice: '1.0umfx',
- *   mnemonic: 'your twelve word mnemonic phrase here...',
- * });
- * ```
- */
-export async function createMnemonicServer(config: {
-  chainId: string;
-  rpcUrl: string;
-  gasPrice: string;
-  gasAdjustment?: number;
-  addressPrefix?: string;
-  mnemonic: string;
-}): Promise<ManifestMCPServer> {
-  const { MnemonicWalletProvider } = await import('./wallet/mnemonic.js');
-
-  const { mnemonic, ...mcpConfig } = config;
-  const walletProvider = new MnemonicWalletProvider(mcpConfig, mnemonic);
-  await walletProvider.connect();
-
-  return new ManifestMCPServer({
-    config: mcpConfig,
-    walletProvider,
-  });
-}

package/src/modules.test.ts

@@ -1,191 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  getAvailableModules,
-  getModuleSubcommands,
-  isSubcommandSupported,
-  getSupportedModules,
-  throwUnsupportedSubcommand,
-} from './modules.js';
-import { ManifestMCPError, ManifestMCPErrorCode } from './types.js';
-
-describe('getAvailableModules', () => {
-  it('should return query and tx modules', () => {
-    const modules = getAvailableModules();
-
-    expect(modules.queryModules).toBeDefined();
-    expect(modules.txModules).toBeDefined();
-    expect(modules.queryModules.length).toBeGreaterThan(0);
-    expect(modules.txModules.length).toBeGreaterThan(0);
-  });
-
-  it('should include expected query modules', () => {
-    const modules = getAvailableModules();
-    const queryNames = modules.queryModules.map(m => m.name);
-
-    expect(queryNames).toContain('bank');
-    expect(queryNames).toContain('staking');
-    expect(queryNames).toContain('distribution');
-    expect(queryNames).toContain('gov');
-    expect(queryNames).toContain('auth');
-    expect(queryNames).toContain('billing');
-    expect(queryNames).toContain('sku');
-    expect(queryNames).toContain('group');
-  });
-
-  it('should include expected tx modules', () => {
-    const modules = getAvailableModules();
-    const txNames = modules.txModules.map(m => m.name);
-
-    expect(txNames).toContain('bank');
-    expect(txNames).toContain('staking');
-    expect(txNames).toContain('distribution');
-    expect(txNames).toContain('gov');
-    expect(txNames).toContain('billing');
-    expect(txNames).toContain('manifest');
-    expect(txNames).toContain('sku');
-    expect(txNames).toContain('group');
-  });
-});
-
-describe('getModuleSubcommands', () => {
-  it('should return subcommands for valid query module', () => {
-    const subcommands = getModuleSubcommands('query', 'bank');
-
-    expect(subcommands.length).toBeGreaterThan(0);
-    expect(subcommands.some(s => s.name === 'balance')).toBe(true);
-    expect(subcommands.some(s => s.name === 'balances')).toBe(true);
-  });
-
-  it('should return subcommands for valid tx module', () => {
-    const subcommands = getModuleSubcommands('tx', 'bank');
-
-    expect(subcommands.length).toBeGreaterThan(0);
-    expect(subcommands.some(s => s.name === 'send')).toBe(true);
-  });
-
-  it('should throw ManifestMCPError for unknown module', () => {
-    expect(() => getModuleSubcommands('query', 'unknown')).toThrow(ManifestMCPError);
-  });
-
-  it('should have UNKNOWN_MODULE error code', () => {
-    try {
-      getModuleSubcommands('query', 'unknown');
-    } catch (error) {
-      expect((error as ManifestMCPError).code).toBe(ManifestMCPErrorCode.UNKNOWN_MODULE);
-    }
-  });
-
-  it('should include aliases in subcommands', () => {
-    const bankSubcommands = getModuleSubcommands('query', 'bank');
-    expect(bankSubcommands.some(s => s.name === 'total')).toBe(true);
-
-    const stakingSubcommands = getModuleSubcommands('tx', 'staking');
-    expect(stakingSubcommands.some(s => s.name === 'undelegate')).toBe(true);
-  });
-});
-
-describe('isSubcommandSupported', () => {
-  it('should return true for supported query subcommands', () => {
-    expect(isSubcommandSupported('query', 'bank', 'balance')).toBe(true);
-    expect(isSubcommandSupported('query', 'staking', 'delegation')).toBe(true);
-  });
-
-  it('should return true for supported tx subcommands', () => {
-    expect(isSubcommandSupported('tx', 'bank', 'send')).toBe(true);
-    expect(isSubcommandSupported('tx', 'staking', 'delegate')).toBe(true);
-  });
-
-  it('should return false for unsupported subcommands', () => {
-    expect(isSubcommandSupported('query', 'bank', 'unknown')).toBe(false);
-    expect(isSubcommandSupported('tx', 'bank', 'unknown')).toBe(false);
-  });
-
-  it('should return false for unknown modules', () => {
-    expect(isSubcommandSupported('query', 'unknown', 'balance')).toBe(false);
-    expect(isSubcommandSupported('tx', 'unknown', 'send')).toBe(false);
-  });
-
-  it('should support aliases', () => {
-    expect(isSubcommandSupported('query', 'bank', 'total')).toBe(true);
-    expect(isSubcommandSupported('tx', 'staking', 'undelegate')).toBe(true);
-  });
-});
-
-describe('getSupportedModules', () => {
-  it('should return query and tx module maps', () => {
-    const modules = getSupportedModules();
-
-    expect(modules.query).toBeDefined();
-    expect(modules.tx).toBeDefined();
-  });
-
-  it('should include subcommand arrays for each module', () => {
-    const modules = getSupportedModules();
-
-    expect(Array.isArray(modules.query.bank)).toBe(true);
-    expect(modules.query.bank).toContain('balance');
-    expect(modules.query.bank).toContain('balances');
-
-    expect(Array.isArray(modules.tx.bank)).toBe(true);
-    expect(modules.tx.bank).toContain('send');
-  });
-});
-
-describe('throwUnsupportedSubcommand', () => {
-  it('should throw ManifestMCPError for unsupported query subcommand', () => {
-    expect(() => throwUnsupportedSubcommand('query', 'bank', 'unknown')).toThrow(ManifestMCPError);
-  });
-
-  it('should throw ManifestMCPError for unsupported tx subcommand', () => {
-    expect(() => throwUnsupportedSubcommand('tx', 'bank', 'unknown')).toThrow(ManifestMCPError);
-  });
-
-  it('should use UNSUPPORTED_QUERY error code for queries', () => {
-    try {
-      throwUnsupportedSubcommand('query', 'bank', 'unknown');
-    } catch (error) {
-      expect((error as ManifestMCPError).code).toBe(ManifestMCPErrorCode.UNSUPPORTED_QUERY);
-    }
-  });
-
-  it('should use UNSUPPORTED_TX error code for transactions', () => {
-    try {
-      throwUnsupportedSubcommand('tx', 'bank', 'unknown');
-    } catch (error) {
-      expect((error as ManifestMCPError).code).toBe(ManifestMCPErrorCode.UNSUPPORTED_TX);
-    }
-  });
-
-  it('should include module and subcommand in error message', () => {
-    try {
-      throwUnsupportedSubcommand('query', 'staking', 'badcmd');
-    } catch (error) {
-      const message = (error as ManifestMCPError).message;
-      expect(message).toContain('staking');
-      expect(message).toContain('badcmd');
-      expect(message).toContain('query');
-    }
-  });
-
-  it('should include availableSubcommands in error details', () => {
-    try {
-      throwUnsupportedSubcommand('tx', 'bank', 'unknown');
-    } catch (error) {
-      const details = (error as ManifestMCPError).details;
-      expect(details?.availableSubcommands).toBeDefined();
-      expect(details?.availableSubcommands).toContain('send');
-      expect(details?.availableSubcommands).toContain('multi-send');
-    }
-  });
-
-  it('should include correct subcommands for each module', () => {
-    try {
-      throwUnsupportedSubcommand('query', 'gov', 'unknown');
-    } catch (error) {
-      const details = (error as ManifestMCPError).details;
-      expect(details?.availableSubcommands).toContain('proposal');
-      expect(details?.availableSubcommands).toContain('proposals');
-      expect(details?.availableSubcommands).toContain('vote');
-    }
-  });
-});