feat: improve diagnostics and settings surfaces

Author: pallyoung

e2e/fixtures/phase2-i18n.ts

@@ -1,7 +1,7 @@
 import { type Page } from "@playwright/test";
 import { type E2ELocaleCode, translateForE2E } from "./i18n.js";
 
-type SettingsSection = "general" | "appearance" | "providers" | "shortcuts";
+type SettingsSection = "general" | "appearance" | "providers" | "shortcuts" | "analysis";
 type ProviderSettingLabel =
   | "base"
   | "config_file"
@@ -15,6 +15,7 @@ const SETTINGS_SECTION_KEYS: Record<SettingsSection, Parameters<typeof translate
   general: "settings.general",
   appearance: "settings.appearance",
   providers: "settings.providers",
+  analysis: "settings.analysis.title",
   shortcuts: "settings.shortcuts.title",
 };
 

packages/server/src/__tests__/diagnostics-commands.test.ts

@@ -1,7 +1,7 @@
 import { mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ProviderDefinition } from "@coder-studio/core";
+import type { LspToolRuntimeStatusEntry, ProviderDefinition } from "@coder-studio/core";
 import { providerRegistry } from "@coder-studio/providers";
 import { describe, expect, it } from "vitest";
 import type { EventBus } from "../bus/event-bus.js";
@@ -57,6 +57,36 @@ function createContext(overrides: Partial<CommandContext> = {}): CommandContext
       },
       ...providerRuntimeDeps,
     },
+    lspMgr: {
+      getRuntimeMode: () => "auto",
+    } as never,
+    lspToolMgr: {
+      runtimeStatus: async ({ serverKind }: { serverKind: string }) =>
+        ({
+          serverKind,
+          displayName: `${serverKind} language server`,
+          available: serverKind === "typescript",
+          autoInstallSupported: serverKind !== "typescript",
+          installReadiness:
+            serverKind === "python"
+              ? "missing_prerequisite"
+              : serverKind === "rust"
+                ? "unsupported_platform"
+                : "ready",
+          missingCommands:
+            serverKind === "python"
+              ? ["pylsp"]
+              : serverKind === "go"
+                ? ["gopls"]
+                : serverKind === "vue"
+                  ? ["vue-language-server"]
+                  : [],
+          missingPrerequisites: serverKind === "python" ? ["python3"] : [],
+        }) satisfies LspToolRuntimeStatusEntry,
+    } as never,
+    lspToolInstallMgr: {
+      getLatestFailure: () => undefined,
+    } as never,
     ...restOverrides,
   };
 }
@@ -103,6 +133,37 @@ describe("diagnostics commands", () => {
         }),
       ])
     );
+    expect(
+      (
+        result.data as {
+          lspServices: Array<{ serverKind: string; status: string }>;
+          metadata: {
+            lspRuntimeContext?: {
+              targetRuntime: "native" | "wsl";
+              managedInstallSupported: boolean;
+            };
+          };
+        }
+      ).lspServices
+    ).toEqual([
+      expect.objectContaining({ serverKind: "typescript", status: "installed" }),
+      expect.objectContaining({ serverKind: "python", status: "prerequisite_missing" }),
+      expect.objectContaining({ serverKind: "go", status: "not_installed" }),
+      expect.objectContaining({ serverKind: "rust", status: "not_installed" }),
+      expect.objectContaining({ serverKind: "vue", status: "not_installed" }),
+    ]);
+    expect(
+      (
+        result.data as {
+          metadata: {
+            lspRuntimeContext?: {
+              targetRuntime: "native" | "wsl";
+              managedInstallSupported: boolean;
+            };
+          };
+        }
+      ).metadata.lspRuntimeContext
+    ).toBeUndefined();
   });
 
   it("surfaces missing provider CLI checks for session start diagnostics", async () => {
@@ -146,6 +207,119 @@ describe("diagnostics commands", () => {
     );
   });
 
+  it("surfaces latest failed LSP install state without affecting canContinue", async () => {
+    const workspaceDir = await mkdtemp(join(tmpdir(), "diagnostics-lsp-runtime-"));
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "diag-session-lsp-install-failed",
+        op: "diagnostics.get",
+        args: {
+          context: "session_start",
+          workspaceId: "ws-1",
+          providerId: "claude",
+        },
+      },
+      createContext({
+        workspaceMgr: {
+          get: (workspaceId: string) =>
+            workspaceId === "ws-1" ? { id: "ws-1", path: workspaceDir } : undefined,
+          list: () => [],
+        } as unknown as WorkspaceManager,
+        lspToolMgr: {
+          runtimeStatus: async ({ serverKind }: { serverKind: string }) =>
+            ({
+              serverKind,
+              displayName: `${serverKind} language server`,
+              available: false,
+              autoInstallSupported: true,
+              installReadiness: "ready",
+              missingCommands: [serverKind],
+              missingPrerequisites: [],
+            }) satisfies LspToolRuntimeStatusEntry,
+        } as never,
+        lspToolInstallMgr: {
+          getLatestFailure: (serverKind: string) =>
+            serverKind === "go"
+              ? {
+                  jobId: "job-go-failed",
+                  serverKind: "go",
+                  status: "failed",
+                  steps: [],
+                  failure: {
+                    code: "command_failed",
+                    serverKind: "go",
+                    message: "install failed",
+                    failedStepId: "install-go-lsp",
+                    command: "go",
+                    args: ["install"],
+                    missingCommands: [],
+                  },
+                }
+              : undefined,
+        } as never,
+      })
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.data).toMatchObject({
+      context: "session_start",
+      canContinue: true,
+      metadata: {
+        workspaceId: "ws-1",
+        workspacePath: workspaceDir,
+        providerId: "claude",
+        lspRuntimeContext: {
+          targetRuntime: "native",
+          managedInstallSupported: true,
+        },
+      },
+    });
+    expect(
+      (result.data as { lspServices: Array<{ serverKind: string; status: string }> }).lspServices
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ serverKind: "go", status: "install_failed" }),
+      ])
+    );
+    expect((result.data as { checks: Array<{ code: string }> }).checks).not.toEqual(
+      expect.arrayContaining([expect.objectContaining({ code: "lsp_install_failed" })])
+    );
+  });
+
+  it("reports runtime_off only when the global LSP runtime mode is off", async () => {
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "diag-session-lsp-runtime-off",
+        op: "diagnostics.get",
+        args: {
+          context: "session_start",
+          workspaceId: "ws-1",
+          providerId: "claude",
+        },
+      },
+      createContext({
+        lspMgr: {
+          getRuntimeMode: () => "off",
+        } as never,
+      })
+    );
+
+    expect(result.ok).toBe(true);
+    expect(
+      (result.data as { lspServices: Array<{ serverKind: string; status: string }> }).lspServices
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ serverKind: "typescript", status: "runtime_off" }),
+        expect.objectContaining({ serverKind: "python", status: "runtime_off" }),
+        expect.objectContaining({ serverKind: "go", status: "runtime_off" }),
+        expect.objectContaining({ serverKind: "rust", status: "runtime_off" }),
+        expect.objectContaining({ serverKind: "vue", status: "runtime_off" }),
+      ])
+    );
+  });
+
   it("blocks session start when node is missing but keeps workspace-open non-blocking", async () => {
     const workspaceDir = await mkdtemp(join(tmpdir(), "diagnostics-base-runtime-"));
     const nodeMissingContext = createContext({

packages/server/src/__tests__/monitoring/aggregation.test.ts

@@ -129,6 +129,64 @@ describe("buildMonitoringSnapshot", () => {
     expect(response.snapshot.workspaces[0]?.label).toBe("ws_1779980247607_u2lfvdjf");
   });
 
+  it("keeps workspace-scoped background roots under the workspace attribution tree", () => {
+    const response = buildMonitoringSnapshot({
+      settings: {
+        ...createDefaultMonitoringSettings(),
+        enabled: true,
+      },
+      sampledAt: 100,
+      host: null,
+      roots: [
+        {
+          ownerId: "lsp:ws-1:typescript",
+          rootPid: 200,
+          kind: "lsp",
+          label: "TypeScript language server",
+          workspaceId: "ws-1",
+          startedAt: 2,
+        },
+      ],
+      workspaceLabels: {
+        "ws-1": "coder-studio",
+      },
+      processRows: [
+        {
+          pid: 200,
+          ppid: 1,
+          cpuPercent: 7,
+          rssBytes: 150,
+          elapsedSec: 45,
+          command: "typescript-language-server",
+        },
+      ],
+      previousSnapshot: null,
+    });
+
+    expect(response.snapshot.workspaces).toEqual([
+      expect.objectContaining({
+        id: "workspace:ws-1",
+        kind: "workspace",
+        label: "coder-studio",
+        cpuPercent: 7,
+        memoryBytes: 150,
+        processCount: 1,
+      }),
+    ]);
+    expect(response.snapshot.backgroundGroups).toEqual([
+      expect.objectContaining({
+        id: "background:lsp:ws-1:typescript",
+        kind: "background_group",
+        parentId: "workspace:ws-1",
+        workspaceId: "ws-1",
+        label: "TypeScript language server",
+        cpuPercent: 7,
+        memoryBytes: 150,
+        processCount: 1,
+      }),
+    ]);
+  });
+
   it("keeps host data when process collection fails", () => {
     const response = buildMonitoringSnapshot({
       settings: {

packages/server/src/__tests__/monitoring/service.test.ts

@@ -520,4 +520,77 @@ describe("MonitoringService", () => {
 
     expect(registry.listRoots().map((root) => root.ownerId)).not.toContain("terminal:term-1");
   });
+
+  it("includes registered lsp roots in background groups", async () => {
+    const registry = new ManagedProcessRegistry({ now: () => 10 });
+    registry.registerBackgroundRoot({
+      ownerId: "lsp:ws-1:typescript",
+      rootPid: 200,
+      kind: "lsp",
+      label: "TypeScript language server",
+      startedAt: 10,
+    });
+
+    const service = new MonitoringService({
+      broadcaster: { broadcast: vi.fn() },
+      settingsRepo: {
+        get: (key: string) => {
+          const settings = {
+            "monitoring.enabled": true,
+            "monitoring.hostMetricsEnabled": true,
+            "monitoring.runtimeSummaryEnabled": true,
+            "monitoring.workspaceAttributionEnabled": true,
+            "monitoring.subprocessDrilldownEnabled": false,
+            "monitoring.sampleIntervalMs": 2000,
+          } as Record<string, unknown>;
+          return settings[key];
+        },
+      },
+      registry,
+      sessionMgr: { getAll: () => [], findSessionIdByTerminal: () => undefined },
+      terminalMgr: { getAll: () => [] },
+      hostCollector: {
+        collect: () => ({
+          cpuPercent: 30,
+          memoryUsedBytes: 300,
+          memoryTotalBytes: 1000,
+          memoryAvailableBytes: 700,
+          loadAverage: [0.3, 0.2, 0.1],
+          uptimeSec: 10,
+          pressure: "normal",
+        }),
+      },
+      processCollector: {
+        collect: async () => [
+          {
+            pid: 200,
+            ppid: 1,
+            cpuPercent: 7,
+            rssBytes: 150,
+            elapsedSec: 12,
+            command: "typescript-language-server --stdio",
+          },
+        ],
+      },
+      setInterval: vi.fn(() => ({ unref: vi.fn() })),
+      clearInterval: vi.fn(),
+      now: () => 10,
+    });
+
+    service.start();
+    const response = await service.recheck();
+
+    expect(response.snapshot.backgroundGroups).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: "background:lsp:ws-1:typescript",
+          kind: "background_group",
+          label: "TypeScript language server",
+          cpuPercent: 7,
+          memoryBytes: 150,
+          processCount: 1,
+        }),
+      ])
+    );
+  });
 });