feat(server): bring Vue 3 LSP online with a tsserver bridge

Volar 3.x removed its embedded TypeScript service and now expects the LSP
client to relay `tsserver/request` notifications to a TypeScript Language
Server with `@vue/typescript-plugin` loaded. Previously vue installs failed
their verify step on Windows and, once installed, returned empty hovers
because no companion bridge existed. This wires up the full path:

- fix(server): make `checkCommandAvailable` fall back to `fs.existsSync`
  (with PATHEXT) for absolute paths. Windows `where.exe` parses `C:` as a
  `path:pattern` separator and rejects absolute paths, which had been
  failing every managed LSP install at the verify step.
- feat(server): spawn a `typescript-language-server` companion alongside
  Volar for vue sessions, configured with `@vue/typescript-plugin` so
  tsserver can answer `_vue:*` commands. Forward Volar's
  `tsserver/request` notifications via `workspace/executeCommand
  ("typescript.tsserverRequest", ...)` and unwrap the tsserver wire
  response (Volar expects `body`, not the `{seq,type,success,body}`
  wrapper).
- feat(server): fan hover / definition / references / typeDefinition /
  declaration out to both Volar and the companion, then merge results.
  Volar 3 deliberately ships without a TS-semantic hover plugin and
  relies on the editor to combine both ends.
- feat(server): expose `CODER_STUDIO_VUE_TSSERVER_BRIDGE=off` so the
  bridge can be disabled when triaging issues.
- feat(web): enrich the Monaco Vue grammar — embed `typescript`/
  `javascript` inside `<script>` (auto-detected via `lang=`), embed
  `css`/`scss`/`less` inside `<style>`, and recognise directive
  shorthand (`v-...`, `:...`, `@...`, `#...`) plus mustache interpolation
  in `<template>`.

Adds bridge + vue-spec unit tests plus an end-to-end Node probe under
`scripts/probe-vue-bridge.mjs` that exercises the live Volar + tsls
handshake (useful for future protocol regressions).

Author: pallyoung

packages/server/src/__tests__/provider-runtime/command-check.test.ts

@@ -57,4 +57,69 @@ describe("checkCommandAvailable", () => {
 
     expect(execFile).toHaveBeenCalledWith("where", ["codex"], { windowsHide: true });
   });
+
+  it("checks the filesystem directly for absolute Windows paths instead of invoking where", async () => {
+    // `where.exe` rejects `C:\...` arguments with "invalid pattern" because it
+    // parses the first colon as a path:pattern separator. Make sure we never
+    // hand absolute paths to it.
+    const execFile = vi.fn();
+    const absolutePath = "C:\\tools\\lsp\\vue\\node_modules\\.bin\\vue-language-server.cmd";
+
+    await expect(
+      checkCommandAvailable(absolutePath, {
+        platform: "win32",
+        runCommand: execFile,
+        existsSync: (file) => file === absolutePath,
+      })
+    ).resolves.toBe(true);
+
+    expect(execFile).not.toHaveBeenCalled();
+  });
+
+  it("returns false for absolute Windows paths that do not exist on disk", async () => {
+    const execFile = vi.fn();
+
+    await expect(
+      checkCommandAvailable("C:\\tools\\missing.cmd", {
+        platform: "win32",
+        runCommand: execFile,
+        existsSync: () => false,
+        pathExt: ".CMD;.EXE",
+      })
+    ).resolves.toBe(false);
+
+    expect(execFile).not.toHaveBeenCalled();
+  });
+
+  it("appends PATHEXT extensions when an absolute Windows path has no extension", async () => {
+    const execFile = vi.fn();
+    const baseline = "C:\\tools\\bin\\vue-language-server";
+    const resolved = `${baseline}.CMD`;
+
+    await expect(
+      checkCommandAvailable(baseline, {
+        platform: "win32",
+        runCommand: execFile,
+        existsSync: (file) => file === resolved,
+        pathExt: ".EXE;.CMD",
+      })
+    ).resolves.toBe(true);
+
+    expect(execFile).not.toHaveBeenCalled();
+  });
+
+  it("checks the filesystem directly for absolute POSIX paths", async () => {
+    const execFile = vi.fn();
+    const absolutePath = "/opt/coder-studio/lsp-tools/go/bin/gopls";
+
+    await expect(
+      checkCommandAvailable(absolutePath, {
+        platform: "linux",
+        runCommand: execFile,
+        existsSync: (file) => file === absolutePath,
+      })
+    ).resolves.toBe(true);
+
+    expect(execFile).not.toHaveBeenCalled();
+  });
 });

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

@@ -340,6 +340,199 @@ describe("LspManager", () => {
     });
   });
 
+  it("attaches a typescript companion + tsserver bridge to vue sessions when both ends resolve", async () => {
+    const vueSummary = {
+      workspaceId: "ws-1",
+      serverKind: "vue" as const,
+      status: "ready" as const,
+      capabilities: {
+        definition: true,
+        references: true,
+        hover: true,
+        documentSymbols: true,
+        diagnostics: true,
+      },
+    };
+    const sessionDeps: Array<unknown> = [];
+    const createSession = vi.fn((deps) => {
+      sessionDeps.push(deps);
+      return {
+        start: vi.fn(async () => vueSummary),
+        stop: vi.fn(async () => {}),
+        getSummary: () => vueSummary,
+        openDocument: async () => 1,
+        changeDocument: async () => 2,
+        closeDocument: async () => {},
+        definition: async () => [],
+        declaration: async () => [],
+        typeDefinition: async () => [],
+        references: async () => [],
+        hover: async () => null,
+        documentSymbols: async () => [],
+      };
+    });
+    const resolve = vi.fn(async (input: { serverKind: "vue" | "typescript" }) =>
+      input.serverKind === "vue"
+        ? {
+            kind: "ready" as const,
+            serverKind: "vue" as const,
+            displayName: "Vue language server",
+            source: "managed" as const,
+            command: "/tmp/coder-studio/lsp-tools/vue/3.3.2/node_modules/.bin/vue-language-server",
+            args: ["--stdio"],
+          }
+        : {
+            kind: "ready" as const,
+            serverKind: "typescript" as const,
+            displayName: "TypeScript language server",
+            source: "bundled" as const,
+            command: "/usr/local/bin/node",
+            args: ["/bundled/lib/cli.mjs", "--stdio"],
+          }
+    );
+
+    const manager = new LspManager({
+      workspaceMgr: {
+        get: () => ({
+          id: "ws-1",
+          path: process.cwd(),
+          targetRuntime: "native",
+          openedAt: 1,
+          lastActiveAt: 1,
+          uiState: { leftPanelWidth: 250, bottomPanelHeight: 200, focusMode: false },
+        }),
+      },
+      eventBus: { emit: vi.fn() },
+      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      requestTimeoutMs: 1000,
+      idleTtlMs: 1000,
+      restartLimit: 2,
+      lspToolMgr: { resolve } as never,
+      createSession,
+      vueBridgeMode: "auto",
+    });
+
+    await expect(
+      manager.ensureSession({ workspaceId: "ws-1", path: "src/App.vue" })
+    ).resolves.toMatchObject({ kind: "ready", summary: { serverKind: "vue" } });
+
+    expect(resolve).toHaveBeenCalledWith(expect.objectContaining({ serverKind: "vue" }));
+    expect(resolve).toHaveBeenCalledWith(expect.objectContaining({ serverKind: "typescript" }));
+
+    const created = sessionDeps[0] as { spec: { companion?: { initializationOptions?: unknown } } };
+    expect(created).toMatchObject({
+      spec: {
+        serverKind: "vue",
+        command: "/tmp/coder-studio/lsp-tools/vue/3.3.2/node_modules/.bin/vue-language-server",
+        bridges: { tsserverRequest: true },
+        companion: {
+          command: "/usr/local/bin/node",
+          args: ["/bundled/lib/cli.mjs", "--stdio"],
+        },
+      },
+    });
+    // Plugin location comes back in the host's path style; normalize for the
+    // assertion so it works on both POSIX and Windows.
+    const plugins = (
+      created.spec.companion?.initializationOptions as {
+        plugins?: Array<{ name: string; location: string; languages: string[] }>;
+      }
+    )?.plugins;
+    expect(plugins).toHaveLength(1);
+    expect(plugins?.[0]?.name).toBe("@vue/typescript-plugin");
+    expect(plugins?.[0]?.languages).toEqual(["vue"]);
+    expect(plugins?.[0]?.location.replace(/\\/g, "/")).toMatch(
+      /tmp.coder-studio.lsp-tools.vue.3\.3\.2.node_modules.@vue.language-server$/
+    );
+  });
+
+  it("omits the vue tsserver bridge when CODER_STUDIO_VUE_TSSERVER_BRIDGE is off", async () => {
+    const sessionDeps: Array<unknown> = [];
+    const createSession = vi.fn((deps) => {
+      sessionDeps.push(deps);
+      return {
+        start: vi.fn(async () => ({
+          workspaceId: "ws-1",
+          serverKind: "vue" as const,
+          status: "ready" as const,
+          capabilities: {
+            definition: true,
+            references: true,
+            hover: true,
+            documentSymbols: true,
+            diagnostics: true,
+          },
+        })),
+        stop: vi.fn(async () => {}),
+        getSummary: () =>
+          ({
+            workspaceId: "ws-1",
+            serverKind: "vue",
+            status: "ready",
+            capabilities: {
+              definition: true,
+              references: true,
+              hover: true,
+              documentSymbols: true,
+              diagnostics: true,
+            },
+          }) as never,
+        openDocument: async () => 1,
+        changeDocument: async () => 2,
+        closeDocument: async () => {},
+        definition: async () => [],
+        declaration: async () => [],
+        typeDefinition: async () => [],
+        references: async () => [],
+        hover: async () => null,
+        documentSymbols: async () => [],
+      };
+    });
+    const resolve = vi.fn(async () => ({
+      kind: "ready" as const,
+      serverKind: "vue" as const,
+      displayName: "Vue language server",
+      source: "managed" as const,
+      command: "/install/node_modules/.bin/vue-language-server",
+      args: ["--stdio"],
+    }));
+
+    const manager = new LspManager({
+      workspaceMgr: {
+        get: () => ({
+          id: "ws-1",
+          path: process.cwd(),
+          targetRuntime: "native",
+          openedAt: 1,
+          lastActiveAt: 1,
+          uiState: { leftPanelWidth: 250, bottomPanelHeight: 200, focusMode: false },
+        }),
+      },
+      eventBus: { emit: vi.fn() },
+      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      requestTimeoutMs: 1000,
+      idleTtlMs: 1000,
+      restartLimit: 2,
+      lspToolMgr: { resolve } as never,
+      createSession,
+      vueBridgeMode: "off",
+    });
+
+    await manager.ensureSession({ workspaceId: "ws-1", path: "src/App.vue" });
+
+    // Only the vue resolve call — no typescript companion resolution either.
+    expect(resolve).toHaveBeenCalledTimes(1);
+
+    const [created] = sessionDeps;
+    expect(created).toMatchObject({
+      spec: {
+        serverKind: "vue",
+        bridges: undefined,
+        companion: undefined,
+      },
+    });
+  });
+
   it("coalesces concurrent ensureSession calls for the same workspace and server kind", async () => {
     let resolveStart: ((summary: typeof readySummary) => void) | null = null;
     const startPromise = new Promise<typeof readySummary>((resolve) => {