Miscellaneous extension improvements (#3516)

Author: andrewbranch

_extension/package.json

@@ -68,6 +68,25 @@
                             "experimental"
                         ]
                     },
+                    "typescript.native-preview.additionalTsdkLocations": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        },
+                        "default": [],
+                        "description": "Additional paths to tsgo binary directories or @typescript/native-preview packages that should appear in the version selector.",
+                        "tags": [
+                            "experimental"
+                        ]
+                    },
+                    "typescript.native-preview.showDebugInfo": {
+                        "type": "boolean",
+                        "default": false,
+                        "description": "Show debug information (PID, executable path) in the server menu.",
+                        "tags": [
+                            "experimental"
+                        ]
+                    },
                     "typescript.native-preview.goMemLimit": {
                         "type": "string",
                         "description": "Set GOMEMLIMIT for the language server (e.g., '2048MiB', '4GiB'). See https://pkg.go.dev/runtime#hdr-Environment_Variables for more information.",

_extension/src/client.ts

@@ -80,6 +80,7 @@ export class Client implements vscode.Disposable {
                 sendNotification: sendNotificationMiddleware,
                 provideHover: () => undefined,
             },
+            diagnosticCollectionName: "typescript",
             diagnosticPullOptions: {
                 onChange: true,
                 onSave: true,
@@ -248,6 +249,10 @@ export class Client implements vscode.Disposable {
         return this.exe;
     }
 
+    get serverPid(): number | undefined {
+        return (this.client as any)?._serverProcess?.pid;
+    }
+
     /**
      * Initialize an API session and return the socket path for connecting.
      * This allows other extensions to get a direct connection to the API server.

_extension/src/extension.ts

@@ -12,7 +12,10 @@ import {
 } from "./util";
 
 import { TelemetryReporter as VSCodeTelemetryReporter } from "@vscode/extension-telemetry";
-import { SessionManager } from "./session";
+import {
+    promptUseWorkspaceVersion,
+    SessionManager,
+} from "./session";
 import { createTelemetryReporter } from "./telemetryReporting";
 
 export interface ExtensionAPI {
@@ -111,6 +114,11 @@ export async function activate(context: vscode.ExtensionContext): Promise<Extens
 
     await sessionManager.start(context);
 
+    // Prompt user to use workspace version if one is detected and they haven't opted in yet.
+    promptUseWorkspaceVersion(context).catch(err => {
+        output.appendLine(`Error prompting to use workspace version: ${err}`);
+    });
+
     function onLanguageServerInitialized(listener: () => void): vscode.Disposable {
         if (sessionManager.currentSession?.client.isInitialized) {
             listener();

_extension/src/session.ts

@@ -1,3 +1,4 @@
+import * as path from "path";
 import * as vscode from "vscode";
 import { ActiveJsTsEditorTracker } from "./activeJsTsEditorTracker";
 import { Client } from "./client";
@@ -6,7 +7,12 @@ import { ManagedFileContextManager } from "./managedFileContext";
 import { ProjectStatus } from "./projectStatus";
 import { setupStatusBar } from "./statusBar";
 import { TelemetryReporter } from "./telemetryReporting";
-import { getExe } from "./util";
+import {
+    getBuiltinExePath,
+    getExe,
+    resolveTsdkPathToExe,
+    useWorkspaceTsdkStorageKey,
+} from "./util";
 
 /**
  * SessionManager's lifetime is equal to that of the extension. It is responsible
@@ -55,7 +61,7 @@ export class SessionManager implements vscode.Disposable {
             this.outputChannel.appendLine("Restarting TypeScript Native Preview...");
             await this.currentSession.dispose();
         }
-        this.currentSession = new Session(this.outputChannel, this.traceOutputChannel, this.initializedEventEmitter, this.telemetryReporter);
+        this.currentSession = new Session(context, this.outputChannel, this.traceOutputChannel, this.initializedEventEmitter, this.telemetryReporter);
         return this.currentSession.start(context);
     }
 
@@ -91,19 +97,22 @@ export class SessionManager implements vscode.Disposable {
 class Session implements vscode.Disposable {
     client: Client;
     private disposables: vscode.Disposable[] = [];
+    private context: vscode.ExtensionContext;
     private outputChannel: vscode.LogOutputChannel;
     private traceOutputChannel: vscode.LogOutputChannel;
     private telemetryReporter: TelemetryReporter;
     private initializedEventEmitter: vscode.EventEmitter<void>;
 
     constructor(
+        context: vscode.ExtensionContext,
         outputChannel: vscode.LogOutputChannel,
         traceOutputChannel: vscode.LogOutputChannel,
         initializedEventEmitter: vscode.EventEmitter<void>,
         telemetryReporter: TelemetryReporter,
     ) {
         this.client = new Client(outputChannel, traceOutputChannel, initializedEventEmitter, telemetryReporter);
         this.disposables.push(this.client);
+        this.context = context;
         this.outputChannel = outputChannel;
         this.traceOutputChannel = traceOutputChannel;
         this.telemetryReporter = telemetryReporter;
@@ -149,10 +158,13 @@ class Session implements vscode.Disposable {
             this.traceOutputChannel.show();
         }));
 
-        this.disposables.push(vscode.commands.registerCommand("typescript.native-preview.selectVersion", async () => {
+        this.disposables.push(vscode.commands.registerCommand("typescript.selectTypeScriptVersion", async () => {
+            await promptSelectVersion(this.context, this.client, this.outputChannel);
         }));
 
-        this.disposables.push(vscode.commands.registerCommand("typescript.native-preview.showMenu", showCommands));
+        this.disposables.push(vscode.commands.registerCommand("typescript.native-preview.showMenu", () => {
+            showCommands(this.client);
+        }));
 
         this.disposables.push(vscode.commands.registerCommand("typescript.native-preview.reportIssue", () => {
             this.telemetryReporter.sendTelemetryEvent("command.reportIssue");
@@ -247,8 +259,15 @@ class Session implements vscode.Disposable {
     }
 }
 
-async function showCommands(): Promise<void> {
-    const commands: readonly { label: string; description: string; command: string; }[] = [
+async function showCommands(client: Client): Promise<void> {
+    interface CommandItem {
+        label: string;
+        description?: string;
+        kind?: vscode.QuickPickItemKind;
+        command?: string;
+        action?: () => Promise<void>;
+    }
+    const commands: CommandItem[] = [
         {
             label: "$(refresh) Restart Server",
             description: "Restart the TypeScript Native Preview language server",
@@ -269,19 +288,212 @@ async function showCommands(): Promise<void> {
             description: "Report an issue with TypeScript Native Preview",
             command: "typescript.native-preview.reportIssue",
         },
+        {
+            label: "$(versions) Select Version",
+            description: "Choose between bundled and workspace versions",
+            command: "typescript.selectTypeScriptVersion",
+        },
         {
             label: "$(stop-circle) Disable TypeScript Native Preview",
             description: "Switch back to the built-in TypeScript extension",
             command: "typescript.native-preview.disable",
         },
     ];
 
+    const showDebugInfo = vscode.workspace.getConfiguration("typescript.native-preview").get<boolean>("showDebugInfo", false);
+    if (showDebugInfo) {
+        const exe = client.getCurrentExe();
+        const pid = client.serverPid;
+        commands.push({ label: "", kind: vscode.QuickPickItemKind.Separator });
+        if (exe) {
+            commands.push({
+                label: `Executable`,
+                description: exe.path,
+                action: async () => {
+                    await vscode.env.clipboard.writeText(exe.path);
+                    vscode.window.showInformationMessage("Executable path copied to clipboard.");
+                },
+            });
+        }
+        if (pid) {
+            commands.push({
+                label: `PID`,
+                description: `${pid}`,
+                action: async () => {
+                    await vscode.env.clipboard.writeText(`${pid}`);
+                    vscode.window.showInformationMessage("Server PID copied to clipboard.");
+                },
+            });
+        }
+    }
+
     const selected = await vscode.window.showQuickPick(commands, {
         placeHolder: "TypeScript Native Preview Commands",
     });
 
     if (selected) {
-        await vscode.commands.executeCommand(selected.command);
+        if (selected.action) {
+            await selected.action();
+        }
+        else if (selected.command) {
+            await vscode.commands.executeCommand(selected.command);
+        }
+    }
+}
+
+interface VersionQuickPickItem extends vscode.QuickPickItem {
+    run(): Promise<void>;
+}
+
+interface DetectedVersion {
+    label: string;
+    version: string;
+    tsdkPath: string;
+    exePath: string;
+}
+
+async function findWorkspaceNativePreviewPackages(): Promise<DetectedVersion[]> {
+    const results: DetectedVersion[] = [];
+    for (const folder of vscode.workspace.workspaceFolders ?? []) {
+        const packagePath = vscode.Uri.joinPath(folder.uri, "node_modules", "@typescript", "native-preview");
+        const resolved = await resolveTsdkPathToExe(path.normalize(packagePath.fsPath));
+        if (!resolved) continue;
+        results.push({
+            label: folder.name,
+            version: resolved?.version ?? "unknown",
+            tsdkPath: path.normalize(packagePath.fsPath),
+            exePath: resolved?.path ?? "",
+        });
+    }
+    return results;
+}
+
+async function promptSelectVersion(context: vscode.ExtensionContext, client: Client, outputChannel: vscode.LogOutputChannel): Promise<void> {
+    const config = vscode.workspace.getConfiguration("typescript.native-preview");
+    const currentExePath = client.getCurrentExe()?.path;
+    const builtinExe = await getBuiltinExePath(context);
+    const workspaceVersions = await findWorkspaceNativePreviewPackages();
+    const bundledVersion = context.extension.packageJSON.version as string;
+    const items: VersionQuickPickItem[] = [];
+
+    // Bundled version
+    items.push({
+        label: (currentExePath === builtinExe.path ? "• " : "") + "Use Bundled Version",
+        description: bundledVersion,
+        detail: builtinExe.path,
+        run: async () => {
+            await context.workspaceState.update(useWorkspaceTsdkStorageKey, false);
+            await config.update("tsdk", undefined, vscode.ConfigurationTarget.Workspace);
+            outputChannel.appendLine("Switched to bundled tsgo version.");
+        },
+    });
+
+    // Workspace versions
+    if (vscode.workspace.isTrusted) {
+        for (const wsVersion of workspaceVersions) {
+            const isActive = currentExePath === wsVersion.tsdkPath;
+            items.push({
+                label: (isActive ? "• " : "") + "Use Workspace Version",
+                description: wsVersion.version,
+                detail: wsVersion.tsdkPath,
+                run: async () => {
+                    await context.workspaceState.update(useWorkspaceTsdkStorageKey, true);
+                    await config.update("tsdk", wsVersion.tsdkPath, vscode.ConfigurationTarget.Workspace);
+                    outputChannel.appendLine(`Switched to workspace tsgo version (${wsVersion.version}).`);
+                },
+            });
+        }
+    }
+    else if (workspaceVersions.length > 0) {
+        items.push({
+            label: "",
+            kind: vscode.QuickPickItemKind.Separator,
+            run: async () => {},
+        });
+        items.push({
+            label: "$(lock) Manage Workspace Trust to select a workspace version",
+            run: async () => {
+                await vscode.commands.executeCommand("workbench.trust.manage");
+            },
+        });
+    }
+
+    // Additional tsdk locations from settings
+    const additionalLocations = config.get<string[]>("additionalTsdkLocations", []);
+    if (additionalLocations.length > 0) {
+        items.push({
+            label: "",
+            kind: vscode.QuickPickItemKind.Separator,
+            run: async () => {},
+        });
+        for (const loc of additionalLocations) {
+            const resolved = await resolveTsdkPathToExe(loc);
+            if (!resolved) continue;
+            if (resolved.path === builtinExe.path) continue;
+            if (workspaceVersions.some(ws => ws.exePath === resolved.path)) continue;
+            const isActive = currentExePath === resolved.path;
+            items.push({
+                label: (isActive ? "• " : "") + "Use Custom Version",
+                description: resolved.version,
+                detail: resolved.path,
+                run: async () => {
+                    await context.workspaceState.update(useWorkspaceTsdkStorageKey, true);
+                    await config.update("tsdk", loc, vscode.ConfigurationTarget.Workspace);
+                    outputChannel.appendLine(`Switched to custom tsgo version at ${loc}.`);
+                },
+            });
+        }
+    }
+
+    const selected = await vscode.window.showQuickPick<VersionQuickPickItem>(items, {
+        placeHolder: "Select the TypeScript Native Preview version to use",
+    });
+
+    if (selected) {
+        await selected.run();
+        // Restart server to pick up the new version
+        await vscode.commands.executeCommand("typescript.native-preview.restart");
+    }
+}
+
+/**
+ * If the workspace has `@typescript/native-preview` installed and the user
+ * hasn't already opted in or dismissed the prompt, ask whether they'd like
+ * to use the workspace version.
+ */
+export async function promptUseWorkspaceVersion(context: vscode.ExtensionContext): Promise<void> {
+    if (!vscode.workspace.isTrusted) return;
+
+    const useWorkspaceTsdk = context.workspaceState.get<boolean>(useWorkspaceTsdkStorageKey, false);
+    if (useWorkspaceTsdk) return; // already opted in
+
+    const suppressKey = "typescript.native-preview.suppressPromptWorkspaceTsdk";
+    if (context.workspaceState.get<boolean>(suppressKey, false)) return;
+
+    const workspaceVersions = await findWorkspaceNativePreviewPackages();
+    if (workspaceVersions.length === 0) return;
+
+    const wsVersion = workspaceVersions[0];
+    const allow = "Allow";
+    const dismiss = "Dismiss";
+    const suppress = "Never in this Workspace";
+
+    const result = await vscode.window.showInformationMessage(
+        `This workspace contains a TypeScript Native Preview version (${wsVersion.version}). Would you like to use the workspace version?`,
+        allow,
+        dismiss,
+        suppress,
+    );
+
+    if (result === allow) {
+        if (!vscode.workspace.isTrusted) return;
+        await context.workspaceState.update(useWorkspaceTsdkStorageKey, true);
+        const config = vscode.workspace.getConfiguration("typescript.native-preview");
+        await config.update("tsdk", wsVersion.tsdkPath, vscode.ConfigurationTarget.Workspace);
+        await vscode.commands.executeCommand("typescript.native-preview.restart");
+    }
+    else if (result === suppress) {
+        await context.workspaceState.update(suppressKey, true);
     }
 }