dsh-wsl-workspace 0.1.0

package/lib/paths-DBaSmi7x.js

@@ -0,0 +1,105 @@
+//#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}`;
+}
+/**
+* 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
+export { mntToWindowsPath as a, windowsToMntPath as c, joinUnc as i, isValidWslUsername as n, normalizeLinuxPath as o, isWindowsPathShaped as r, parseWslUnc as s, isAbsoluteLinuxPath as t };
+
+//# sourceMappingURL=paths-DBaSmi7x.js.map

package/lib/paths-DBaSmi7x.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths-DBaSmi7x.js","names":[],"sources":["../src/shared/paths.ts"],"sourcesContent":["/**\n * WSL path helpers shared by the client and host halves. Pure and\n * dependency-free so both planes can import them without a runtime edge.\n */\n\n/** WSL2 default loopback bridge host: `\\\\wsl.localhost\\<distro>\\...`. */\nconst WSL_LOCALHOST_HOST = 'wsl.localhost'\n/** Legacy WSL interop host: `\\\\wsl$\\<distro>\\...`. */\nconst WSL_LEGACY_HOST = 'wsl$'\n\n/** The two UNC hosts WSL exposes a distribution's filesystem under. */\nconst UNC_HOSTS = [WSL_LOCALHOST_HOST, WSL_LEGACY_HOST]\n\n/** One WSL workspace coordinate parsed out of a UNC path. */\nexport interface WslUncTarget {\n  /** Distro name (e.g. `Ubuntu`) as `wsl -l -q` reports it. */\n  readonly distro: string\n  /** Normalized absolute Linux path (leading `/`; no trailing slash except root). */\n  readonly linuxPath: string\n}\n\n/**\n * Parse a WSL UNC path into its distro and Linux path. Accepts the WSL2\n * `\\\\wsl.localhost\\<distro>\\<linux>` form, the legacy `\\\\wsl$\\<distro>\\<linux>`\n * interop form, and forward-slash spellings of either.\n * @param raw - candidate absolute path.\n * @returns the parsed target, or null when the path is not a WSL UNC.\n */\nexport function parseWslUnc(raw: string): WslUncTarget | null {\n  const normalized = raw.replace(/\\\\/g, '/').replace(/\\/\\/+/g, '//')\n  if (!normalized.startsWith('//')) return null\n  const segments = normalized.slice(2).split('/')\n  const host = (segments[0] ?? '').toLowerCase()\n  if (!UNC_HOSTS.includes(host)) return null\n  const distro = segments[1] ?? ''\n  if (distro === '') return null\n  const rest = segments.slice(2).filter(segment => segment.length > 0)\n  return { distro, linuxPath: `/${rest.join('/')}` }\n}\n\n/**\n * Whether a path resolves into a WSL distro through either UNC form.\n * @param raw - candidate absolute path.\n * @returns whether the path parses as a WSL UNC.\n */\nexport function isWslUnc(raw: string): boolean {\n  return parseWslUnc(raw) !== null\n}\n\n/**\n * Translate a WSL UNC path to the absolute Linux path a process inside the\n * distribution can open. Throws on non-WSL input: callers rely on this\n * conversion to hand paths to the Linux world, so a silent pass-through\n * would hand a Windows path to bash.\n * @param uncPath - a path {@link parseWslUnc} accepts.\n * @returns the absolute Linux path.\n */\nexport function uncToLinux(uncPath: string): string {\n  const parts = parseWslUnc(uncPath)\n  if (parts === null) {\n    throw new Error(`wsl-workspace: \"${uncPath}\" is not a WSL UNC path`)\n  }\n  return parts.linuxPath\n}\n\n/**\n * Normalize a Linux absolute path for the Host: collapse repeated slashes and\n * strip a trailing slash (root becomes `/`).\n * @param path - absolute Linux path.\n * @returns the normalized path.\n */\nexport function normalizeLinuxPath(path: string): string {\n  const collapsed = path.replace(/\\/+/g, '/')\n  return collapsed === '/' ? '/' : collapsed.replace(/\\/$/, '')\n}\n\n/**\n * Whether a path is an absolute, non-empty Linux path.\n * @param path - candidate.\n * @returns whether it starts with `/` and contains no NUL.\n */\nexport function isAbsoluteLinuxPath(path: string): boolean {\n  return path.startsWith('/') && !path.includes('\\0')\n}\n\n/**\n * Join a distro and a Linux absolute path into the WSL2 UNC form used as the\n * workspace identity (`\\\\wsl.localhost\\<distro>\\<linux>`, backslash segments).\n * @param distro - distro name.\n * @param linuxPath - absolute Linux path (leading `/`).\n * @returns the UNC path.\n */\nexport function joinUnc(distro: string, linuxPath: string): string {\n  if (!isAbsoluteLinuxPath(linuxPath)) {\n    throw new Error(`wsl-workspace: cannot map a non-absolute Linux path \"${linuxPath}\" to UNC`)\n  }\n  // Defense in depth: a distribution name with separators or dot-dirs would\n  // escape the `\\\\wsl.localhost\\` share structure (the host route validates\n  // wire-supplied names too; every other caller passes through here).\n  if (distro === '' || distro === '.' || distro === '..' || /[\\\\/]/.test(distro)) {\n    throw new Error(`wsl-workspace: invalid distribution name \"${distro}\"`)\n  }\n  const normalized = linuxPath.replace(/\\/+/g, '/').replace(/\\/$/, '')\n  const withoutLeading = normalized.startsWith('/') ? normalized.slice(1) : normalized\n  const windowsSegments = withoutLeading.replace(/\\//g, '\\\\')\n  const suffix = windowsSegments === '' ? '' : `\\\\${windowsSegments}`\n  return `\\\\\\\\wsl.localhost\\\\${distro}${suffix}`\n}\n\n/**\n * Translate a Windows drive path to the drvfs mount path WSL distributions\n * conventionally expose it at (`C:\\foo` → `/mnt/c/foo`). Only single-letter\n * drives under `/mnt` are mapped; custom mount points are out of scope.\n * @param path - the candidate Windows path.\n * @returns the `/mnt/<drive>/…` path, or `null` for non-drive paths.\n */\nexport function windowsToMntPath(path: string): string | null {\n  const match = /^([A-Za-z]):[\\\\/](.*)$/.exec(path)\n  if (match === null) return null\n  const rest = (match[2] ?? '').replace(/\\\\/g, '/').replace(/\\/+/g, '/').replace(/\\/$/, '')\n  return `/mnt/${(match[1] ?? '').toLowerCase()}${rest === '' ? '' : `/${rest}`}`\n}\n\n/**\n * Translate a `/mnt/<drive>/…` path back to its Windows drive path.\n * @param linuxPath - the candidate Linux path.\n * @returns the `X:\\…` drive path, or `null` when the path is not a drvfs mount.\n */\nexport function mntToWindowsPath(linuxPath: string): string | null {\n  const match = /^\\/mnt\\/([a-zA-Z])(?:\\/(.*))?$/.exec(linuxPath)\n  if (match === null) return null\n  const rest = (match[2] ?? '').replace(/\\//g, '\\\\')\n  return `${(match[1] ?? '').toUpperCase()}:\\\\${rest}`\n}\n\n/**\n * True when a value is a Windows-shaped path (drive or UNC), which is how\n * the shell executor decides the WSLENV `/p` translation flag: only Windows\n * path values need translation when they cross into the Linux process.\n * @param value - the environment value to classify.\n * @returns whether the value looks like a Windows path.\n */\nexport function isWindowsPathShaped(value: string): boolean {\n  return /^[A-Za-z]:[\\\\/]/.test(value) || value.startsWith('\\\\\\\\')\n}\n\n/** Linux username shape for `wsl.exe -u`: starts with a letter or underscore, then letters/digits/`_`/`.`/`-` (max 64). */\nconst WSL_USERNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/\n\n/**\n * Whether a value is a safe Linux username for `wsl.exe -u`. The check is\n * strict on purpose: a value starting with `-` could be parsed as a wsl.exe\n * option instead of a username.\n * @param value - candidate username.\n * @returns whether it matches the Linux username shape.\n */\nexport function isValidWslUsername(value: string): boolean {\n  return WSL_USERNAME_PATTERN.test(value)\n}\n"],"mappings":";;AAWA,MAAM,YAAY,CAAC,iBAAoB,MAAe;;;;;;;;AAiBtD,SAAgB,YAAY,KAAkC;CAC5D,MAAM,aAAa,IAAI,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,UAAU,IAAI;CACjE,IAAI,CAAC,WAAW,WAAW,IAAI,GAAG,OAAO;CACzC,MAAM,WAAW,WAAW,MAAM,CAAC,CAAC,CAAC,MAAM,GAAG;CAC9C,MAAM,QAAQ,SAAS,MAAM,GAAA,CAAI,YAAY;CAC7C,IAAI,CAAC,UAAU,SAAS,IAAI,GAAG,OAAO;CACtC,MAAM,SAAS,SAAS,MAAM;CAC9B,IAAI,WAAW,IAAI,OAAO;CAE1B,OAAO;EAAE;EAAQ,WAAW,IADf,SAAS,MAAM,CAAC,CAAC,CAAC,QAAO,YAAW,QAAQ,SAAS,CAC/B,CAAC,CAAC,KAAK,GAAG;CAAI;AACnD;;;;;;;AAiCA,SAAgB,mBAAmB,MAAsB;CACvD,MAAM,YAAY,KAAK,QAAQ,QAAQ,GAAG;CAC1C,OAAO,cAAc,MAAM,MAAM,UAAU,QAAQ,OAAO,EAAE;AAC9D;;;;;;AAOA,SAAgB,oBAAoB,MAAuB;CACzD,OAAO,KAAK,WAAW,GAAG,KAAK,CAAC,KAAK,SAAS,IAAI;AACpD;;;;;;;;AASA,SAAgB,QAAQ,QAAgB,WAA2B;CACjE,IAAI,CAAC,oBAAoB,SAAS,GAChC,MAAM,IAAI,MAAM,wDAAwD,UAAU,SAAS;CAK7F,IAAI,WAAW,MAAM,WAAW,OAAO,WAAW,QAAQ,QAAQ,KAAK,MAAM,GAC3E,MAAM,IAAI,MAAM,6CAA6C,OAAO,EAAE;CAExE,MAAM,aAAa,UAAU,QAAQ,QAAQ,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE;CAEnE,MAAM,mBADiB,WAAW,WAAW,GAAG,IAAI,WAAW,MAAM,CAAC,IAAI,WAAA,CACnC,QAAQ,OAAO,IAAI;CAE1D,OAAO,sBAAsB,SADd,oBAAoB,KAAK,KAAK,KAAK;AAEpD;;;;;;;;AASA,SAAgB,iBAAiB,MAA6B;CAC5D,MAAM,QAAQ,yBAAyB,KAAK,IAAI;CAChD,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,QAAQ,MAAM,MAAM,GAAA,CAAI,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,QAAQ,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE;CACxF,OAAO,SAAS,MAAM,MAAM,GAAA,CAAI,YAAY,IAAI,SAAS,KAAK,KAAK,IAAI;AACzE;;;;;;AAOA,SAAgB,iBAAiB,WAAkC;CACjE,MAAM,QAAQ,iCAAiC,KAAK,SAAS;CAC7D,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,QAAQ,MAAM,MAAM,GAAA,CAAI,QAAQ,OAAO,IAAI;CACjD,OAAO,IAAI,MAAM,MAAM,GAAA,CAAI,YAAY,EAAE,KAAK;AAChD;;;;;;;;AASA,SAAgB,oBAAoB,OAAwB;CAC1D,OAAO,kBAAkB,KAAK,KAAK,KAAK,MAAM,WAAW,MAAM;AACjE;;AAGA,MAAM,uBAAuB;;;;;;;;AAS7B,SAAgB,mBAAmB,OAAwB;CACzD,OAAO,qBAAqB,KAAK,KAAK;AACxC"}

package/lib/shell.js

@@ -0,0 +1,382 @@
+import { c as windowsToMntPath, i as joinUnc, n as isValidWslUsername, r as isWindowsPathShaped, s as parseWslUnc } from "./paths-DBaSmi7x.js";
+import { a as getWorkspaceUsername, n as defaultDistroSync } from "./wsl-GjkUifnx.js";
+import z from "@deepseek-ai/schemastery";
+import { ShellExecutor } from "@deepseek-ai/dsh-shell";
+import { MAX_TIMER_DELAY_MS, clampTimeout, deadline, timeoutOf } from "@deepseek-ai/dsh-timeout";
+//#region \0@oxc-project+runtime@0.135.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/shell.ts
+/**
+* Model-friendly environment overrides (same set `dsh-bash-local` hardcodes):
+* disable colors, pagers, and interactive terminal features that would garble
+* tool output. These values cross into the Linux process through WSLENV.
+*/
+const ENV_OVERRIDES = {
+	NO_COLOR: "1",
+	TERM: "dumb",
+	PAGER: "cat",
+	GIT_PAGER: "cat"
+};
+/** Default SIGTERM→SIGKILL grace period (matches `dsh-bash-local`). */
+const DEFAULT_GRACE_MS = 3e3;
+/** Default per-stream spill cap (matches `dsh-bash-local`). */
+const DEFAULT_MAX_SPILL_BYTES = 64 * 1024 * 1024;
+/** Project a settled collect-mode reader into the final CollectedOutput shape. */
+function finalOutput(reader) {
+	const read = reader.readFrom(0);
+	return {
+		text: read.text,
+		truncated: read.lossy,
+		...read.spillPath !== void 0 ? { spillPath: read.spillPath } : {}
+	};
+}
+function assertPositiveFinite(name, value) {
+	if (!Number.isFinite(value) || value <= 0) throw new Error(`wsl-shell: ${name} must be a positive finite number`);
+}
+/**
+* Reject a resolved configuration this executor could not run with, so a
+* stored value is refused where it is written instead of failing at the next
+* command.
+* @param config - the schema-validated configuration.
+* @throws Error naming the field that cannot be used.
+*/
+function assertServiceableWslConfig(config) {
+	const resolved = config;
+	assertPositiveFinite("timeoutMs", resolved.timeoutMs);
+	assertPositiveFinite("maxTimeoutMs", resolved.maxTimeoutMs);
+	assertPositiveFinite("maxOutputBytes", resolved.maxOutputBytes);
+	assertPositiveFinite("maxSpillBytes", resolved.maxSpillBytes);
+	assertPositiveFinite("graceMs", resolved.graceMs);
+	if (resolved.graceMs > MAX_TIMER_DELAY_MS) throw new Error(`wsl-shell: graceMs must be no greater than ${MAX_TIMER_DELAY_MS}`);
+	if (resolved.distro !== void 0 && resolved.distro.trim() === "") throw new Error("wsl-shell: distro must be a non-empty distribution name");
+	if (resolved.username !== void 0 && resolved.username !== "" && !isValidWslUsername(resolved.username)) throw new Error("wsl-shell: username must match the Linux username pattern [A-Za-z_][A-Za-z0-9_.-]*");
+}
+/**
+* WSL bash executor over the LOCAL subprocess service: `wsl.exe` is a Windows
+* executable, so the Windows-side spawn, bounded output, spill files, and
+* process-group termination are the local subprocess seam's mechanics; this
+* executor supplies the Linux-world argv, cwd translation, and WSLENV.
+*/
+var WslShellExecutor = class WslShellExecutor extends ShellExecutor {
+	static inject = ["subprocess"];
+	static Config = z.object({
+		cwd: z.string(),
+		distro: z.string(),
+		username: z.string(),
+		wslPath: z.string().default("wsl.exe"),
+		loginShell: z.boolean().default(true),
+		timeoutMs: z.number().default(12e4),
+		maxTimeoutMs: z.number().default(6e5),
+		maxOutputBytes: z.number().default(64e3),
+		maxSpillBytes: z.number().default(DEFAULT_MAX_SPILL_BYTES),
+		graceMs: z.number().default(DEFAULT_GRACE_MS)
+	});
+	resolved;
+	/** Validated config (schemastery applied the defaults before construction). */
+	get config() {
+		return this.resolved;
+	}
+	constructor(ctx, config) {
+		super(ctx);
+		const entry = config;
+		assertServiceableWslConfig(entry);
+		this.resolved = entry;
+	}
+	/**
+	* Resolve a request into a fully-specified spec: fill `workdir` from
+	* `config.cwd`, and `timeoutMs` from `config.timeoutMs`, capped at
+	* `config.maxTimeoutMs`. The tool layer calls this before
+	* {@link run}/{@link start}, so those methods receive explicit values.
+	*/
+	resolve(request) {
+		const timeoutMs = clampTimeout(request.timeoutMs, this.config.timeoutMs, this.config.maxTimeoutMs, "wsl-shell: request.timeoutMs");
+		const stdoutMaxBytes = request.stdoutMaxBytes ?? this.config.maxOutputBytes;
+		assertPositiveFinite("request.stdoutMaxBytes", stdoutMaxBytes);
+		return {
+			command: request.command,
+			workdir: request.workdir ?? this.config.cwd ?? process.cwd(),
+			timeoutMs,
+			stdoutMaxBytes,
+			...request.signal ? { signal: request.signal } : {},
+			...request.stdin !== void 0 ? { stdin: request.stdin } : {},
+			...request.env !== void 0 ? { env: request.env } : {},
+			...request.dshEnv !== void 0 ? { dshEnv: request.dshEnv } : {},
+			sandboxPolicy: request.sandboxPolicy
+		};
+	}
+	/**
+	* Translate a resolved spec into the Linux execution plan. Fails loud on a
+	* workdir that names neither the WSL world (UNC or Linux path) nor a
+	* Windows drive path (reached through `/mnt/<drive>`).
+	* @param spec - the resolved execution spec.
+	* @returns the translated plan, including the complete argv.
+	*/
+	plan(spec) {
+		const workdir = spec.workdir;
+		let distro;
+		let linuxCwd;
+		let windowsCwd;
+		let username;
+		const unc = parseWslUnc(workdir);
+		if (unc !== null) {
+			distro = unc.distro;
+			linuxCwd = unc.linuxPath;
+			windowsCwd = process.env.SystemRoot ?? process.cwd();
+			username = this.resolveUser(spec, joinUnc(unc.distro, unc.linuxPath));
+		} else if (workdir.startsWith("/")) {
+			distro = this.resolveDistro(spec);
+			linuxCwd = workdir;
+			windowsCwd = process.cwd();
+			username = this.resolveUser(spec, void 0);
+		} else {
+			const mnt = windowsToMntPath(workdir);
+			if (mnt === null) throw new Error(`wsl-shell: workdir "${workdir}" is not in the WSL execution world`);
+			distro = this.resolveDistro(spec);
+			linuxCwd = mnt;
+			windowsCwd = workdir;
+			username = this.resolveUser(spec, void 0);
+		}
+		const env = this.withWslEnv(spec);
+		const argv = [
+			this.config.wslPath,
+			"-d",
+			distro,
+			...username !== void 0 && username !== "" ? ["-u", username] : [],
+			"--cd",
+			linuxCwd,
+			"-e",
+			"bash",
+			this.config.loginShell ? "-lc" : "-c",
+			spec.command
+		];
+		return {
+			distro,
+			linuxCwd,
+			windowsCwd,
+			env,
+			argv
+		};
+	}
+	/**
+	* Resolve the distribution for a workdir that carries none. The chain:
+	* the calling session's distribution (`DSH_WSL_DISTRO`, contributed by the
+	* host half from the session's UNC workspace cwd — the common case for a
+	* model passing a Linux `workdir`), then the configured `distro`, then the
+	* host's default distribution (cached registry read) as a last resort for
+	* plugin-driven calls with no session. Fails loud when every source is
+	* absent rather than guessing a distro the path does not belong to.
+	* @param spec - the resolved execution spec (its dshEnv carries the session fact).
+	* @returns the distribution name.
+	*/
+	resolveDistro(spec) {
+		const fromEnv = spec.dshEnv?.DSH_WSL_DISTRO;
+		if (fromEnv !== void 0 && fromEnv !== "") return fromEnv;
+		const configured = this.config.distro;
+		if (configured !== void 0 && configured !== "") return configured;
+		const fallback = defaultDistroSync();
+		if (fallback !== void 0) return fallback;
+		throw new Error("wsl-shell: Linux workdir carries no distribution; no session DSH_WSL_DISTRO, distro config, or default distribution is available");
+	}
+	/**
+	* Resolve the Linux user bash runs as. The chain: the calling session's
+	* workspace user (`DSH_WSL_USER`, contributed by the host half), then the
+	* workspace's stored username when the workdir is a UNC path, then the
+	* configured `username`. Absent everywhere, the distribution's default
+	* user runs. Invalid values are skipped (they were validated on write;
+	* the guard is defense in depth).
+	* @param spec - the resolved execution spec (its dshEnv carries the session fact).
+	* @param uncKey - canonical UNC key of the workdir when it is a UNC path.
+	* @returns the username, or undefined for the distro default user.
+	*/
+	resolveUser(spec, uncKey) {
+		const candidates = [
+			spec.dshEnv?.DSH_WSL_USER,
+			uncKey === void 0 ? void 0 : getWorkspaceUsername(uncKey),
+			this.config.username
+		];
+		for (const candidate of candidates) if (candidate !== void 0 && candidate !== "" && isValidWslUsername(candidate)) return candidate;
+	}
+	/**
+	* Merge the caller env layers and inject `WSLENV` so the Windows-side
+	* values reach the Linux process. Windows-path-shaped values get the `/p`
+	* translation flag (they become `/mnt/<drive>/…` inside WSL); the ambient
+	* `WSLENV` value is preserved and extended.
+	* @param spec - the resolved execution spec.
+	* @returns the explicit environment map for the spawn.
+	*/
+	withWslEnv(spec) {
+		const env = {
+			...ENV_OVERRIDES,
+			...spec.env,
+			...spec.dshEnv
+		};
+		const flags = [];
+		for (const [key, value] of Object.entries(env)) {
+			if (key.toUpperCase() === "WSLENV") continue;
+			flags.push(isWindowsPathShaped(value) ? `${key}/p` : key);
+		}
+		env.WSLENV = [process.env.WSLENV, flags.join(":")].filter((part) => part !== void 0 && part !== "").join(":");
+		return env;
+	}
+	/** Map a plan onto a fully-specified subprocess spawn. */
+	spawnSpec(plan, spec, stdoutMaxBytes, signal) {
+		const collect = (maxBytes) => ({
+			maxBytes,
+			spill: { maxBytes: this.config.maxSpillBytes }
+		});
+		return {
+			argv: plan.argv,
+			cwd: plan.windowsCwd,
+			stdio: {
+				stdin: spec.stdin !== void 0 ? { data: spec.stdin } : "ignore",
+				stdout: collect(stdoutMaxBytes),
+				stderr: collect(this.config.maxOutputBytes)
+			},
+			graceMs: this.config.graceMs,
+			signal,
+			env: plan.env
+		};
+	}
+	/** The collect-mode readers this executor requested (present by construction). */
+	static collected(handle) {
+		const { stdout, stderr } = handle.collected;
+		/* v8 ignore start -- collect dispositions expose both readers by the seam contract; defensive. */
+		if (stdout === void 0 || stderr === void 0) throw new Error("wsl-shell: subprocess implementation dropped a requested collect stream");
+		/* v8 ignore stop */
+		return {
+			stdout,
+			stderr
+		};
+	}
+	/** Run one command in the foreground. */
+	async run(spec) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			const plan = this.plan(spec);
+			const d = _usingCtx$1.u(deadline(spec.signal, spec.timeoutMs, "WSL_BASH_TIMEOUT"));
+			const handle = this.ctx.subprocess.spawn(this.spawnSpec(plan, spec, spec.stdoutMaxBytes, d.signal));
+			const outcome = await handle.done;
+			const collected = WslShellExecutor.collected(handle);
+			const timedOut = timeoutOf(d.signal, "WSL_BASH_TIMEOUT") !== void 0;
+			const aborted = d.signal.aborted && !timedOut;
+			return {
+				...outcome,
+				timedOut,
+				aborted,
+				timeoutMs: spec.timeoutMs,
+				stdout: finalOutput(collected.stdout),
+				stderr: finalOutput(collected.stderr)
+			};
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	/** Start one command in the background and return its live handle. */
+	start(spec) {
+		const plan = this.plan(spec);
+		const running = this.ctx.subprocess.spawn(this.spawnSpec(plan, spec, this.config.maxOutputBytes, spec.signal));
+		const collected = WslShellExecutor.collected(running);
+		let spawnFailureNote;
+		const consumeSpawnFailure = () => {
+			const note = spawnFailureNote ?? "";
+			spawnFailureNote = void 0;
+			return note;
+		};
+		let stdoutOffset = 0;
+		let stderrOffset = 0;
+		const proc = {
+			status: "running",
+			exitCode: null,
+			signal: null,
+			done: running.done.then((outcome) => {
+				if (proc.status === "running") proc.status = spec.signal?.aborted === true || outcome.signal !== null ? "killed" : "completed";
+				proc.exitCode = outcome.exitCode;
+				proc.signal = outcome.signal;
+			}, (error) => {
+				proc.status = "killed";
+				spawnFailureNote = `spawn failed: ${String(error)}`;
+			}),
+			readOutput: () => {
+				const out = collected.stdout.readFrom(stdoutOffset);
+				const err = collected.stderr.readFrom(stderrOffset);
+				stdoutOffset = out.nextOffset;
+				stderrOffset = err.nextOffset;
+				const errText = err.text.length > 0 ? err.text : consumeSpawnFailure();
+				const separator = out.text.length > 0 && !out.text.endsWith("\n") ? "\n" : "";
+				return {
+					delta: out.text + (errText.length > 0 ? `${separator}[stderr]\n${errText}` : ""),
+					lossy: out.lossy || err.lossy,
+					...out.spillPath !== void 0 ? { stdoutSpillPath: out.spillPath } : {},
+					...err.spillPath !== void 0 ? { stderrSpillPath: err.spillPath } : {}
+				};
+			},
+			kill: () => {
+				if (proc.status !== "running") return false;
+				proc.status = "killed";
+				running.terminate();
+				return true;
+			}
+		};
+		return proc;
+	}
+};
+//#endregion
+export { WslShellExecutor, WslShellExecutor as default, assertServiceableWslConfig };
+
+//# sourceMappingURL=shell.js.map

package/lib/shell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.js","names":[],"sources":["../src/shell.ts"],"sourcesContent":["/**\n * WSL Service Provider for the `ctx.shell` capability seam. Every command\n * runs inside one WSL distribution as `wsl.exe -d <distro> [-u <user>]\n * --cd <linux cwd> -e bash -lc <command>`, so the model-facing bash dialect\n * matches the execution world exactly — the \"like direct calls\" experience\n * of a WSL workspace session.\n *\n * The executor is a fresh implementation modeled on\n * `@deepseek-ai/dsh-bash-local` (same deadline fusion, bounded collect,\n * background adaptation) but does NOT register the shared `shell` settings\n * namespace: the host composition already registers it through its own\n * executor, and a second registration from a preset realm would collide.\n * Configuration rides the preset row instead.\n * @module dsh-wsl-workspace/shell\n */\n\nimport { Context } from '@deepseek-ai/cordis'\nimport z from '@deepseek-ai/schemastery'\nimport { ShellExecutor } from '@deepseek-ai/dsh-shell'\nimport type {\n  CollectedOutput,\n  ShellExecRequest,\n  ShellExecSpec,\n  ShellProcess,\n  ShellProcessRead,\n  ShellRunResult,\n} from '@deepseek-ai/dsh-shell'\nimport type {\n  SubprocessCollect,\n  SubprocessHandle,\n  SubprocessOutputReader,\n  SubprocessSpawnSpec,\n} from '@deepseek-ai/dsh-subprocess'\nimport { clampTimeout, deadline, MAX_TIMER_DELAY_MS, timeoutOf } from '@deepseek-ai/dsh-timeout'\nimport {\n  isWindowsPathShaped,\n  isValidWslUsername,\n  joinUnc,\n  parseWslUnc,\n  windowsToMntPath,\n} from './shared/paths.ts'\nimport { getWorkspaceUsername } from './shared/wsl-credentials.ts'\nimport { defaultDistroSync } from './shared/wsl.ts'\n\n/**\n * Model-friendly environment overrides (same set `dsh-bash-local` hardcodes):\n * disable colors, pagers, and interactive terminal features that would garble\n * tool output. These values cross into the Linux process through WSLENV.\n */\nconst ENV_OVERRIDES = {\n  NO_COLOR: '1',\n  TERM: 'dumb',\n  PAGER: 'cat',\n  GIT_PAGER: 'cat',\n} as const\n\n/** Default SIGTERM→SIGKILL grace period (matches `dsh-bash-local`). */\nconst DEFAULT_GRACE_MS = 3_000\n\n/** Default per-stream spill cap (matches `dsh-bash-local`). */\nconst DEFAULT_MAX_SPILL_BYTES = 64 * 1024 * 1024\n\n/** Plugin config (all optional — `static Config` supplies the defaults). */\nexport interface Config {\n  /** Default working directory (a WSL UNC or Linux path); per-call workdir wins. */\n  cwd?: string\n  /**\n   * Default distribution used only when a call's workdir carries no distro\n   * (UNC workdirs always do; Linux/Windows drive workdirs do not).\n   */\n  distro?: string\n  /**\n   * Linux user bash runs as when the call carries no per-workspace user\n   * (`wsl.exe -u <username>`); undefined/empty = the distro default user.\n   */\n  username?: string\n  /** The `wsl.exe` executable (absolute path or PATH name). */\n  wslPath?: string\n  /** Start bash as a login shell (`-lc`) so user profile PATHs (nvm, cargo…) load. */\n  loginShell?: boolean\n  /** Default foreground timeout in milliseconds. */\n  timeoutMs?: number\n  /** Upper bound for per-call timeout overrides. */\n  maxTimeoutMs?: number\n  /** Per-stream in-memory output cap; overflow spills to a temp file. */\n  maxOutputBytes?: number\n  /** Per-stream spill-file cap; larger streams retain only their in-memory tail. */\n  maxSpillBytes?: number\n  /** Grace period for kill escalation and inherited pipes; at most `MAX_TIMER_DELAY_MS`. */\n  graceMs?: number\n}\n\n/** The shape after schemastery applied the defaults. */\ntype ResolvedConfig = Required<Omit<Config, 'cwd' | 'distro' | 'username'>> & Pick<Config, 'cwd' | 'distro' | 'username'>\n\n/** Project a settled collect-mode reader into the final CollectedOutput shape. */\nfunction finalOutput(reader: SubprocessOutputReader): CollectedOutput {\n  const read = reader.readFrom(0)\n  return {\n    text: read.text,\n    truncated: read.lossy,\n    ...read.spillPath !== undefined ? { spillPath: read.spillPath } : {},\n  }\n}\n\nfunction assertPositiveFinite(name: string, value: number): void {\n  if (!Number.isFinite(value) || value <= 0) {\n    throw new Error(`wsl-shell: ${name} must be a positive finite number`)\n  }\n}\n\n/**\n * Reject a resolved configuration this executor could not run with, so a\n * stored value is refused where it is written instead of failing at the next\n * command.\n * @param config - the schema-validated configuration.\n * @throws Error naming the field that cannot be used.\n */\nexport function assertServiceableWslConfig(config: Config): void {\n  const resolved = config as ResolvedConfig\n  assertPositiveFinite('timeoutMs', resolved.timeoutMs)\n  assertPositiveFinite('maxTimeoutMs', resolved.maxTimeoutMs)\n  assertPositiveFinite('maxOutputBytes', resolved.maxOutputBytes)\n  assertPositiveFinite('maxSpillBytes', resolved.maxSpillBytes)\n  assertPositiveFinite('graceMs', resolved.graceMs)\n  if (resolved.graceMs > MAX_TIMER_DELAY_MS) {\n    throw new Error(`wsl-shell: graceMs must be no greater than ${MAX_TIMER_DELAY_MS}`)\n  }\n  if (resolved.distro !== undefined && resolved.distro.trim() === '') {\n    throw new Error('wsl-shell: distro must be a non-empty distribution name')\n  }\n  if (resolved.username !== undefined && resolved.username !== '' && !isValidWslUsername(resolved.username)) {\n    throw new Error('wsl-shell: username must match the Linux username pattern [A-Za-z_][A-Za-z0-9_.-]*')\n  }\n}\n\n/** One translated execution plan: the Linux world coordinates plus the argv. */\ninterface WslPlan {\n  /** Distribution the command runs in. */\n  distro: string\n  /** Linux working directory handed to `wsl.exe --cd`. */\n  linuxCwd: string\n  /** A valid Windows directory for the `wsl.exe` process itself. */\n  windowsCwd: string\n  /** Environment map (ENV_OVERRIDES + caller env + dshEnv) with WSLENV set. */\n  env: Record<string, string>\n  /** Full argv to hand to `ctx.subprocess`. */\n  argv: readonly string[]\n}\n\n/**\n * WSL bash executor over the LOCAL subprocess service: `wsl.exe` is a Windows\n * executable, so the Windows-side spawn, bounded output, spill files, and\n * process-group termination are the local subprocess seam's mechanics; this\n * executor supplies the Linux-world argv, cwd translation, and WSLENV.\n */\nexport class WslShellExecutor extends ShellExecutor {\n  static inject = ['subprocess']\n\n  static Config: z<Config> = z.object({\n    cwd: z.string(),\n    distro: z.string(),\n    username: z.string(),\n    wslPath: z.string().default('wsl.exe'),\n    loginShell: z.boolean().default(true),\n    timeoutMs: z.number().default(120_000),\n    maxTimeoutMs: z.number().default(600_000),\n    maxOutputBytes: z.number().default(64_000),\n    maxSpillBytes: z.number().default(DEFAULT_MAX_SPILL_BYTES),\n    graceMs: z.number().default(DEFAULT_GRACE_MS),\n  })\n\n  private readonly resolved: ResolvedConfig\n\n  /** Validated config (schemastery applied the defaults before construction). */\n  get config(): ResolvedConfig {\n    return this.resolved\n  }\n\n  constructor(ctx: Context, config: Config) {\n    super(ctx)\n    const entry = config as ResolvedConfig\n    assertServiceableWslConfig(entry)\n    this.resolved = entry\n  }\n\n  /**\n   * Resolve a request into a fully-specified spec: fill `workdir` from\n   * `config.cwd`, and `timeoutMs` from `config.timeoutMs`, capped at\n   * `config.maxTimeoutMs`. The tool layer calls this before\n   * {@link run}/{@link start}, so those methods receive explicit values.\n   */\n  resolve(request: ShellExecRequest): ShellExecSpec {\n    const timeoutMs = clampTimeout(\n      request.timeoutMs,\n      this.config.timeoutMs,\n      this.config.maxTimeoutMs,\n      'wsl-shell: request.timeoutMs',\n    )\n    const stdoutMaxBytes = request.stdoutMaxBytes ?? this.config.maxOutputBytes\n    assertPositiveFinite('request.stdoutMaxBytes', stdoutMaxBytes)\n    return {\n      command: request.command,\n      workdir: request.workdir ?? this.config.cwd ?? process.cwd(),\n      timeoutMs,\n      stdoutMaxBytes,\n      ...request.signal ? { signal: request.signal } : {},\n      ...request.stdin !== undefined ? { stdin: request.stdin } : {},\n      ...request.env !== undefined ? { env: request.env } : {},\n      ...request.dshEnv !== undefined ? { dshEnv: request.dshEnv } : {},\n      sandboxPolicy: request.sandboxPolicy,\n    }\n  }\n\n  /**\n   * Translate a resolved spec into the Linux execution plan. Fails loud on a\n   * workdir that names neither the WSL world (UNC or Linux path) nor a\n   * Windows drive path (reached through `/mnt/<drive>`).\n   * @param spec - the resolved execution spec.\n   * @returns the translated plan, including the complete argv.\n   */\n  private plan(spec: ShellExecSpec): WslPlan {\n    const workdir = spec.workdir\n    let distro: string\n    let linuxCwd: string\n    let windowsCwd: string\n    let username: string | undefined\n    const unc = parseWslUnc(workdir)\n    if (unc !== null) {\n      distro = unc.distro\n      linuxCwd = unc.linuxPath\n      // The `wsl.exe` process itself needs a plain Windows directory: its own\n      // cwd is irrelevant (`--cd` sets the Linux side), and spawning with a\n      // UNC cwd is a documented Node/Windows edge. SystemRoot always exists.\n      windowsCwd = process.env.SystemRoot ?? process.cwd()\n      username = this.resolveUser(spec, joinUnc(unc.distro, unc.linuxPath))\n    } else if (workdir.startsWith('/')) {\n      distro = this.resolveDistro(spec)\n      linuxCwd = workdir\n      windowsCwd = process.cwd()\n      username = this.resolveUser(spec, undefined)\n    } else {\n      const mnt = windowsToMntPath(workdir)\n      if (mnt === null) {\n        throw new Error(`wsl-shell: workdir \"${workdir}\" is not in the WSL execution world`)\n      }\n      distro = this.resolveDistro(spec)\n      linuxCwd = mnt\n      windowsCwd = workdir\n      username = this.resolveUser(spec, undefined)\n    }\n    const env = this.withWslEnv(spec)\n    const argv = [\n      this.config.wslPath,\n      '-d', distro,\n      ...(username !== undefined && username !== '' ? ['-u', username] : []),\n      '--cd', linuxCwd,\n      '-e', 'bash',\n      this.config.loginShell ? '-lc' : '-c',\n      spec.command,\n    ]\n    return { distro, linuxCwd, windowsCwd, env, argv }\n  }\n\n  /**\n   * Resolve the distribution for a workdir that carries none. The chain:\n   * the calling session's distribution (`DSH_WSL_DISTRO`, contributed by the\n   * host half from the session's UNC workspace cwd — the common case for a\n   * model passing a Linux `workdir`), then the configured `distro`, then the\n   * host's default distribution (cached registry read) as a last resort for\n   * plugin-driven calls with no session. Fails loud when every source is\n   * absent rather than guessing a distro the path does not belong to.\n   * @param spec - the resolved execution spec (its dshEnv carries the session fact).\n   * @returns the distribution name.\n   */\n  private resolveDistro(spec: ShellExecSpec): string {\n    const fromEnv = spec.dshEnv?.DSH_WSL_DISTRO\n    if (fromEnv !== undefined && fromEnv !== '') return fromEnv\n    const configured = this.config.distro\n    if (configured !== undefined && configured !== '') return configured\n    const fallback = defaultDistroSync()\n    if (fallback !== undefined) return fallback\n    throw new Error(\n      'wsl-shell: Linux workdir carries no distribution; no session DSH_WSL_DISTRO, distro config, '\n      + 'or default distribution is available',\n    )\n  }\n\n  /**\n   * Resolve the Linux user bash runs as. The chain: the calling session's\n   * workspace user (`DSH_WSL_USER`, contributed by the host half), then the\n   * workspace's stored username when the workdir is a UNC path, then the\n   * configured `username`. Absent everywhere, the distribution's default\n   * user runs. Invalid values are skipped (they were validated on write;\n   * the guard is defense in depth).\n   * @param spec - the resolved execution spec (its dshEnv carries the session fact).\n   * @param uncKey - canonical UNC key of the workdir when it is a UNC path.\n   * @returns the username, or undefined for the distro default user.\n   */\n  private resolveUser(spec: ShellExecSpec, uncKey: string | undefined): string | undefined {\n    const candidates = [\n      spec.dshEnv?.DSH_WSL_USER,\n      uncKey === undefined ? undefined : getWorkspaceUsername(uncKey),\n      this.config.username,\n    ]\n    for (const candidate of candidates) {\n      if (candidate !== undefined && candidate !== '' && isValidWslUsername(candidate)) return candidate\n    }\n    return undefined\n  }\n\n  /**\n   * Merge the caller env layers and inject `WSLENV` so the Windows-side\n   * values reach the Linux process. Windows-path-shaped values get the `/p`\n   * translation flag (they become `/mnt/<drive>/…` inside WSL); the ambient\n   * `WSLENV` value is preserved and extended.\n   * @param spec - the resolved execution spec.\n   * @returns the explicit environment map for the spawn.\n   */\n  private withWslEnv(spec: ShellExecSpec): Record<string, string> {\n    const env: Record<string, string> = { ...ENV_OVERRIDES, ...spec.env, ...spec.dshEnv }\n    const flags: string[] = []\n    for (const [key, value] of Object.entries(env)) {\n      if (key.toUpperCase() === 'WSLENV') continue\n      flags.push(isWindowsPathShaped(value) ? `${key}/p` : key)\n    }\n    const ambient = process.env.WSLENV\n    const merged = [ambient, flags.join(':')].filter(part => part !== undefined && part !== '').join(':')\n    env.WSLENV = merged\n    return env\n  }\n\n  /** Map a plan onto a fully-specified subprocess spawn. */\n  private spawnSpec(plan: WslPlan, spec: ShellExecSpec, stdoutMaxBytes: number, signal: AbortSignal | undefined): SubprocessSpawnSpec {\n    const collect = (maxBytes: number): SubprocessCollect =>\n      ({ maxBytes, spill: { maxBytes: this.config.maxSpillBytes } })\n    return {\n      argv: plan.argv,\n      cwd: plan.windowsCwd,\n      stdio: {\n        stdin: spec.stdin !== undefined ? { data: spec.stdin } : 'ignore',\n        stdout: collect(stdoutMaxBytes),\n        stderr: collect(this.config.maxOutputBytes),\n      },\n      graceMs: this.config.graceMs,\n      signal,\n      env: plan.env,\n    }\n  }\n\n  /** The collect-mode readers this executor requested (present by construction). */\n  private static collected(handle: SubprocessHandle): { stdout: SubprocessOutputReader; stderr: SubprocessOutputReader } {\n    const { stdout, stderr } = handle.collected\n    /* v8 ignore start -- collect dispositions expose both readers by the seam contract; defensive. */\n    if (stdout === undefined || stderr === undefined) {\n      throw new Error('wsl-shell: subprocess implementation dropped a requested collect stream')\n    }\n    /* v8 ignore stop */\n    return { stdout, stderr }\n  }\n\n  /** Run one command in the foreground. */\n  async run(spec: ShellExecSpec): Promise<ShellRunResult> {\n    const plan = this.plan(spec)\n    using d = deadline(spec.signal, spec.timeoutMs, 'WSL_BASH_TIMEOUT')\n    const handle = this.ctx.subprocess.spawn(this.spawnSpec(plan, spec, spec.stdoutMaxBytes, d.signal))\n    const outcome = await handle.done\n    const collected = WslShellExecutor.collected(handle)\n    // Only this executor's timeout reason counts as timedOut; outer deadlines count as aborts.\n    const timedOut = timeoutOf(d.signal, 'WSL_BASH_TIMEOUT') !== undefined\n    const aborted = d.signal.aborted && !timedOut\n    return {\n      ...outcome,\n      timedOut,\n      aborted,\n      timeoutMs: spec.timeoutMs,\n      stdout: finalOutput(collected.stdout),\n      stderr: finalOutput(collected.stderr),\n    }\n  }\n\n  /** Start one command in the background and return its live handle. */\n  start(spec: ShellExecSpec): ShellProcess {\n    const plan = this.plan(spec)\n    // Background runs ignore timeoutMs; callers stop them through kill() or spec.signal.\n    const running = this.ctx.subprocess.spawn(this.spawnSpec(plan, spec, this.config.maxOutputBytes, spec.signal))\n    const collected = WslShellExecutor.collected(running)\n\n    // A spawn failure produces no process output, so the subprocess service has\n    // nothing to buffer; the note is delivered exactly once through the read path.\n    let spawnFailureNote: string | undefined\n    const consumeSpawnFailure = (): string => {\n      const note = spawnFailureNote ?? ''\n      spawnFailureNote = undefined\n      return note\n    }\n\n    let stdoutOffset = 0\n    let stderrOffset = 0\n    const proc: ShellProcess = {\n      status: 'running',\n      exitCode: null,\n      signal: null,\n      done: running.done.then((outcome) => {\n        if (proc.status === 'running') {\n          proc.status = spec.signal?.aborted === true || outcome.signal !== null ? 'killed' : 'completed'\n        }\n        proc.exitCode = outcome.exitCode\n        proc.signal = outcome.signal\n      }, (error: unknown) => {\n        proc.status = 'killed'\n        spawnFailureNote = `spawn failed: ${String(error)}`\n      }),\n      readOutput: (): ShellProcessRead => {\n        const out = collected.stdout.readFrom(stdoutOffset)\n        const err = collected.stderr.readFrom(stderrOffset)\n        stdoutOffset = out.nextOffset\n        stderrOffset = err.nextOffset\n        const errText = err.text.length > 0 ? err.text : consumeSpawnFailure()\n        const separator = out.text.length > 0 && !out.text.endsWith('\\n') ? '\\n' : ''\n        const delta = out.text\n          + (errText.length > 0 ? `${separator}[stderr]\\n${errText}` : '')\n        return {\n          delta,\n          lossy: out.lossy || err.lossy,\n          ...out.spillPath !== undefined ? { stdoutSpillPath: out.spillPath } : {},\n          ...err.spillPath !== undefined ? { stderrSpillPath: err.spillPath } : {},\n        }\n      },\n      kill: (): boolean => {\n        if (proc.status !== 'running') return false\n        proc.status = 'killed'\n        running.terminate()\n        return true\n      },\n    }\n    return proc\n  }\n}\n\nexport default WslShellExecutor\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAM,gBAAgB;CACpB,UAAU;CACV,MAAM;CACN,OAAO;CACP,WAAW;AACb;;AAGA,MAAM,mBAAmB;;AAGzB,MAAM,0BAA0B,KAAK,OAAO;;AAoC5C,SAAS,YAAY,QAAiD;CACpE,MAAM,OAAO,OAAO,SAAS,CAAC;CAC9B,OAAO;EACL,MAAM,KAAK;EACX,WAAW,KAAK;EAChB,GAAG,KAAK,cAAc,KAAA,IAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;CACrE;AACF;AAEA,SAAS,qBAAqB,MAAc,OAAqB;CAC/D,IAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,GACtC,MAAM,IAAI,MAAM,cAAc,KAAK,kCAAkC;AAEzE;;;;;;;;AASA,SAAgB,2BAA2B,QAAsB;CAC/D,MAAM,WAAW;CACjB,qBAAqB,aAAa,SAAS,SAAS;CACpD,qBAAqB,gBAAgB,SAAS,YAAY;CAC1D,qBAAqB,kBAAkB,SAAS,cAAc;CAC9D,qBAAqB,iBAAiB,SAAS,aAAa;CAC5D,qBAAqB,WAAW,SAAS,OAAO;CAChD,IAAI,SAAS,UAAU,oBACrB,MAAM,IAAI,MAAM,8CAA8C,oBAAoB;CAEpF,IAAI,SAAS,WAAW,KAAA,KAAa,SAAS,OAAO,KAAK,MAAM,IAC9D,MAAM,IAAI,MAAM,yDAAyD;CAE3E,IAAI,SAAS,aAAa,KAAA,KAAa,SAAS,aAAa,MAAM,CAAC,mBAAmB,SAAS,QAAQ,GACtG,MAAM,IAAI,MAAM,oFAAoF;AAExG;;;;;;;AAsBA,IAAa,mBAAb,MAAa,yBAAyB,cAAc;CAClD,OAAO,SAAS,CAAC,YAAY;CAE7B,OAAO,SAAoB,EAAE,OAAO;EAClC,KAAK,EAAE,OAAO;EACd,QAAQ,EAAE,OAAO;EACjB,UAAU,EAAE,OAAO;EACnB,SAAS,EAAE,OAAO,CAAC,CAAC,QAAQ,SAAS;EACrC,YAAY,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI;EACpC,WAAW,EAAE,OAAO,CAAC,CAAC,QAAQ,IAAO;EACrC,cAAc,EAAE,OAAO,CAAC,CAAC,QAAQ,GAAO;EACxC,gBAAgB,EAAE,OAAO,CAAC,CAAC,QAAQ,IAAM;EACzC,eAAe,EAAE,OAAO,CAAC,CAAC,QAAQ,uBAAuB;EACzD,SAAS,EAAE,OAAO,CAAC,CAAC,QAAQ,gBAAgB;CAC9C,CAAC;CAED;;CAGA,IAAI,SAAyB;EAC3B,OAAO,KAAK;CACd;CAEA,YAAY,KAAc,QAAgB;EACxC,MAAM,GAAG;EACT,MAAM,QAAQ;EACd,2BAA2B,KAAK;EAChC,KAAK,WAAW;CAClB;;;;;;;CAQA,QAAQ,SAA0C;EAChD,MAAM,YAAY,aAChB,QAAQ,WACR,KAAK,OAAO,WACZ,KAAK,OAAO,cACZ,8BACF;EACA,MAAM,iBAAiB,QAAQ,kBAAkB,KAAK,OAAO;EAC7D,qBAAqB,0BAA0B,cAAc;EAC7D,OAAO;GACL,SAAS,QAAQ;GACjB,SAAS,QAAQ,WAAW,KAAK,OAAO,OAAO,QAAQ,IAAI;GAC3D;GACA;GACA,GAAG,QAAQ,SAAS,EAAE,QAAQ,QAAQ,OAAO,IAAI,CAAC;GAClD,GAAG,QAAQ,UAAU,KAAA,IAAY,EAAE,OAAO,QAAQ,MAAM,IAAI,CAAC;GAC7D,GAAG,QAAQ,QAAQ,KAAA,IAAY,EAAE,KAAK,QAAQ,IAAI,IAAI,CAAC;GACvD,GAAG,QAAQ,WAAW,KAAA,IAAY,EAAE,QAAQ,QAAQ,OAAO,IAAI,CAAC;GAChE,eAAe,QAAQ;EACzB;CACF;;;;;;;;CASA,KAAa,MAA8B;EACzC,MAAM,UAAU,KAAK;EACrB,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,MAAM,MAAM,YAAY,OAAO;EAC/B,IAAI,QAAQ,MAAM;GAChB,SAAS,IAAI;GACb,WAAW,IAAI;GAIf,aAAa,QAAQ,IAAI,cAAc,QAAQ,IAAI;GACnD,WAAW,KAAK,YAAY,MAAM,QAAQ,IAAI,QAAQ,IAAI,SAAS,CAAC;EACtE,OAAO,IAAI,QAAQ,WAAW,GAAG,GAAG;GAClC,SAAS,KAAK,cAAc,IAAI;GAChC,WAAW;GACX,aAAa,QAAQ,IAAI;GACzB,WAAW,KAAK,YAAY,MAAM,KAAA,CAAS;EAC7C,OAAO;GACL,MAAM,MAAM,iBAAiB,OAAO;GACpC,IAAI,QAAQ,MACV,MAAM,IAAI,MAAM,uBAAuB,QAAQ,oCAAoC;GAErF,SAAS,KAAK,cAAc,IAAI;GAChC,WAAW;GACX,aAAa;GACb,WAAW,KAAK,YAAY,MAAM,KAAA,CAAS;EAC7C;EACA,MAAM,MAAM,KAAK,WAAW,IAAI;EAChC,MAAM,OAAO;GACX,KAAK,OAAO;GACZ;GAAM;GACN,GAAI,aAAa,KAAA,KAAa,aAAa,KAAK,CAAC,MAAM,QAAQ,IAAI,CAAC;GACpE;GAAQ;GACR;GAAM;GACN,KAAK,OAAO,aAAa,QAAQ;GACjC,KAAK;EACP;EACA,OAAO;GAAE;GAAQ;GAAU;GAAY;GAAK;EAAK;CACnD;;;;;;;;;;;;CAaA,cAAsB,MAA6B;EACjD,MAAM,UAAU,KAAK,QAAQ;EAC7B,IAAI,YAAY,KAAA,KAAa,YAAY,IAAI,OAAO;EACpD,MAAM,aAAa,KAAK,OAAO;EAC/B,IAAI,eAAe,KAAA,KAAa,eAAe,IAAI,OAAO;EAC1D,MAAM,WAAW,kBAAkB;EACnC,IAAI,aAAa,KAAA,GAAW,OAAO;EACnC,MAAM,IAAI,MACR,kIAEF;CACF;;;;;;;;;;;;CAaA,YAAoB,MAAqB,QAAgD;EACvF,MAAM,aAAa;GACjB,KAAK,QAAQ;GACb,WAAW,KAAA,IAAY,KAAA,IAAY,qBAAqB,MAAM;GAC9D,KAAK,OAAO;EACd;EACA,KAAK,MAAM,aAAa,YACtB,IAAI,cAAc,KAAA,KAAa,cAAc,MAAM,mBAAmB,SAAS,GAAG,OAAO;CAG7F;;;;;;;;;CAUA,WAAmB,MAA6C;EAC9D,MAAM,MAA8B;GAAE,GAAG;GAAe,GAAG,KAAK;GAAK,GAAG,KAAK;EAAO;EACpF,MAAM,QAAkB,CAAC;EACzB,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG,GAAG;GAC9C,IAAI,IAAI,YAAY,MAAM,UAAU;GACpC,MAAM,KAAK,oBAAoB,KAAK,IAAI,GAAG,IAAI,MAAM,GAAG;EAC1D;EAGA,IAAI,SADW,CADC,QAAQ,IAAI,QACH,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,QAAO,SAAQ,SAAS,KAAA,KAAa,SAAS,EAAE,CAAC,CAAC,KAAK,GAC/E;EAClB,OAAO;CACT;;CAGA,UAAkB,MAAe,MAAqB,gBAAwB,QAAsD;EAClI,MAAM,WAAW,cACd;GAAE;GAAU,OAAO,EAAE,UAAU,KAAK,OAAO,cAAc;EAAE;EAC9D,OAAO;GACL,MAAM,KAAK;GACX,KAAK,KAAK;GACV,OAAO;IACL,OAAO,KAAK,UAAU,KAAA,IAAY,EAAE,MAAM,KAAK,MAAM,IAAI;IACzD,QAAQ,QAAQ,cAAc;IAC9B,QAAQ,QAAQ,KAAK,OAAO,cAAc;GAC5C;GACA,SAAS,KAAK,OAAO;GACrB;GACA,KAAK,KAAK;EACZ;CACF;;CAGA,OAAe,UAAU,QAA8F;EACrH,MAAM,EAAE,QAAQ,WAAW,OAAO;;EAElC,IAAI,WAAW,KAAA,KAAa,WAAW,KAAA,GACrC,MAAM,IAAI,MAAM,yEAAyE;;EAG3F,OAAO;GAAE;GAAQ;EAAO;CAC1B;;CAGA,MAAM,IAAI,MAA8C;;;GACtD,MAAM,OAAO,KAAK,KAAK,IAAI;GAC3B,MAAM,IAAA,YAAA,EAAI,SAAS,KAAK,QAAQ,KAAK,WAAW,kBAAkB,CAAA;GAClE,MAAM,SAAS,KAAK,IAAI,WAAW,MAAM,KAAK,UAAU,MAAM,MAAM,KAAK,gBAAgB,EAAE,MAAM,CAAC;GAClG,MAAM,UAAU,MAAM,OAAO;GAC7B,MAAM,YAAY,iBAAiB,UAAU,MAAM;GAEnD,MAAM,WAAW,UAAU,EAAE,QAAQ,kBAAkB,MAAM,KAAA;GAC7D,MAAM,UAAU,EAAE,OAAO,WAAW,CAAC;GACrC,OAAO;IACL,GAAG;IACH;IACA;IACA,WAAW,KAAK;IAChB,QAAQ,YAAY,UAAU,MAAM;IACpC,QAAQ,YAAY,UAAU,MAAM;GACtC;;;;;;CACF;;CAGA,MAAM,MAAmC;EACvC,MAAM,OAAO,KAAK,KAAK,IAAI;EAE3B,MAAM,UAAU,KAAK,IAAI,WAAW,MAAM,KAAK,UAAU,MAAM,MAAM,KAAK,OAAO,gBAAgB,KAAK,MAAM,CAAC;EAC7G,MAAM,YAAY,iBAAiB,UAAU,OAAO;EAIpD,IAAI;EACJ,MAAM,4BAAoC;GACxC,MAAM,OAAO,oBAAoB;GACjC,mBAAmB,KAAA;GACnB,OAAO;EACT;EAEA,IAAI,eAAe;EACnB,IAAI,eAAe;EACnB,MAAM,OAAqB;GACzB,QAAQ;GACR,UAAU;GACV,QAAQ;GACR,MAAM,QAAQ,KAAK,MAAM,YAAY;IACnC,IAAI,KAAK,WAAW,WAClB,KAAK,SAAS,KAAK,QAAQ,YAAY,QAAQ,QAAQ,WAAW,OAAO,WAAW;IAEtF,KAAK,WAAW,QAAQ;IACxB,KAAK,SAAS,QAAQ;GACxB,IAAI,UAAmB;IACrB,KAAK,SAAS;IACd,mBAAmB,iBAAiB,OAAO,KAAK;GAClD,CAAC;GACD,kBAAoC;IAClC,MAAM,MAAM,UAAU,OAAO,SAAS,YAAY;IAClD,MAAM,MAAM,UAAU,OAAO,SAAS,YAAY;IAClD,eAAe,IAAI;IACnB,eAAe,IAAI;IACnB,MAAM,UAAU,IAAI,KAAK,SAAS,IAAI,IAAI,OAAO,oBAAoB;IACrE,MAAM,YAAY,IAAI,KAAK,SAAS,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,OAAO;IAG3E,OAAO;KACL,OAHY,IAAI,QACb,QAAQ,SAAS,IAAI,GAAG,UAAU,YAAY,YAAY;KAG7D,OAAO,IAAI,SAAS,IAAI;KACxB,GAAG,IAAI,cAAc,KAAA,IAAY,EAAE,iBAAiB,IAAI,UAAU,IAAI,CAAC;KACvE,GAAG,IAAI,cAAc,KAAA,IAAY,EAAE,iBAAiB,IAAI,UAAU,IAAI,CAAC;IACzE;GACF;GACA,YAAqB;IACnB,IAAI,KAAK,WAAW,WAAW,OAAO;IACtC,KAAK,SAAS;IACd,QAAQ,UAAU;IAClB,OAAO;GACT;EACF;EACA,OAAO;CACT;AACF"}