chore: add type check for CI

.vscode/launch.json

@@ -10,7 +10,7 @@
       "name": "Launch Program",
       "skipFiles": ["<node_internals>/**"],
       "program": "${workspaceFolder}/dist/index.js",
-      "preLaunchTask": "tsc: build - tsconfig.json",
+      "preLaunchTask": "tsc: build - tsconfig.build.json",
       "outFiles": ["${workspaceFolder}/dist/**/*.js"]
     }
   ]

eslint.config.js

@@ -29,7 +29,7 @@ export default defineConfig([
         files,
         languageOptions: {
             parserOptions: {
-                project: "./tsconfig.lint.json",
+                project: "./tsconfig.json",
                 tsconfigRootDir: import.meta.dirname,
             },
         },

package.json

@@ -18,14 +18,15 @@
   "scripts": {
     "prepare": "npm run build",
     "build:clean": "rm -rf dist",
-    "build:compile": "tsc",
+    "build:compile": "tsc --project tsconfig.build.json",
     "build:chmod": "chmod +x dist/index.js",
     "build": "npm run build:clean && npm run build:compile && npm run build:chmod",
     "inspect": "npm run build && mcp-inspector -- dist/index.js",
     "prettier": "prettier",
-    "check": "npm run build && npm run check:lint && npm run check:format",
+    "check": "npm run build && npm run check:types && npm run check:lint && npm run check:format",
     "check:lint": "eslint .",
     "check:format": "prettier -c .",
+    "check:types": "tsc --noEmit --project tsconfig.json",
     "reformat": "prettier --write .",
     "generate": "./scripts/generate.sh",
     "test": "jest --coverage"

scripts/apply.ts

@@ -44,6 +44,7 @@ async function main() {
     const openapi = JSON.parse(specFile) as OpenAPIV3_1.Document;
     for (const path in openapi.paths) {
         for (const method in openapi.paths[path]) {
+            // @ts-expect-error This is a workaround for the OpenAPI types
             const operation = openapi.paths[path][method] as OpenAPIV3_1.OperationObject;
 
             if (!operation.operationId || !operation.tags?.length) {

scripts/filter.ts

@@ -43,11 +43,14 @@ function filterOpenapi(openapi: OpenAPIV3_1.Document): OpenAPIV3_1.Document {
     for (const path in openapi.paths) {
         const filteredMethods = {} as OpenAPIV3_1.PathItemObject;
         for (const method in openapi.paths[path]) {
+            // @ts-expect-error This is a workaround for the OpenAPI types
             if (allowedOperations.includes((openapi.paths[path][method] as { operationId: string }).operationId)) {
+                // @ts-expect-error This is a workaround for the OpenAPI types
                 filteredMethods[method] = openapi.paths[path][method] as OpenAPIV3_1.OperationObject;
             }
         }
         if (Object.keys(filteredMethods).length > 0) {
+            // @ts-expect-error This is a workaround for the OpenAPI types
             filteredPaths[path] = filteredMethods;
         }
     }

src/common/atlas/apiClient.ts

@@ -3,7 +3,7 @@ import type { FetchOptions } from "openapi-fetch";
 import { AccessToken, ClientCredentials } from "simple-oauth2";
 import { ApiClientError } from "./apiClientError.js";
 import { paths, operations } from "./openapi.js";
-import { BaseEvent } from "../../telemetry/types.js";
+import { CommonProperties, TelemetryEvent } from "../../telemetry/types.js";
 import { packageInfo } from "../../packageInfo.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
@@ -123,7 +123,7 @@ export class ApiClient {
         }>;
     }
 
-    async sendEvents(events: BaseEvent[]): Promise<void> {
+    async sendEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void> {
         let endpoint = "api/private/unauth/telemetry/events";
         const headers: Record<string, string> = {
             Accept: "application/json",

src/server.ts

@@ -107,7 +107,6 @@ export class Server {
             timestamp: new Date().toISOString(),
             source: "mdbmcp",
             properties: {
-                ...this.telemetry.getCommonProperties(),
                 result: "success",
                 duration_ms: commandDuration,
                 component: "server",
@@ -119,7 +118,7 @@ export class Server {
         if (command === "start") {
             event.properties.startup_time_ms = commandDuration;
             event.properties.read_only_mode = this.userConfig.readOnly || false;
-            event.properties.disallowed_tools = this.userConfig.disabledTools || [];
+            event.properties.disabled_tools = this.userConfig.disabledTools || [];
         }
         if (command === "stop") {
             event.properties.runtime_duration_ms = Date.now() - this.startTime;

src/telemetry/eventCache.ts

@@ -13,7 +13,7 @@ export class EventCache {
     private cache: LRUCache<number, BaseEvent>;
     private nextId = 0;
 
-    private constructor() {
+    constructor() {
         this.cache = new LRUCache({
             max: EventCache.MAX_EVENTS,
             // Using FIFO eviction strategy for events

src/telemetry/telemetry.ts

@@ -113,7 +113,12 @@ export class Telemetry {
      */
     private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<EventResult> {
         try {
-            await client.sendEvents(events);
+            await client.sendEvents(
+                events.map((event) => ({
+                    ...event,
+                    properties: { ...this.getCommonProperties(), ...event.properties },
+                }))
+            );
             return { success: true };
         } catch (error) {
             return {

src/telemetry/types.ts

@@ -8,49 +8,46 @@ export type TelemetryBoolSet = "true" | "false";
 /**
  * Base interface for all events
  */
-export interface Event {
+export type TelemetryEvent<T> = {
     timestamp: string;
     source: "mdbmcp";
-    properties: Record<string, unknown>;
-}
-
-export interface BaseEvent extends Event {
-    properties: CommonProperties & {
+    properties: T & {
         component: string;
         duration_ms: number;
         result: TelemetryResult;
         category: string;
-    } & Event["properties"];
-}
+    };
+};
+
+export type BaseEvent = TelemetryEvent<unknown>;
 
 /**
  * Interface for tool events
  */
-export interface ToolEvent extends BaseEvent {
-    properties: {
-        command: string;
-        error_code?: string;
-        error_type?: string;
-        project_id?: string;
-        org_id?: string;
-        cluster_name?: string;
-        is_atlas?: boolean;
-    } & BaseEvent["properties"];
-}
+export type ToolEventProperties = {
+    command: string;
+    error_code?: string;
+    error_type?: string;
+    project_id?: string;
+    org_id?: string;
+    cluster_name?: string;
+    is_atlas?: boolean;
+};
 
+export type ToolEvent = TelemetryEvent<ToolEventProperties>;
 /**
  * Interface for server events
  */
-export interface ServerEvent extends BaseEvent {
-    properties: {
-        command: ServerCommand;
-        reason?: string;
-        startup_time_ms?: number;
-        runtime_duration_ms?: number;
-        read_only_mode?: boolean;
-        disabled_tools?: string[];
-    } & BaseEvent["properties"];
-}
+export type ServerEventProperties = {
+    command: ServerCommand;
+    reason?: string;
+    startup_time_ms?: number;
+    runtime_duration_ms?: number;
+    read_only_mode?: boolean;
+    disabled_tools?: string[];
+};
+
+export type ServerEvent = TelemetryEvent<ServerEventProperties>;
 
 /**
  * Interface for static properties, they can be fetched once and reused.
@@ -69,6 +66,7 @@ export type CommonStaticProperties = {
  * Common properties for all events that might change.
  */
 export type CommonProperties = {
+    device_id?: string;
     mcp_client_version?: string;
     mcp_client_name?: string;
     config_atlas_auth?: TelemetryBoolSet;

src/tools/tool.ts

@@ -43,7 +43,6 @@ export abstract class ToolBase {
             timestamp: new Date().toISOString(),
             source: "mdbmcp",
             properties: {
-                ...this.telemetry.getCommonProperties(),
                 command: this.name,
                 category: this.category,
                 component: "tool",

tests/integration/inMemoryTransport.ts

@@ -2,7 +2,7 @@ import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
 
 export class InMemoryTransport implements Transport {
-    private outputController: ReadableStreamDefaultController<JSONRPCMessage>;
+    private outputController: ReadableStreamDefaultController<JSONRPCMessage> | undefined;
 
     private startPromise: Promise<unknown>;
 
@@ -35,13 +35,13 @@ export class InMemoryTransport implements Transport {
     }
 
     send(message: JSONRPCMessage): Promise<void> {
-        this.outputController.enqueue(message);
+        this.outputController?.enqueue(message);
         return Promise.resolve();
     }
 
     // eslint-disable-next-line @typescript-eslint/require-await
     async close(): Promise<void> {
-        this.outputController.close();
+        this.outputController?.close();
         this.onclose?.();
     }
     onclose?: (() => void) | undefined;

tests/integration/tools/atlas/atlasHelpers.ts

@@ -74,7 +74,7 @@ export function parseTable(text: string): Record<string, string>[] {
     return data
         .filter((_, index) => index >= 2)
         .map((cells) => {
-            const row = {};
+            const row: Record<string, string> = {};
             cells.forEach((cell, index) => {
                 row[headers[index]] = cell;
             });

tests/unit/telemetry.test.ts

@@ -21,16 +21,23 @@ describe("Telemetry", () => {
 
     // Helper function to create properly typed test events
     function createTestEvent(options?: {
-        source?: string;
         result?: TelemetryResult;
         component?: string;
         category?: string;
         command?: string;
         duration_ms?: number;
-    }): BaseEvent {
+    }): Omit<BaseEvent, "properties"> & {
+        properties: {
+            component: string;
+            duration_ms: number;
+            result: TelemetryResult;
+            category: string;
+            command: string;
+        };
+    } {
         return {
             timestamp: new Date().toISOString(),
-            source: options?.source || "mdbmcp",
+            source: "mdbmcp",
             properties: {
                 component: options?.component || "test-component",
                 duration_ms: options?.duration_ms || 100,
@@ -48,6 +55,12 @@ describe("Telemetry", () => {
         appendEventsCalls = 0,
         sendEventsCalledWith = undefined,
         appendEventsCalledWith = undefined,
+    }: {
+        sendEventsCalls?: number;
+        clearEventsCalls?: number;
+        appendEventsCalls?: number;
+        sendEventsCalledWith?: BaseEvent[] | undefined;
+        appendEventsCalledWith?: BaseEvent[] | undefined;
     } = {}) {
         const { calls: sendEvents } = mockApiClient.sendEvents.mock;
         const { calls: clearEvents } = mockEventCache.clearEvents.mock;
@@ -58,7 +71,15 @@ describe("Telemetry", () => {
         expect(appendEvents.length).toBe(appendEventsCalls);
 
         if (sendEventsCalledWith) {
-            expect(sendEvents[0]?.[0]).toEqual(sendEventsCalledWith);
+            expect(sendEvents[0]?.[0]).toEqual(
+                sendEventsCalledWith.map((event) => ({
+                    ...event,
+                    properties: {
+                        ...telemetry.getCommonProperties(),
+                        ...event.properties,
+                    },
+                }))
+            );
         }
 
         if (appendEventsCalledWith) {
@@ -71,7 +92,7 @@ describe("Telemetry", () => {
         jest.clearAllMocks();
 
         // Setup mocked API client
-        mockApiClient = new MockApiClient() as jest.Mocked<ApiClient>;
+        mockApiClient = new MockApiClient({ baseUrl: "" }) as jest.Mocked<ApiClient>;
         mockApiClient.sendEvents = jest.fn().mockResolvedValue(undefined);
         mockApiClient.hasCredentials = jest.fn().mockReturnValue(true);
 

tsconfig.build.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "strictNullChecks": true,
+    "esModuleInterop": true,
+    "types": ["node", "jest"],
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "typeRoots": ["./node_modules/@types", "./src/types"]
+  },
+  "include": ["src/**/*.ts"]
+}

tsconfig.jest.json

@@ -1,5 +1,5 @@
 {
-  "extends": "./tsconfig.json",
+  "extends": "./tsconfig.build.json",
   "compilerOptions": {
     "module": "esnext",
     "target": "esnext",