fix(lsp): skip didOpen when server is stopped

Author: limityan

src/crates/core/src/service/lsp/workspace_manager.rs

@@ -9,7 +9,7 @@
 //! - Push real-time events to the frontend
 
 use anyhow::{anyhow, Result};
-use log::{debug, error, info, warn};
+use log::{debug, error, info, trace, warn};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::PathBuf;
@@ -310,7 +310,7 @@ impl WorkspaceLspManager {
         let server_language = match self.get_running_server_for_language(&language).await {
             Some(lang) => lang,
             None => {
-                debug!(
+                trace!(
                     "LSP server not running for language: {}, skipping didOpen",
                     language
                 );

src/web-ui/src/tools/lsp/services/LspDocumentService.ts

@@ -117,11 +117,15 @@ class LspDocumentService {
     const manager = WorkspaceLspManager.getOrCreate(workspacePath);
 
     try {
-      await manager.openDocument(
+      const openResult = await manager.openDocument(
         event.uri,
         state.language,
         event.content
       );
+
+      if (!openResult.opened) {
+        return;
+      }
 
       state.isOpen = true;
       state.lastSyncedContent = event.content;

src/web-ui/src/tools/lsp/services/WorkspaceLspManager.test.ts

@@ -0,0 +1,149 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const invokeMock = vi.hoisted(() => vi.fn());
+const listenMock = vi.hoisted(() => vi.fn(async () => () => {}));
+
+vi.mock('@tauri-apps/api/core', () => ({
+  invoke: invokeMock
+}));
+
+vi.mock('@tauri-apps/api/event', () => ({
+  listen: listenMock
+}));
+
+vi.mock('@/shared/notification-system', () => ({
+  notificationService: {
+    progress: vi.fn(),
+    error: vi.fn(),
+    loading: vi.fn(() => ({
+      updateMessage: vi.fn(),
+      complete: vi.fn()
+    }))
+  }
+}));
+
+vi.mock('@/infrastructure/i18n', () => ({
+  i18nService: {
+    t: vi.fn((key: string) => key)
+  }
+}));
+
+import { WorkspaceLspManager } from './WorkspaceLspManager';
+
+function serverState(status: 'stopped' | 'starting' | 'running' | 'failed' | 'restarting') {
+  return {
+    status,
+    language: 'rust',
+    startedAt: null,
+    lastError: null,
+    restartCount: 0,
+    documentCount: 0
+  };
+}
+
+describe('WorkspaceLspManager', () => {
+  afterEach(() => {
+    invokeMock.mockReset();
+    listenMock.mockReset();
+    listenMock.mockResolvedValue(() => {});
+    (WorkspaceLspManager as unknown as {
+      instances: Map<string, WorkspaceLspManager>;
+    }).instances.clear();
+  });
+
+  it('skips didOpen when the language server is stopped', async () => {
+    invokeMock.mockImplementation(async (command: string) => {
+      if (command === 'lsp_open_workspace') {
+        return undefined;
+      }
+      if (command === 'lsp_get_server_state') {
+        return serverState('stopped');
+      }
+      if (command === 'lsp_open_document') {
+        throw new Error('didOpen should not be sent for a stopped server');
+      }
+      return undefined;
+    });
+
+    const manager = WorkspaceLspManager.getOrCreate('D:\\workspace\\BitFun');
+
+    const result = await manager.openDocument(
+      'file:///D:/workspace/BitFun/src/main.rs',
+      'rust',
+      'fn main() {}'
+    );
+
+    expect(result).toEqual({
+      language: 'rust',
+      opened: false,
+      skippedReason: 'server-not-running',
+      serverStatus: 'stopped'
+    });
+    expect(invokeMock).not.toHaveBeenCalledWith('lsp_open_document', expect.anything());
+  });
+
+  it('sends didOpen when the language server is running', async () => {
+    invokeMock.mockImplementation(async (command: string) => {
+      if (command === 'lsp_open_workspace') {
+        return undefined;
+      }
+      if (command === 'lsp_get_server_state') {
+        return serverState('running');
+      }
+      if (command === 'lsp_open_document') {
+        return undefined;
+      }
+      return undefined;
+    });
+
+    const manager = WorkspaceLspManager.getOrCreate('D:\\workspace\\BitFun');
+
+    const result = await manager.openDocument(
+      'file:///D:/workspace/BitFun/src/main.rs',
+      'rust',
+      'fn main() {}'
+    );
+
+    expect(result).toEqual({ language: 'rust', opened: true });
+    expect(invokeMock).toHaveBeenCalledWith('lsp_open_document', {
+      request: {
+        workspacePath: 'D:\\workspace\\BitFun',
+        uri: 'file:///D:/workspace/BitFun/src/main.rs',
+        language: 'rust',
+        content: 'fn main() {}'
+      }
+    });
+  });
+
+  it('caches stopped server state to avoid repeated state queries during UI remounts', async () => {
+    invokeMock.mockImplementation(async (command: string) => {
+      if (command === 'lsp_open_workspace') {
+        return undefined;
+      }
+      if (command === 'lsp_get_server_state') {
+        return serverState('stopped');
+      }
+      if (command === 'lsp_open_document') {
+        throw new Error('didOpen should not be sent for a stopped server');
+      }
+      return undefined;
+    });
+
+    const manager = WorkspaceLspManager.getOrCreate('D:\\workspace\\BitFun');
+
+    await manager.openDocument('file:///D:/workspace/BitFun/src/main.rs', 'rust', 'fn main() {}');
+    await manager.openDocument('file:///D:/workspace/BitFun/src/lib.rs', 'rust', 'pub fn lib() {}');
+
+    expect(invokeMock).toHaveBeenCalledTimes(2);
+    expect(invokeMock).toHaveBeenCalledWith('lsp_open_workspace', {
+      request: { workspacePath: 'D:\\workspace\\BitFun' }
+    });
+    expect(invokeMock).toHaveBeenCalledWith('lsp_get_server_state', {
+      request: {
+        workspacePath: 'D:\\workspace\\BitFun',
+        language: 'rust'
+      }
+    });
+    expect(invokeMock).not.toHaveBeenCalledWith('lsp_open_document', expect.anything());
+  });
+});

src/web-ui/src/tools/lsp/services/WorkspaceLspManager.ts

@@ -38,16 +38,29 @@ interface ServerState {
   documentCount: number;
 }
 
+type OpenDocumentSkippedReason = 'server-not-running';
+
+export interface OpenDocumentResult {
+  language: string;
+  opened: boolean;
+  skippedReason?: OpenDocumentSkippedReason;
+  serverStatus?: ServerState['status'];
+}
+
+interface CachedServerStatus {
+  status: ServerState['status'];
+  updatedAt: number;
+}
+
 export class WorkspaceLspManager {
   private static instances = new Map<string, WorkspaceLspManager>();
 
   private workspacePath: string;
   private eventUnlisten?: UnlistenFn;
   private isInitialized = false;
-  
-
-  private startingLanguages = new Set<string>();
-  private languageReadyPromises = new Map<string, Promise<void>>();
+  private serverStatusByLanguage = new Map<string, CachedServerStatus>();
+  private skippedOpenNoticeLanguages = new Set<string>();
+  private readonly SERVER_STATUS_CACHE_TTL_MS = 30000;
 
 
   private diagnosticsCallbacks = new Map<string, Array<(diagnostics: any[]) => void>>();
@@ -155,7 +168,81 @@ export class WorkspaceLspManager {
     return uri.toLowerCase();
   }
 
-  
+
+  private normalizeLanguage(language: string): string {
+    return language.trim().toLowerCase();
+  }
+
+
+  private isServerStatus(status?: string): status is ServerState['status'] {
+    return status === 'stopped'
+      || status === 'starting'
+      || status === 'running'
+      || status === 'failed'
+      || status === 'restarting';
+  }
+
+
+  private rememberServerStatus(language: string, status: ServerState['status']): void {
+    const key = this.normalizeLanguage(language);
+    this.serverStatusByLanguage.set(key, {
+      status,
+      updatedAt: Date.now()
+    });
+
+    if (status === 'running') {
+      this.skippedOpenNoticeLanguages.delete(key);
+    }
+  }
+
+
+  private getFreshCachedServerStatus(language: string): ServerState['status'] | undefined {
+    const cached = this.serverStatusByLanguage.get(this.normalizeLanguage(language));
+    if (!cached) {
+      return undefined;
+    }
+
+    if (Date.now() - cached.updatedAt > this.SERVER_STATUS_CACHE_TTL_MS) {
+      return undefined;
+    }
+
+    return cached.status;
+  }
+
+
+  private async getDocumentOpenAvailability(language: string): Promise<{
+    canOpen: boolean;
+    status?: ServerState['status'];
+    skippedReason?: OpenDocumentSkippedReason;
+  }> {
+    const cachedStatus = this.getFreshCachedServerStatus(language);
+    if (cachedStatus) {
+      return cachedStatus === 'running'
+        ? { canOpen: true, status: cachedStatus }
+        : {
+            canOpen: false,
+            status: cachedStatus,
+            skippedReason: 'server-not-running'
+          };
+    }
+
+    const state = await this.getServerState(language);
+    if (!state) {
+      return { canOpen: true };
+    }
+
+    this.rememberServerStatus(language, state.status);
+
+    return state.status === 'running'
+      ? { canOpen: true, status: state.status }
+      : {
+          canOpen: false,
+          status: state.status,
+          skippedReason: 'server-not-running'
+        };
+  }
+
+
   private onDiagnosticsReceived(data: LspEvent['data']) {
     const { uri, diagnostics } = data;
 
@@ -186,6 +273,9 @@ export class WorkspaceLspManager {
 
     if (!language) return;
 
+    if (this.isServerStatus(status)) {
+      this.rememberServerStatus(language, status);
+    }
 
     switch (status) {
       case 'starting':
@@ -282,21 +372,10 @@ export class WorkspaceLspManager {
       progressNotif.complete();
       this.indexingProgressNotifications.delete(language);
     }
-    
-
-    this.startingLanguages.delete(language);
   }
 
 
-  async openDocument(uri: string, language: string, content: string): Promise<string> {
-
-    if (this.startingLanguages.has(language)) {
-      const readyPromise = this.languageReadyPromises.get(language);
-      if (readyPromise) {
-        await readyPromise;
-      }
-    }
-    
+  async openDocument(uri: string, language: string, content: string): Promise<OpenDocumentResult> {
     if (!this.isInitialized) {
       try {
         await this.initialize();
@@ -305,21 +384,28 @@ export class WorkspaceLspManager {
         throw initError;
       }
     }
-    
 
-    if (!this.startingLanguages.has(language)) {
-      this.startingLanguages.add(language);
-      
-
-      const readyPromise = new Promise<void>((resolve) => {
+    // didOpen is only meaningful when a language server is actually running.
+    // Checking the state here prevents layout/remount churn (for example window
+    // fullscreen transitions) from generating batches of backend no-op logs.
+    const availability = await this.getDocumentOpenAvailability(language);
+    if (!availability.canOpen) {
+      const key = this.normalizeLanguage(language);
+      if (!this.skippedOpenNoticeLanguages.has(key)) {
+        log.debug('Skipped LSP didOpen because language server is not running', {
+          workspacePath: this.workspacePath,
+          language,
+          status: availability.status
+        });
+        this.skippedOpenNoticeLanguages.add(key);
+      }
 
-        setTimeout(() => {
-          this.startingLanguages.delete(language);
-          this.languageReadyPromises.delete(language);
-          resolve();
-        }, 5000);
-      });
-      this.languageReadyPromises.set(language, readyPromise);
+      return {
+        language,
+        opened: false,
+        skippedReason: availability.skippedReason,
+        serverStatus: availability.status
+      };
     }
 
     try {
@@ -341,7 +427,7 @@ export class WorkspaceLspManager {
 
 
 
-      return language;
+      return { language, opened: true };
     } catch (error) {
       log.error('Failed to open document', { workspacePath: this.workspacePath, uri, language, error });
       throw error;