fix: #225 support relative paths and ${workspaceFolder} in mise.binPath

Author: hverlin

docs/src/content/docs/reference/Settings.md

@@ -38,6 +38,8 @@ Path to the mise binary (automatically detected on startup).
 
 If set to `mise` (default), it will use `mise` available in `PATH`.
 
+Relative paths (e.g. `./bin/mise`) and `${workspaceFolder}` variables are resolved against the workspace folders.
+
 See https://mise.jdx.dev/getting-started.html to install mise.
 
 ---

package.json

@@ -169,7 +169,7 @@
         "mise.binPath": {
           "order": 2,
           "type": "string",
-          "markdownDescription": "Path to the mise binary (automatically detected on startup).\n\nIf set to `mise` (default), it will use `mise` available in `PATH`.\n\nSee https://mise.jdx.dev/getting-started.html to install mise.",
+          "markdownDescription": "Path to the mise binary (automatically detected on startup).\n\nIf set to `mise` (default), it will use `mise` available in `PATH`.\n\nRelative paths (e.g. `./bin/mise`) and `${workspaceFolder}` variables are resolved against the workspace folders.\n\nSee https://mise.jdx.dev/getting-started.html to install mise.",
           "default": "mise"
         },
         "mise.miseEnv": {

src/configuration.ts

@@ -1,6 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
 import { deepMerge } from "@std/collections";
 import * as vscode from "vscode";
+import { resolveConfiguredBinPath } from "./utils/fileUtils";
 import { logger } from "./utils/logger";
 
 export const CONFIGURATION_FLAGS = {
@@ -114,7 +115,21 @@ export const getMiseEnv = (): string | undefined => {
 };
 
 export const getConfiguredBinPath = (): string | undefined => {
-	return getExtensionConfig().get<string>(CONFIGURATION_FLAGS.binPath)?.trim();
+	const configuredPath = getExtensionConfig()
+		.get<string>(CONFIGURATION_FLAGS.binPath)
+		?.trim();
+
+	if (!configuredPath) {
+		return configuredPath;
+	}
+
+	return resolveConfiguredBinPath(
+		configuredPath,
+		vscode.workspace.workspaceFolders?.map((folder) => ({
+			name: folder.name,
+			fsPath: folder.uri.fsPath,
+		})) ?? [],
+	);
 };
 
 export const updateBinPath = async (binPath: string) => {

src/e2e-tests/relative-bin-path.e2e.ts

@@ -0,0 +1,72 @@
+import * as assert from "node:assert";
+import { execFile } from "node:child_process";
+import { mkdir, rm, symlink } from "node:fs/promises";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import * as vscode from "vscode";
+import { MiseService } from "../miseService";
+
+const execFileAsync = promisify(execFile);
+
+suite("Relative binPath Test Suite", function () {
+	this.timeout(20_000);
+
+	let workspaceRoot: string;
+	let binDir: string;
+	let miseService: MiseService;
+	let originalBinPath: string | undefined;
+
+	// initializeMisePath only reads workspaceState from the context
+	const fakeContext = {
+		workspaceState: { get: () => undefined },
+	} as unknown as vscode.ExtensionContext;
+
+	const getGlobalBinPathValue = () =>
+		vscode.workspace.getConfiguration("mise").inspect<string>("binPath")
+			?.globalValue;
+
+	const updateBinPath = (value: string | undefined) =>
+		vscode.workspace
+			.getConfiguration("mise")
+			.update("binPath", value, vscode.ConfigurationTarget.Global);
+
+	setup(async () => {
+		workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? "";
+		assert.ok(workspaceRoot, "Workspace root should be available");
+
+		originalBinPath = getGlobalBinPathValue();
+
+		const { stdout } = await execFileAsync("which", ["mise"]);
+		const miseBin = stdout.trim();
+		assert.ok(miseBin, "mise should be available in PATH");
+
+		binDir = path.join(workspaceRoot, "bin");
+		await rm(binDir, { recursive: true, force: true });
+		await mkdir(binDir, { recursive: true });
+		await symlink(miseBin, path.join(binDir, "mise"));
+
+		miseService = new MiseService(fakeContext);
+	});
+
+	teardown(async () => {
+		await updateBinPath(originalBinPath);
+		await rm(binDir, { recursive: true, force: true });
+	});
+
+	test("a relative binPath is resolved against the workspace and not overwritten", async () => {
+		await updateBinPath("./bin/mise");
+
+		await miseService.initializeMisePath();
+
+		assert.equal(
+			miseService.getMiseBinaryPath(),
+			path.join(workspaceRoot, "bin", "mise"),
+		);
+		// the configured relative path must survive activation instead of
+		// being rewritten to the resolved absolute path
+		assert.equal(getGlobalBinPathValue(), "./bin/mise");
+
+		const { stdout } = await miseService.execMiseCommand("version");
+		assert.ok(stdout.trim().length > 0, "mise version should produce output");
+	});
+});

src/utils/fileUtils.test.ts

@@ -3,6 +3,7 @@ import {
 	compareSourcePaths,
 	getShebangFileExtension,
 	getSourceProximityRank,
+	resolveConfiguredBinPath,
 } from "./fileUtils";
 
 describe("getSourceProximityRank", () => {
@@ -103,3 +104,102 @@ describe("getShebangFileExtension", () => {
 		expect(getShebangFileExtension("#!/usr/bin/env made-up\n")).toBeUndefined();
 	});
 });
+
+describe("resolveConfiguredBinPath", () => {
+	const folders = [
+		{ name: "frontend", fsPath: "/repo/frontend" },
+		{ name: "backend", fsPath: "/repo/backend" },
+	];
+	const existsIn = (...paths: string[]) => {
+		return (filePath: string) => paths.includes(filePath);
+	};
+	// biome-ignore lint/suspicious/noTemplateCurlyInString: literal VS Code variable
+	const workspaceFolderVar = "${workspaceFolder}";
+
+	it("leaves bare command names untouched for PATH lookup", () => {
+		expect(resolveConfiguredBinPath("mise", folders, existsIn())).toBe("mise");
+		expect(resolveConfiguredBinPath("mise.exe", folders, existsIn())).toBe(
+			"mise.exe",
+		);
+	});
+
+	it("leaves absolute paths untouched", () => {
+		expect(
+			resolveConfiguredBinPath("/usr/local/bin/mise", folders, existsIn()),
+		).toBe("/usr/local/bin/mise");
+	});
+
+	it("resolves relative paths against the first workspace folder containing the file", () => {
+		expect(
+			resolveConfiguredBinPath(
+				"./bin/mise",
+				folders,
+				existsIn("/repo/backend/bin/mise"),
+			),
+		).toBe("/repo/backend/bin/mise");
+		expect(
+			resolveConfiguredBinPath(
+				"bin/mise",
+				folders,
+				existsIn("/repo/frontend/bin/mise", "/repo/backend/bin/mise"),
+			),
+		).toBe("/repo/frontend/bin/mise");
+	});
+
+	it("falls back to the first workspace folder when the file does not exist", () => {
+		expect(resolveConfiguredBinPath("./bin/mise", folders, existsIn())).toBe(
+			"/repo/frontend/bin/mise",
+		);
+	});
+
+	it("resolves workspaceFolder variables", () => {
+		expect(
+			resolveConfiguredBinPath(
+				`${workspaceFolderVar}/bin/mise`,
+				folders,
+				existsIn("/repo/backend/bin/mise"),
+			),
+		).toBe("/repo/backend/bin/mise");
+		expect(
+			resolveConfiguredBinPath(
+				`${workspaceFolderVar}/bin/mise`,
+				folders,
+				existsIn(),
+			),
+		).toBe("/repo/frontend/bin/mise");
+	});
+
+	it("resolves named workspaceFolder variables against the named folder", () => {
+		expect(
+			resolveConfiguredBinPath(
+				// biome-ignore lint/suspicious/noTemplateCurlyInString: literal VS Code variable
+				"${workspaceFolder:backend}/bin/mise",
+				folders,
+				existsIn(),
+			),
+		).toBe("/repo/backend/bin/mise");
+	});
+
+	it("expands the home directory prefix", () => {
+		const resolved = resolveConfiguredBinPath(
+			"~/bin/mise",
+			folders,
+			existsIn(),
+		);
+		expect(resolved.endsWith("bin/mise")).toBe(true);
+		expect(resolved.startsWith("~")).toBe(false);
+	});
+
+	it("returns the configured path unchanged without workspace folders", () => {
+		expect(resolveConfiguredBinPath("./bin/mise", [], existsIn())).toBe(
+			"./bin/mise",
+		);
+		expect(
+			resolveConfiguredBinPath(
+				`${workspaceFolderVar}/bin/mise`,
+				[],
+				existsIn(),
+			),
+		).toBe(`${workspaceFolderVar}/bin/mise`);
+	});
+});

src/utils/fileUtils.ts

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -15,6 +16,62 @@ export function expandPath(filePath: string): string {
 	return res;
 }
 
+const WORKSPACE_FOLDER_VARIABLE = /^\$\{workspaceFolder(?::([^}]+))?\}[/\\]?/;
+
+/**
+ * Resolve a configured binary path (`mise.binPath`) that may reference the
+ * workspace: `${workspaceFolder}`/`${workspaceFolder:folderName}` variables
+ * and relative paths like `./bin/mise` are resolved against the workspace
+ * folders (the first folder where the file exists wins). Bare command names
+ * without a path separator (e.g. `mise`) are left untouched so they are
+ * looked up in `PATH`.
+ */
+export function resolveConfiguredBinPath(
+	configuredPath: string,
+	workspaceFolders: readonly { name: string; fsPath: string }[],
+	exists: (filePath: string) => boolean = existsSync,
+): string {
+	const variableMatch = configuredPath.match(WORKSPACE_FOLDER_VARIABLE);
+
+	if (variableMatch) {
+		const [prefix, folderName] = variableMatch;
+		const folders = folderName
+			? workspaceFolders.filter((folder) => folder.name === folderName)
+			: workspaceFolders;
+
+		const candidates = folders.map((folder) =>
+			path.join(folder.fsPath, configuredPath.slice(prefix.length)),
+		);
+
+		return (
+			candidates.find((candidate) => exists(candidate)) ??
+			candidates[0] ??
+			configuredPath
+		);
+	}
+
+	if (configuredPath.startsWith("~/") || configuredPath.startsWith("~\\")) {
+		return path.join(os.homedir(), configuredPath.slice(2));
+	}
+
+	if (
+		path.isAbsolute(configuredPath) ||
+		(!configuredPath.includes("/") && !configuredPath.includes("\\"))
+	) {
+		return configuredPath;
+	}
+
+	const candidates = workspaceFolders.map((folder) =>
+		path.resolve(folder.fsPath, configuredPath),
+	);
+
+	return (
+		candidates.find((candidate) => exists(candidate)) ??
+		candidates[0] ??
+		configuredPath
+	);
+}
+
 const SHEBANG_EXTENSIONS: Record<string, string> = {
 	bash: "sh",
 	sh: "sh",