fix: typing and launch things

Author: bajrangCoder

src/cm/lsp/diagnostics.ts

@@ -10,6 +10,8 @@ import {
 } from "@codemirror/state";
 import type { EditorView } from "@codemirror/view";
 import type {
+	LSPClientWithWorkspace,
+	LSPPluginAPI,
 	LspDiagnostic,
 	PublishDiagnosticsParams,
 	RawDiagnostic,
@@ -70,24 +72,8 @@ const severities: DiagnosticSeverity[] = [
 	"hint",
 ];
 
-interface LSPPluginInstance {
-	fromPosition: (
-		pos: { line: number; character: number },
-		doc: unknown,
-	) => number;
-	syncedDoc: { length: number };
-	unsyncedChanges: {
-		mapPos: (pos: number, assoc?: number, mode?: MapMode) => number | null;
-		empty: boolean;
-	};
-	client: {
-		sync: () => void;
-	};
-	clear: () => void;
-}
-
 function storeLspDiagnostics(
-	plugin: LSPPluginInstance,
+	plugin: LSPPluginAPI,
 	diagnostics: RawDiagnostic[],
 ): StateEffect<LspDiagnostic[]> {
 	const items: LspDiagnostic[] = [];
@@ -133,7 +119,7 @@ function storeLspDiagnostics(
 }
 
 function mapDiagnostics(
-	plugin: LSPPluginInstance,
+	plugin: LSPPluginAPI,
 	state: EditorState,
 ): Diagnostic[] {
 	plugin.client.sync();
@@ -159,24 +145,11 @@ function mapDiagnostics(
 }
 
 function lspLinterSource(view: EditorView): Diagnostic[] {
-	const plugin = LSPPlugin.get(view) as LSPPluginInstance | null;
+	const plugin = LSPPlugin.get(view) as LSPPluginAPI | null;
 	if (!plugin) return [];
 	return mapDiagnostics(plugin, view.state);
 }
 
-interface WorkspaceFile {
-	version: number;
-	getView: () => EditorView | null;
-}
-
-interface WorkspaceWithGetFile {
-	getFile: (uri: string) => WorkspaceFile | null;
-}
-
-interface LSPClientWithWorkspace {
-	workspace: WorkspaceWithGetFile;
-}
-
 export function lspDiagnosticsClientExtension(): {
 	clientCapabilities: Record<string, unknown>;
 	notificationHandlers: Record<
@@ -200,7 +173,7 @@ export function lspDiagnosticsClientExtension(): {
 				client: LSPClient,
 				params: PublishDiagnosticsParams,
 			): boolean => {
-				const clientWithWorkspace = client as LSPClientWithWorkspace;
+				const clientWithWorkspace = client as unknown as LSPClientWithWorkspace;
 				const file = clientWithWorkspace.workspace.getFile(params.uri);
 				if (
 					!file ||
@@ -210,7 +183,7 @@ export function lspDiagnosticsClientExtension(): {
 				}
 				const view = file.getView();
 				if (!view) return false;
-				const plugin = LSPPlugin.get(view) as LSPPluginInstance | null;
+				const plugin = LSPPlugin.get(view) as LSPPluginAPI | null;
 				if (!plugin) return false;
 
 				view.dispatch({

src/cm/lsp/index.ts

@@ -26,10 +26,13 @@ export type {
 	BuiltinExtensionsConfig,
 	ClientManagerOptions,
 	ClientState,
+	DiagnosticRelatedInformation,
 	FileMetadata,
 	FormattingOptions,
+	LSPClientWithWorkspace,
 	LSPDiagnostic,
 	LSPFormattingOptions,
+	LSPPluginAPI,
 	LspDiagnostic,
 	LspServerDefinition,
 	Position,

src/cm/lsp/inlayHints.ts

@@ -21,6 +21,7 @@ import type {
 	InlayHintLabelPart,
 	Position,
 } from "vscode-languageserver-types";
+import type { LSPPluginAPI } from "./types";
 
 // ============================================================================
 // Types
@@ -131,15 +132,6 @@ function buildDecos(hints: ProcessedHint[], docLen: number): DecorationSet {
 // Plugin
 // ============================================================================
 
-interface PluginAPI {
-	uri: string;
-	client: LSPClient;
-	toPosition: (offset: number) => Position;
-	fromPosition: (pos: Position, doc?: unknown) => number;
-	syncedDoc: { length: number };
-	unsyncedChanges: { mapPos: (pos: number) => number | null };
-}
-
 function createPlugin(config: InlayHintsConfig) {
 	const delay = config.debounceMs ?? 200;
 	const max = config.maxHints ?? 500;
@@ -179,7 +171,7 @@ function createPlugin(config: InlayHintsConfig) {
 			}
 
 			async fetch(): Promise<void> {
-				const lsp = LSPPlugin.get(this.view) as PluginAPI | null;
+				const lsp = LSPPlugin.get(this.view) as LSPPluginAPI | null;
 				if (!lsp?.client.connected) return;
 
 				const caps = lsp.client.serverCapabilities;
@@ -220,7 +212,7 @@ function createPlugin(config: InlayHintsConfig) {
 			}
 
 			process(
-				lsp: PluginAPI,
+				lsp: LSPPluginAPI,
 				hints: InlayHint[],
 				docLen: number,
 			): ProcessedHint[] {

src/cm/lsp/serverLauncher.ts

@@ -202,6 +202,10 @@ async function startInteractiveServer(
 			console.warn(`[${serverId}] ${data}`);
 		} else if (type === "stdout" && data && data.trim()) {
 			console.info(`[${serverId}] ${data}`);
+			// Detect when the axs proxy signals it's listening
+			if (/listening on/i.test(data)) {
+				signalServerReady(serverId);
+			}
 		}
 	};
 	const uuid = await executor.start(command, callback, true);
@@ -217,59 +221,68 @@ function sleep(ms: number): Promise<void> {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * Tracks servers that have signaled they're ready (listening)
+ * Key: serverId, Value: timestamp when ready
+ */
+const serverReadySignals = new Map<string, number>();
+
+/**
+ * Called when stdout contains a "listening" message from the axs proxy.
+ * This signals that the server is ready to accept connections.
+ */
+export function signalServerReady(serverId: string): void {
+	serverReadySignals.set(serverId, Date.now());
+}
+
+/**
+ * Wait for the LSP server to be ready.
+ *
+ * This function polls for a ready signal (set when stdout contains "listening")
+ */
 async function waitForWebSocket(
 	url: string,
 	options: WaitOptions = {},
 ): Promise<void> {
-	const { attempts = 20, delay = 200, probeTimeout = 2000 } = options;
+	const {
+		delay = 100, // Poll interval
+		probeTimeout = 5000, // Max wait time
+	} = options;
+
+	// Extract server ID from URL (e.g., "ws://127.0.0.1:2090" -> check by port)
+	const portMatch = url.match(/:(\d+)/);
+	const port = portMatch ? portMatch[1] : null;
+
+	// Find the server ID that's starting on this port
+	let targetServerId: string | null = null;
+	const entries = Array.from(managedServers.entries());
+	for (const [serverId, entry] of entries) {
+		if (
+			entry.command.includes(`--port ${port}`) ||
+			entry.command.includes(`:${port}`)
+		) {
+			targetServerId = serverId;
+			break;
+		}
+	}
 
-	let lastError: Error | null = null;
-	for (let i = 0; i < attempts; i++) {
-		try {
-			await new Promise<void>((resolve, reject) => {
-				let socket: WebSocket | null = null;
-				let timer: ReturnType<typeof setTimeout> | null = null;
-				try {
-					socket = new WebSocket(url);
-				} catch (error) {
-					reject(error);
-					return;
-				}
-
-				const cleanup = (cb?: () => void): void => {
-					if (timer) clearTimeout(timer);
-					if (socket) {
-						socket.onopen = null;
-						socket.onerror = null;
-						try {
-							socket.close();
-						} catch (_) {
-							// Ignore close errors
-						}
-					}
-					if (cb) cb();
-				};
-
-				socket.onopen = () => cleanup(resolve);
-				socket.onerror = (event: Event) =>
-					cleanup(() =>
-						reject(
-							event instanceof Error ? event : new Error("websocket error"),
-						),
-					);
-				timer = setTimeout(
-					() => cleanup(() => reject(new Error("timeout"))),
-					probeTimeout,
-				);
-			});
+	const deadline = Date.now() + probeTimeout;
+
+	while (Date.now() < deadline) {
+		// Check if we got a ready signal
+		if (targetServerId && serverReadySignals.has(targetServerId)) {
+			// Server is ready, clear the signal and return
+			serverReadySignals.delete(targetServerId);
 			return;
-		} catch (error) {
-			lastError = error instanceof Error ? error : new Error(String(error));
-			await sleep(delay);
 		}
+
+		await sleep(delay);
 	}
-	const reason = lastError ? lastError.message || String(lastError) : "unknown";
-	throw new Error(`WebSocket ${url} did not become ready (${reason})`);
+
+	// Timeout reached, proceed anyway (transport will retry if needed)
+	console.debug(
+		`[LSP] waitForWebSocket timed out for ${url}, proceeding anyway`,
+	);
 }
 
 interface LspError extends Error {

src/cm/lsp/types.ts

@@ -6,8 +6,9 @@ import type {
 	Workspace,
 	WorkspaceFile,
 } from "@codemirror/lsp-client";
-import type { ChangeSet, Extension, Text } from "@codemirror/state";
+import type { ChangeSet, Extension, MapMode, Text } from "@codemirror/state";
 import type { EditorView } from "@codemirror/view";
+
 import type {
 	Diagnostic as LSPDiagnostic,
 	FormattingOptions as LSPFormattingOptions,
@@ -247,6 +248,20 @@ export interface LspDiagnostic {
 	severity: "error" | "warning" | "info" | "hint";
 	message: string;
 	source?: string;
+	/** Related diagnostic information (e.g., location of declaration for 'unused' errors) */
+	relatedInformation?: DiagnosticRelatedInformation[];
+}
+
+/** Related information for a diagnostic (mapped to editor positions) */
+export interface DiagnosticRelatedInformation {
+	/** Document URI */
+	uri: string;
+	/** Start position (offset in document) */
+	from: number;
+	/** End position (offset in document) */
+	to: number;
+	/** Message describing the relationship */
+	message: string;
 }
 
 export interface PublishDiagnosticsParams {
@@ -261,6 +276,17 @@ export interface RawDiagnostic {
 	code?: number | string;
 	source?: string;
 	message: string;
+	/** Related diagnostic locations from LSP (raw positions) */
+	relatedInformation?: RawDiagnosticRelatedInformation[];
+}
+
+/** Raw related information from LSP (before position mapping) */
+export interface RawDiagnosticRelatedInformation {
+	location: {
+		uri: string;
+		range: Range;
+	};
+	message: string;
 }
 
 // ============================================================================
@@ -285,6 +311,54 @@ export interface ParsedUri {
 	isFileUri?: boolean;
 }
 
+/**
+ * Interface representing the LSPPlugin instance API.
+ */
+export interface LSPPluginAPI {
+	/** The document URI this plugin is attached to */
+	uri: string;
+	/** The LSP client instance */
+	client: LSPClient & { sync: () => void; connected?: boolean };
+	/** Convert a document offset to an LSP Position */
+	toPosition: (offset: number) => { line: number; character: number };
+	/** Convert an LSP Position to a document offset */
+	fromPosition: (
+		pos: { line: number; character: number },
+		doc?: unknown,
+	) => number;
+	/** The currently synced document state */
+	syncedDoc: { length: number };
+	/** Pending changes that haven't been synced yet */
+	unsyncedChanges: {
+		mapPos: (pos: number, assoc?: number, mode?: MapMode) => number | null;
+		empty: boolean;
+	};
+	/** Clear pending changes */
+	clear: () => void;
+}
+
+/**
+ * Interface for workspace file with view access
+ */
+export interface WorkspaceFileWithView {
+	version: number;
+	getView: () => EditorView | null;
+}
+
+/**
+ * Interface for workspace with file access
+ */
+export interface WorkspaceWithFileAccess {
+	getFile: (uri: string) => WorkspaceFileWithView | null;
+}
+
+/**
+ * LSPClient with workspace access (for type casting in notification handlers)
+ */
+export interface LSPClientWithWorkspace {
+	workspace: WorkspaceWithFileAccess;
+}
+
 // Extend the LSPClient with Acode-specific properties
 declare module "@codemirror/lsp-client" {
 	interface LSPClient {