dsh-wsl-workspace 0.3.2 → 0.4.0

package/lib/{wsl-C5_mxGPM.js → wsl-qwxCKU5O.js}

@@ -1,228 +1,229 @@
-import { execFile, execFileSync } from "node:child_process";
-import { promisify } from "node:util";
-//#region src/shared/paths.ts
-/** The two UNC hosts WSL exposes a distribution's filesystem under. */
-const UNC_HOSTS = ["wsl.localhost", "wsl$"];
-/**
-* Parse a WSL UNC path into its distro and Linux path. Accepts the WSL2
-* `\\wsl.localhost\<distro>\<linux>` form, the legacy `\\wsl$\<distro>\<linux>`
-* interop form, and forward-slash spellings of either.
-* @param raw - candidate absolute path.
-* @returns the parsed target, or null when the path is not a WSL UNC.
-*/
-function parseWslUnc(raw) {
-	const normalized = raw.replace(/\\/g, "/").replace(/\/\/+/g, "//");
-	if (!normalized.startsWith("//")) return null;
-	const segments = normalized.slice(2).split("/");
-	const host = (segments[0] ?? "").toLowerCase();
-	if (!UNC_HOSTS.includes(host)) return null;
-	const distro = segments[1] ?? "";
-	if (distro === "") return null;
-	return {
-		distro,
-		linuxPath: `/${segments.slice(2).filter((segment) => segment.length > 0).join("/")}`
-	};
-}
-/**
-* Normalize a Linux absolute path for the Host: collapse repeated slashes and
-* strip a trailing slash (root becomes `/`).
-* @param path - absolute Linux path.
-* @returns the normalized path.
-*/
-function normalizeLinuxPath(path) {
-	const collapsed = path.replace(/\/+/g, "/");
-	return collapsed === "/" ? "/" : collapsed.replace(/\/$/, "");
-}
-/**
-* Whether a path is an absolute, non-empty Linux path.
-* @param path - candidate.
-* @returns whether it starts with `/` and contains no NUL.
-*/
-function isAbsoluteLinuxPath(path) {
-	return path.startsWith("/") && !path.includes("\0");
-}
-/**
-* Join a distro and a Linux absolute path into the WSL2 UNC form used as the
-* workspace identity (`\\wsl.localhost\<distro>\<linux>`, backslash segments).
-* @param distro - distro name.
-* @param linuxPath - absolute Linux path (leading `/`).
-* @returns the UNC path.
-*/
-function joinUnc(distro, linuxPath) {
-	if (!isAbsoluteLinuxPath(linuxPath)) throw new Error(`wsl-workspace: cannot map a non-absolute Linux path "${linuxPath}" to UNC`);
-	if (distro === "" || distro === "." || distro === ".." || /[\\/]/.test(distro)) throw new Error(`wsl-workspace: invalid distribution name "${distro}"`);
-	const normalized = linuxPath.replace(/\/+/g, "/").replace(/\/$/, "");
-	const windowsSegments = (normalized.startsWith("/") ? normalized.slice(1) : normalized).replace(/\//g, "\\");
-	return `\\\\wsl.localhost\\${distro}${windowsSegments === "" ? "" : `\\${windowsSegments}`}`;
-}
-/**
-* Translate a Windows drive path to the drvfs mount path WSL distributions
-* conventionally expose it at (`C:\foo` → `/mnt/c/foo`). Only single-letter
-* drives under `/mnt` are mapped; custom mount points are out of scope.
-* @param path - the candidate Windows path.
-* @returns the `/mnt/<drive>/…` path, or `null` for non-drive paths.
-*/
-function windowsToMntPath(path) {
-	const match = /^([A-Za-z]):[\\/](.*)$/.exec(path);
-	if (match === null) return null;
-	const rest = (match[2] ?? "").replace(/\\/g, "/").replace(/\/+/g, "/").replace(/\/$/, "");
-	return `/mnt/${(match[1] ?? "").toLowerCase()}${rest === "" ? "" : `/${rest}`}`;
-}
-/**
-* Translate a `/mnt/<drive>/…` path back to its Windows drive path.
-* @param linuxPath - the candidate Linux path.
-* @returns the `X:\…` drive path, or `null` when the path is not a drvfs mount.
-*/
-function mntToWindowsPath(linuxPath) {
-	const match = /^\/mnt\/([a-zA-Z])(?:\/(.*))?$/.exec(linuxPath);
-	if (match === null) return null;
-	const rest = (match[2] ?? "").replace(/\//g, "\\");
-	return `${(match[1] ?? "").toUpperCase()}:\\${rest}`;
-}
-/**
-* Canonical Windows drive path for store keys and cross-realm identity:
-* separators unified to `\`, trailing separator stripped, and the WHOLE path
-* lowercased — Windows paths compare case-insensitively, and the workspace
-* registry may realpath a different casing than the caller spelled (8.3 or
-* on-disk casing), so the store key must collide across casings.
-* @param path - candidate Windows drive path.
-* @returns the canonical form, or `null` when not drive-shaped.
-*/
-function canonicalWindowsPath(path) {
-	const match = /^([A-Za-z]):[\\/](.*)$/.exec(path);
-	if (match === null) return null;
-	const rest = (match[2] ?? "").replace(/[\\/]+/g, "\\").replace(/\\$/, "").toLowerCase();
-	return `${(match[1] ?? "").toLowerCase()}:\\${rest}`;
-}
-/**
-* True when a value is a Windows-shaped path (drive or UNC), which is how
-* the shell executor decides the WSLENV `/p` translation flag: only Windows
-* path values need translation when they cross into the Linux process.
-* @param value - the environment value to classify.
-* @returns whether the value looks like a Windows path.
-*/
-function isWindowsPathShaped(value) {
-	return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
-}
-/** Linux username shape for `wsl.exe -u`: starts with a letter or underscore, then letters/digits/`_`/`.`/`-` (max 64). */
-const WSL_USERNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/;
-/**
-* Whether a value is a safe Linux username for `wsl.exe -u`. The check is
-* strict on purpose: a value starting with `-` could be parsed as a wsl.exe
-* option instead of a username.
-* @param value - candidate username.
-* @returns whether it matches the Linux username shape.
-*/
-function isValidWslUsername(value) {
-	return WSL_USERNAME_PATTERN.test(value);
-}
-//#endregion
-//#region src/shared/wsl.ts
-/**
-* WSL discovery helpers (host side): enumerate installed distributions
-* through `wsl.exe -l -q` and read the default distribution from the Lxss
-* registry key. `wsl.exe` output is UTF-16LE on most builds, so decoding
-* sniffs for NUL bytes before choosing an encoding.
-* @module dsh-wsl-workspace/shared/wsl
-*/
-const execFileAsync = promisify(execFile);
-/** Executable timeout for the short discovery calls. */
-const DISCOVERY_TIMEOUT_MS = 1e4;
-const LXSS_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Lxss";
-/** Human text for an unknown rejection. */
-function messageOf(value) {
-	return value instanceof Error ? value.message : String(value);
-}
-/**
-* Decode `wsl.exe -l -q` output. Newer builds emit UTF-8; most emit UTF-16LE
-* with NUL bytes interleaved — the NUL probe picks the right one.
-* @param buffer - the raw captured output.
-* @returns the decoded text.
-*/
-function decodeWslOutput(buffer) {
-	return buffer.includes(0) ? buffer.toString("utf16le") : buffer.toString("utf8");
-}
-/**
-* List installed WSL distributions in `wsl.exe` order.
-* @param wslPath - the `wsl.exe` executable (absolute or PATH name).
-* @returns distribution names, blank lines dropped.
-*/
-async function listDistros(wslPath = "wsl.exe") {
-	let stdout;
-	try {
-		stdout = (await execFileAsync(wslPath, ["-l", "-q"], {
-			encoding: "buffer",
-			timeout: DISCOVERY_TIMEOUT_MS
-		})).stdout;
-	} catch (error) {
-		throw new Error(`wsl-workspace: cannot list WSL distributions (${messageOf(error)}); is WSL installed?`);
-	}
-	return decodeWslOutput(stdout).split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-}
-/**
-* Read the user's default distribution from the Lxss registry. Non-fatal:
-* returns `undefined` when the value is absent or unreadable (the caller
-* falls back to list order).
-* @returns the default distribution name, or `undefined`.
-*/
-async function defaultDistro() {
-	try {
-		const value = await execFileAsync("reg.exe", [
-			"query",
-			LXSS_KEY,
-			"/v",
-			"DefaultDistribution"
-		], { timeout: DISCOVERY_TIMEOUT_MS });
-		const guid = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/i.exec(value.stdout)?.[1];
-		if (guid === void 0) return void 0;
-		const name = await execFileAsync("reg.exe", [
-			"query",
-			`${LXSS_KEY}\\${guid}`,
-			"/v",
-			"DistributionName"
-		], { timeout: DISCOVERY_TIMEOUT_MS });
-		const distro = /DistributionName\s+REG_SZ\s+(.+)/i.exec(name.stdout)?.[1]?.trim();
-		return distro === void 0 || distro === "" ? void 0 : distro;
-	} catch {
-		return;
-	}
-}
-/** Module-level cache for {@link defaultDistroSync} (one registry read per process). */
-let syncDefaultResolved = false;
-let syncDefault;
-/**
-* Synchronous variant of {@link defaultDistro} for executors that must
-* resolve a distribution inside a synchronous plan step. Cached after the
-* first read; non-fatal (returns `undefined` when the registry is
-* unreadable, letting the caller fail loud with its own message).
-* @returns the default distribution name, or `undefined`.
-*/
-function defaultDistroSync() {
-	if (syncDefaultResolved) return syncDefault;
-	syncDefaultResolved = true;
-	try {
-		const value = execFileSync("reg.exe", [
-			"query",
-			LXSS_KEY,
-			"/v",
-			"DefaultDistribution"
-		], { timeout: DISCOVERY_TIMEOUT_MS });
-		const guid = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/i.exec(String(value))?.[1];
-		if (guid === void 0) return void 0;
-		const name = execFileSync("reg.exe", [
-			"query",
-			`${LXSS_KEY}\\${guid}`,
-			"/v",
-			"DistributionName"
-		], { timeout: DISCOVERY_TIMEOUT_MS });
-		const distro = /DistributionName\s+REG_SZ\s+(.+)/i.exec(String(name))?.[1]?.trim();
-		syncDefault = distro === void 0 || distro === "" ? void 0 : distro;
-	} catch {
-		syncDefault = void 0;
-	}
-	return syncDefault;
-}
-//#endregion
-export { isAbsoluteLinuxPath as a, joinUnc as c, parseWslUnc as d, windowsToMntPath as f, canonicalWindowsPath as i, mntToWindowsPath as l, defaultDistroSync as n, isValidWslUsername as o, listDistros as r, isWindowsPathShaped as s, defaultDistro as t, normalizeLinuxPath as u };
-
-//# sourceMappingURL=wsl-C5_mxGPM.js.map
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/shared/paths.ts
+/** The two UNC hosts WSL exposes a distribution's filesystem under. */
+const UNC_HOSTS = ["wsl.localhost", "wsl$"];
+/**
+* Parse a WSL UNC path into its distro and Linux path. Accepts the WSL2
+* `\\wsl.localhost\<distro>\<linux>` form, the legacy `\\wsl$\<distro>\<linux>`
+* interop form, and forward-slash spellings of either.
+* @param raw - candidate absolute path.
+* @returns the parsed target, or null when the path is not a WSL UNC.
+*/
+function parseWslUnc(raw) {
+	const normalized = raw.replace(/\\/g, "/").replace(/\/\/+/g, "//");
+	if (!normalized.startsWith("//")) return null;
+	const segments = normalized.slice(2).split("/");
+	const host = (segments[0] ?? "").toLowerCase();
+	if (!UNC_HOSTS.includes(host)) return null;
+	const parts = segments.filter((segment) => segment.length > 0);
+	const distro = parts[1] ?? "";
+	if (distro === "") return null;
+	return {
+		distro,
+		linuxPath: `/${parts.slice(2).join("/")}`
+	};
+}
+/**
+* Normalize a Linux absolute path for the Host: collapse repeated slashes and
+* strip a trailing slash (root becomes `/`).
+* @param path - absolute Linux path.
+* @returns the normalized path.
+*/
+function normalizeLinuxPath(path) {
+	const collapsed = path.replace(/\/+/g, "/");
+	return collapsed === "/" ? "/" : collapsed.replace(/\/$/, "");
+}
+/**
+* Whether a path is an absolute, non-empty Linux path.
+* @param path - candidate.
+* @returns whether it starts with `/` and contains no NUL.
+*/
+function isAbsoluteLinuxPath(path) {
+	return path.startsWith("/") && !path.includes("\0");
+}
+/**
+* Join a distro and a Linux absolute path into the WSL2 UNC form used as the
+* workspace identity (`\\wsl.localhost\<distro>\<linux>`, backslash segments).
+* @param distro - distro name.
+* @param linuxPath - absolute Linux path (leading `/`).
+* @returns the UNC path.
+*/
+function joinUnc(distro, linuxPath) {
+	if (!isAbsoluteLinuxPath(linuxPath)) throw new Error(`wsl-workspace: cannot map a non-absolute Linux path "${linuxPath}" to UNC`);
+	if (distro === "" || distro === "." || distro === ".." || /[\\/]/.test(distro)) throw new Error(`wsl-workspace: invalid distribution name "${distro}"`);
+	const normalized = linuxPath.replace(/\/+/g, "/").replace(/\/$/, "");
+	const windowsSegments = (normalized.startsWith("/") ? normalized.slice(1) : normalized).replace(/\//g, "\\");
+	return `\\\\wsl.localhost\\${distro}${windowsSegments === "" ? "" : `\\${windowsSegments}`}`;
+}
+/**
+* Translate a Windows drive path to the drvfs mount path WSL distributions
+* conventionally expose it at (`C:\foo` → `/mnt/c/foo`). Only single-letter
+* drives under `/mnt` are mapped; custom mount points are out of scope.
+* @param path - the candidate Windows path.
+* @returns the `/mnt/<drive>/…` path, or `null` for non-drive paths.
+*/
+function windowsToMntPath(path) {
+	const match = /^([A-Za-z]):[\\/](.*)$/.exec(path);
+	if (match === null) return null;
+	const rest = (match[2] ?? "").replace(/\\/g, "/").replace(/\/+/g, "/").replace(/\/$/, "");
+	return `/mnt/${(match[1] ?? "").toLowerCase()}${rest === "" ? "" : `/${rest}`}`;
+}
+/**
+* Translate a `/mnt/<drive>/…` path back to its Windows drive path.
+* @param linuxPath - the candidate Linux path.
+* @returns the `X:\…` drive path, or `null` when the path is not a drvfs mount.
+*/
+function mntToWindowsPath(linuxPath) {
+	const match = /^\/mnt\/([a-zA-Z])(?:\/(.*))?$/.exec(linuxPath);
+	if (match === null) return null;
+	const rest = (match[2] ?? "").replace(/\//g, "\\");
+	return `${(match[1] ?? "").toUpperCase()}:\\${rest}`;
+}
+/**
+* Canonical Windows drive path for store keys and cross-realm identity:
+* separators unified to `\`, trailing separator stripped, and the WHOLE path
+* lowercased — Windows paths compare case-insensitively, and the workspace
+* registry may realpath a different casing than the caller spelled (8.3 or
+* on-disk casing), so the store key must collide across casings.
+* @param path - candidate Windows drive path.
+* @returns the canonical form, or `null` when not drive-shaped.
+*/
+function canonicalWindowsPath(path) {
+	const match = /^([A-Za-z]):[\\/](.*)$/.exec(path);
+	if (match === null) return null;
+	const rest = (match[2] ?? "").replace(/[\\/]+/g, "\\").replace(/\\$/, "").toLowerCase();
+	return `${(match[1] ?? "").toLowerCase()}:\\${rest}`;
+}
+/**
+* True when a value is a Windows-shaped path (drive or UNC), which is how
+* the shell executor decides the WSLENV `/p` translation flag: only Windows
+* path values need translation when they cross into the Linux process.
+* @param value - the environment value to classify.
+* @returns whether the value looks like a Windows path.
+*/
+function isWindowsPathShaped(value) {
+	return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+}
+/** Linux username shape for `wsl.exe -u`: starts with a letter or underscore, then letters/digits/`_`/`.`/`-` (max 64). */
+const WSL_USERNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/;
+/**
+* Whether a value is a safe Linux username for `wsl.exe -u`. The check is
+* strict on purpose: a value starting with `-` could be parsed as a wsl.exe
+* option instead of a username.
+* @param value - candidate username.
+* @returns whether it matches the Linux username shape.
+*/
+function isValidWslUsername(value) {
+	return WSL_USERNAME_PATTERN.test(value);
+}
+//#endregion
+//#region src/shared/wsl.ts
+/**
+* WSL discovery helpers (host side): enumerate installed distributions
+* through `wsl.exe -l -q` and read the default distribution from the Lxss
+* registry key. `wsl.exe` output is UTF-16LE on most builds, so decoding
+* sniffs for NUL bytes before choosing an encoding.
+* @module dsh-wsl-workspace/shared/wsl
+*/
+const execFileAsync = promisify(execFile);
+/** Executable timeout for the short discovery calls. */
+const DISCOVERY_TIMEOUT_MS = 1e4;
+const LXSS_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Lxss";
+/** Human text for an unknown rejection. */
+function messageOf(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+/**
+* Decode `wsl.exe -l -q` output. Newer builds emit UTF-8; most emit UTF-16LE
+* with NUL bytes interleaved — the NUL probe picks the right one.
+* @param buffer - the raw captured output.
+* @returns the decoded text.
+*/
+function decodeWslOutput(buffer) {
+	return buffer.includes(0) ? buffer.toString("utf16le") : buffer.toString("utf8");
+}
+/**
+* List installed WSL distributions in `wsl.exe` order.
+* @param wslPath - the `wsl.exe` executable (absolute or PATH name).
+* @returns distribution names, blank lines dropped.
+*/
+async function listDistros(wslPath = "wsl.exe") {
+	let stdout;
+	try {
+		stdout = (await execFileAsync(wslPath, ["-l", "-q"], {
+			encoding: "buffer",
+			timeout: DISCOVERY_TIMEOUT_MS
+		})).stdout;
+	} catch (error) {
+		throw new Error(`wsl-workspace: cannot list WSL distributions (${messageOf(error)}); is WSL installed?`);
+	}
+	return decodeWslOutput(stdout).split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+/**
+* Read the user's default distribution from the Lxss registry. Non-fatal:
+* returns `undefined` when the value is absent or unreadable (the caller
+* falls back to list order).
+* @returns the default distribution name, or `undefined`.
+*/
+async function defaultDistro() {
+	try {
+		const value = await execFileAsync("reg.exe", [
+			"query",
+			LXSS_KEY,
+			"/v",
+			"DefaultDistribution"
+		], { timeout: DISCOVERY_TIMEOUT_MS });
+		const guid = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/i.exec(value.stdout)?.[1];
+		if (guid === void 0) return void 0;
+		const name = await execFileAsync("reg.exe", [
+			"query",
+			`${LXSS_KEY}\\${guid}`,
+			"/v",
+			"DistributionName"
+		], { timeout: DISCOVERY_TIMEOUT_MS });
+		const distro = /DistributionName\s+REG_SZ\s+(.+)/i.exec(name.stdout)?.[1]?.trim();
+		return distro === void 0 || distro === "" ? void 0 : distro;
+	} catch {
+		return;
+	}
+}
+/** Module-level cache for {@link defaultDistroSync} (one registry read per process). */
+let syncDefaultResolved = false;
+let syncDefault;
+/**
+* Synchronous variant of {@link defaultDistro} for executors that must
+* resolve a distribution inside a synchronous plan step. Cached after the
+* first read; non-fatal (returns `undefined` when the registry is
+* unreadable, letting the caller fail loud with its own message).
+* @returns the default distribution name, or `undefined`.
+*/
+function defaultDistroSync() {
+	if (syncDefaultResolved) return syncDefault;
+	syncDefaultResolved = true;
+	try {
+		const value = execFileSync("reg.exe", [
+			"query",
+			LXSS_KEY,
+			"/v",
+			"DefaultDistribution"
+		], { timeout: DISCOVERY_TIMEOUT_MS });
+		const guid = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/i.exec(String(value))?.[1];
+		if (guid === void 0) return void 0;
+		const name = execFileSync("reg.exe", [
+			"query",
+			`${LXSS_KEY}\\${guid}`,
+			"/v",
+			"DistributionName"
+		], { timeout: DISCOVERY_TIMEOUT_MS });
+		const distro = /DistributionName\s+REG_SZ\s+(.+)/i.exec(String(name))?.[1]?.trim();
+		syncDefault = distro === void 0 || distro === "" ? void 0 : distro;
+	} catch {
+		syncDefault = void 0;
+	}
+	return syncDefault;
+}
+//#endregion
+export { isAbsoluteLinuxPath as a, joinUnc as c, parseWslUnc as d, windowsToMntPath as f, canonicalWindowsPath as i, mntToWindowsPath as l, defaultDistroSync as n, isValidWslUsername as o, listDistros as r, isWindowsPathShaped as s, defaultDistro as t, normalizeLinuxPath as u };
+
+//# sourceMappingURL=wsl-qwxCKU5O.js.map

package/lib/wsl-qwxCKU5O.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsl-qwxCKU5O.js","names":[],"sources":["../src/shared/paths.ts","../src/shared/wsl.ts"],"sourcesContent":["/**\r\n * WSL path helpers shared by the client and host halves. Pure and\r\n * dependency-free so both planes can import them without a runtime edge.\r\n */\r\n\r\n/** WSL2 default loopback bridge host: `\\\\wsl.localhost\\<distro>\\...`. */\r\nconst WSL_LOCALHOST_HOST = 'wsl.localhost'\r\n/** Legacy WSL interop host: `\\\\wsl$\\<distro>\\...`. */\r\nconst WSL_LEGACY_HOST = 'wsl$'\r\n\r\n/** The two UNC hosts WSL exposes a distribution's filesystem under. */\r\nconst UNC_HOSTS = [WSL_LOCALHOST_HOST, WSL_LEGACY_HOST]\r\n\r\n/** One WSL workspace coordinate parsed out of a UNC path. */\r\nexport interface WslUncTarget {\r\n  /** Distro name (e.g. `Ubuntu`) as `wsl -l -q` reports it. */\r\n  readonly distro: string\r\n  /** Normalized absolute Linux path (leading `/`; no trailing slash except root). */\r\n  readonly linuxPath: string\r\n}\r\n\r\n/**\r\n * Parse a WSL UNC path into its distro and Linux path. Accepts the WSL2\r\n * `\\\\wsl.localhost\\<distro>\\<linux>` form, the legacy `\\\\wsl$\\<distro>\\<linux>`\r\n * interop form, and forward-slash spellings of either.\r\n * @param raw - candidate absolute path.\r\n * @returns the parsed target, or null when the path is not a WSL UNC.\r\n */\r\nexport function parseWslUnc(raw: string): WslUncTarget | null {\r\n  const normalized = raw.replace(/\\\\/g, '/').replace(/\\/\\/+/g, '//')\r\n  if (!normalized.startsWith('//')) return null\r\n  const segments = normalized.slice(2).split('/')\r\n  const host = (segments[0] ?? '').toLowerCase()\r\n  if (!UNC_HOSTS.includes(host)) return null\r\n  // Empty segments (double separators anywhere after the host) are\r\n  // collapsed: `\\\\wsl.localhost\\\\Ubuntu\\home` and trailing slashes must\r\n  // parse the same as their single-separator spelling.\r\n  const parts = segments.filter(segment => segment.length > 0)\r\n  const distro = parts[1] ?? ''\r\n  if (distro === '') return null\r\n  return { distro, linuxPath: `/${parts.slice(2).join('/')}` }\r\n}\r\n\r\n/**\r\n * Whether a path resolves into a WSL distro through either UNC form.\r\n * @param raw - candidate absolute path.\r\n * @returns whether the path parses as a WSL UNC.\r\n */\r\nexport function isWslUnc(raw: string): boolean {\r\n  return parseWslUnc(raw) !== null\r\n}\r\n\r\n/**\r\n * Translate a WSL UNC path to the absolute Linux path a process inside the\r\n * distribution can open. Throws on non-WSL input: callers rely on this\r\n * conversion to hand paths to the Linux world, so a silent pass-through\r\n * would hand a Windows path to bash.\r\n * @param uncPath - a path {@link parseWslUnc} accepts.\r\n * @returns the absolute Linux path.\r\n */\r\nexport function uncToLinux(uncPath: string): string {\r\n  const parts = parseWslUnc(uncPath)\r\n  if (parts === null) {\r\n    throw new Error(`wsl-workspace: \"${uncPath}\" is not a WSL UNC path`)\r\n  }\r\n  return parts.linuxPath\r\n}\r\n\r\n/**\r\n * Normalize a Linux absolute path for the Host: collapse repeated slashes and\r\n * strip a trailing slash (root becomes `/`).\r\n * @param path - absolute Linux path.\r\n * @returns the normalized path.\r\n */\r\nexport function normalizeLinuxPath(path: string): string {\r\n  const collapsed = path.replace(/\\/+/g, '/')\r\n  return collapsed === '/' ? '/' : collapsed.replace(/\\/$/, '')\r\n}\r\n\r\n/**\r\n * Whether a path is an absolute, non-empty Linux path.\r\n * @param path - candidate.\r\n * @returns whether it starts with `/` and contains no NUL.\r\n */\r\nexport function isAbsoluteLinuxPath(path: string): boolean {\r\n  return path.startsWith('/') && !path.includes('\\0')\r\n}\r\n\r\n/**\r\n * Join a distro and a Linux absolute path into the WSL2 UNC form used as the\r\n * workspace identity (`\\\\wsl.localhost\\<distro>\\<linux>`, backslash segments).\r\n * @param distro - distro name.\r\n * @param linuxPath - absolute Linux path (leading `/`).\r\n * @returns the UNC path.\r\n */\r\nexport function joinUnc(distro: string, linuxPath: string): string {\r\n  if (!isAbsoluteLinuxPath(linuxPath)) {\r\n    throw new Error(`wsl-workspace: cannot map a non-absolute Linux path \"${linuxPath}\" to UNC`)\r\n  }\r\n  // Defense in depth: a distribution name with separators or dot-dirs would\r\n  // escape the `\\\\wsl.localhost\\` share structure (the host route validates\r\n  // wire-supplied names too; every other caller passes through here).\r\n  if (distro === '' || distro === '.' || distro === '..' || /[\\\\/]/.test(distro)) {\r\n    throw new Error(`wsl-workspace: invalid distribution name \"${distro}\"`)\r\n  }\r\n  const normalized = linuxPath.replace(/\\/+/g, '/').replace(/\\/$/, '')\r\n  const withoutLeading = normalized.startsWith('/') ? normalized.slice(1) : normalized\r\n  const windowsSegments = withoutLeading.replace(/\\//g, '\\\\')\r\n  const suffix = windowsSegments === '' ? '' : `\\\\${windowsSegments}`\r\n  return `\\\\\\\\wsl.localhost\\\\${distro}${suffix}`\r\n}\r\n\r\n/**\r\n * Translate a Windows drive path to the drvfs mount path WSL distributions\r\n * conventionally expose it at (`C:\\foo` → `/mnt/c/foo`). Only single-letter\r\n * drives under `/mnt` are mapped; custom mount points are out of scope.\r\n * @param path - the candidate Windows path.\r\n * @returns the `/mnt/<drive>/…` path, or `null` for non-drive paths.\r\n */\r\nexport function windowsToMntPath(path: string): string | null {\r\n  const match = /^([A-Za-z]):[\\\\/](.*)$/.exec(path)\r\n  if (match === null) return null\r\n  const rest = (match[2] ?? '').replace(/\\\\/g, '/').replace(/\\/+/g, '/').replace(/\\/$/, '')\r\n  return `/mnt/${(match[1] ?? '').toLowerCase()}${rest === '' ? '' : `/${rest}`}`\r\n}\r\n\r\n/**\r\n * Translate a `/mnt/<drive>/…` path back to its Windows drive path.\r\n * @param linuxPath - the candidate Linux path.\r\n * @returns the `X:\\…` drive path, or `null` when the path is not a drvfs mount.\r\n */\r\nexport function mntToWindowsPath(linuxPath: string): string | null {\r\n  const match = /^\\/mnt\\/([a-zA-Z])(?:\\/(.*))?$/.exec(linuxPath)\r\n  if (match === null) return null\r\n  const rest = (match[2] ?? '').replace(/\\//g, '\\\\')\r\n  return `${(match[1] ?? '').toUpperCase()}:\\\\${rest}`\r\n}\r\n\r\n/**\r\n * Canonical Windows drive path for store keys and cross-realm identity:\r\n * separators unified to `\\`, trailing separator stripped, and the WHOLE path\r\n * lowercased — Windows paths compare case-insensitively, and the workspace\r\n * registry may realpath a different casing than the caller spelled (8.3 or\r\n * on-disk casing), so the store key must collide across casings.\r\n * @param path - candidate Windows drive path.\r\n * @returns the canonical form, or `null` when not drive-shaped.\r\n */\r\nexport function canonicalWindowsPath(path: string): string | null {\r\n  const match = /^([A-Za-z]):[\\\\/](.*)$/.exec(path)\r\n  if (match === null) return null\r\n  const rest = (match[2] ?? '').replace(/[\\\\/]+/g, '\\\\').replace(/\\\\$/, '').toLowerCase()\r\n  return `${(match[1] ?? '').toLowerCase()}:\\\\${rest}`\r\n}\r\n\r\n/**\r\n * True when a value is a Windows-shaped path (drive or UNC), which is how\r\n * the shell executor decides the WSLENV `/p` translation flag: only Windows\r\n * path values need translation when they cross into the Linux process.\r\n * @param value - the environment value to classify.\r\n * @returns whether the value looks like a Windows path.\r\n */\r\nexport function isWindowsPathShaped(value: string): boolean {\r\n  return /^[A-Za-z]:[\\\\/]/.test(value) || value.startsWith('\\\\\\\\')\r\n}\r\n\r\n/** Linux username shape for `wsl.exe -u`: starts with a letter or underscore, then letters/digits/`_`/`.`/`-` (max 64). */\r\nconst WSL_USERNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/\r\n\r\n/**\r\n * Whether a value is a safe Linux username for `wsl.exe -u`. The check is\r\n * strict on purpose: a value starting with `-` could be parsed as a wsl.exe\r\n * option instead of a username.\r\n * @param value - candidate username.\r\n * @returns whether it matches the Linux username shape.\r\n */\r\nexport function isValidWslUsername(value: string): boolean {\r\n  return WSL_USERNAME_PATTERN.test(value)\r\n}\r\n","/**\n * WSL discovery helpers (host side): enumerate installed distributions\n * through `wsl.exe -l -q` and read the default distribution from the Lxss\n * registry key. `wsl.exe` output is UTF-16LE on most builds, so decoding\n * sniffs for NUL bytes before choosing an encoding.\n * @module dsh-wsl-workspace/shared/wsl\n */\n\nimport { execFile, execFileSync } from 'node:child_process'\nimport { promisify } from 'node:util'\n\nconst execFileAsync = promisify(execFile)\n\n/** Executable timeout for the short discovery calls. */\nconst DISCOVERY_TIMEOUT_MS = 10_000\n\nconst LXSS_KEY = 'HKCU\\\\Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Lxss'\n\n/** Human text for an unknown rejection. */\nfunction messageOf(value: unknown): string {\n  return value instanceof Error ? value.message : String(value)\n}\n\n/**\n * Decode `wsl.exe -l -q` output. Newer builds emit UTF-8; most emit UTF-16LE\n * with NUL bytes interleaved — the NUL probe picks the right one.\n * @param buffer - the raw captured output.\n * @returns the decoded text.\n */\nexport function decodeWslOutput(buffer: Buffer): string {\n  return buffer.includes(0) ? buffer.toString('utf16le') : buffer.toString('utf8')\n}\n\n/**\n * List installed WSL distributions in `wsl.exe` order.\n * @param wslPath - the `wsl.exe` executable (absolute or PATH name).\n * @returns distribution names, blank lines dropped.\n */\nexport async function listDistros(wslPath = 'wsl.exe'): Promise<string[]> {\n  let stdout: Buffer\n  try {\n    const result = await execFileAsync(wslPath, ['-l', '-q'], { encoding: 'buffer', timeout: DISCOVERY_TIMEOUT_MS })\n    stdout = result.stdout as Buffer\n  } catch (error) {\n    throw new Error(`wsl-workspace: cannot list WSL distributions (${messageOf(error)}); is WSL installed?`)\n  }\n  return decodeWslOutput(stdout)\n    .split(/\\r?\\n/)\n    .map(line => line.trim())\n    .filter(line => line.length > 0)\n}\n\n/**\n * Read the user's default distribution from the Lxss registry. Non-fatal:\n * returns `undefined` when the value is absent or unreadable (the caller\n * falls back to list order).\n * @returns the default distribution name, or `undefined`.\n */\nexport async function defaultDistro(): Promise<string | undefined> {\n  try {\n    const value = await execFileAsync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const guid = /DefaultDistribution\\s+REG_SZ\\s+(\\{[0-9a-fA-F-]+\\})/i.exec(value.stdout)?.[1]\n    if (guid === undefined) return undefined\n    const name = await execFileAsync('reg.exe', ['query', `${LXSS_KEY}\\\\${guid}`, '/v', 'DistributionName'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const distro = /DistributionName\\s+REG_SZ\\s+(.+)/i.exec(name.stdout)?.[1]?.trim()\n    return distro === undefined || distro === '' ? undefined : distro\n  } catch {\n    return undefined\n  }\n}\n\n/** Module-level cache for {@link defaultDistroSync} (one registry read per process). */\nlet syncDefaultResolved = false\nlet syncDefault: string | undefined\n\n/**\n * Synchronous variant of {@link defaultDistro} for executors that must\n * resolve a distribution inside a synchronous plan step. Cached after the\n * first read; non-fatal (returns `undefined` when the registry is\n * unreadable, letting the caller fail loud with its own message).\n * @returns the default distribution name, or `undefined`.\n */\nexport function defaultDistroSync(): string | undefined {\n  if (syncDefaultResolved) return syncDefault\n  syncDefaultResolved = true\n  try {\n    const value = execFileSync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const guid = /DefaultDistribution\\s+REG_SZ\\s+(\\{[0-9a-fA-F-]+\\})/i.exec(String(value))?.[1]\n    if (guid === undefined) return undefined\n    const name = execFileSync('reg.exe', ['query', `${LXSS_KEY}\\\\${guid}`, '/v', 'DistributionName'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const distro = /DistributionName\\s+REG_SZ\\s+(.+)/i.exec(String(name))?.[1]?.trim()\n    syncDefault = distro === undefined || distro === '' ? undefined : distro\n  } catch {\n    syncDefault = undefined\n  }\n  return syncDefault\n}\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-wsl-workspace",
   "description": "WSL workspace support for DeepSeek Harness: add a WSL workspace from the web GUI and run the whole agent session (bash + file tools) inside the WSL distribution, VS Code Remote-WSL style. No toolchain install inside WSL required.",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -9,7 +9,7 @@
   },
   "main": "lib/index.js",
   "scripts": {
-    "build": "tsdown && node scripts/verify-lib.mjs",
+    "build": "tsdown && node scripts/prune-lib.mjs && node scripts/verify-lib.mjs",
     "verify": "node scripts/verify-lib.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
@@ -31,9 +31,20 @@
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-sidebar"
       ]
+    },
+    "compatibility": {
+      "dshReleases": {
+        "0.1.0-rc.7": "compatible",
+        "0.1.0-rc.8": "compatible",
+        "0.1.1-rc.1": "compatible",
+        "0.1.1-rc.2": "compatible"
+      }
     }
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=24"
+  },
   "keywords": [
     "deepseek-harness",
     "dsh",