feat: introduces dry mode for CLI

Author: himanshusinghs

src/common/config/argsParserOptions.ts

@@ -60,6 +60,7 @@ export const OPTIONS = {
         "apiDeprecationErrors",
         "apiStrict",
         "disableEmbeddingsValidation",
+        "dry",
         "help",
         "indexCheck",
         "ipv6",

src/common/config/userConfig.ts

@@ -167,4 +167,10 @@ export const UserConfigSchema = z4.object({
         )
         .default([])
         .describe("An array of preview features that are enabled."),
+    dry: z4
+        .boolean()
+        .default(false)
+        .describe(
+            "When true, runs the server in dry mode: dumps configuration and enabled tools, then exits without starting the server."
+        ),
 });

src/index.ts

@@ -44,13 +44,15 @@ import { StdioRunner } from "./transports/stdio.js";
 import { StreamableHttpRunner } from "./transports/streamableHttp.js";
 import { systemCA } from "@mongodb-js/devtools-proxy-support";
 import { Keychain } from "./common/keychain.js";
+import { DryModeRunner } from "./transports/dryModeRunner.js";
 
 async function main(): Promise<void> {
     systemCA().catch(() => undefined); // load system CA asynchronously as in mongosh
 
     const config = createUserConfig();
     assertHelpMode(config);
     assertVersionMode(config);
+    await DryModeRunner.assertDryMode({ userConfig: config });
 
     const transportRunner =
         config.transport === "stdio"

src/transports/dryModeRunner.ts

@@ -0,0 +1,79 @@
+import { InMemoryTransport } from "./inMemoryTransport.js";
+import { TransportRunnerBase, type TransportRunnerConfig } from "./base.js";
+import { type Server } from "../server.js";
+
+export type DryModeTestHelpers = {
+    exit(this: void, exitCode: number): never;
+    logger: {
+        log(this: void, message: string): void;
+        error(this: void, message: string): void;
+    };
+};
+
+type DryModeRunnerConfig = TransportRunnerConfig & DryModeTestHelpers;
+
+const defaultLogger: DryModeTestHelpers["logger"] = {
+    log(message) {
+        console.warn(message);
+    },
+    error(message) {
+        console.error(message);
+    },
+};
+
+export class DryModeRunner extends TransportRunnerBase {
+    private server: Server | undefined;
+    private exitProcess: DryModeTestHelpers["exit"];
+    private consoleLogger: DryModeTestHelpers["logger"];
+
+    constructor({ exit, logger, ...transportRunnerConfig }: DryModeRunnerConfig) {
+        super(transportRunnerConfig);
+        this.exitProcess = exit;
+        this.consoleLogger = logger;
+    }
+
+    async start(): Promise<void> {
+        try {
+            this.server = await this.setupServer();
+            const transport = new InMemoryTransport();
+
+            await this.server.connect(transport);
+        } catch (error: unknown) {
+            this.consoleLogger.error(`Fatal error running server: ${error as string}`);
+            this.exitProcess(1);
+        }
+    }
+
+    async closeTransport(): Promise<void> {
+        await this.server?.close();
+    }
+
+    private dumpConfig(): void {
+        this.consoleLogger.log("Configuration:");
+        this.consoleLogger.log(JSON.stringify(this.userConfig, null, 2));
+    }
+
+    private dumpTools(): void {
+        const tools = this.server?.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            category: tool.category,
+        }));
+        this.consoleLogger.log("Enabled tools:");
+        this.consoleLogger.log(JSON.stringify(tools, null, 2));
+    }
+
+    static async assertDryMode(
+        runnerConfig: TransportRunnerConfig,
+        exit: DryModeTestHelpers["exit"] = (exitCode: number) => process.exit(exitCode),
+        logger: DryModeTestHelpers["logger"] = defaultLogger
+    ): Promise<void> | never {
+        if (runnerConfig.userConfig.dry) {
+            const runner = new this({ ...runnerConfig, exit, logger });
+            await runner.start();
+            runner.dumpConfig();
+            runner.dumpTools();
+            exit(0);
+        }
+    }
+}

tests/integration/inMemoryTransport.ts renamed to src/transports/inMemoryTransport.ts

@@ -5,7 +5,7 @@ import { Server, type ServerOptions } from "../../src/server.js";
 import { Telemetry } from "../../src/telemetry/telemetry.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "./inMemoryTransport.js";
+import { InMemoryTransport } from "../../src/transports/inMemoryTransport.js";
 import { type UserConfig } from "../../src/common/config/userConfig.js";
 import { ResourceUpdatedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";

tests/integration/helpers.ts

@@ -10,7 +10,7 @@ import { Session } from "../../../../src/common/session.js";
 import { CompositeLogger } from "../../../../src/common/logger.js";
 import { DeviceId } from "../../../../src/helpers/deviceId.js";
 import { ExportsManager } from "../../../../src/common/exportsManager.js";
-import { InMemoryTransport } from "../../inMemoryTransport.js";
+import { InMemoryTransport } from "../../../../src/transports/inMemoryTransport.js";
 import { Telemetry } from "../../../../src/telemetry/telemetry.js";
 import { Server } from "../../../../src/server.js";
 import { type ConnectionErrorHandler, connectionErrorHandler } from "../../../../src/common/connectionErrorHandler.js";

tests/integration/tools/mongodb/mongodbTool.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { DryModeRunner, type DryModeTestHelpers } from "../../../src/transports/dryModeRunner.js";
+import { type UserConfig } from "../../../src/common/config/userConfig.js";
+import { type TransportRunnerConfig } from "../../../src/transports/base.js";
+import { defaultTestConfig } from "../../integration/helpers.js";
+
+describe("DryModeRunner", () => {
+    let exitMock: DryModeTestHelpers["exit"];
+    let loggerMock: DryModeTestHelpers["logger"];
+    let runnerConfig: TransportRunnerConfig;
+
+    beforeEach(() => {
+        exitMock = vi.fn<DryModeTestHelpers["exit"]>();
+        loggerMock = {
+            log: vi.fn(),
+            error: vi.fn(),
+        };
+        runnerConfig = {
+            userConfig: defaultTestConfig,
+        } as TransportRunnerConfig;
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should not do anything if dry mode is disabled", async () => {
+        await DryModeRunner.assertDryMode(runnerConfig, exitMock, loggerMock);
+        expect(exitMock).not.toHaveBeenCalled();
+        expect(loggerMock.log).not.toHaveBeenCalled();
+    });
+
+    it.each([{ transport: "http", httpHost: "127.0.0.1", httpPort: "3001" }, { transport: "stdio" }] as Array<
+        Partial<UserConfig>
+    >)("should run in dry mode if enabled for transport - $transport", async (partialConfig) => {
+        runnerConfig.userConfig = {
+            ...runnerConfig.userConfig,
+            ...partialConfig,
+            dry: true,
+        };
+        await DryModeRunner.assertDryMode(runnerConfig, exitMock, loggerMock);
+        expect(exitMock).toHaveBeenCalledWith(0);
+        expect(loggerMock.log).toHaveBeenNthCalledWith(1, "Configuration:");
+        expect(loggerMock.log).toHaveBeenNthCalledWith(2, JSON.stringify(runnerConfig.userConfig, null, 2));
+        expect(loggerMock.log).toHaveBeenNthCalledWith(3, "Enabled tools:");
+        expect(loggerMock.log).toHaveBeenNthCalledWith(4, expect.stringContaining('"name": "connect"'));
+    });
+});