fix: configure extensions per workspace folder in multi-root workspaces (#280)

Author: hverlin

.vscode-test.js

@@ -1,7 +1,22 @@
 const { defineConfig } = require("@vscode/test-cli");
+const fs = require("node:fs");
 const path = require("node:path");
 const fixturesPath = path.join(__dirname, "src/e2e-tests/fixtures/");
 
+// The multi-root suites write workspace-level settings, which land in the
+// .code-workspace file itself. Those writes are part of what is under test and
+// cannot always be cleaned reliably, so the suite runs against a throwaway
+// gitignored copy of the committed workspace file, refreshed on every run.
+const multiRootWorkspaceFile = path.join(
+	fixturesPath,
+	"multi-root-workspace",
+	"multi-root.generated.code-workspace",
+);
+fs.copyFileSync(
+	path.join(fixturesPath, "multi-root-workspace", "multi-root.code-workspace"),
+	multiRootWorkspaceFile,
+);
+
 // MISE_CEILING_PATHS stops mise from traversing above the fixtures directory,
 // so the workspaces under test never inherit this repository's own mise config.
 // Ceiling paths are exclusive: configs at the workspace root are still loaded.
@@ -175,6 +190,80 @@ module.exports = defineConfig([
 			timeout: 60_000,
 		},
 	},
+	{
+		label: "multi-root",
+		files: "src/e2e-tests/multi-root/*.e2e.ts",
+		// a `.code-workspace` file, so vscode opens a multi-root workspace whose
+		// folders are subdirectories of the directory holding the file
+		workspaceFolder: multiRootWorkspaceFile,
+		env: {
+			MISE_CEILING_PATHS: fixturesPath,
+			MISE_LOCKED: "0",
+			MISE_TRUSTED_CONFIG_PATHS: fixturesPath,
+			MISE_GLOBAL_CONFIG_FILE: path.join(
+				fixturesPath,
+				"multi-root-workspace",
+				"global-config.toml",
+			),
+			// the go toolchains the suite installs stay inside the fixture
+			MISE_DATA_DIR: path.join(
+				fixturesPath,
+				"multi-root-workspace",
+				".mise-data",
+			),
+			MISE_CACHE_DIR: path.join(
+				fixturesPath,
+				"multi-root-workspace",
+				".mise-cache",
+			),
+		},
+		// golang.go is the extension under test: mise writes `go.goroot` and
+		// `go.alternateTools` for it. shell-format has a window-scoped setting
+		// (`shellformat.path`), which folder-scoped configuration cannot hold.
+		installExtensions: ["golang.go", "foxundermoon.shell-format"],
+		mocha: {
+			require: ["tsx/cjs"],
+			// the go suite installs two toolchains
+			timeout: 600_000,
+		},
+	},
+	{
+		label: "go",
+		files: "src/e2e-tests/go/*.e2e.ts",
+		workspaceFolder: path.join(fixturesPath, "go-workspace"),
+		env: {
+			MISE_CEILING_PATHS: fixturesPath,
+			MISE_LOCKED: "0",
+			MISE_TRUSTED_CONFIG_PATHS: fixturesPath,
+			MISE_GLOBAL_CONFIG_FILE: path.join(
+				fixturesPath,
+				"go-workspace",
+				"global-config.toml",
+			),
+			// shares the toolchain store of the multi-root fixture, so each go
+			// version is downloaded once per CI run
+			MISE_DATA_DIR: path.join(
+				fixturesPath,
+				"multi-root-workspace",
+				".mise-data",
+			),
+			MISE_CACHE_DIR: path.join(
+				fixturesPath,
+				"multi-root-workspace",
+				".mise-cache",
+			),
+			// keep the build cache in the fixture, and never let go swap in
+			// another toolchain than the one mise resolves
+			GOCACHE: path.join(fixturesPath, "go-workspace", ".gocache"),
+			GOTOOLCHAIN: "local",
+		},
+		installExtensions: ["golang.go"],
+		mocha: {
+			require: ["tsx/cjs"],
+			// installs a toolchain and compiles the go stdlib on a cold cache
+			timeout: 600_000,
+		},
+	},
 	{
 		label: "monorepo",
 		files: "src/e2e-tests/monorepo/*.e2e.ts",

docs/src/content/docs/reference/Mutli-folders.md

@@ -10,3 +10,9 @@ If you are using a workspace with multiple root folders (see [multi-root workspa
 ![select-folder.png](select-folder.png)
 
 In this screenshot, the currently selected folder is `workspace-1` (indicated by the small `●` icon).
+
+The selected folder is the one shown in the sidebar views (tools, tasks, environment variables) and the one used to run mise commands.
+
+## Extension settings
+
+When [automatic extension configuration](/mise-vscode/reference/settings/#miseconfigureextensionsautomatically) runs in a multi-root workspace, each folder is configured with the tools of its own mise config. Settings are written at the folder level when the target extension supports it, so two folders pinning different versions of the same tool each get their own version. Settings that only exist per window are taken from the selected folder.

src/configuration.ts

@@ -340,22 +340,86 @@ export type VSCodeSettingValue =
 	| Array<string | number | boolean>
 	| Record<string, string | number | boolean>;
 
+/**
+ * A setting the extension stops managing: the value it wrote earlier is
+ * removed instead of updated, so nothing is left pointing at a tool the
+ * extension no longer chooses.
+ */
+export const REMOVE_SETTING = null;
+
 export type VSCodeSetting = {
 	key: string;
-	value: VSCodeSettingValue;
+	value: VSCodeSettingValue | typeof REMOVE_SETTING;
 };
 
 const isObject = (value: unknown) =>
 	typeof value === "object" && value !== null && !Array.isArray(value);
 
+const valueAtTarget = (
+	inspection: ReturnType<vscode.WorkspaceConfiguration["inspect"]>,
+	target: vscode.ConfigurationTarget,
+) => {
+	switch (target) {
+		case vscode.ConfigurationTarget.Global:
+			return inspection?.globalValue;
+		case vscode.ConfigurationTarget.WorkspaceFolder:
+			return inspection?.workspaceFolderValue;
+		default:
+			return inspection?.workspaceValue;
+	}
+};
+
 export async function updateVSCodeSettings(
 	newSettings: VSCodeSetting[],
 	target: vscode.ConfigurationTarget,
-): Promise<string[]> {
+	{
+		/** A value the extension is allowed to remove, defaults to none */
+		canRemove = (_value: unknown) => false,
+		resource,
+	}: {
+		canRemove?: (value: unknown) => boolean;
+		/** The folder the settings apply to, for folder-scoped targets */
+		resource?: vscode.Uri;
+	} = {},
+): Promise<{ updatedKeys: string[]; unsupportedKeys: string[] }> {
 	const updatedKeys: string[] = [];
-	const configuration = vscode.workspace.getConfiguration();
+	/** keys vscode refused to write per folder (the setting is window-scoped) */
+	const unsupportedKeys: string[] = [];
+	const configuration = vscode.workspace.getConfiguration(undefined, resource);
+
+	const update = async (key: string, value: unknown) => {
+		try {
+			await configuration.update(key, value, target);
+			updatedKeys.push(key);
+		} catch (error) {
+			if (target === vscode.ConfigurationTarget.WorkspaceFolder) {
+				logger.debug(`${key} cannot be written per folder: ${error}`);
+				unsupportedKeys.push(key);
+				return;
+			}
+			throw error;
+		}
+	};
 
 	for (const newSetting of newSettings) {
+		if (newSetting.value === REMOVE_SETTING) {
+			const previousValue = valueAtTarget(
+				configuration.inspect(newSetting.key),
+				target,
+			);
+			// what the user wrote by hand stays: only a leftover of a previous
+			// run is removed
+			if (previousValue === undefined || !canRemove(previousValue)) {
+				continue;
+			}
+
+			logger.info(
+				`Removing ${newSetting.key}: the extension does not set it anymore`,
+			);
+			await update(newSetting.key, undefined);
+			continue;
+		}
+
 		const currentValue = configuration.get(newSetting.key);
 
 		if (isDeepStrictEqual(currentValue, newSetting.value)) {
@@ -371,36 +435,64 @@ export async function updateVSCodeSettings(
 				continue;
 			}
 
-			updatedKeys.push(newSetting.key);
-			await configuration.update(newSetting.key, mergedValue, target);
+			await update(newSetting.key, mergedValue);
 		} else {
-			updatedKeys.push(newSetting.key);
-			await configuration.update(newSetting.key, newSetting.value, target);
+			await update(newSetting.key, newSetting.value);
 		}
 	}
-	return updatedKeys;
+	return { updatedKeys, unsupportedKeys };
 }
 
+const SELECTED_WORKSPACE_FOLDER_KEY = "selectedWorkspaceFolder";
+
+/**
+ * The workspace folder the extension works on. A multi-root workspace may hold
+ * several folders with the same name (`services/api` and `apps/api` are both
+ * called `api`), so the selection is stored as a path: stored by name, picking
+ * the second one kept resolving to the first.
+ */
 export const getCurrentWorkspaceFolder = (context: vscode.ExtensionContext) => {
 	const availableFolders = vscode.workspace.workspaceFolders;
-	if (!availableFolders) {
+	if (!availableFolders?.length) {
 		return;
 	}
 
-	const selectedWorkspaceFolder = context.workspaceState.get(
-		"selectedWorkspaceFolder",
+	const selectedWorkspaceFolder = context.workspaceState.get<string>(
+		SELECTED_WORKSPACE_FOLDER_KEY,
 	);
 	if (!selectedWorkspaceFolder) {
 		return availableFolders[0];
 	}
 
-	const foundFolder = availableFolders.find(
-		(folder) => folder.name === selectedWorkspaceFolder,
+	return (
+		availableFolders.find(
+			(folder) => folder.uri.fsPath === selectedWorkspaceFolder,
+		) ??
+		// selections made before the key held a path
+		availableFolders.find(
+			(folder) => folder.name === selectedWorkspaceFolder,
+		) ??
+		availableFolders[0]
+	);
+};
+
+export const setCurrentWorkspaceFolder = (
+	context: vscode.ExtensionContext,
+	folder: vscode.WorkspaceFolder,
+) => {
+	return context.workspaceState.update(
+		SELECTED_WORKSPACE_FOLDER_KEY,
+		folder.uri.fsPath,
+	);
+};
+
+export const clearCurrentWorkspaceFolder = (
+	context: vscode.ExtensionContext,
+) => {
+	return context.workspaceState.update(
+		SELECTED_WORKSPACE_FOLDER_KEY,
+		undefined,
 	);
-	if (foundFolder) {
-		return foundFolder;
-	}
-	return availableFolders[0];
 };
 
 export const getCurrentWorkspaceFolderPath = (

src/e2e-tests/fixtures/go-workspace/.gitignore

@@ -0,0 +1,3 @@
+# Written at runtime by the go e2e suite
+.vscode/
+.gocache/

src/e2e-tests/fixtures/go-workspace/demo_test.go

@@ -0,0 +1,13 @@
+package demo
+
+import (
+	"runtime"
+	"testing"
+)
+
+// Fails when built with any toolchain other than the one mise.toml pins
+func TestToolchainVersion(t *testing.T) {
+	if runtime.Version() != "go1.25.0" {
+		t.Fatalf("built with %s, mise.toml pins go1.25.0", runtime.Version())
+	}
+}

src/e2e-tests/fixtures/go-workspace/global-config.toml

@@ -0,0 +1,4 @@
+# Stands in for the machine global config. It pins another go on purpose: the
+# extension has to configure the project version, not this one.
+[tools]
+go = "1.24.0"

src/e2e-tests/fixtures/go-workspace/go.mod

@@ -0,0 +1,3 @@
+module example.com/fixture/demo
+
+go 1.25.0

src/e2e-tests/fixtures/go-workspace/mise.toml

@@ -0,0 +1,5 @@
+[tools]
+# must win over the go of global-config.toml.
+# Same version as multi-root-workspace/wk2, the two fixtures share their
+# toolchain store.
+go = "1.25.0"

src/e2e-tests/fixtures/multi-root-workspace/.gitignore

@@ -0,0 +1,7 @@
+# Written at runtime by the multi-root e2e suites
+.mise-data/
+.mise-cache/
+# throwaway copy of multi-root.code-workspace the suite runs against
+*.generated.code-workspace
+# folder-scoped settings written by per-folder extension configuration
+.vscode/

src/e2e-tests/fixtures/multi-root-workspace/global-config.toml

@@ -0,0 +1,8 @@
+# Stands in for the machine global config: the version pinned here must never
+# win over the one a workspace folder declares.
+[tools]
+jq = "1.6"
+
+[tasks.global-only-task]
+description = "Task defined in the global config"
+run = "echo 'global'"