Merge branch 'master' into release

Author: MaxKless

apps/intellij/src/main/kotlin/dev/nx/console/ProjectPostStartup.kt

@@ -1,13 +1,11 @@
 package dev.nx.console
 
-import com.intellij.ide.plugins.PluginManagerCore
 import com.intellij.openapi.project.DumbService
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.startup.ProjectActivity
 import dev.nx.console.ai.PeriodicAiCheckService
 import dev.nx.console.cloud.CIPEMonitoringService
 import dev.nx.console.ide.ProjectGraphErrorProblemProvider
-import dev.nx.console.mcp.McpServerService
 import dev.nx.console.nxls.NxlsService
 import dev.nx.console.settings.NxConsoleSettingsProvider
 import dev.nx.console.telemetry.TelemetryEvent
@@ -18,7 +16,6 @@ import dev.nx.console.utils.nxBasePath
 import dev.nx.console.utils.sync_services.NxProjectJsonToProjectMap
 import dev.nx.console.utils.sync_services.NxVersionUtil
 import java.io.File
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
 internal class ProjectPostStartup : ProjectActivity {
@@ -57,19 +54,6 @@ internal class ProjectPostStartup : ProjectActivity {
 
             // Initialize periodic AI configuration check
             PeriodicAiCheckService.getInstance(project).initialize()
-
-            val aiAssistantPlugin =
-                PluginManagerCore.plugins.find { it.pluginId.idString == "com.intellij.ml.llm" }
-            if (aiAssistantPlugin != null && aiAssistantPlugin.isEnabled) {
-                // Wait for indexing to complete
-
-                delay(10000)
-
-                val mcpService = McpServerService.getInstance(project)
-                if (!mcpService.isMcpServerSetup()) {
-                    Notifier.notifyMcpServerInstall(project)
-                }
-            }
         }
 
         TelemetryService.getInstance(project)

apps/intellij/src/main/kotlin/dev/nx/console/ai/PeriodicAiCheckService.kt

@@ -11,10 +11,12 @@ import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.application.EDT
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.project.Project
+import dev.nx.console.mcp.McpServerService
 import dev.nx.console.telemetry.TelemetryEvent
 import dev.nx.console.telemetry.TelemetryService
 import dev.nx.console.utils.NxLatestVersionGeneralCommandLine
 import dev.nx.console.utils.NxProvenance
+import java.io.File
 import kotlinx.coroutines.*
 
 @Service(Service.Level.PROJECT)
@@ -75,6 +77,12 @@ class PeriodicAiCheckService(private val project: Project, private val cs: Corou
 
         try {
             val workspaceRoot = project.basePath ?: "."
+
+            // Only run AI checks in Nx workspaces
+            if (!File(workspaceRoot, "nx.json").exists()) {
+                return
+            }
+
             val (hasProvenance, _) =
                 withContext(Dispatchers.IO) { NxProvenance.nxLatestProvenanceCheck(workspaceRoot) }
 
@@ -205,6 +213,7 @@ class PeriodicAiCheckService(private val project: Project, private val cs: Corou
                     mapOf("source" to "notification"),
                 )
             ConfigureAiAgentsService.getInstance(project).runConfigureCommand()
+            McpServerService.getInstance(project).setupMcpServer()
         }
     }
 

apps/intellij/src/main/kotlin/dev/nx/console/utils/Notifier.kt

@@ -203,42 +203,6 @@ class Notifier {
             getGroup().createNotification(message, type).setTitle("Nx Console").notify(project)
         }
 
-        fun notifyMcpServerInstall(project: Project) {
-            val hideNotificationPropertyKey = "nx.console.mcp.server.install.notification.hide"
-
-            if (
-                PropertiesComponent.getInstance(project)
-                    .getBoolean(hideNotificationPropertyKey, false)
-            ) {
-                return
-            }
-
-            val notification =
-                getGroup()
-                    .createNotification(
-                        "Install the Nx MCP Server to enhance AI assistant with Nx-specific knowledge?",
-                        NotificationType.INFORMATION,
-                    )
-                    .setTitle("Nx Console")
-
-            notification.addActions(
-                setOf(
-                    NotificationAction.createSimpleExpiring("Install") {
-                        notification.expire()
-                        val mcpService = dev.nx.console.mcp.McpServerService.getInstance(project)
-                        mcpService.setupMcpServer()
-                    },
-                    NotificationAction.createSimpleExpiring("Don't ask again") {
-                        notification.expire()
-                        PropertiesComponent.getInstance(project)
-                            .setValue(hideNotificationPropertyKey, true)
-                    },
-                )
-            )
-
-            notification.notify(project)
-        }
-
         fun notifyAiAssistantPluginRequired(project: Project) {
             getGroup()
                 .createNotification(

apps/nx-mcp-e2e/src/http-multi-client.test.ts

@@ -0,0 +1,184 @@
+import {
+  cleanupNxWorkspace,
+  defaultVersion,
+  e2eCwd,
+  newWorkspace,
+  simpleReactWorkspaceOptions,
+  uniq,
+  TestMCPClient,
+} from '@nx-console/shared-e2e-utils';
+import { spawn, ChildProcess } from 'node:child_process';
+import { rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { workspaceRoot } from 'nx/src/devkit-exports';
+
+describe('HTTP Multi-Client', () => {
+  let serverProcess: ChildProcess;
+  const serverPort = 9922;
+  const workspaceName = uniq('nx-mcp-http-test');
+  const testWorkspacePath = join(e2eCwd, workspaceName);
+  const serverPath = join(workspaceRoot, 'dist', 'apps', 'nx-mcp', 'main.js');
+
+  // Helper to wait for HTTP server to be ready by polling
+  async function waitForServerReady(
+    port: number,
+    timeoutMs = 60000,
+  ): Promise<void> {
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        // Try to connect to the server
+        // this is not an official supported thing in the spec but it works for checkign aliveness
+        const response = await fetch(`http://localhost:${port}/mcp`, {
+          method: 'OPTIONS',
+        });
+
+        // If we get any response (even an error), the server is up
+        console.log(`Server is ready on port ${port}`);
+        return;
+      } catch (error) {
+        // Server not ready yet, wait and retry
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+
+    throw new Error(`Timeout waiting for server to be ready on port ${port}`);
+  }
+
+  beforeAll(async () => {
+    // Create workspace
+    newWorkspace({
+      name: workspaceName,
+      options: simpleReactWorkspaceOptions,
+    });
+
+    // Start HTTP MCP server without workspace path
+    // The workspace will be determined per-session based on requests
+    serverProcess = spawn(
+      'node',
+      [serverPath, '--transport=http', `--port=${serverPort}`],
+      {
+        stdio: 'pipe',
+        env: {
+          ...process.env,
+          NX_NO_CLOUD: 'true',
+          MCP_AUTO_OPEN_ENABLED: 'false',
+        },
+        cwd: testWorkspacePath, // Set working directory to workspace
+      },
+    );
+
+    // Log server output for debugging
+    serverProcess.stdout?.on('data', (data) => {
+      if (process.env['NX_VERBOSE_LOGGING']) {
+        console.log(`[MCP Server] ${data.toString()}`);
+      }
+    });
+
+    serverProcess.stderr?.on('data', (data) => {
+      if (process.env['NX_VERBOSE_LOGGING']) {
+        console.error(`[MCP Server Error] ${data.toString()}`);
+      }
+    });
+
+    // Wait for server to be ready by polling the endpoint
+    await waitForServerReady(serverPort);
+
+    console.log(`MCP HTTP server confirmed ready on port ${serverPort}`);
+  });
+
+  afterAll(async () => {
+    // Kill server
+    if (serverProcess) {
+      serverProcess.kill('SIGTERM');
+      // Wait a bit for graceful shutdown
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      if (!serverProcess.killed) {
+        serverProcess.kill('SIGKILL');
+      }
+    }
+
+    // Clean up workspace
+    await cleanupNxWorkspace(testWorkspacePath, defaultVersion);
+    rmSync(testWorkspacePath, { recursive: true, force: true });
+  });
+
+  it('should handle two simultaneous clients listing tools', async () => {
+    const serverUrl = `http://localhost:${serverPort}/mcp`;
+
+    // Create two test clients
+    const client1 = new TestMCPClient(serverUrl, 'test-client-1');
+    const client2 = new TestMCPClient(serverUrl, 'test-client-2');
+
+    // Connect both clients in parallel
+    await Promise.all([client1.connect(), client2.connect()]);
+
+    // Make two simultaneous requests
+    const [tools1, tools2] = await Promise.all([
+      client1.listTools(),
+      client2.listTools(),
+    ]);
+
+    // Verify both clients got valid responses
+    expect(tools1).toBeDefined();
+    expect(tools2).toBeDefined();
+
+    const toolNames1 = tools1.map((tool: any) => tool.name);
+    const toolNames2 = tools2.map((tool: any) => tool.name);
+
+    // Both should have the same set of tools
+    const expectedTools = [
+      'nx_docs',
+      'nx_available_plugins',
+      'nx_workspace',
+      'nx_workspace_path',
+      'nx_project_details',
+      'nx_generators',
+      'nx_generator_schema',
+    ];
+
+    expect(toolNames1).toEqual(expectedTools);
+    expect(toolNames2).toEqual(expectedTools);
+
+    console.log('Both clients successfully connected and retrieved tools');
+
+    // Disconnect both clients
+    await Promise.all([client1.disconnect(), client2.disconnect()]);
+  });
+
+  it('should allow both clients to invoke tools and get results', async () => {
+    const serverUrl = `http://localhost:${serverPort}/mcp`;
+
+    // Create two test clients
+    const client1 = new TestMCPClient(serverUrl, 'test-client-3');
+    const client2 = new TestMCPClient(serverUrl, 'test-client-4');
+
+    // Connect both clients in parallel
+    await Promise.all([client1.connect(), client2.connect()]);
+
+    // Make two simultaneous tool calls
+    const [result1, result2] = await Promise.all([
+      client1.callTool('nx_workspace_path', {}),
+      client2.callTool('nx_workspace_path', {}),
+    ]);
+
+    // Verify both clients got valid tool results
+    expect(result1.content).toBeDefined();
+    expect(result2.content).toBeDefined();
+
+    // The nx_workspace_path tool returns the workspace path as text
+    expect(result1.content[0].type).toBe('text');
+    expect(result1.content[0].text).toContain(testWorkspacePath);
+
+    expect(result2.content[0].type).toBe('text');
+    expect(result2.content[0].text).toContain(testWorkspacePath);
+
+    console.log(
+      'Both clients successfully invoked tools and received correct results',
+    );
+
+    // Disconnect both clients
+    await Promise.all([client1.disconnect(), client2.disconnect()]);
+  });
+});

apps/vscode/package.json

@@ -206,11 +206,6 @@
           "when": "view == nxCloudRecentCIPE && viewItem == run",
           "group": "inline@1"
         },
-        {
-          "command": "nxCloud.helpMeFixCipeError",
-          "when": "view == nxCloudRecentCIPE && viewItem == failedTask && isInCursor",
-          "group": "inline@1"
-        },
         {
           "command": "nxConsole.showProblems",
           "when": "view == nxProjects && viewItem == projectGraphError",
@@ -310,10 +305,6 @@
           "command": "nxCloud.showRunInApp",
           "when": "false"
         },
-        {
-          "command": "nxCloud.helpMeFixCipeError",
-          "when": "false"
-        },
         {
           "command": "nxCloud.applyAiFix",
           "when": "false"
@@ -904,14 +895,6 @@
         "command": "nxCloud.openApp",
         "icon": "$(cloud)"
       },
-      {
-        "title": "Help me fix the latest CIPE error",
-        "command": "nxCloud.helpMeFixCipeError",
-        "icon": {
-          "dark": "assets/cursor-dark.svg",
-          "light": "assets/cursor-light.svg"
-        }
-      },
       {
         "title": "Apply AI Fix",
         "command": "nxCloud.applyAiFix"

apps/vscode/src/assets/cursor-dark.svg

@@ -1 +1,2 @@
 export * from './lib/utils';
+export * from './lib/mcp-test-client';

apps/vscode/src/assets/cursor-light.svg

@@ -0,0 +1,38 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+export class TestMCPClient {
+  private client: Client;
+  private transport: StreamableHTTPClientTransport | null = null;
+
+  constructor(
+    private serverUrl: string,
+    clientName: string,
+  ) {
+    this.client = new Client({
+      name: clientName,
+      version: '1.0.0',
+    });
+  }
+
+  async connect(): Promise<void> {
+    this.transport = new StreamableHTTPClientTransport(new URL(this.serverUrl));
+    await this.client.connect(this.transport);
+  }
+
+  async listTools(): Promise<any[]> {
+    const result = await this.client.listTools();
+    return result.tools;
+  }
+
+  async callTool(name: string, args: Record<string, any> = {}): Promise<any> {
+    return await this.client.callTool({
+      name,
+      arguments: args,
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    await this.client.close();
+  }
+}