@manifest-network/manifest-mcp-browser 0.1.1 → 0.1.6

package/src/cosmos.ts

@@ -1,18 +1,6 @@
 import { CosmosClientManager } from './client.js';
 import { CosmosQueryResult, CosmosTxResult, ManifestMCPError, ManifestMCPErrorCode } from './types.js';
-import { getSupportedModules } from './modules.js';
-import { routeBankQuery } from './queries/bank.js';
-import { routeStakingQuery } from './queries/staking.js';
-import { routeDistributionQuery } from './queries/distribution.js';
-import { routeGovQuery } from './queries/gov.js';
-import { routeAuthQuery } from './queries/auth.js';
-import { routeBillingQuery } from './queries/billing.js';
-import { routeBankTransaction } from './transactions/bank.js';
-import { routeStakingTransaction } from './transactions/staking.js';
-import { routeDistributionTransaction } from './transactions/distribution.js';
-import { routeGovTransaction } from './transactions/gov.js';
-import { routeBillingTransaction } from './transactions/billing.js';
-import { routeManifestTransaction } from './transactions/manifest.js';
+import { getQueryHandler, getTxHandler } from './modules.js';
 
 // Validation pattern for module/subcommand names (alphanumeric, hyphens, underscores)
 // First character must not be a hyphen to prevent potential issues
@@ -30,11 +18,6 @@ function validateName(name: string, field: string): void {
   }
 }
 
-// Get module lists from the authoritative registry
-const supportedModules = getSupportedModules();
-const QUERY_MODULES = Object.keys(supportedModules.query);
-const TX_MODULES = Object.keys(supportedModules.tx);
-
 /**
  * Execute a Cosmos query via manifestjs RPC client
  */
@@ -52,35 +35,10 @@ export async function cosmosQuery(
 
   const queryClient = await clientManager.getQueryClient();
 
-  let result: Record<string, unknown>;
-
   try {
-    switch (module) {
-      case 'bank':
-        result = await routeBankQuery(queryClient, subcommand, args);
-        break;
-      case 'staking':
-        result = await routeStakingQuery(queryClient, subcommand, args);
-        break;
-      case 'distribution':
-        result = await routeDistributionQuery(queryClient, subcommand, args);
-        break;
-      case 'gov':
-        result = await routeGovQuery(queryClient, subcommand, args);
-        break;
-      case 'auth':
-        result = await routeAuthQuery(queryClient, subcommand, args);
-        break;
-      case 'billing':
-        result = await routeBillingQuery(queryClient, subcommand, args);
-        break;
-      default:
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.UNKNOWN_MODULE,
-          `Unknown query module: ${module}`,
-          { availableModules: QUERY_MODULES }
-        );
-    }
+    // Get handler from registry (throws if module not found)
+    const handler = getQueryHandler(module);
+    const result = await handler(queryClient, subcommand, args);
 
     return {
       module,
@@ -116,71 +74,17 @@ export async function cosmosTx(
 
   const signingClient = await clientManager.getSigningClient();
   const senderAddress = await clientManager.getAddress();
-  const config = clientManager.getConfig();
 
   try {
-    switch (module) {
-      case 'bank':
-        return await routeBankTransaction(
-          signingClient,
-          senderAddress,
-          subcommand,
-          args,
-          config,
-          waitForConfirmation
-        );
-      case 'staking':
-        return await routeStakingTransaction(
-          signingClient,
-          senderAddress,
-          subcommand,
-          args,
-          config,
-          waitForConfirmation
-        );
-      case 'distribution':
-        return await routeDistributionTransaction(
-          signingClient,
-          senderAddress,
-          subcommand,
-          args,
-          config,
-          waitForConfirmation
-        );
-      case 'gov':
-        return await routeGovTransaction(
-          signingClient,
-          senderAddress,
-          subcommand,
-          args,
-          config,
-          waitForConfirmation
-        );
-      case 'billing':
-        return await routeBillingTransaction(
-          signingClient,
-          senderAddress,
-          subcommand,
-          args,
-          config,
-          waitForConfirmation
-        );
-      case 'manifest':
-        return await routeManifestTransaction(
-          signingClient,
-          senderAddress,
-          subcommand,
-          args,
-          config,
-          waitForConfirmation
-        );
-      default:
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.UNKNOWN_MODULE,
-          `Unknown tx module: ${module}`,
-          { availableModules: TX_MODULES }
-        );
-    }
+    // Get handler from registry (throws if module not found)
+    const handler = getTxHandler(module);
+    return await handler(
+      signingClient,
+      senderAddress,
+      subcommand,
+      args,
+      waitForConfirmation
+    );
   } catch (error) {
     if (error instanceof ManifestMCPError) {
       // Re-throw with enriched context if not already present

package/src/index.ts

@@ -32,6 +32,20 @@ const SENSITIVE_FIELDS = new Set([
   '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
  */
@@ -210,7 +224,7 @@ export class ManifestMCPServer {
     this.server = new Server(
       {
         name: '@manifest-network/manifest-mcp-browser',
-        version: '0.1.0',
+        version: '0.1.1',
       },
       {
         capabilities: {
@@ -297,17 +311,7 @@ export class ManifestMCPServer {
       case 'cosmos_query': {
         const module = toolInput.module as string;
         const subcommand = toolInput.subcommand as string;
-        const rawArgs = toolInput.args;
-
-        // Handle both array and string inputs for args
-        let args: string[];
-        if (Array.isArray(rawArgs)) {
-          args = rawArgs.map(String);
-        } else if (typeof rawArgs === 'string' && rawArgs.length > 0) {
-          args = rawArgs.split(/\s+/);
-        } else {
-          args = [];
-        }
+        const args = parseArgs(toolInput.args);
 
         if (!module || !subcommand) {
           throw new ManifestMCPError(
@@ -331,19 +335,9 @@ export class ManifestMCPServer {
       case 'cosmos_tx': {
         const module = toolInput.module as string;
         const subcommand = toolInput.subcommand as string;
-        const rawArgs = toolInput.args;
+        const args = parseArgs(toolInput.args);
         const waitForConfirmation = (toolInput.wait_for_confirmation as boolean) || false;
 
-        // Handle both array and string inputs for args
-        let args: string[];
-        if (Array.isArray(rawArgs)) {
-          args = rawArgs.map(String);
-        } else if (typeof rawArgs === 'string' && rawArgs.length > 0) {
-          args = rawArgs.split(/\s+/);
-        } else {
-          args = [];
-        }
-
         if (!module || !subcommand || args.length === 0) {
           throw new ManifestMCPError(
             ManifestMCPErrorCode.TX_FAILED,

package/src/modules.test.ts

@@ -4,6 +4,7 @@ import {
   getModuleSubcommands,
   isSubcommandSupported,
   getSupportedModules,
+  throwUnsupportedSubcommand,
 } from './modules.js';
 import { ManifestMCPError, ManifestMCPErrorCode } from './types.js';
 
@@ -27,6 +28,7 @@ describe('getAvailableModules', () => {
     expect(queryNames).toContain('gov');
     expect(queryNames).toContain('auth');
     expect(queryNames).toContain('billing');
+    expect(queryNames).toContain('sku');
   });
 
   it('should include expected tx modules', () => {
@@ -39,6 +41,7 @@ describe('getAvailableModules', () => {
     expect(txNames).toContain('gov');
     expect(txNames).toContain('billing');
     expect(txNames).toContain('manifest');
+    expect(txNames).toContain('sku');
   });
 });
 
@@ -125,3 +128,62 @@ describe('getSupportedModules', () => {
     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');
+    }
+  });
+});

package/src/modules.ts

@@ -1,4 +1,68 @@
-import { ModuleInfo, AvailableModules, ManifestMCPError, ManifestMCPErrorCode } from './types.js';
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { ModuleInfo, AvailableModules, ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, QueryResult } from './types.js';
+import { ManifestQueryClient } from './client.js';
+
+// Import query handlers
+import { routeBankQuery } from './queries/bank.js';
+import { routeStakingQuery } from './queries/staking.js';
+import { routeDistributionQuery } from './queries/distribution.js';
+import { routeGovQuery } from './queries/gov.js';
+import { routeAuthQuery } from './queries/auth.js';
+import { routeBillingQuery } from './queries/billing.js';
+import { routeSkuQuery } from './queries/sku.js';
+
+// Import transaction handlers
+import { routeBankTransaction } from './transactions/bank.js';
+import { routeStakingTransaction } from './transactions/staking.js';
+import { routeDistributionTransaction } from './transactions/distribution.js';
+import { routeGovTransaction } from './transactions/gov.js';
+import { routeBillingTransaction } from './transactions/billing.js';
+import { routeManifestTransaction } from './transactions/manifest.js';
+import { routeSkuTransaction } from './transactions/sku.js';
+
+/**
+ * Handler function type for query modules
+ */
+export type QueryHandler = (
+  queryClient: ManifestQueryClient,
+  subcommand: string,
+  args: string[]
+) => Promise<QueryResult>;
+
+/**
+ * Handler function type for transaction modules
+ */
+export type TxHandler = (
+  signingClient: SigningStargateClient,
+  senderAddress: string,
+  subcommand: string,
+  args: string[],
+  waitForConfirmation: boolean
+) => Promise<CosmosTxResult>;
+
+/**
+ * Throw an error for an unsupported subcommand.
+ * Automatically looks up available subcommands from the module registry.
+ *
+ * @param type - 'query' or 'tx'
+ * @param module - The module name (e.g., 'bank', 'staking')
+ * @param subcommand - The unsupported subcommand that was requested
+ */
+export function throwUnsupportedSubcommand(
+  type: 'query' | 'tx',
+  module: string,
+  subcommand: string
+): never {
+  const registry = type === 'query' ? QUERY_MODULES : TX_MODULES;
+  const moduleInfo = registry[module];
+  const availableSubcommands = moduleInfo?.subcommands.map(s => s.name) ?? [];
+
+  throw new ManifestMCPError(
+    type === 'query' ? ManifestMCPErrorCode.UNSUPPORTED_QUERY : ManifestMCPErrorCode.UNSUPPORTED_TX,
+    `Unsupported ${module} ${type === 'query' ? 'query' : 'transaction'} subcommand: ${subcommand}`,
+    { availableSubcommands }
+  );
+}
 
 /**
  * Static module registry for browser-compatible module discovery
@@ -11,19 +75,30 @@ interface SubcommandInfo {
   args?: string; // Usage hint for arguments
 }
 
-interface ModuleRegistry {
+interface QueryModuleRegistry {
+  [moduleName: string]: {
+    description: string;
+    subcommands: SubcommandInfo[];
+    handler: QueryHandler;
+  };
+}
+
+interface TxModuleRegistry {
   [moduleName: string]: {
     description: string;
     subcommands: SubcommandInfo[];
+    handler: TxHandler;
   };
 }
 
 /**
  * Query modules registry
+ * Each module includes metadata and its handler function
  */
-const QUERY_MODULES: ModuleRegistry = {
+const QUERY_MODULES: QueryModuleRegistry = {
   bank: {
     description: 'Querying commands for the bank module',
+    handler: routeBankQuery,
     subcommands: [
       { name: 'balance', description: 'Query account balance for a specific denom' },
       { name: 'balances', description: 'Query all balances for an account' },
@@ -39,6 +114,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   staking: {
     description: 'Querying commands for the staking module',
+    handler: routeStakingQuery,
     subcommands: [
       { name: 'delegation', description: 'Query a delegation' },
       { name: 'delegations', description: 'Query all delegations for a delegator' },
@@ -56,6 +132,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   distribution: {
     description: 'Querying commands for the distribution module',
+    handler: routeDistributionQuery,
     subcommands: [
       { name: 'rewards', description: 'Query distribution rewards for a delegator' },
       { name: 'commission', description: 'Query validator commission' },
@@ -69,6 +146,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   gov: {
     description: 'Querying commands for the governance module',
+    handler: routeGovQuery,
     subcommands: [
       { name: 'proposal', description: 'Query a proposal by ID' },
       { name: 'proposals', description: 'Query all proposals' },
@@ -82,6 +160,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   auth: {
     description: 'Querying commands for the auth module',
+    handler: routeAuthQuery,
     subcommands: [
       { name: 'account', description: 'Query account by address' },
       { name: 'accounts', description: 'Query all accounts' },
@@ -96,6 +175,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   billing: {
     description: 'Querying commands for the Manifest billing module',
+    handler: routeBillingQuery,
     subcommands: [
       { name: 'params', description: 'Query billing parameters' },
       { name: 'lease', description: 'Query a lease by UUID' },
@@ -111,14 +191,29 @@ const QUERY_MODULES: ModuleRegistry = {
       { name: 'credit-estimate', description: 'Query credit estimate for a tenant' },
     ],
   },
+  sku: {
+    description: 'Querying commands for the Manifest SKU module',
+    handler: routeSkuQuery,
+    subcommands: [
+      { name: 'params', description: 'Query SKU module parameters' },
+      { name: 'provider', description: 'Query a provider by UUID', args: '<provider-uuid>' },
+      { name: 'providers', description: 'Query all providers', args: '[--active-only] [--limit N]' },
+      { name: 'sku', description: 'Query a SKU by UUID', args: '<sku-uuid>' },
+      { name: 'skus', description: 'Query all SKUs', args: '[--active-only] [--limit N]' },
+      { name: 'skus-by-provider', description: 'Query SKUs by provider UUID', args: '<provider-uuid> [--active-only] [--limit N]' },
+      { name: 'provider-by-address', description: 'Query providers by address', args: '<address> [--active-only] [--limit N]' },
+    ],
+  },
 };
 
 /**
  * Transaction modules registry
+ * Each module includes metadata and its handler function
  */
-const TX_MODULES: ModuleRegistry = {
+const TX_MODULES: TxModuleRegistry = {
   bank: {
     description: 'Bank transaction subcommands',
+    handler: routeBankTransaction,
     subcommands: [
       { name: 'send', description: 'Send tokens to another account', args: '<to-address> <amount> (e.g., manifest1abc... 1000000umfx)' },
       { name: 'multi-send', description: 'Send tokens to multiple accounts', args: '<to-address:amount>... (e.g., manifest1a:1000umfx manifest1b:2000umfx)' },
@@ -126,6 +221,7 @@ const TX_MODULES: ModuleRegistry = {
   },
   staking: {
     description: 'Staking transaction subcommands',
+    handler: routeStakingTransaction,
     subcommands: [
       { name: 'delegate', description: 'Delegate tokens to a validator' },
       { name: 'unbond', description: 'Unbond tokens from a validator' },
@@ -135,6 +231,7 @@ const TX_MODULES: ModuleRegistry = {
   },
   distribution: {
     description: 'Distribution transaction subcommands',
+    handler: routeDistributionTransaction,
     subcommands: [
       { name: 'withdraw-rewards', description: 'Withdraw rewards from a validator' },
       { name: 'set-withdraw-addr', description: 'Set withdraw address' },
@@ -143,6 +240,7 @@ const TX_MODULES: ModuleRegistry = {
   },
   gov: {
     description: 'Governance transaction subcommands',
+    handler: routeGovTransaction,
     subcommands: [
       { name: 'vote', description: 'Vote on a proposal' },
       { name: 'weighted-vote', description: 'Weighted vote on a proposal' },
@@ -151,20 +249,40 @@ const TX_MODULES: ModuleRegistry = {
   },
   billing: {
     description: 'Manifest billing transaction subcommands',
+    handler: routeBillingTransaction,
     subcommands: [
       { name: 'fund-credit', description: 'Fund credit for a tenant', args: '<tenant-address> <amount> (e.g., manifest1abc... 1000000umfx)' },
       { name: 'create-lease', description: 'Create a new lease', args: '[--meta-hash <hex>] <sku-uuid:quantity>... (e.g., sku-123:1 sku-456:2)' },
-      { name: 'close-lease', description: 'Close one or more leases', args: '<lease-uuid>... (e.g., lease-123 lease-456)' },
+      { name: 'close-lease', description: 'Close one or more leases', args: '[--reason <text>] <lease-uuid>... (e.g., lease-123 lease-456)' },
       { name: 'withdraw', description: 'Withdraw earnings from leases', args: '<lease-uuid>... OR --provider <provider-uuid> [--limit <1-100>]' },
+      { name: 'create-lease-for-tenant', description: 'Create a lease on behalf of a tenant', args: '<tenant-address> [--meta-hash <hex>] <sku-uuid:quantity>...' },
+      { name: 'acknowledge-lease', description: 'Acknowledge one or more pending leases', args: '<lease-uuid>...' },
+      { name: 'reject-lease', description: 'Reject one or more pending leases', args: '[--reason <text>] <lease-uuid>...' },
+      { name: 'cancel-lease', description: 'Cancel one or more pending leases', args: '<lease-uuid>...' },
+      { name: 'update-params', description: 'Update billing module parameters (governance)', args: '<max-leases-per-tenant> <max-items-per-lease> <min-lease-duration> <max-pending-leases-per-tenant> <pending-timeout> [<allowed-address>...]' },
     ],
   },
   manifest: {
     description: 'Manifest module transaction subcommands',
+    handler: routeManifestTransaction,
     subcommands: [
       { name: 'payout', description: 'Execute a payout to multiple addresses' },
       { name: 'burn-held-balance', description: 'Burn held balance' },
     ],
   },
+  sku: {
+    description: 'Manifest SKU module transaction subcommands',
+    handler: routeSkuTransaction,
+    subcommands: [
+      { name: 'create-provider', description: 'Create a new provider', args: '<address> <payout-address> <api-url> [--meta-hash <hex>]' },
+      { name: 'update-provider', description: 'Update an existing provider', args: '<provider-uuid> <address> <payout-address> <api-url> [--meta-hash <hex>] [--active <true|false>]' },
+      { name: 'deactivate-provider', description: 'Deactivate a provider', args: '<provider-uuid>' },
+      { name: 'create-sku', description: 'Create a new SKU', args: '<provider-uuid> <name> <unit (per-hour|per-day)> <base-price> [--meta-hash <hex>]' },
+      { name: 'update-sku', description: 'Update an existing SKU', args: '<sku-uuid> <provider-uuid> <name> <unit (per-hour|per-day)> <base-price> [--meta-hash <hex>] [--active <true|false>]' },
+      { name: 'deactivate-sku', description: 'Deactivate a SKU', args: '<sku-uuid>' },
+      { name: 'update-params', description: 'Update SKU module parameters (governance)', args: '<allowed-address>...' },
+    ],
+  },
 };
 
 /**
@@ -276,3 +394,35 @@ export function getSupportedModules(): {
 
   return result;
 }
+
+/**
+ * Get the handler function for a query module
+ * @throws ManifestMCPError if module is not found
+ */
+export function getQueryHandler(module: string): QueryHandler {
+  const moduleInfo = QUERY_MODULES[module];
+  if (!moduleInfo) {
+    throw new ManifestMCPError(
+      ManifestMCPErrorCode.UNKNOWN_MODULE,
+      `Unknown query module: ${module}`,
+      { availableModules: Object.keys(QUERY_MODULES) }
+    );
+  }
+  return moduleInfo.handler;
+}
+
+/**
+ * Get the handler function for a transaction module
+ * @throws ManifestMCPError if module is not found
+ */
+export function getTxHandler(module: string): TxHandler {
+  const moduleInfo = TX_MODULES[module];
+  if (!moduleInfo) {
+    throw new ManifestMCPError(
+      ManifestMCPErrorCode.UNKNOWN_MODULE,
+      `Unknown tx module: ${module}`,
+      { availableModules: Object.keys(TX_MODULES) }
+    );
+  }
+  return moduleInfo.handler;
+}