chore: add type check for CI

We have been running lint which did catch most TypeScript errors but there's more complex type issues which arise from the TypeScript compiler itself. This adds a type check step and fixes existing issues with it.

Author: gagik

.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"]
     }
   ]

package-lock.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"

package.json

@@ -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/apply.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;
         }
     }

scripts/filter.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/common/atlas/apiClient.ts

@@ -119,7 +119,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/server.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/eventCache.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: { ...event.properties, ...this.getCommonProperties() },
+                }))
+            );
             return { success: true };
         } catch (error) {
             return {

src/telemetry/telemetry.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;