19928292758

Committed 04 Dec 2025 12:03PM UTC coverage: 80.172% (-0.4%) from 80.581%

Build # 19928292758

Build Type

Pull #777

github

Committed by

web-flow

Commit Message

Merge 305c35330 into 18ff7cc01

Pull Request Pull Request #777: chore: adopt strict validation for all command line arguments MCP-298

Run Details

1451 of 1892 branches covered (76.69%)

Branch coverage included in aggregate %.

82 of 121 new or added lines in 8 files covered. (67.77%)

18 existing lines in 2 files now uncovered.

6640 of 8200 relevant lines covered (80.98%)

79.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.6

/src/index.ts

#!/usr/bin/env node

function enableFipsIfRequested(): void {
    let fipsError: Error | undefined;
    const tlsFIPSMode = process.argv.includes("--tlsFIPSMode");

    if (tlsFIPSMode) {
        try {
            // eslint-disable-next-line
            require("crypto").setFips(1);
        } catch (err: unknown) {
            fipsError ??= err as Error;
        }
    }

    if (tlsFIPSMode) {
        if (!fipsError && !crypto.getFips()) {
            fipsError = new Error("FIPS mode not enabled despite requested due to unknown error.");
        }
    }

    if (fipsError) {
        if (process.config.variables.node_shared_openssl) {
            console.error(
                "Could not enable FIPS mode. Please ensure that your system OpenSSL installation supports FIPS."
            );
        } else {
            console.error("Could not enable FIPS mode. This installation does not appear to support FIPS.");
        }
        console.error("Error details:");
        console.error(fipsError);
        process.exit(1);
    }
}

enableFipsIfRequested();

import crypto from "crypto";
import { ConsoleLogger, LogId } from "./common/logger.js";
import { createUserConfig } from "./common/config/createUserConfig.js";
import { type UserConfig } from "./common/config/userConfig.js";
import { packageInfo } from "./common/packageInfo.js";
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 { DryRunModeRunner } from "./transports/dryModeRunner.js";

async function main(): Promise<void> {
    systemCA().catch(() => undefined); // load system CA asynchronously as in mongosh

    const {
        error,
        warnings,
        parsed: config,
    } = createUserConfig({
        args: process.argv.slice(2),
    });

    if (!config || (error && error.length)) {
        console.error(`${error}
- Refer to https://www.mongodb.com/docs/mcp-server/get-started/ for setting up the MCP Server.`);
        process.exit(1);
    }

    if (warnings && warnings.length) {
        console.warn(`${warnings.join("\n")}
- Refer to https://www.mongodb.com/docs/mcp-server/get-started/ for setting up the MCP Server.`);
    }

    if (config.help) {
        handleHelpRequest();
    }

    if (config.version) {
        handleVersionRequest();
    }

    if (config.dryRun) {
        await handleDryRunRequest(config);
    }

    const transportRunner =
        config.transport === "stdio"
            ? new StdioRunner({
                  userConfig: config,
              })
            : new StreamableHttpRunner({
                  userConfig: config,
              });
    const shutdown = (): void => {
        transportRunner.logger.info({
            id: LogId.serverCloseRequested,
            context: "server",
            message: `Server close requested`,
        });

        transportRunner
            .close()
            .then(() => {
                transportRunner.logger.info({
                    id: LogId.serverClosed,
                    context: "server",
                    message: `Server closed`,
                });
                process.exit(0);
            })
            .catch((error: unknown) => {
                transportRunner.logger.error({
                    id: LogId.serverCloseFailure,
                    context: "server",
                    message: `Error closing server: ${error as string}`,
                });
                process.exit(1);
            });
    };

    process.on("SIGINT", shutdown);
    process.on("SIGABRT", shutdown);
    process.on("SIGTERM", shutdown);
    process.on("SIGQUIT", shutdown);

    try {
        await transportRunner.start();
    } catch (error: unknown) {
        transportRunner.logger.info({
            id: LogId.serverCloseRequested,
            context: "server",
            message: `Closing server due to error: ${error as string}`,
            noRedaction: true,
        });

        try {
            await transportRunner.close();
            transportRunner.logger.info({
                id: LogId.serverClosed,
                context: "server",
                message: "Server closed",
            });
        } catch (error: unknown) {
            transportRunner.logger.error({
                id: LogId.serverCloseFailure,
                context: "server",
                message: `Error closing server: ${error as string}`,
            });
        }
        throw error;
    }
}

main().catch((error: unknown) => {
    // At this point, we may be in a very broken state, so we can't rely on the logger
    // being functional. Instead, create a brand new ConsoleLogger and log the error
    // to the console.
    const logger = new ConsoleLogger(Keychain.root);
    logger.emergency({
        id: LogId.serverStartFailure,
        context: "server",
        message: `Fatal error running server: ${error as string}`,
    });
    process.exit(1);
});

function handleHelpRequest(): never {
    console.log("For usage information refer to the README.md:");
    console.log("https://github.com/mongodb-js/mongodb-mcp-server?tab=readme-ov-file#quick-start");
    process.exit(0);
}

function handleVersionRequest(): never {
    console.log(packageInfo.version);
    process.exit(0);
}

export async function handleDryRunRequest(config: UserConfig): Promise<never> {
    try {
        const runner = new DryRunModeRunner({
            userConfig: config,
            logger: {
                log(message): void {
                    console.log(message);
                },
                error(message): void {
                    console.error(message);
                },
            },
        });
        await runner.start();
        await runner.close();
        process.exit(0);
    } catch (error) {
        console.error(`Fatal error running server in dry run mode: ${error as string}`);
        process.exit(1);
    }
}

1	#!/usr/bin/env node	3✔
2
3	function enableFipsIfRequested(): void {	×
4	let fipsError: Error \| undefined;	×
5	const tlsFIPSMode = process.argv.includes("--tlsFIPSMode");	×
6
7	if (tlsFIPSMode) {	×
8	try {	×
9	// eslint-disable-next-line
10	require("crypto").setFips(1);	×
11	} catch (err: unknown) {	×
12	fipsError ??= err as Error;	×
13	}	×
14	}	×
15
16	if (tlsFIPSMode) {	×
17	if (!fipsError && !crypto.getFips()) {	×
18	fipsError = new Error("FIPS mode not enabled despite requested due to unknown error.");	×
19	}	×
20	}	×
21
22	if (fipsError) {	×
23	if (process.config.variables.node_shared_openssl) {	×
24	console.error(	×
25	"Could not enable FIPS mode. Please ensure that your system OpenSSL installation supports FIPS."	×
26	);	×
27	} else {	×
28	console.error("Could not enable FIPS mode. This installation does not appear to support FIPS.");	×
29	}	×
30	console.error("Error details:");	×
31	console.error(fipsError);	×
32	process.exit(1);	×
33	}	×
34	}	×
35
36	enableFipsIfRequested();	×
37
38	import crypto from "crypto";	×
39	import { ConsoleLogger, LogId } from "./common/logger.js";	×
40	import { createUserConfig } from "./common/config/createUserConfig.js";	×
41	import { type UserConfig } from "./common/config/userConfig.js";
42	import { packageInfo } from "./common/packageInfo.js";	×
43	import { StdioRunner } from "./transports/stdio.js";	×
44	import { StreamableHttpRunner } from "./transports/streamableHttp.js";	×
45	import { systemCA } from "@mongodb-js/devtools-proxy-support";	×
46	import { Keychain } from "./common/keychain.js";	×
47	import { DryRunModeRunner } from "./transports/dryModeRunner.js";	×
48
49	async function main(): Promise<void> {	×
50	systemCA().catch(() => undefined); // load system CA asynchronously as in mongosh	×
51
NEW 52	const {	×
NEW 53	error,	×
NEW 54	warnings,	×
NEW 55	parsed: config,	×
NEW 56	} = createUserConfig({	×
NEW 57	args: process.argv.slice(2),	×
NEW 58	});	×
59
NEW 60	if (!config \|\| (error && error.length)) {	×
NEW 61	console.error(`${error}	×
NEW 62	- Refer to https://www.mongodb.com/docs/mcp-server/get-started/ for setting up the MCP Server.`);	×
NEW 63	process.exit(1);	×
NEW 64	}	×
65
NEW 66	if (warnings && warnings.length) {	×
NEW 67	console.warn(`${warnings.join("\n")}	×
NEW 68	- Refer to https://www.mongodb.com/docs/mcp-server/get-started/ for setting up the MCP Server.`);	×
NEW 69	}	×
70
71	if (config.help) {	×
72	handleHelpRequest();	×
73	}	×
74
75	if (config.version) {	×
76	handleVersionRequest();	×
77	}	×
78
79	if (config.dryRun) {	×
80	await handleDryRunRequest(config);	×
81	}	×
82
83	const transportRunner =	×
84	config.transport === "stdio"	×
85	? new StdioRunner({	×
86	userConfig: config,	×
87	})	×
88	: new StreamableHttpRunner({	×
89	userConfig: config,	×
90	});	×
91	const shutdown = (): void => {	×
92	transportRunner.logger.info({	×
93	id: LogId.serverCloseRequested,	×
94	context: "server",	×
95	message: `Server close requested`,	×
96	});	×
97
98	transportRunner	×
99	.close()	×
100	.then(() => {	×
101	transportRunner.logger.info({	×
102	id: LogId.serverClosed,	×
103	context: "server",	×
104	message: `Server closed`,	×
105	});	×
106	process.exit(0);	×
107	})	×
108	.catch((error: unknown) => {	×
109	transportRunner.logger.error({	×
110	id: LogId.serverCloseFailure,	×
111	context: "server",	×
112	message: `Error closing server: ${error as string}`,	×
113	});	×
114	process.exit(1);	×
115	});	×
116	};	×
117
118	process.on("SIGINT", shutdown);	×
119	process.on("SIGABRT", shutdown);	×
120	process.on("SIGTERM", shutdown);	×
121	process.on("SIGQUIT", shutdown);	×
122
123	try {	×
124	await transportRunner.start();	×
125	} catch (error: unknown) {	×
126	transportRunner.logger.info({	×
127	id: LogId.serverCloseRequested,	×
128	context: "server",	×
129	message: `Closing server due to error: ${error as string}`,	×
130	noRedaction: true,	×
131	});	×
132
133	try {	×
134	await transportRunner.close();	×
135	transportRunner.logger.info({	×
136	id: LogId.serverClosed,	×
137	context: "server",	×
138	message: "Server closed",	×
139	});	×
140	} catch (error: unknown) {	×
141	transportRunner.logger.error({	×
142	id: LogId.serverCloseFailure,	×
143	context: "server",	×
144	message: `Error closing server: ${error as string}`,	×
145	});	×
146	}	×
147	throw error;	×
148	}	×
149	}	×
150
151	main().catch((error: unknown) => {	×
152	// At this point, we may be in a very broken state, so we can't rely on the logger
153	// being functional. Instead, create a brand new ConsoleLogger and log the error
154	// to the console.
155	const logger = new ConsoleLogger(Keychain.root);	×
156	logger.emergency({	×
157	id: LogId.serverStartFailure,	×
158	context: "server",	×
159	message: `Fatal error running server: ${error as string}`,	×
160	});	×
161	process.exit(1);	×
162	});	×
163
164	function handleHelpRequest(): never {	×
165	console.log("For usage information refer to the README.md:");	×
166	console.log("https://github.com/mongodb-js/mongodb-mcp-server?tab=readme-ov-file#quick-start");	×
167	process.exit(0);	×
168	}	×
169
170	function handleVersionRequest(): never {	×
171	console.log(packageInfo.version);	×
172	process.exit(0);	×
173	}	×
174
175	export async function handleDryRunRequest(config: UserConfig): Promise<never> {	×
176	try {	×
177	const runner = new DryRunModeRunner({	×
178	userConfig: config,	×
179	logger: {	×
180	log(message): void {	×
181	console.log(message);	×
182	},	×
183	error(message): void {	×
184	console.error(message);	×
185	},	×
186	},	×
187	});	×
188	await runner.start();	×
189	await runner.close();	×
190	process.exit(0);	×
191	} catch (error) {	×
192	console.error(`Fatal error running server in dry run mode: ${error as string}`);	×
193	process.exit(1);	×
194	}	×
195	}	×

mongodb-js / mongodb-mcp-server / 19928292758

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous