Address PR review comments from review #3773277390

- Fix race condition in server-manager getOrRestart: serialize concurrent
  calls per server type using pendingStarts map with async/await pattern
- Fix lsp-handlers filePath docstring: document that relative paths are
  accepted and resolved against getUserWorkspaceDir()
- Fix semantic_validation/syntax_validation READMEs: clarify that before/
  after .ql files differ (not identical as previously stated)
- Fix semantic_validation/after/monitoring-state.json: update parameter
  shape to use ql_code matching the codeql_lsp_diagnostics tool contract
- Add concurrent access serialization test for server-manager

Author: data-douser

client/integration-tests/primitives/tools/codeql_lsp_diagnostics/semantic_validation/README.md

@@ -13,5 +13,5 @@ references undefined types (e.g., `UndefinedType`).
 ## EXPECTED OUTPUTS
 
 - `isValid` is `false` with semantic diagnostics about unresolvable types.
-- The `semantic_query.ql` file remains unchanged (identical in before/ and after/).
+- The `before/semantic_query.ql` contains the erroneous query; `after/semantic_query.ql` shows the corrected version after addressing the diagnostics.
 - Monitoring state updated to record a successful `codeql_lsp_diagnostics` call.

client/integration-tests/primitives/tools/codeql_lsp_diagnostics/semantic_validation/after/monitoring-state.json

@@ -1,35 +1,17 @@
 {
   "sessions": [
     {
-      "sessionId": "codeql-eval-session",
-      "queryPath": "/test/semantic_query.ql",
-      "language": "javascript",
-      "queryType": "test",
-      "description": "CodeQL LSP diagnostics test",
-      "status": "active",
-      "state": {
-        "compilationStatus": "success",
-        "testStatus": "no_tests",
-        "documentationStatus": "missing",
-        "filesPresent": ["/test/semantic_query.ql"]
-      },
-      "mcpCalls": [
+      "id": "integration_test_session",
+      "calls": [
         {
-          "callId": "eval-call-1",
-          "timestamp": "2024-01-01T00:00:00.000Z",
-          "toolName": "codeql_lsp_diagnostics",
+          "tool": "codeql_lsp_diagnostics",
+          "timestamp": "2026-02-08T00:00:00.000Z",
+          "status": "success",
           "parameters": {
-            "sessionId": "codeql-eval-session",
-            "query": "from DataFlow::Configuration cfg select cfg",
-            "language": "javascript"
-          },
-          "success": true,
-          "duration": 1500,
-          "result": "semantic validation completed"
+            "ql_code": "from NonExistentType item\nwhere item.someProperty() = \"value\"\nselect item, \"This has semantic errors\""
+          }
         }
-      ],
-      "testExecutions": [],
-      "qualityScores": []
+      ]
     }
   ]
 }

client/integration-tests/primitives/tools/codeql_lsp_diagnostics/syntax_validation/README.md

@@ -11,5 +11,5 @@ Tests that `codeql_lsp_diagnostics` detects syntax errors in invalid QL code.
 ## EXPECTED OUTPUTS
 
 - `isValid` is `false` with one or more error diagnostics.
-- The `test_query.ql` file remains unchanged (identical in before/ and after/).
+- The `before/test_query.ql` contains the erroneous query; `after/test_query.ql` shows the corrected version after addressing the diagnostics.
 - Monitoring state updated to record a successful `codeql_lsp_diagnostics` call.

server/dist/codeql-development-mcp-server.js

@@ -58,6 +58,9 @@ export class CodeQLServerManager {
   /** Keyed by `CodeQLServerType` — at most one per type at a time. */
   private servers = new Map<CodeQLServerType, ManagedServer>();
 
+  /** In-flight `getOrRestart` promises, keyed by server type, to serialize concurrent calls. */
+  private pendingStarts = new Map<CodeQLServerType, Promise<CodeQLCLIServer | CodeQLLanguageServer | CodeQLQueryServer>>();
+
   /** The session ID used for cache isolation. */
   private sessionId: string;
 
@@ -264,11 +267,41 @@ export class CodeQLServerManager {
   /**
    * Get an existing server if its config matches, otherwise stop the old
    * one and start a new server.
+   *
+   * Concurrent calls for the same server type are serialized via
+   * `pendingStarts` to avoid spawning duplicate server processes.
    */
   private async getOrRestart(
     type: CodeQLServerType,
     config: ServerConfig,
     factory: () => CodeQLCLIServer | CodeQLLanguageServer | CodeQLQueryServer,
+  ): Promise<CodeQLCLIServer | CodeQLLanguageServer | CodeQLQueryServer> {
+    // If another call is already starting a server of this type, wait for it
+    // to settle (success or failure) and then re-check whether the result is
+    // still usable.
+    const inflight = this.pendingStarts.get(type);
+    if (inflight) {
+      try { await inflight; } catch { /* swallow — original caller handles the rejection */ }
+    }
+
+    const work = this.doGetOrRestart(type, config, factory);
+    this.pendingStarts.set(type, work);
+    try {
+      return await work;
+    } finally {
+      if (this.pendingStarts.get(type) === work) {
+        this.pendingStarts.delete(type);
+      }
+    }
+  }
+
+  /**
+   * Core logic for getOrRestart, separated to allow serialization.
+   */
+  private async doGetOrRestart(
+    type: CodeQLServerType,
+    config: ServerConfig,
+    factory: () => CodeQLCLIServer | CodeQLLanguageServer | CodeQLQueryServer,
   ): Promise<CodeQLCLIServer | CodeQLLanguageServer | CodeQLQueryServer> {
     const hash = computeConfigHash(type, config);
     const existing = this.servers.get(type);

server/dist/codeql-development-mcp-server.js.map

@@ -27,7 +27,11 @@ export interface LSPToolParams {
   character: number;
   /** Optional override for the file content (if not reading from disk). */
   fileContent?: string;
-  /** Absolute path to the QL file. */
+  /**
+   * Path to the QL file. May be absolute or relative.
+   * Relative paths are resolved against `getUserWorkspaceDir()`
+   * (respects the `CODEQL_MCP_WORKSPACE` environment variable).
+   */
   filePath: string;
   /** 0-based line number in the document. */
   line: number;

server/src/lib/server-manager.ts

@@ -165,6 +165,20 @@ describe('CodeQLServerManager', () => {
       expect(manager.isRunning('language')).toBe(true);
       expect(server1.shutdown).toHaveBeenCalled();
     });
+
+    it('should serialize concurrent calls for the same server type', async () => {
+      const manager = new CodeQLServerManager({ sessionId: 'ls-concurrent' });
+      const config = { searchPath: '/ql' };
+
+      // Fire two concurrent requests — both should resolve to the same server
+      const [server1, server2] = await Promise.all([
+        manager.getLanguageServer(config),
+        manager.getLanguageServer(config),
+      ]);
+
+      expect(server1).toBe(server2);
+      expect(manager.isRunning('language')).toBe(true);
+    });
   });
 
   describe('getQueryServer', () => {