adressed PR remarks

Author: jeroenvervaeke

src/common/session.ts

@@ -15,6 +15,7 @@ import type {
 import type { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { ErrorCodes, MongoDBError } from "./errors.js";
 import type { ExportsManager } from "./exportsManager.js";
+import type { Client } from "@mongodb-js-preview/atlas-local";
 
 export interface SessionOptions {
     apiBaseUrl: string;
@@ -42,6 +43,7 @@ export class Session extends EventEmitter<SessionEvents> {
         version?: string;
         title?: string;
     };
+    atlasLocalClient?: Client;
 
     public logger: CompositeLogger;
 
@@ -93,6 +95,10 @@ export class Session extends EventEmitter<SessionEvents> {
         this.connectionManager.setClientName(this.mcpClient.name || "unknown");
     }
 
+    setAtlasLocalClient(atlasLocalClient: Client): void {
+        this.atlasLocalClient = atlasLocalClient;
+    }
+
     async disconnect(): Promise<void> {
         const atlasCluster = this.connectedAtlasCluster;
 

src/server.ts

@@ -2,7 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { Session } from "./common/session.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { AtlasTools } from "./tools/atlas/tools.js";
-import { BuildAtlasLocalTools } from "./tools/atlasLocal/tools.js";
+import { AtlasLocalTools } from "./tools/atlasLocal/tools.js";
 import { MongoDbTools } from "./tools/mongodb/tools.js";
 import { Resources } from "./resources/resources.js";
 import type { LogLevel } from "./common/logger.js";
@@ -61,8 +61,10 @@ export class Server {
 
         this.mcpServer.server.registerCapabilities({ logging: {}, resources: { listChanged: true, subscribe: true } });
 
+        await this.tryInitializeAtlasLocalClient();
+
         // TODO: Eventually we might want to make tools reactive too instead of relying on custom logic.
-        await this.registerTools();
+        this.registerTools();
 
         // This is a workaround for an issue we've seen with some models, where they'll see that everything in the `arguments`
         // object is optional, and then not pass it at all. However, the MCP server expects the `arguments` object to be if
@@ -193,9 +195,23 @@ export class Server {
         this.telemetry.emitEvents([event]).catch(() => {});
     }
 
-    private async registerTools(): Promise<void> {
-        const atlasLocalTools = await BuildAtlasLocalTools();
-        for (const toolConstructor of [...AtlasTools, ...atlasLocalTools, ...MongoDbTools]) {
+    private async tryInitializeAtlasLocalClient(): Promise<void> {
+        try {
+            const { Client: AtlasLocalClient } = await import("@mongodb-js-preview/atlas-local");
+
+            const client = AtlasLocalClient.connect();
+            this.session.setAtlasLocalClient(client);
+        } catch (error) {
+            console.warn(
+                "Failed to initialize Atlas Local client, atlas-local tools will be disabled (error: ",
+                error,
+                ")"
+            );
+        }
+    }
+
+    private registerTools(): void {
+        for (const toolConstructor of [...AtlasTools, ...AtlasLocalTools, ...MongoDbTools]) {
             const tool = new toolConstructor(this.session, this.userConfig, this.telemetry);
             if (tool.register(this)) {
                 this.tools.push(tool);

src/tools/atlasLocal/atlasLocalTool.ts

@@ -2,17 +2,31 @@ import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type { TelemetryToolMetadata, ToolArgs, ToolCategory } from "../tool.js";
 import { ToolBase } from "../tool.js";
 import type { ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type AtlasLocal from "@mongodb-js-preview/atlas-local";
+import type { Client } from "@mongodb-js-preview/atlas-local";
 
 export abstract class AtlasLocalToolBase extends ToolBase {
     public category: ToolCategory = "atlas-local";
-    // Will be injected by BuildAtlasLocalTools() in atlasLocal/tools.ts
-    public client?: AtlasLocal.Client;
 
     protected verifyAllowed(): boolean {
-        return this.client !== undefined && super.verifyAllowed();
+        return this.session.atlasLocalClient !== undefined && super.verifyAllowed();
     }
 
+    protected async execute(): Promise<CallToolResult> {
+        // Get the client
+        const client = this.session.atlasLocalClient;
+
+        // If the client is not found, throw an error
+        // This should never happen, because the tool should have been disabled.
+        // verifyAllowed in the base class returns false if the client is not found
+        if (!client) {
+            throw new Error("Atlas Local client not found, tool should have been disabled.");
+        }
+
+        return this.executeWithAtlasLocalClient(client);
+    }
+
+    protected abstract executeWithAtlasLocalClient(client: Client): Promise<CallToolResult>;
+
     protected handleError(
         error: unknown,
         args: ToolArgs<typeof this.argsShape>

src/tools/atlasLocal/read/listDeployments.ts

@@ -3,24 +3,15 @@ import { AtlasLocalToolBase } from "../atlasLocalTool.js";
 import type { OperationType } from "../../tool.js";
 import { formatUntrustedData } from "../../tool.js";
 import type { Deployment } from "@mongodb-js-preview/atlas-local";
+import type { Client } from "@mongodb-js-preview/atlas-local";
 
 export class ListDeploymentsTool extends AtlasLocalToolBase {
     public name = "atlas-local-list-deployments";
     protected description = "List MongoDB Atlas local deployments";
     public operationType: OperationType = "read";
     protected argsShape = {};
 
-    protected async execute(): Promise<CallToolResult> {
-        // Get the client
-        const client = this.client;
-
-        // If the client is not found, throw an error
-        // This should never happen, because the tool should have been disabled.
-        // verifyAllowed in the base class returns false if the client is not found
-        if (!client) {
-            throw new Error("Atlas Local client not found, tool should have been disabled.");
-        }
-
+    protected async executeWithAtlasLocalClient(client: Client): Promise<CallToolResult> {
         // List the deployments
         const deployments = await client.listDeployments();
 

src/tools/atlasLocal/tools.ts

@@ -1,33 +1,3 @@
 import { ListDeploymentsTool } from "./read/listDeployments.js";
-import type AtlasLocal from "@mongodb-js-preview/atlas-local";
 
-// Don't use this directly, use BuildAtlasLocalTools instead
-const atlasLocalTools = [ListDeploymentsTool];
-
-// Build the Atlas Local tools
-export const BuildAtlasLocalTools = async (): Promise<typeof atlasLocalTools> => {
-    // Initialize the Atlas Local client
-    const client = await GetAtlasLocalClient();
-
-    // If the client is found, set it on the tools
-    // On unsupported platforms, the client will be undefined
-    if (client) {
-        // Set the client on the tools
-        atlasLocalTools.forEach((tool) => {
-            tool.prototype.client = client;
-        });
-    }
-
-    return atlasLocalTools;
-};
-
-export const GetAtlasLocalClient = async (): Promise<AtlasLocal.Client | undefined> => {
-    try {
-        const { Client: AtlasLocalClient } = await import("@mongodb-js-preview/atlas-local");
-        return AtlasLocalClient.connect();
-    } catch (error) {
-        // We only get here if the user is running atlas-local on a unsupported platform
-        console.warn("Atlas Local native binding not available:", error);
-        return undefined;
-    }
-};
+export const AtlasLocalTools = [ListDeploymentsTool];

tests/integration/tools/atlas-local/listDeployments.test.ts

@@ -9,6 +9,8 @@ import { describe, expect, it } from "vitest";
 
 const isMacOSInGitHubActions = process.platform === "darwin" && process.env.GITHUB_ACTIONS === "true";
 
+// Docker is not available on macOS in GitHub Actions
+// That's why we skip the tests on macOS in GitHub Actions
 describe("atlas-local-list-deployments", () => {
     const integration = setupIntegrationTest(
         () => defaultTestConfig,