@xortex/xcode 3.0.0

package/services/lsp/manager.ts

@@ -0,0 +1,289 @@
+import { logForDebugging } from '../../utils/debug.js'
+import { isBareMode } from '../../utils/envUtils.js'
+import { errorMessage } from '../../utils/errors.js'
+import { logError } from '../../utils/log.js'
+import {
+  createLSPServerManager,
+  type LSPServerManager,
+} from './LSPServerManager.js'
+import { registerLSPNotificationHandlers } from './passiveFeedback.js'
+
+/**
+ * Initialization state of the LSP server manager
+ */
+type InitializationState = 'not-started' | 'pending' | 'success' | 'failed'
+
+/**
+ * Global singleton instance of the LSP server manager.
+ * Initialized during Claude Code startup.
+ */
+let lspManagerInstance: LSPServerManager | undefined
+
+/**
+ * Current initialization state
+ */
+let initializationState: InitializationState = 'not-started'
+
+/**
+ * Error from last initialization attempt, if any
+ */
+let initializationError: Error | undefined
+
+/**
+ * Generation counter to prevent stale initialization promises from updating state
+ */
+let initializationGeneration = 0
+
+/**
+ * Promise that resolves when initialization completes (success or failure)
+ */
+let initializationPromise: Promise<void> | undefined
+
+/**
+ * Test-only sync reset. shutdownLspServerManager() is async and tears down
+ * real connections; this only clears the module-scope singleton state so
+ * reinitializeLspServerManager() early-returns on 'not-started' in downstream
+ * tests on the same shard.
+ */
+export function _resetLspManagerForTesting(): void {
+  initializationState = 'not-started'
+  initializationError = undefined
+  initializationPromise = undefined
+  initializationGeneration++
+}
+
+/**
+ * Get the singleton LSP server manager instance.
+ * Returns undefined if not yet initialized, initialization failed, or still pending.
+ *
+ * Callers should check for undefined and handle gracefully, as initialization happens
+ * asynchronously during Claude Code startup. Use getInitializationStatus() to
+ * distinguish between pending, failed, and not-started states.
+ */
+export function getLspServerManager(): LSPServerManager | undefined {
+  // Don't return a broken instance if initialization failed
+  if (initializationState === 'failed') {
+    return undefined
+  }
+  return lspManagerInstance
+}
+
+/**
+ * Get the current initialization status of the LSP server manager.
+ *
+ * @returns Status object with current state and error (if failed)
+ */
+export function getInitializationStatus():
+  | { status: 'not-started' }
+  | { status: 'pending' }
+  | { status: 'success' }
+  | { status: 'failed'; error: Error } {
+  if (initializationState === 'failed') {
+    return {
+      status: 'failed',
+      error: initializationError || new Error('Initialization failed'),
+    }
+  }
+  if (initializationState === 'not-started') {
+    return { status: 'not-started' }
+  }
+  if (initializationState === 'pending') {
+    return { status: 'pending' }
+  }
+  return { status: 'success' }
+}
+
+/**
+ * Check whether at least one language server is connected and healthy.
+ * Backs LSPTool.isEnabled().
+ */
+export function isLspConnected(): boolean {
+  if (initializationState === 'failed') return false
+  const manager = getLspServerManager()
+  if (!manager) return false
+  const servers = manager.getAllServers()
+  if (servers.size === 0) return false
+  for (const server of servers.values()) {
+    if (server.state !== 'error') return true
+  }
+  return false
+}
+
+/**
+ * Wait for LSP server manager initialization to complete.
+ *
+ * Returns immediately if initialization has already completed (success or failure).
+ * If initialization is pending, waits for it to complete.
+ * If initialization hasn't started, returns immediately.
+ *
+ * @returns Promise that resolves when initialization is complete
+ */
+export async function waitForInitialization(): Promise<void> {
+  // If already initialized or failed, return immediately
+  if (initializationState === 'success' || initializationState === 'failed') {
+    return
+  }
+
+  // If pending and we have a promise, wait for it
+  if (initializationState === 'pending' && initializationPromise) {
+    await initializationPromise
+  }
+
+  // If not started, return immediately (nothing to wait for)
+}
+
+/**
+ * Initialize the LSP server manager singleton.
+ *
+ * This function is called during Claude Code startup. It synchronously creates
+ * the manager instance, then starts async initialization (loading LSP configs)
+ * in the background without blocking the startup process.
+ *
+ * Safe to call multiple times - will only initialize once (idempotent).
+ * However, if initialization previously failed, calling again will retry.
+ */
+export function initializeLspServerManager(): void {
+  // --bare / SIMPLE: no LSP. LSP is for editor integration (diagnostics,
+  // hover, go-to-def in the REPL). Scripted -p calls have no use for it.
+  if (isBareMode()) {
+    return
+  }
+  logForDebugging('[LSP MANAGER] initializeLspServerManager() called')
+
+  // Skip if already initialized or currently initializing
+  if (lspManagerInstance !== undefined && initializationState !== 'failed') {
+    logForDebugging(
+      '[LSP MANAGER] Already initialized or initializing, skipping',
+    )
+    return
+  }
+
+  // Reset state for retry if previous initialization failed
+  if (initializationState === 'failed') {
+    lspManagerInstance = undefined
+    initializationError = undefined
+  }
+
+  // Create the manager instance and mark as pending
+  lspManagerInstance = createLSPServerManager()
+  initializationState = 'pending'
+  logForDebugging('[LSP MANAGER] Created manager instance, state=pending')
+
+  // Increment generation to invalidate any pending initializations
+  const currentGeneration = ++initializationGeneration
+  logForDebugging(
+    `[LSP MANAGER] Starting async initialization (generation ${currentGeneration})`,
+  )
+
+  // Start initialization asynchronously without blocking
+  // Store the promise so callers can await it via waitForInitialization()
+  initializationPromise = lspManagerInstance
+    .initialize()
+    .then(() => {
+      // Only update state if this is still the current initialization
+      if (currentGeneration === initializationGeneration) {
+        initializationState = 'success'
+        logForDebugging('LSP server manager initialized successfully')
+
+        // Register passive notification handlers for diagnostics
+        if (lspManagerInstance) {
+          registerLSPNotificationHandlers(lspManagerInstance)
+        }
+      }
+    })
+    .catch((error: unknown) => {
+      // Only update state if this is still the current initialization
+      if (currentGeneration === initializationGeneration) {
+        initializationState = 'failed'
+        initializationError = error as Error
+        // Clear the instance since it's not usable
+        lspManagerInstance = undefined
+
+        logError(error as Error)
+        logForDebugging(
+          `Failed to initialize LSP server manager: ${errorMessage(error)}`,
+        )
+      }
+    })
+}
+
+/**
+ * Force re-initialization of the LSP server manager, even after a prior
+ * successful init. Called from refreshActivePlugins() after plugin caches
+ * are cleared, so newly-loaded plugin LSP servers are picked up.
+ *
+ * Fixes https://github.com/anthropics/claude-code/issues/15521:
+ * loadAllPlugins() is memoized and can be called very early in startup
+ * (via getCommands prefetch in setup.ts) before marketplaces are reconciled,
+ * caching an empty plugin list. initializeLspServerManager() then reads that
+ * stale memoized result and initializes with 0 servers. Unlike commands/agents/
+ * hooks/MCP, LSP was never re-initialized on plugin refresh.
+ *
+ * Safe to call when no LSP plugins changed: initialize() is just config
+ * parsing (servers are lazy-started on first use). Also safe during pending
+ * init: the generation counter invalidates the in-flight promise.
+ */
+export function reinitializeLspServerManager(): void {
+  if (initializationState === 'not-started') {
+    // initializeLspServerManager() was never called (e.g. headless subcommand
+    // path). Don't start it now.
+    return
+  }
+
+  logForDebugging('[LSP MANAGER] reinitializeLspServerManager() called')
+
+  // Best-effort shutdown of any running servers on the old instance so
+  // /reload-plugins doesn't leak child processes. Fire-and-forget: the
+  // primary use case (issue #15521) has 0 servers so this is usually a no-op.
+  if (lspManagerInstance) {
+    void lspManagerInstance.shutdown().catch(err => {
+      logForDebugging(
+        `[LSP MANAGER] old instance shutdown during reinit failed: ${errorMessage(err)}`,
+      )
+    })
+  }
+
+  // Force the idempotence check in initializeLspServerManager() to fall
+  // through. Generation counter handles invalidating any in-flight init.
+  lspManagerInstance = undefined
+  initializationState = 'not-started'
+  initializationError = undefined
+
+  initializeLspServerManager()
+}
+
+/**
+ * Shutdown the LSP server manager and clean up resources.
+ *
+ * This should be called during Claude Code shutdown. Stops all running LSP servers
+ * and clears internal state. Safe to call when not initialized (no-op).
+ *
+ * NOTE: Errors during shutdown are logged for monitoring but NOT propagated to the caller.
+ * State is always cleared even if shutdown fails, to prevent resource accumulation.
+ * This is acceptable during application exit when recovery is not possible.
+ *
+ * @returns Promise that resolves when shutdown completes (errors are swallowed)
+ */
+export async function shutdownLspServerManager(): Promise<void> {
+  if (lspManagerInstance === undefined) {
+    return
+  }
+
+  try {
+    await lspManagerInstance.shutdown()
+    logForDebugging('LSP server manager shut down successfully')
+  } catch (error: unknown) {
+    logError(error as Error)
+    logForDebugging(
+      `Failed to shutdown LSP server manager: ${errorMessage(error)}`,
+    )
+  } finally {
+    // Always clear state even if shutdown failed
+    lspManagerInstance = undefined
+    initializationState = 'not-started'
+    initializationError = undefined
+    initializationPromise = undefined
+    // Increment generation to invalidate any pending initializations
+    initializationGeneration++
+  }
+}

package/services/lsp/passiveFeedback.ts

@@ -0,0 +1,328 @@
+import { fileURLToPath } from 'url'
+import type { PublishDiagnosticsParams } from 'vscode-languageserver-protocol'
+import { logForDebugging } from '../../utils/debug.js'
+import { toError } from '../../utils/errors.js'
+import { logError } from '../../utils/log.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import type { DiagnosticFile } from '../diagnosticTracking.js'
+import { registerPendingLSPDiagnostic } from './LSPDiagnosticRegistry.js'
+import type { LSPServerManager } from './LSPServerManager.js'
+
+/**
+ * Map LSP severity to Claude diagnostic severity
+ *
+ * Maps LSP severity numbers to Claude diagnostic severity strings.
+ * Accepts numeric severity values (1=Error, 2=Warning, 3=Information, 4=Hint)
+ * or undefined, defaulting to 'Error' for invalid/missing values.
+ */
+function mapLSPSeverity(
+  lspSeverity: number | undefined,
+): 'Error' | 'Warning' | 'Info' | 'Hint' {
+  // LSP DiagnosticSeverity enum:
+  // 1 = Error, 2 = Warning, 3 = Information, 4 = Hint
+  switch (lspSeverity) {
+    case 1:
+      return 'Error'
+    case 2:
+      return 'Warning'
+    case 3:
+      return 'Info'
+    case 4:
+      return 'Hint'
+    default:
+      return 'Error'
+  }
+}
+
+/**
+ * Convert LSP diagnostics to Claude diagnostic format
+ *
+ * Converts LSP PublishDiagnosticsParams to DiagnosticFile[] format
+ * used by Claude's attachment system.
+ */
+export function formatDiagnosticsForAttachment(
+  params: PublishDiagnosticsParams,
+): DiagnosticFile[] {
+  // Parse URI (may be file:// or plain path) and normalize to file system path
+  let uri: string
+  try {
+    // Handle both file:// URIs and plain paths
+    uri = params.uri.startsWith('file://')
+      ? fileURLToPath(params.uri)
+      : params.uri
+  } catch (error) {
+    const err = toError(error)
+    logError(err)
+    logForDebugging(
+      `Failed to convert URI to file path: ${params.uri}. Error: ${err.message}. Using original URI as fallback.`,
+    )
+    // Gracefully fallback to original URI - LSP servers may send malformed URIs
+    uri = params.uri
+  }
+
+  const diagnostics = params.diagnostics.map(
+    (diag: {
+      message: string
+      severity?: number
+      range: {
+        start: { line: number; character: number }
+        end: { line: number; character: number }
+      }
+      source?: string
+      code?: string | number
+    }) => ({
+      message: diag.message,
+      severity: mapLSPSeverity(diag.severity),
+      range: {
+        start: {
+          line: diag.range.start.line,
+          character: diag.range.start.character,
+        },
+        end: {
+          line: diag.range.end.line,
+          character: diag.range.end.character,
+        },
+      },
+      source: diag.source,
+      code:
+        diag.code !== undefined && diag.code !== null
+          ? String(diag.code)
+          : undefined,
+    }),
+  )
+
+  return [
+    {
+      uri,
+      diagnostics,
+    },
+  ]
+}
+
+/**
+ * Handler registration result with tracking data
+ */
+export type HandlerRegistrationResult = {
+  /** Total number of servers */
+  totalServers: number
+  /** Number of successful registrations */
+  successCount: number
+  /** Registration errors per server */
+  registrationErrors: Array<{ serverName: string; error: string }>
+  /** Runtime failure tracking (shared across all handler invocations) */
+  diagnosticFailures: Map<string, { count: number; lastError: string }>
+}
+
+/**
+ * Register LSP notification handlers on all servers
+ *
+ * Sets up handlers to listen for textDocument/publishDiagnostics notifications
+ * from all LSP servers and routes them to Claude's diagnostic system.
+ * Uses public getAllServers() API for clean access to server instances.
+ *
+ * @returns Tracking data for registration status and runtime failures
+ */
+export function registerLSPNotificationHandlers(
+  manager: LSPServerManager,
+): HandlerRegistrationResult {
+  // Register handlers on all configured servers to capture diagnostics from any language
+  const servers = manager.getAllServers()
+
+  // Track partial failures - allow successful server registrations even if some fail
+  const registrationErrors: Array<{ serverName: string; error: string }> = []
+  let successCount = 0
+
+  // Track consecutive failures per server to warn users after 3+ failures
+  const diagnosticFailures: Map<string, { count: number; lastError: string }> =
+    new Map()
+
+  for (const [serverName, serverInstance] of servers.entries()) {
+    try {
+      // Validate server instance has onNotification method
+      if (
+        !serverInstance ||
+        typeof serverInstance.onNotification !== 'function'
+      ) {
+        const errorMsg = !serverInstance
+          ? 'Server instance is null/undefined'
+          : 'Server instance has no onNotification method'
+
+        registrationErrors.push({ serverName, error: errorMsg })
+
+        const err = new Error(`${errorMsg} for ${serverName}`)
+        logError(err)
+        logForDebugging(
+          `Skipping handler registration for ${serverName}: ${errorMsg}`,
+        )
+        continue // Skip this server but track the failure
+      }
+
+      // Errors are isolated to avoid breaking other servers
+      serverInstance.onNotification(
+        'textDocument/publishDiagnostics',
+        (params: unknown) => {
+          logForDebugging(
+            `[PASSIVE DIAGNOSTICS] Handler invoked for ${serverName}! Params type: ${typeof params}`,
+          )
+          try {
+            // Validate params structure before casting
+            if (
+              !params ||
+              typeof params !== 'object' ||
+              !('uri' in params) ||
+              !('diagnostics' in params)
+            ) {
+              const err = new Error(
+                `LSP server ${serverName} sent invalid diagnostic params (missing uri or diagnostics)`,
+              )
+              logError(err)
+              logForDebugging(
+                `Invalid diagnostic params from ${serverName}: ${jsonStringify(params)}`,
+              )
+              return
+            }
+
+            const diagnosticParams = params as PublishDiagnosticsParams
+            logForDebugging(
+              `Received diagnostics from ${serverName}: ${diagnosticParams.diagnostics.length} diagnostic(s) for ${diagnosticParams.uri}`,
+            )
+
+            // Convert LSP diagnostics to Claude format (can throw on invalid URIs)
+            const diagnosticFiles =
+              formatDiagnosticsForAttachment(diagnosticParams)
+
+            // Only send notification if there are diagnostics
+            const firstFile = diagnosticFiles[0]
+            if (
+              !firstFile ||
+              diagnosticFiles.length === 0 ||
+              firstFile.diagnostics.length === 0
+            ) {
+              logForDebugging(
+                `Skipping empty diagnostics from ${serverName} for ${diagnosticParams.uri}`,
+              )
+              return
+            }
+
+            // Register diagnostics for async delivery via attachment system
+            // Follows same pattern as AsyncHookRegistry for consistent async attachment delivery
+            try {
+              registerPendingLSPDiagnostic({
+                serverName,
+                files: diagnosticFiles,
+              })
+
+              logForDebugging(
+                `LSP Diagnostics: Registered ${diagnosticFiles.length} diagnostic file(s) from ${serverName} for async delivery`,
+              )
+
+              // Success - reset failure counter for this server
+              diagnosticFailures.delete(serverName)
+            } catch (error) {
+              const err = toError(error)
+              logError(err)
+              logForDebugging(
+                `Error registering LSP diagnostics from ${serverName}: ` +
+                  `URI: ${diagnosticParams.uri}, ` +
+                  `Diagnostic count: ${firstFile.diagnostics.length}, ` +
+                  `Error: ${err.message}`,
+              )
+
+              // Track consecutive failures and warn after 3+
+              const failures = diagnosticFailures.get(serverName) || {
+                count: 0,
+                lastError: '',
+              }
+              failures.count++
+              failures.lastError = err.message
+              diagnosticFailures.set(serverName, failures)
+
+              if (failures.count >= 3) {
+                logForDebugging(
+                  `WARNING: LSP diagnostic handler for ${serverName} has failed ${failures.count} times consecutively. ` +
+                    `Last error: ${failures.lastError}. ` +
+                    `This may indicate a problem with the LSP server or diagnostic processing. ` +
+                    `Check logs for details.`,
+                )
+              }
+            }
+          } catch (error) {
+            // Catch any unexpected errors from the entire handler to prevent breaking the notification loop
+            const err = toError(error)
+            logError(err)
+            logForDebugging(
+              `Unexpected error processing diagnostics from ${serverName}: ${err.message}`,
+            )
+
+            // Track consecutive failures and warn after 3+
+            const failures = diagnosticFailures.get(serverName) || {
+              count: 0,
+              lastError: '',
+            }
+            failures.count++
+            failures.lastError = err.message
+            diagnosticFailures.set(serverName, failures)
+
+            if (failures.count >= 3) {
+              logForDebugging(
+                `WARNING: LSP diagnostic handler for ${serverName} has failed ${failures.count} times consecutively. ` +
+                  `Last error: ${failures.lastError}. ` +
+                  `This may indicate a problem with the LSP server or diagnostic processing. ` +
+                  `Check logs for details.`,
+              )
+            }
+
+            // Don't re-throw - isolate errors to this server only
+          }
+        },
+      )
+
+      logForDebugging(`Registered diagnostics handler for ${serverName}`)
+      successCount++
+    } catch (error) {
+      const err = toError(error)
+
+      registrationErrors.push({
+        serverName,
+        error: err.message,
+      })
+
+      logError(err)
+      logForDebugging(
+        `Failed to register diagnostics handler for ${serverName}: ` +
+          `Error: ${err.message}`,
+      )
+    }
+  }
+
+  // Report overall registration status
+  const totalServers = servers.size
+  if (registrationErrors.length > 0) {
+    const failedServers = registrationErrors
+      .map(e => `${e.serverName} (${e.error})`)
+      .join(', ')
+    // Log aggregate failures for tracking
+    logError(
+      new Error(
+        `Failed to register diagnostics for ${registrationErrors.length} LSP server(s): ${failedServers}`,
+      ),
+    )
+    logForDebugging(
+      `LSP notification handler registration: ${successCount}/${totalServers} succeeded. ` +
+        `Failed servers: ${failedServers}. ` +
+        `Diagnostics from failed servers will not be delivered.`,
+    )
+  } else {
+    logForDebugging(
+      `LSP notification handlers registered successfully for all ${totalServers} server(s)`,
+    )
+  }
+
+  // Return tracking data for monitoring and testing
+  return {
+    totalServers,
+    successCount,
+    registrationErrors,
+    diagnosticFailures,
+  }
+}

package/services/mcp/InProcessTransport.ts

@@ -0,0 +1,63 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js'
+
+/**
+ * In-process linked transport pair for running an MCP server and client
+ * in the same process without spawning a subprocess.
+ *
+ * `send()` on one side delivers to `onmessage` on the other.
+ * `close()` on either side calls `onclose` on both.
+ */
+class InProcessTransport implements Transport {
+  private peer: InProcessTransport | undefined
+  private closed = false
+
+  onclose?: () => void
+  onerror?: (error: Error) => void
+  onmessage?: (message: JSONRPCMessage) => void
+
+  /** @internal */
+  _setPeer(peer: InProcessTransport): void {
+    this.peer = peer
+  }
+
+  async start(): Promise<void> {}
+
+  async send(message: JSONRPCMessage): Promise<void> {
+    if (this.closed) {
+      throw new Error('Transport is closed')
+    }
+    // Deliver to the other side asynchronously to avoid stack depth issues
+    // with synchronous request/response cycles
+    queueMicrotask(() => {
+      this.peer?.onmessage?.(message)
+    })
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) {
+      return
+    }
+    this.closed = true
+    this.onclose?.()
+    // Close the peer if it hasn't already closed
+    if (this.peer && !this.peer.closed) {
+      this.peer.closed = true
+      this.peer.onclose?.()
+    }
+  }
+}
+
+/**
+ * Creates a pair of linked transports for in-process MCP communication.
+ * Messages sent on one transport are delivered to the other's `onmessage`.
+ *
+ * @returns [clientTransport, serverTransport]
+ */
+export function createLinkedTransportPair(): [Transport, Transport] {
+  const a = new InProcessTransport()
+  const b = new InProcessTransport()
+  a._setPeer(b)
+  b._setPeer(a)
+  return [a, b]
+}