Fix remaining LSP and restore regressions

Author: pallyoung

packages/server/src/__tests__/fixtures/fake-lsp-server.js

@@ -16,8 +16,13 @@ const connection = createMessageConnection(
 const docs = new Map();
 const exitAfterInitMs = Number(process.env.CODER_STUDIO_FAKE_LSP_EXIT_AFTER_INIT_MS ?? "0");
 const hoverDelayMs = Number(process.env.CODER_STUDIO_FAKE_LSP_HOVER_DELAY_MS ?? "0");
+const stderrOnInit = process.env.CODER_STUDIO_FAKE_LSP_STDERR_ON_INIT ?? "";
 
 connection.onRequest("initialize", () => {
+  if (stderrOnInit) {
+    process.stderr.write(`${stderrOnInit}\n`);
+  }
+
   if (exitAfterInitMs > 0) {
     const timer = setTimeout(() => process.exit(0), exitAfterInitMs);
     timer.unref?.();

packages/server/src/lsp-tools/definitions.ts

@@ -73,3 +73,28 @@ export function getLspToolDefinition(serverKind: LspServerKind): LspToolDefiniti
 export function getLspCommandOverridePrefix(serverKind: LspServerKind): string {
   return `CODER_STUDIO_LSP_${serverKind.toUpperCase()}`;
 }
+
+export function getManagedPrerequisites(
+  serverKind: LspServerKind,
+  platform: NodeJS.Platform = process.platform
+): string[] {
+  if (serverKind === "python" && platform === "win32") {
+    return ["python3", "python"];
+  }
+
+  return getLspToolDefinition(serverKind).managed?.prerequisites ?? [];
+}
+
+export async function resolveManagedPythonCommand(
+  commandExists: (command: string) => Promise<boolean>,
+  platform: NodeJS.Platform = process.platform
+): Promise<string | null> {
+  const candidates = getManagedPrerequisites("python", platform);
+  for (const candidate of candidates) {
+    if (await commandExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}

packages/server/src/lsp-tools/install-manager.test.ts

@@ -18,6 +18,7 @@ const workspace: Workspace = {
 describe("LspToolInstallManager", () => {
   afterEach(() => {
     vi.restoreAllMocks();
+    vi.unstubAllGlobals();
   });
 
   it("returns missing_prerequisite when python3 is unavailable", async () => {
@@ -39,6 +40,61 @@ describe("LspToolInstallManager", () => {
     });
   });
 
+  it("allows managed Python install on Windows when python is available but python3 is not", async () => {
+    const root = mkdtempSync(join(tmpdir(), "lsp-tools-"));
+    let installed = false;
+    const venvRoot = join(root, "python", "1.14.0", "venv");
+    const pipPath = join(venvRoot, "Scripts", "pip.exe");
+    const executablePath = join(venvRoot, "Scripts", "pylsp.exe");
+
+    const manager = new LspToolInstallManager({
+      manifestStore: new FileManifestStore(root),
+      platform: "win32",
+      commandExists: vi.fn(async (command: string) => {
+        if (command === "python3") {
+          return false;
+        }
+        if (command === "python") {
+          return true;
+        }
+        if (command === executablePath) {
+          return installed;
+        }
+        return false;
+      }),
+      runCommand: vi.fn(async (file: string, args: string[]) => {
+        if (file === "python" && args[0] === "-m" && args[1] === "venv") {
+          return { stdout: "created venv", stderr: "" };
+        }
+
+        if (file === pipPath) {
+          installed = true;
+          return { stdout: "installed pylsp", stderr: "" };
+        }
+
+        throw new Error(`unexpected command: ${file}`);
+      }),
+    });
+
+    const started = await manager.start({
+      workspace,
+      serverKind: "python",
+    });
+
+    await vi.waitFor(() => {
+      expect(manager.get(started.jobId)?.status).toBe("succeeded");
+    });
+
+    expect(manager.get(started.jobId)?.steps).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: "create-python-venv",
+          command: "python",
+        }),
+      ])
+    );
+  });
+
   it("returns unsupported_platform for WSL workspaces", async () => {
     const manager = new LspToolInstallManager({
       manifestStore: new FileManifestStore(mkdtempSync(join(tmpdir(), "lsp-tools-"))),

packages/server/src/lsp-tools/install-manager.ts

@@ -14,7 +14,11 @@ import {
   checkCommandAvailable,
 } from "../provider-runtime/command-check.js";
 import { type CommandRunner, runCommandAsString } from "../provider-runtime/command-runner.js";
-import { getLspToolDefinition } from "./definitions.js";
+import {
+  getLspToolDefinition,
+  getManagedPrerequisites,
+  resolveManagedPythonCommand,
+} from "./definitions.js";
 import { FileManifestStore } from "./manifest-store.js";
 
 const EXCERPT_LIMIT = 400;
@@ -35,6 +39,7 @@ const RUST_ANALYZER_RELEASE_TAG = "2026-05-18";
 export interface LspToolInstallManagerDeps extends CommandCheckDeps {
   manifestStore: FileManifestStore;
   commandExists?: CommandAvailabilityCheck;
+  platform?: NodeJS.Platform;
   runCommand?: CommandRunner;
 }
 
@@ -76,6 +81,7 @@ export class LspToolInstallManager {
     const definition = getLspToolDefinition(input.serverKind);
     const managed = definition.managed;
     const jobId = randomUUID();
+    const platform = this.deps.platform ?? process.platform;
 
     if (!managed || input.workspace.targetRuntime !== "native") {
       return {
@@ -107,9 +113,17 @@ export class LspToolInstallManager {
     const commandExists =
       this.deps.commandExists ?? ((command: string) => checkCommandAvailable(command, this.deps));
     const missingPrerequisites: string[] = [];
-    for (const prerequisite of managed.prerequisites) {
-      if (!(await commandExists(prerequisite))) {
-        missingPrerequisites.push(prerequisite);
+    let pythonCommand: string | null = null;
+    if (input.serverKind === "python") {
+      pythonCommand = await resolveManagedPythonCommand(commandExists, platform);
+      if (!pythonCommand) {
+        missingPrerequisites.push(...getManagedPrerequisites("python", platform));
+      }
+    } else {
+      for (const prerequisite of getManagedPrerequisites(input.serverKind, platform)) {
+        if (!(await commandExists(prerequisite))) {
+          missingPrerequisites.push(prerequisite);
+        }
       }
     }
 
@@ -146,21 +160,19 @@ export class LspToolInstallManager {
         ? join(
             installRoot,
             "venv",
-            process.platform === "win32" ? "Scripts" : "bin",
-            process.platform === "win32" ? "pylsp.exe" : "pylsp"
+            platform === "win32" ? "Scripts" : "bin",
+            platform === "win32" ? "pylsp.exe" : "pylsp"
           )
         : input.serverKind === "go"
-          ? join(installRoot, "bin", process.platform === "win32" ? "gopls.exe" : "gopls")
-          : join(
-              installRoot,
-              "bin",
-              process.platform === "win32" ? "rust-analyzer.exe" : "rust-analyzer"
-            );
+          ? join(installRoot, "bin", platform === "win32" ? "gopls.exe" : "gopls")
+          : join(installRoot, "bin", platform === "win32" ? "rust-analyzer.exe" : "rust-analyzer");
 
     const plannedSteps = this.planInstallSteps({
       serverKind: input.serverKind,
       installRoot,
       executablePath,
+      platform,
+      pythonCommand,
       version: managed.version,
     });
 
@@ -183,6 +195,7 @@ export class LspToolInstallManager {
     if (!managed) {
       return;
     }
+    const platform = this.deps.platform ?? process.platform;
 
     job.status = "running";
     this.jobs.set(job.jobId, job);
@@ -193,16 +206,17 @@ export class LspToolInstallManager {
         ? join(
             installRoot,
             "venv",
-            process.platform === "win32" ? "Scripts" : "bin",
-            process.platform === "win32" ? "pylsp.exe" : "pylsp"
+            platform === "win32" ? "Scripts" : "bin",
+            platform === "win32" ? "pylsp.exe" : "pylsp"
           )
         : serverKind === "go"
-          ? join(installRoot, "bin", process.platform === "win32" ? "gopls.exe" : "gopls")
-          : join(
-              installRoot,
-              "bin",
-              process.platform === "win32" ? "rust-analyzer.exe" : "rust-analyzer"
-            );
+          ? join(installRoot, "bin", platform === "win32" ? "gopls.exe" : "gopls")
+          : join(installRoot, "bin", platform === "win32" ? "rust-analyzer.exe" : "rust-analyzer");
+
+    const commandExists =
+      this.deps.commandExists ?? ((command: string) => checkCommandAvailable(command, this.deps));
+    const pythonCommand =
+      serverKind === "python" ? await resolveManagedPythonCommand(commandExists, platform) : null;
 
     mkdirSync(dirname(executablePath), { recursive: true });
 
@@ -217,6 +231,8 @@ export class LspToolInstallManager {
           serverKind,
           installRoot,
           executablePath,
+          platform,
+          pythonCommand,
           version: managed.version,
         }).find((candidate) => candidate.id === step.id);
 
@@ -225,9 +241,6 @@ export class LspToolInstallManager {
         }
 
         if (step.kind === "verify") {
-          const commandExists =
-            this.deps.commandExists ??
-            ((command: string) => checkCommandAvailable(command, this.deps));
           const available = await commandExists(executablePath);
           if (!available) {
             throw Object.assign(new Error(`Verification failed for ${definition.displayName}`), {
@@ -269,7 +282,7 @@ export class LspToolInstallManager {
       executablePath,
       installedAt: Date.now(),
       source: "managed",
-      platform: process.platform,
+      platform,
     });
 
     job.status = "succeeded";
@@ -282,18 +295,20 @@ export class LspToolInstallManager {
     serverKind: LspServerKind;
     installRoot: string;
     executablePath: string;
+    platform: NodeJS.Platform;
+    pythonCommand: string | null;
     version: string;
   }): InstallPlanStep[] {
     if (input.serverKind === "python") {
       const venvRoot = join(input.installRoot, "venv");
-      const binDir = join(venvRoot, process.platform === "win32" ? "Scripts" : "bin");
-      const pipPath = join(binDir, process.platform === "win32" ? "pip.exe" : "pip");
+      const binDir = join(venvRoot, input.platform === "win32" ? "Scripts" : "bin");
+      const pipPath = join(binDir, input.platform === "win32" ? "pip.exe" : "pip");
       return [
         {
           id: "create-python-venv",
           title: "Create Python virtual environment",
           kind: "install",
-          command: "python3",
+          command: input.pythonCommand ?? "python3",
           args: ["-m", "venv", venvRoot],
           cwd: input.installRoot,
         },

packages/server/src/lsp-tools/manager.test.ts

@@ -85,6 +85,66 @@ describe("LspToolManager.resolve", () => {
     });
   });
 
+  it("ignores a managed manifest when the JSON is corrupted", async () => {
+    const root = mkdtempSync(join(tmpdir(), "lsp-tools-"));
+    mkdirSync(join(root, "python"), { recursive: true });
+    writeFileSync(join(root, "python", "manifest.json"), "{invalid json", "utf8");
+
+    const manager = new LspToolManager({
+      manifestStore: new FileManifestStore(root),
+      commandExists: vi.fn(async (command: string) => command === "python3"),
+      resolveBundledCommand: vi.fn(() => null),
+    });
+
+    const result = await manager.resolve({
+      workspace,
+      serverKind: "python",
+      env: {},
+    });
+
+    expect(result).toMatchObject({
+      kind: "tool_missing",
+      serverKind: "python",
+      errorCode: "lsp_tool_missing",
+    });
+  });
+
+  it("ignores a managed manifest when the stored version no longer matches the definition", async () => {
+    const root = mkdtempSync(join(tmpdir(), "lsp-tools-"));
+    const executablePath = join(root, "python", "old", "bin", "pylsp");
+    mkdirSync(dirname(executablePath), { recursive: true });
+    writeFileSync(executablePath, "#!/bin/sh\nexit 0\n", { mode: 0o755 });
+    writeFileSync(
+      join(root, "python", "manifest.json"),
+      JSON.stringify({
+        serverKind: "python",
+        version: "0.0.1",
+        executablePath,
+        installedAt: 1,
+        source: "managed",
+        platform: process.platform,
+      })
+    );
+
+    const manager = new LspToolManager({
+      manifestStore: new FileManifestStore(root),
+      commandExists: vi.fn(async (command: string) => command === "python3"),
+      resolveBundledCommand: vi.fn(() => null),
+    });
+
+    const result = await manager.resolve({
+      workspace,
+      serverKind: "python",
+      env: {},
+    });
+
+    expect(result).toMatchObject({
+      kind: "tool_missing",
+      serverKind: "python",
+      errorCode: "lsp_tool_missing",
+    });
+  });
+
   it("uses the bundled TypeScript language server before system PATH", async () => {
     const root = mkdtempSync(join(tmpdir(), "lsp-tools-"));
     const manager = new LspToolManager({