@mrclrchtr/supi-lsp 11.0.1 → 11.2.0

package/src/config/typescript-launch.ts

@@ -0,0 +1,276 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { major, prerelease, valid } from "semver";
+import type { ServerConfig, TypeScriptSelection } from "./server-config.ts";
+
+interface CompilerPackage {
+  directory: string;
+  name?: string;
+  version?: string;
+  bin?: unknown;
+}
+
+/** Launch options and truthful compiler facts for one root; never cached across starts. */
+export interface TypeScriptLaunch {
+  /** Native packages use their declared Node launcher, without a PATH dependency. */
+  command?: string;
+  args?: string[];
+  initializationOptions: unknown;
+  typescript?: TypeScriptSelection;
+}
+
+/** Retain already-known selection facts when validating launch files fails. */
+class TypeScriptLaunchError extends Error {
+  readonly typescript: TypeScriptSelection | undefined;
+  constructor(message: string, options: ErrorOptions & { typescript?: TypeScriptSelection }) {
+    super(message, options);
+    this.typescript = options.typescript;
+  }
+}
+
+/** True for an installed package name/alias, never a path, URL, or package subpath. */
+export function isTypeScriptPackageName(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    /^(?:@[a-z0-9._-]+\/)?[a-z0-9_][a-z0-9._-]*$/i.test(value) &&
+    ![".", ".."].includes(value)
+  );
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+/** Resolve fresh package files using Node's root-relative node_modules search paths.
+ * Probing the package directory (rather than require.resolve's cached realpath) both
+ * detects broken selections and observes package-manager symlink changes on retry.
+ * Package exports need not expose package.json; no compiler code is executed.
+ */
+function findPackage(name: string, from: string): CompilerPackage | undefined {
+  const require = createRequire(path.join(from, "__supi_lsp_resolve__.cjs"));
+  for (const base of require.resolve.paths(name) ?? []) {
+    const directory = path.join(base, name);
+    try {
+      fs.lstatSync(directory);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+      throw error;
+    }
+    return readCompilerPackage(fs.realpathSync(directory));
+  }
+  return undefined;
+}
+
+function readCompilerPackage(directory: string): CompilerPackage {
+  const manifest = record(
+    JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8")),
+  );
+  if (
+    !manifest ||
+    (manifest.name !== undefined && typeof manifest.name !== "string") ||
+    (manifest.version !== undefined &&
+      (typeof manifest.version !== "string" || !valid(manifest.version)))
+  ) {
+    throw new Error(`Invalid package manifest at ${directory}`);
+  }
+  return {
+    directory,
+    name: typeof manifest.name === "string" ? manifest.name : undefined,
+    version: typeof manifest.version === "string" ? manifest.version : undefined,
+    bin: manifest.bin,
+  };
+}
+
+/** Apply the bounded TypeScript compiler policy without changing the settings snapshot.
+ * Programmatic configurations without loader provenance remain manual. Explicit
+ * launch fields bypass all package probing; a selector may not coexist with them.
+ */
+export function resolveTypeScriptLaunch(
+  name: string,
+  config: ServerConfig,
+  root: string,
+): TypeScriptLaunch {
+  const unchanged = { initializationOptions: config.initializationOptions };
+  if (name !== "typescript") return unchanged;
+  if (isManualTypeScriptLaunch(config, root)) return unchanged;
+  const selector = config.typescriptPackage;
+  let selected = selector ?? "typescript";
+  try {
+    if (!isTypeScriptPackageName(selected))
+      throw new Error("Expected an installed package name or alias, not a filesystem path.");
+    const probe = (installedName: string) => {
+      selected = installedName; // Retain the failing candidate's identity for the error.
+      return findPackage(installedName, root);
+    };
+    const selection =
+      selector === undefined ? selectAutomaticCompiler(probe) : { selected, pkg: probe(selected) };
+    const { pkg } = selection;
+    selected = selection.selected;
+    if (!pkg) {
+      if (selector !== undefined) throw new Error("Selected package is not installed.");
+      return unchanged; // Preserve TLS's legacy lookup when neither candidate exists.
+    }
+    return compilerLaunch(config.initializationOptions, pkg, selected);
+  } catch (error) {
+    throw new TypeScriptLaunchError(
+      `TypeScript launch at ${root}, package "${selected}": ${error instanceof Error ? error.message : String(error)} Repair/install the selected TypeScript package, or use explicit launch configuration; then refresh health. Reload after changing launch settings.`,
+      {
+        cause: error,
+        typescript: error instanceof TypeScriptLaunchError ? error.typescript : undefined,
+      },
+    );
+  }
+}
+
+/** Short-circuit on native metadata; validate only the winner's launch files later. */
+function selectAutomaticCompiler(probe: (name: string) => CompilerPackage | undefined): {
+  selected: string;
+  pkg?: CompilerPackage;
+} {
+  const canonical = probe("typescript");
+  if (canonical && compilerBackend(canonical) === "native")
+    return { selected: "typescript", pkg: canonical };
+  const native = probe("@typescript/native");
+  if (native) {
+    if (compilerBackend(native) !== "native")
+      throw new Error("@typescript/native must alias the stable native typescript package.");
+    return { selected: "@typescript/native", pkg: native };
+  }
+  if (canonical) return { selected: "typescript", pkg: canonical };
+  return { selected: "@typescript/typescript6", pkg: probe("@typescript/typescript6") };
+}
+
+/** Determine launch authority and reject conflicting selectors without probing installations. */
+export function isManualTypeScriptLaunch(config: ServerConfig, root: string): boolean {
+  const fields = config.typescriptExplicitFields ?? { command: "programmatic configuration" };
+  const tsserver = record(record(config.initializationOptions)?.tsserver);
+  const conflicts = [
+    ...(fields.command ? [`command (${fields.command})`] : []),
+    ...(fields.args ? [`args (${fields.args})`] : []),
+    ...(tsserver && Object.hasOwn(tsserver, "path")
+      ? [
+          `initializationOptions.tsserver.path (${fields.tsserverPath ?? "programmatic configuration"})`,
+        ]
+      : []),
+  ];
+  if (config.typescriptPackage !== undefined && conflicts.length) {
+    throw new Error(
+      `TypeScript launch at ${root}: typescriptPackage "${config.typescriptPackage}" (${fields.typescriptPackage ?? "programmatic configuration"}) conflicts with ${conflicts.join(", ")}. Remove the selector or the explicit launch fields and reload.`,
+    );
+  }
+  return conflicts.length > 0;
+}
+
+/** Classify consulted metadata before considering a lower-priority candidate. */
+function compilerBackend(pkg: CompilerPackage): "native" | "tsserver" {
+  if (pkg.name === "@typescript/typescript6" && !pkg.version) return "tsserver";
+  if (pkg.name === "typescript" && !pkg.version)
+    throw new Error(
+      `Selected implementation at ${pkg.directory} has no compiler version in package.json.`,
+    );
+  const version = pkg.version && !prerelease(pkg.version) ? major(pkg.version) : undefined;
+  if (pkg.name === "@typescript/typescript6" && version === 6) return "tsserver";
+  if (pkg.name === "typescript" && version !== undefined && version <= 7)
+    return version === 7 ? "native" : "tsserver";
+  throw new Error(
+    `Unsupported automatic TypeScript backend ${pkg.name ?? "(unknown identity)"} ${pkg.version ?? "(unknown version)"}. Select an installed stable TS7 or legacy TypeScript package with typescriptPackage, or configure command/args manually.`,
+  );
+}
+
+function compilerLaunch(
+  initializationOptions: unknown,
+  selectedPackage: CompilerPackage,
+  selected: string,
+): TypeScriptLaunch {
+  let pkg = selectedPackage;
+  const backend = compilerBackend(pkg);
+  if (backend === "native") return nativeLaunch(initializationOptions, pkg, selected);
+  const wrapper = pkg.name === "@typescript/typescript6" ? pkg : undefined;
+  if (wrapper) {
+    const underlying = findPackage("@typescript/old", wrapper.directory);
+    if (!underlying)
+      throw new Error(`Wrapper at ${wrapper.directory} has no @typescript/old dependency.`);
+    pkg = underlying;
+  }
+  // TLS ignores an explicit path without implementation version metadata and
+  // tries other installations. Fail here rather than report a compiler it won't use.
+  if (!pkg.version)
+    throw new Error(
+      `Selected implementation at ${pkg.directory} has no compiler version in package.json; TLS would ignore this selection.`,
+    );
+  if (compilerBackend(pkg) !== "tsserver" || pkg.name !== "typescript")
+    throw new Error(`Wrapper implementation at ${pkg.directory} must be legacy TypeScript.`);
+  const serverPath = path.join(pkg.directory, "lib/tsserver.js");
+  if (!fs.statSync(serverPath).isFile()) throw new Error(`No tsserver.js at ${serverPath}.`);
+  const options = record(initializationOptions);
+  const tsserver = record(options?.tsserver);
+  return {
+    initializationOptions: { ...options, tsserver: { ...tsserver, path: serverPath } },
+    typescript: {
+      backend: "tsserver",
+      packageName: selected,
+      compilerVersion: pkg.version,
+      ...(wrapper?.version ? { wrapperVersion: wrapper.version } : {}),
+    },
+  };
+}
+
+function nativeLaunch(
+  initializationOptions: unknown,
+  pkg: CompilerPackage,
+  selected: string,
+): TypeScriptLaunch {
+  const typescript: TypeScriptSelection = {
+    backend: "native",
+    packageName: selected,
+    compilerVersion: pkg.version,
+  };
+  try {
+    return {
+      command: process.execPath,
+      args: [nativeLauncher(pkg), "--lsp", "--stdio"],
+      initializationOptions,
+      typescript,
+    };
+  } catch (error) {
+    throw new TypeScriptLaunchError(error instanceof Error ? error.message : String(error), {
+      cause: error,
+      typescript,
+    });
+  }
+}
+
+function nativeLauncher(pkg: CompilerPackage): string {
+  const executable = record(pkg.bin)?.tsc;
+  if (typeof executable !== "string" || !executable || path.isAbsolute(executable))
+    throw new Error(
+      `Native package at ${pkg.directory} must declare a relative bin.tsc executable.`,
+    );
+  const launcher = path.resolve(pkg.directory, executable);
+  const relative = path.relative(pkg.directory, launcher);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || !fs.statSync(launcher).isFile())
+    throw new Error(`Invalid native tsc executable at ${launcher}.`);
+  return launcher;
+}
+
+/** Non-throwing selection probe shared by discovery and missing-server reporting. */
+export function inspectTypeScriptLaunch(
+  name: string,
+  config: ServerConfig,
+  root: string,
+): Pick<TypeScriptLaunch, "typescript"> & { command: string; failureMessage?: string } {
+  try {
+    const { command, typescript } = resolveTypeScriptLaunch(name, config, root);
+    return { command: command ?? config.command, ...(typescript ? { typescript } : {}) };
+  } catch (error) {
+    const typescript = error instanceof TypeScriptLaunchError ? error.typescript : undefined;
+    return {
+      command: typescript?.backend === "native" ? process.execPath : config.command,
+      ...(typescript ? { typescript } : {}),
+      failureMessage: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/src/manager/manager-project-info.ts

@@ -1,6 +1,10 @@
 import type { LspClient } from "../client/client.ts";
 import { getServerOperationSupport } from "../config/operation-support.ts";
-import type { ProjectServerInfo, ProjectServerStatusReason } from "../config/server-config.ts";
+import type {
+  ProjectServerInfo,
+  ProjectServerStatusReason,
+  TypeScriptSelection,
+} from "../config/server-config.ts";
 import { displayRelativeFilePath } from "../summary.ts";
 
 interface ProjectServerInfoInput {
@@ -10,29 +14,37 @@ interface ProjectServerInfoInput {
   client: LspClient | undefined;
   unavailableReason?: "missing-command" | "start-failed" | "runtime-error";
   statusReason?: ProjectServerStatusReason;
+  typescript?: TypeScriptSelection;
+  failureMessage?: string;
   /** Filter files from ambient project status without changing explicit routing. */
   includeOpenFile?: (file: string) => boolean;
 }
 
+function projectStatus(input: ProjectServerInfoInput): ProjectServerInfo["status"] {
+  if (input.statusReason || input.failureMessage) return "error";
+  if (input.client?.status === "running") return "running";
+  if (
+    input.client?.status === "error" ||
+    input.unavailableReason === "start-failed" ||
+    input.unavailableReason === "runtime-error"
+  )
+    return "error";
+  return "unavailable";
+}
+
 export function buildProjectServerInfo(
   input: ProjectServerInfoInput,
   cwd: string,
 ): ProjectServerInfo {
-  const status = input.statusReason
-    ? "error"
-    : input.client?.status === "running"
-      ? "running"
-      : input.client?.status === "error" || input.unavailableReason === "start-failed"
-        ? "error"
-        : input.unavailableReason === "runtime-error"
-          ? "error"
-          : "unavailable";
+  const status = projectStatus(input);
 
   return {
     name: input.serverName,
     root: input.root,
     fileTypes: input.fileTypes,
     status,
+    ...(input.typescript ? { typescript: input.typescript } : {}),
+    ...(input.failureMessage ? { failureMessage: input.failureMessage } : {}),
     ...(input.statusReason ? { statusReason: input.statusReason } : {}),
     openFiles:
       input.client?.openFiles

package/src/manager/manager.ts

@@ -48,6 +48,7 @@ import type {
   WorkspaceSymbol,
 } from "../config/types.ts";
 import { FileChangeType } from "../config/types.ts";
+import { inspectTypeScriptLaunch } from "../config/typescript-launch.ts";
 import { boundCwd } from "../debug-telemetry.ts";
 import {
   accumulateOutstandingDiagnostics,
@@ -437,8 +438,12 @@ export class LspManager {
   canServeFile(filePath: string): boolean {
     const route = this.resolveFileRoute(filePath);
     if (!route) return false;
-    if (this.getUnavailableReason(route.key, route.serverConfig.command)) return false;
-    return this.isServerCommandAvailable(route.serverConfig.command);
+    if (this.getUnavailableReason(route.key, route.serverName, route.root)) return false;
+    if (this.clients.get(route.key)?.status === "running") return true;
+    const launch = inspectTypeScriptLaunch(route.serverName, route.serverConfig, route.root);
+    // A broken selection is a route failure, not an absent executable. Let
+    // startup record it so lazy readiness and health expose the actual error.
+    return Boolean(launch.failureMessage) || this.isServerCommandAvailable(launch.command);
   }
 
   /**
@@ -517,13 +522,21 @@ export class LspManager {
     return available;
   }
 
-  private getUnavailableReason(key: string, command?: string): UnavailableReason | null {
+  private getUnavailableReason(
+    key: string,
+    serverName: string,
+    root: string,
+  ): UnavailableReason | null {
     const reason = this.unavailable.get(key);
     if (!reason) return null;
 
-    if (reason === "missing-command" && command && this.isServerCommandAvailable(command)) {
-      this.unavailable.delete(key);
-      return null;
+    const config = this.config.servers[serverName];
+    if (reason === "missing-command" && config) {
+      const launch = inspectTypeScriptLaunch(serverName, config, root);
+      if (!launch.failureMessage && this.isServerCommandAvailable(launch.command)) {
+        this.unavailable.delete(key);
+        return null;
+      }
     }
 
     return reason;
@@ -573,7 +586,7 @@ export class LspManager {
     if (this.shouldBlockRetiredRoute(key, root, retryFailedStart)) return null;
     const routeGeneration = this.getRouteRetirementGeneration(key);
     if (retryFailedStart) this.unavailable.delete(key);
-    if (!retryFailedStart && this.getUnavailableReason(key, serverConfig.command)) return null;
+    if (!retryFailedStart && this.getUnavailableReason(key, serverName, root)) return null;
 
     // Return existing client
     const existing = this.clients.get(key);
@@ -1460,22 +1473,30 @@ export class LspManager {
     }
   }
 
+  /** Record a root-aware selection/command failure without starting a client. */
+  private recordUnavailableLaunch(route: FileRoute): boolean {
+    const { serverName, serverConfig, root, key } = route;
+    const launch = inspectTypeScriptLaunch(serverName, serverConfig, root);
+    const command = launch.command;
+    if (!launch.failureMessage && commandExists(command)) return false;
+    this.unavailable.set(key, launch.failureMessage ? "start-failed" : "missing-command");
+    this.failedStarts.set(key, {
+      serverName,
+      root,
+      failureMessage:
+        launch.failureMessage ?? `Configured server command is not available: ${command}`,
+    });
+    return true;
+  }
+
   /**
    * Perform the actual server start — extracted so the public method can
    * deduplicate via pendingStarts without wrapping the entire body.
    */
   private async performStart(route: FileRoute, routeGeneration: number): Promise<LspClient | null> {
     const { serverName, serverConfig, root, key } = route;
-    // Validate command exists
-    if (!commandExists(serverConfig.command)) {
-      this.unavailable.set(key, "missing-command");
-      this.failedStarts.set(key, {
-        serverName,
-        root,
-        failureMessage: `Configured server command is not available: ${serverConfig.command}`,
-      });
-      return null;
-    }
+    // Client.start resolves again at actual spawn time, including every retry.
+    if (this.recordUnavailableLaunch(route)) return null;
 
     // Spawn new client
     const client = this.createClient(serverName, serverConfig, root, key);
@@ -1659,14 +1680,26 @@ export class LspManager {
 
   getProjectServerInfo(serverName: string, root: string, fileTypes: string[]): ProjectServerInfo {
     const key = clientKey(serverName, root);
+    const client = this.clients.get(key);
+    const config = this.config.servers[serverName];
+    const selection: Pick<DetectedProjectServer, "typescript" | "failureMessage"> =
+      client?.status === "running"
+        ? { typescript: client.typescriptSelection }
+        : config
+          ? inspectTypeScriptLaunch(serverName, config, root)
+          : {};
     return buildProjectServerInfo(
       {
+        ...selection,
+        failureMessage:
+          this.failedStarts.get(key)?.failureMessage ??
+          this.processCrashRecoveries.get(key)?.failureMessage ??
+          selection.failureMessage,
         serverName,
         root,
         fileTypes,
         client: this.clients.get(key),
-        unavailableReason:
-          this.getUnavailableReason(key, this.config.servers[serverName]?.command) ?? undefined,
+        unavailableReason: this.getUnavailableReason(key, serverName, root) ?? undefined,
         statusReason: this.processCrashRecoveries.get(key)?.statusReason,
         includeOpenFile: (file) => this.isAutomaticScopePath(file),
       },
@@ -2975,7 +3008,7 @@ export class LspManager {
     control?: CodeRequestControl,
   ): Promise<{ kind: "enrolled" } | { kind: "unavailable"; reason: string }> {
     throwIfCodeRequestInterrupted(control);
-    const files = [...new Set(filePaths)].sort();
+    const files = [...new Set(filePaths)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
     const routeKey = clientKey(client.name, client.root);
     if (this.clients.get(routeKey) !== client) {
       return { kind: "unavailable", reason: "The semantic route changed during rename planning." };

package/src/provider/refactor-planning.ts

@@ -87,8 +87,7 @@ export async function runFilteredCodeActionRefactor(options: {
   if (!response || response.reason) {
     return {
       kind: "unavailable",
-      reason:
-        response?.reason ?? `No code actions are available for refactor operation "${operation}".`,
+      reason: `Refactor operation "${operation}" is unavailable: ${response?.reason ?? "No code actions are available."}`,
     };
   }
   const actions = response.value;
@@ -136,7 +135,9 @@ export function isUpdateImportsCodeAction(action: CodeAction): boolean {
 
 export function isDeleteDeadCodeCodeAction(action: CodeAction): boolean {
   const kind = typeof action?.kind === "string" ? action.kind : "";
-  return kind === "source.removeUnused" || kind.startsWith("source.removeUnused.");
+  return codeActionKindsForOperation("delete_dead_code").some(
+    (requested) => kind === requested || kind.startsWith(`${requested}.`),
+  );
 }
 
 interface PreciseCodeActionPlan {

package/src/session/runtime-controller.ts

@@ -519,8 +519,8 @@ export class LspRuntimeController {
     return this.#configurationError;
   }
 
-  /** Get the missing servers warning (servers whose binary is not on PATH). */
-  getMissingServers(): Array<{ name: string; command: string }> {
+  /** Report missing executables and root-specific compiler selection failures. */
+  getMissingServers(): ReturnType<typeof scanMissingServers> {
     if (this.#state.kind !== "ready") return [];
     return scanMissingServers(
       this.#state.config,

package/src/session/scanner.ts

@@ -7,6 +7,7 @@ import type {
   MissingServer,
   ServerConfig,
 } from "../config/types.ts";
+import { inspectTypeScriptLaunch } from "../config/typescript-launch.ts";
 import type { LspManager } from "../manager/manager.ts";
 import { commandExists } from "../utils.ts";
 import {
@@ -32,20 +33,16 @@ export function scanProjectCapabilities(
 
   return Object.entries(config.servers)
     .flatMap(([serverName, server]) => {
-      if (!commandExists(server.command)) return [];
       const allRoots = new Set(markerMatches.get(serverName) ?? []);
       if (extensionBasedServers.has(serverName)) {
         allRoots.add(cwd);
       }
       const roots = dedupeTopmostRoots(Array.from(allRoots));
-      return roots.map(
-        (root) =>
-          ({
-            name: serverName,
-            root,
-            fileTypes: [...server.fileTypes],
-          }) satisfies DetectedProjectServer,
-      );
+      return roots.flatMap((root) => {
+        const { command, ...selection } = inspectTypeScriptLaunch(serverName, server, root);
+        if (!selection.failureMessage && !commandExists(command)) return [];
+        return [{ name: serverName, root, fileTypes: [...server.fileTypes], ...selection }];
+      });
     })
     .sort((a, b) => a.root.localeCompare(b.root) || a.name.localeCompare(b.name));
 }
@@ -79,8 +76,6 @@ function inspectDirectory(
   ctx: HintContext,
 ): void {
   for (const [serverName, server] of Object.entries(servers)) {
-    if (!commandExists(server.command)) continue;
-
     if (server.rootMarkers.length === 0) {
       if (hasMatchingFile(directory, entryNames, server.fileTypes)) {
         ctx.extensionBasedServers.add(serverName);
@@ -122,7 +117,7 @@ export async function startDetectedServers(
 
 /**
  * Scan the project for languages whose source files exist but whose LSP server
- * binary is not installed on PATH. Walks the project directory tree collecting
+ * executable or selected compiler is unavailable. Walks the project tree collecting
  * file extensions, then checks each configured server.
  */
 export function scanMissingServers(
@@ -142,14 +137,31 @@ export function scanMissingServers(
   });
 
   const missing: MissingServer[] = [];
+  const { markerMatches } = collectServerHints(config, cwd, maxDepth, policy);
 
   for (const [name, server] of Object.entries(config.servers)) {
-    if (commandExists(server.command)) continue;
-
     const matching = server.fileTypes.filter((ft) => foundExtensions.has(ft));
     if (matching.length === 0) continue;
 
-    missing.push({ name, command: server.command, foundExtensions: matching });
+    const roots = dedupeTopmostRoots(Array.from(markerMatches.get(name) ?? []));
+    for (const root of roots.length ? roots : [cwd]) {
+      const selection = inspectTypeScriptLaunch(name, server, root);
+      const command = selection.command;
+      if (selection.failureMessage) {
+        missing.push({
+          name,
+          command,
+          foundExtensions: matching,
+          root,
+          failureMessage: selection.failureMessage,
+        });
+        continue;
+      }
+      if (!commandExists(command)) {
+        missing.push({ name, command, foundExtensions: matching });
+        break;
+      }
+    }
   }
 
   return missing;