Enhance MCP command management and config-manager features

package.json

@@ -95,7 +95,8 @@
     ]
   },
   "devDependencies": {
-    "@rockcarver/frodo-lib": "4.0.0-37",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@rockcarver/frodo-lib": "4.0.0-39",
     "@types/colors": "^1.2.1",
     "@types/fs-extra": "^11.0.1",
     "@types/jest": "^29.2.3",
@@ -138,6 +139,7 @@
     "tsup": "^8.1.0",
     "typescript": "^5.2.2",
     "uuid": "^11.1.0",
-    "yesno": "^0.4.0"
+    "yesno": "^0.4.0",
+    "zod": "^4.3.6"
   }
 }

src/app.ts

@@ -26,6 +26,7 @@ import info from './cli/info/info';
 import journey from './cli/journey/journey';
 import log from './cli/log/log';
 import mapping from './cli/mapping/mapping';
+import mcp from './cli/mcp/mcp';
 import node from './cli/node/node';
 import oauth from './cli/oauth/oauth';
 import promote from './cli/promote/promote';
@@ -93,6 +94,7 @@ process.argv = normalizeExpandedHelpArgv(process.argv);
     program.addCommand(journey());
     program.addCommand(log());
     program.addCommand(mapping());
+    program.addCommand(mcp().helpGroup(utilitiesCommandsHeading));
     program.addCommand(node());
     program.addCommand(oauth());
     program.addCommand(promote());

src/cli/mcp/mcp.ts

@@ -0,0 +1,15 @@
+import { FrodoStubCommand } from '../FrodoCommand';
+import mcpServer from './server/server.js';
+
+/**
+ * Top-level MCP command group.
+ */
+export default function setup() {
+  const program = new FrodoStubCommand('mcp')
+    .description('Manage Model Context Protocol (MCP) integrations.')
+    .withStability('experimental');
+
+  program.addCommand(mcpServer());
+
+  return program;
+}

src/cli/mcp/server/server-start.ts

@@ -0,0 +1,190 @@
+import { createMcpService, frodo, state } from '@rockcarver/frodo-lib';
+import { Option } from 'commander';
+
+import {
+  startHttpTransport,
+  startStdioTransport,
+} from '../../../ops/McpServerOps.js';
+import { printMessage } from '../../../utils/Console';
+import { FrodoCommand } from '../../FrodoCommand';
+
+type McpPolicyPreset = 'read-only' | 'standard' | 'admin';
+
+/** Parsed options for `frodo mcp server start`. */
+type McpStartOptions = {
+  /** Policy preset controlling capability exposure. */
+  policy: McpPolicyPreset;
+  /** Optional allow-list of top-level capability domains. */
+  includeDomains?: string[];
+  /** Optional deny-list of top-level capability domains. */
+  excludeDomains?: string[];
+  /** Whether to include the `utils` top-level domain. */
+  includeUtils?: boolean;
+  /** Transport mode to launch. */
+  transport?: 'stdio' | 'http';
+  /** Bind host for HTTP transport. */
+  bindHost?: string;
+  /** Bind port for HTTP transport. */
+  port?: string;
+  /** Build and validate service composition without launching transport. */
+  dryRun?: boolean;
+  /** Print startup summary as JSON. */
+  json?: boolean;
+};
+
+/**
+ * MCP server start command.
+ */
+export default function setup() {
+  const program = new FrodoCommand('frodo mcp server start', [])
+    .description('Start an MCP server session from frodo-lib capabilities.')
+    .withStability('experimental')
+    .addOption(
+      new Option('--policy <preset>', 'Capability policy preset.')
+        .choices(['read-only', 'standard', 'admin'])
+        .default('standard')
+    )
+    .addOption(
+      new Option(
+        '--include-domains <domain...>',
+        'Only include the listed top-level domains in capability discovery.'
+      )
+    )
+    .addOption(
+      new Option(
+        '--exclude-domains <domain...>',
+        'Exclude listed top-level domains from capability discovery.'
+      )
+    )
+    .addOption(
+      new Option(
+        '--include-utils',
+        'Include the utils domain in discovery.'
+      ).default(false)
+    )
+    .addOption(
+      new Option('--transport <transport>', 'Server transport mode.')
+        .choices(['stdio', 'http'])
+        .default('stdio')
+    )
+    .addOption(
+      new Option('--bind-host <host>', 'Bind host for HTTP transport.').default(
+        '127.0.0.1'
+      )
+    )
+    .addOption(
+      new Option('--port <port>', 'Bind port for HTTP transport.').default(
+        '6277'
+      )
+    )
+    .addOption(
+      new Option(
+        '--dry-run',
+        'Build and validate MCP service composition, then exit.'
+      ).default(false)
+    )
+    .addOption(
+      new Option('--json', 'Print startup summary as JSON.').default(false)
+    )
+    .action(async (host, realm, username, password, options, command) => {
+      command.handleDefaultArgsAndOpts(
+        host,
+        realm,
+        username,
+        password,
+        options,
+        command
+      );
+
+      const opts = options as McpStartOptions;
+      const service = createMcpService({
+        policyPreset: opts.policy,
+        inventoryOptions: {
+          includeTopLevelDomains: opts.includeDomains,
+          excludeTopLevelDomains: opts.excludeDomains,
+          includeUtils: !!opts.includeUtils,
+        },
+        // Reuse the preconfigured frodo singleton; the CLI has already
+        // applied connection credentials via handleDefaultArgsAndOpts.
+        runtimeOptions: {
+          resolveFrodoForRequest: async () => frodo,
+        },
+      });
+
+      const startupSummary = {
+        policy: service.policy.name,
+        transport: opts.transport,
+        http: {
+          bindHost: opts.bindHost,
+          port: Number(opts.port),
+        },
+        authMode: inferAuthModeFromState(),
+        toolCounts: {
+          total: service.manifest.totalToolCount,
+          generic: service.manifest.genericTools.length,
+          special: service.manifest.specialTools.length,
+        },
+        descriptorCount: service.manifest.backingDescriptorCount,
+      };
+
+      if (opts.json) {
+        printMessage(JSON.stringify(startupSummary, null, 2), 'data');
+      } else {
+        printMessage('MCP server startup summary:', 'info');
+        printMessage(`  Policy: ${startupSummary.policy}`);
+        printMessage(`  Transport: ${startupSummary.transport}`);
+        printMessage(`  Auth mode: ${startupSummary.authMode}`);
+        printMessage(
+          `  Tools: ${startupSummary.toolCounts.total} total (${startupSummary.toolCounts.generic} generic, ${startupSummary.toolCounts.special} special)`
+        );
+        printMessage(
+          `  Backing descriptors: ${startupSummary.descriptorCount}`
+        );
+        if (opts.transport === 'http') {
+          printMessage(
+            `  HTTP endpoint (planned): http://${startupSummary.http.bindHost}:${startupSummary.http.port}/mcp`
+          );
+        }
+      }
+
+      if (opts.dryRun) {
+        printMessage('Dry run completed successfully.', 'info');
+        return;
+      }
+
+      const transport = opts.transport ?? 'stdio';
+      if (transport === 'stdio') {
+        await startStdioTransport(service);
+      } else {
+        await startHttpTransport(
+          service,
+          opts.bindHost ?? '127.0.0.1',
+          Number(opts.port ?? '6277')
+        );
+      }
+    });
+
+  return program;
+}
+
+/**
+ * Infers runtime auth mode from currently configured global state.
+ */
+function inferAuthModeFromState():
+  | 'service-account'
+  | 'admin-account'
+  | 'state-config' {
+  const serviceAccountId = state.getServiceAccountId();
+  const serviceAccountJwk = state.getServiceAccountJwk();
+  if (serviceAccountId && serviceAccountJwk) {
+    return 'service-account';
+  }
+
+  const username = state.getUsername();
+  const password = state.getPassword();
+  if (username && password) {
+    return 'admin-account';
+  }
+
+  return 'state-config';
+}

src/cli/mcp/server/server-tools.ts

@@ -0,0 +1,100 @@
+import { createMcpService } from '@rockcarver/frodo-lib';
+import { Option } from 'commander';
+
+import { printMessage } from '../../../utils/Console';
+import { FrodoCommand } from '../../FrodoCommand';
+
+type McpPolicyPreset = 'read-only' | 'standard' | 'admin';
+
+/** Parsed options for `frodo mcp server tools`. */
+type McpToolsOptions = {
+  /** Policy preset controlling capability exposure. */
+  policy: McpPolicyPreset;
+  /** Optional allow-list of top-level capability domains. */
+  includeDomains?: string[];
+  /** Optional deny-list of top-level capability domains. */
+  excludeDomains?: string[];
+  /** Whether to include the `utils` top-level domain. */
+  includeUtils?: boolean;
+  /** Print tool definitions as JSON. */
+  json?: boolean;
+};
+
+/**
+ * Lists the current MCP tool surface derived from frodo-lib descriptors.
+ */
+export default function setup() {
+  const program = new FrodoCommand('frodo mcp server tools', ['realm'])
+    .description('List MCP tools exposed under the current policy/profile.')
+    .withStability('experimental')
+    .addOption(
+      new Option('--policy <preset>', 'Capability policy preset.')
+        .choices(['read-only', 'standard', 'admin'])
+        .default('standard')
+    )
+    .addOption(
+      new Option(
+        '--include-domains <domain...>',
+        'Only include the listed top-level domains in capability discovery.'
+      )
+    )
+    .addOption(
+      new Option(
+        '--exclude-domains <domain...>',
+        'Exclude listed top-level domains from capability discovery.'
+      )
+    )
+    .addOption(
+      new Option(
+        '--include-utils',
+        'Include the utils domain in discovery.'
+      ).default(false)
+    )
+    .addOption(new Option('--json', 'Print tool list as JSON.').default(false))
+    .action(async (host, username, password, options, command) => {
+      command.handleDefaultArgsAndOpts(
+        host,
+        username,
+        password,
+        options,
+        command
+      );
+
+      const opts = options as McpToolsOptions;
+      const service = createMcpService({
+        policyPreset: opts.policy,
+        inventoryOptions: {
+          includeTopLevelDomains: opts.includeDomains,
+          excludeTopLevelDomains: opts.excludeDomains,
+          includeUtils: !!opts.includeUtils,
+        },
+      });
+
+      const tools = service.listTools();
+      if (opts.json) {
+        printMessage(
+          JSON.stringify(
+            {
+              policy: service.policy.name,
+              total: tools.length,
+              tools,
+            },
+            null,
+            2
+          ),
+          'data'
+        );
+        return;
+      }
+
+      printMessage(
+        `MCP tools (${tools.length}) for policy '${service.policy.name}':`,
+        'info'
+      );
+      for (const tool of tools) {
+        printMessage(`- ${tool.name}: ${tool.description}`);
+      }
+    });
+
+  return program;
+}

src/cli/mcp/server/server.ts

@@ -0,0 +1,17 @@
+import { FrodoStubCommand } from '../../FrodoCommand';
+import startCmd from './server-start.js';
+import toolsCmd from './server-tools.js';
+
+/**
+ * MCP server command group.
+ */
+export default function setup() {
+  const program = new FrodoStubCommand('server')
+    .description('Manage Frodo MCP server lifecycle and metadata.')
+    .withStability('experimental');
+
+  program.addCommand(startCmd().name('start'));
+  program.addCommand(toolsCmd().name('tools'));
+
+  return program;
+}