@bacnh85/pi-windows-tools 0.1.0

package/extensions/lib/safety.ts

@@ -0,0 +1,107 @@
+export type CommandRisk = "safe" | "confirm";
+
+export interface RiskResult {
+	risk: CommandRisk;
+	reasons: string[];
+}
+
+// ── Dangerous command patterns (case-insensitive prefix/path match) ──
+
+const DESTRUCTIVE_COMMANDS: { pattern: RegExp; reason: string }[] = [
+	// PowerShell destructive
+	{ pattern: /remove-item\s+-recurse\s+-force/i, reason: "Recursive force delete" },
+	{ pattern: /rm\s+-[rf]+\s+/i, reason: "Recursive force remove" },
+	{ pattern: /rmdir\s+\/s\s+\/q/i, reason: "Recursive quiet directory remove" },
+	{ pattern: /del\s+\/s\s+\/q/i, reason: "Recursive quiet file delete" },
+
+	// Disk operations
+	{ pattern: /^format\s+/i, reason: "Format disk" },
+	{ pattern: /^diskpart\b/i, reason: "Disk partition tool" },
+
+	// Registry
+	{ pattern: /reg\s+delete/i, reason: "Registry key delete" },
+
+	// Service management
+	{ pattern: /sc\s+delete/i, reason: "Service delete" },
+
+	// Network
+	{ pattern: /netsh\s+advfirewall\s+reset/i, reason: "Firewall reset" },
+
+	// Git destructive
+	{ pattern: /git\s+clean\s+-fdx/i, reason: "Force clean git ignored files" },
+	{ pattern: /git\s+reset\s+--hard/i, reason: "Hard git reset" },
+	{ pattern: /git\s+push\s+--force/i, reason: "Force git push" },
+	{ pattern: /git\s+push\s+--force-with-lease/i, reason: "Force git push" },
+
+	// Package publish
+	{ pattern: /npm\s+publish/i, reason: "npm package publish" },
+	{ pattern: /pnpm\s+publish/i, reason: "pnpm package publish" },
+	{ pattern: /yarn\s+publish/i, reason: "yarn package publish" },
+
+	// System commands
+	{ pattern: /stop-computer/i, reason: "Shutdown computer" },
+	{ pattern: /restart-computer/i, reason: "Restart computer" },
+	{ pattern: /^shutdown\s+/i, reason: "Shutdown/restart computer" },
+
+	// Ownership/permissions (destructive)
+	{ pattern: /takeown\s+\/f/i, reason: "Take ownership of file" },
+	{ pattern: /icacls\s+\/grant/i, reason: "Grant file permissions" },
+
+	// WSL destructive
+	{ pattern: /wsl\s+--unregister/i, reason: "Unregister WSL distro" },
+	{ pattern: /wsl\s+--terminate/i, reason: "Terminate WSL distro" },
+];
+
+// ── Sensitive file / path patterns (case-insensitive) ──
+
+const SENSITIVE_FILE_PATTERNS: { pattern: RegExp; reason: string }[] = [
+	// Environment / secrets
+	{ pattern: /(?:^|[\s\\/])\.env(?:\.[a-z0-9]+)?$/i, reason: "Environment file" },
+	{ pattern: /\.pem$/i, reason: "Private key (PEM)" },
+	{ pattern: /\.key$/i, reason: "Private key file" },
+	{ pattern: /id_rsa$/i, reason: "SSH private key (RSA)" },
+	{ pattern: /id_ed25519$/i, reason: "SSH private key (Ed25519)" },
+	{ pattern: /[\\/]\.ssh[\\/]/i, reason: "SSH directory" },
+	{ pattern: /[\\/]\.aws[\\/]/i, reason: "AWS credentials" },
+	{ pattern: /[\\/]\.azure[\\/]/i, reason: "Azure credentials" },
+	{ pattern: /[\\/]\.kube[\\/]/i, reason: "Kubernetes config" },
+	{ pattern: /[\\/]\.gcloud[\\/]/i, reason: "Google Cloud credentials" },
+	{ pattern: /npmrc$/i, reason: "npm config (may contain tokens)" },
+	{ pattern: /\.pypirc$/i, reason: "Python package config (may contain tokens)" },
+	{ pattern: /[\\/]AppData[\\/]Roaming[\\/]Microsoft[\\/]Credentials/i, reason: "Windows stored credentials" },
+];
+
+/**
+ * Classify a command string for risk.
+ * Returns the highest risk level found along with matched rules.
+ */
+export function classifyCommand(command: string): RiskResult {
+	const reasons: string[] = [];
+
+	// Check destructive patterns
+	for (const rule of DESTRUCTIVE_COMMANDS) {
+		if (rule.pattern.test(command)) {
+			reasons.push(rule.reason);
+		}
+	}
+
+	// Check sensitive file paths in the command
+	for (const rule of SENSITIVE_FILE_PATTERNS) {
+		if (rule.pattern.test(command)) {
+			reasons.push(rule.reason);
+		}
+	}
+
+	if (reasons.length > 0) {
+		return { risk: "confirm", reasons };
+	}
+
+	return { risk: "safe", reasons: [] };
+}
+
+/**
+ * Check if a path matches any sensitive file pattern.
+ */
+export function isSensitivePath(path: string): boolean {
+	return SENSITIVE_FILE_PATTERNS.some(rule => rule.pattern.test(path));
+}

package/extensions/lib/shell-detect.ts

@@ -0,0 +1,73 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+
+export type WindowsShellKind = "pwsh" | "powershell" | "cmd" | "git-bash" | "wsl";
+
+export interface ShellInfo {
+	kind: WindowsShellKind;
+	displayName: string;
+	executable: string;
+	available: boolean;
+	version?: string;
+}
+
+function where(cmd: string): string | null {
+	try {
+		return execFileSync("where", [cmd], { encoding: "utf8", timeout: 3000 })
+			.split(/\r?\n/)[0]?.trim() || null;
+	} catch { return null; }
+}
+
+function getVersion(cmd: string, args: string[]): string | undefined {
+	try {
+		return execFileSync(cmd, args, { encoding: "utf8", timeout: 3000 })
+			.split(/\r?\n/)[0]?.trim();
+	} catch { return undefined; }
+}
+
+export function detectShell(kind: WindowsShellKind): ShellInfo {
+	switch (kind) {
+		case "pwsh": {
+			const exe = where("pwsh");
+			return { kind, displayName: "PowerShell 7+", executable: exe || "pwsh.exe", available: !!exe, version: exe ? getVersion(exe, ["--version"]) : undefined };
+		}
+		case "powershell": {
+			const exe = where("powershell");
+			return { kind, displayName: "Windows PowerShell", executable: exe || "powershell.exe", available: !!exe, version: exe ? getVersion(exe, ["-Command", "$PSVersionTable.PSVersion.ToString()"]) : undefined };
+		}
+		case "cmd": {
+			const comspec = process.env.ComSpec || "cmd.exe";
+			const exe = existsSync(comspec) ? comspec : where("cmd");
+			return { kind, displayName: "Command Prompt", executable: exe || "cmd.exe", available: !!exe || process.platform === "win32" };
+		}
+		case "git-bash": {
+			const candidates = ["C:\\Program Files\\Git\\bin\\bash.exe", "C:\\Program Files (x86)\\Git\\bin\\bash.exe", process.env.PI_GIT_BASH_PATH || ""].filter(Boolean);
+			const fromPath = where("bash");
+			const exe = candidates.find(c => existsSync(c)) || (fromPath ? fromPath : null);
+			const isGitBash = exe && (exe.toLowerCase().includes("git") || exe.toLowerCase().includes("program files") || exe.toLowerCase().includes("scoop") || exe.toLowerCase().includes("chocolatey") || getVersion(exe, ["--version"])?.toLowerCase().includes("gnu bash") === true);
+			return { kind, displayName: "Git Bash", executable: exe || "bash.exe", available: !!exe && !!isGitBash, version: exe ? getVersion(exe, ["--version"]) : undefined };
+		}
+		case "wsl": {
+			const exe = where("wsl");
+			return { kind, displayName: "WSL", executable: "wsl.exe", available: !!exe, version: exe ? getVersion("wsl.exe", ["--status"]) : undefined };
+		}
+	}
+}
+
+export function detectAllShells(): ShellInfo[] {
+	return (["pwsh", "powershell", "cmd", "git-bash", "wsl"] as WindowsShellKind[]).map(detectShell);
+}
+
+export function getAvailableShells(): ShellInfo[] {
+	return detectAllShells().filter(s => s.available);
+}
+
+export function getDefaultShell(): ShellInfo {
+	const envShell = process.env.PI_WINDOWS_SHELL as WindowsShellKind | undefined;
+	if (envShell && detectShell(envShell).available) return detectShell(envShell);
+	for (const kind of ["pwsh", "powershell", "git-bash", "cmd", "wsl"] as WindowsShellKind[]) {
+		const info = detectShell(kind);
+		if (info.available) return info;
+	}
+	return detectShell("cmd");
+}

package/extensions/lib/shell-exec.ts

@@ -0,0 +1,159 @@
+import { spawn } from "node:child_process";
+import type { WindowsShellKind } from "./shell-detect";
+import { getDefaultShell, detectShell } from "./shell-detect";
+
+export interface ExecOptions {
+	shell?: WindowsShellKind;
+	cwd?: string;
+	env?: Record<string, string>;
+	timeoutMs?: number;
+}
+
+export interface ExecResult {
+	command: string;
+	shell: WindowsShellKind;
+	cwd: string;
+	exitCode: number | null;
+	stdout: string;
+	stderr: string;
+	timedOut: boolean;
+	cancelled: boolean;
+}
+
+/**
+ * Merge custom env with process.env deduplicating case-insensitively.
+ * On Windows, "PATH" and "Path" are the same variable — passing both
+ * causes duplicate entries. This keeps the custom value when keys
+ * differ only in case.
+ */
+export function mergeEnv(customEnv: Record<string, string>): Record<string, string> {
+	const merged: Record<string, string> = {};
+
+	// Build set of lowercase custom keys for O(1) lookup
+	const customLower = new Set<string>();
+	for (const key of Object.keys(customEnv)) {
+		customLower.add(key.toLowerCase());
+	}
+
+	// Copy process.env keys, skipping any that match a custom key case-insensitively
+	for (const key of Object.keys(process.env)) {
+		if (customLower.has(key.toLowerCase())) continue;
+		const val = process.env[key];
+		if (val !== undefined) {
+			merged[key] = val;
+		}
+	}
+
+	// Add custom keys (they win)
+	for (const [key, val] of Object.entries(customEnv)) {
+		merged[key] = val;
+	}
+
+	return merged;
+}
+
+/**
+ * Build the arg array for a given shell kind.
+ */
+export function buildShellArgs(kind: WindowsShellKind, command: string, distro?: string): { exe: string; args: string[] } {
+	switch (kind) {
+		case "pwsh":
+		case "powershell": {
+			const info = detectShell(kind);
+			return {
+				exe: info.executable,
+				args: [
+					"-NoLogo",
+					"-NoProfile",
+					"-NonInteractive",
+					"-ExecutionPolicy", "Bypass",
+					"-Command", command,
+				],
+			};
+		}
+		case "cmd": {
+			const comspec = process.env.ComSpec || "cmd.exe";
+			return {
+				exe: comspec,
+				args: ["/c", command],
+			};
+		}
+		case "git-bash": {
+			const info = detectShell(kind);
+			return {
+				exe: info.executable,
+				args: ["-lc", command],
+			};
+		}
+		case "wsl": {
+			const distroFlag = distro ? ["-d", distro] : [];
+			return {
+				exe: "wsl.exe",
+				args: [...distroFlag, "--", "bash", "-lc", command],
+			};
+		}
+	}
+}
+
+/**
+ * Execute a command through the specified Windows shell.
+ * Returns stdout, stderr, exit code, and cancellation/timeout info.
+ */
+export function executeCommand(command: string, options: ExecOptions = {}): Promise<ExecResult> {
+	const shellKind = options.shell || getDefaultShell().kind;
+	const cwd = options.cwd || process.cwd();
+	const env = options.env || {};
+
+	// Use WSL_DISTRO from env or config if user set it
+	const distro = process.env.PI_WSL_DISTRO || undefined;
+	const { exe, args } = buildShellArgs(shellKind, command, distro);
+
+	return new Promise((resolve) => {
+		const child = spawn(exe, args, {
+			cwd,
+			env: mergeEnv(env),
+		});
+
+		let stdout = "";
+		let stderr = "";
+		let timedOut = false;
+
+		const timer = options.timeoutMs
+			? setTimeout(() => {
+					timedOut = true;
+					child.kill("SIGTERM");
+			  }, options.timeoutMs)
+			: null;
+
+		child.stdout?.on("data", (chunk: Buffer) => { stdout += chunk.toString("utf8"); });
+		child.stderr?.on("data", (chunk: Buffer) => { stderr += chunk.toString("utf8"); });
+
+		child.on("close", (exitCode, signal) => {
+			if (timer) clearTimeout(timer);
+			resolve({
+				command,
+				shell: shellKind,
+				cwd,
+				exitCode: timedOut ? null : exitCode,
+				stdout: stdout.replace(/\r\n/g, "\n"),
+				stderr: stderr.replace(/\r\n/g, "\n"),
+				timedOut,
+				cancelled: signal !== null && !timedOut,
+			});
+		});
+
+		child.on("error", () => {
+			if (timer) clearTimeout(timer);
+			resolve({
+				command,
+				shell: shellKind,
+				cwd,
+				exitCode: 1,
+				stdout,
+				stderr: stderr || "Failed to spawn process",
+				timedOut: false,
+				cancelled: false,
+			});
+		});
+	});
+}

package/extensions/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/extensions/test/audit.test.ts

@@ -0,0 +1,47 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { record, entries, clear, format } from "../lib/audit";
+
+describe("audit", () => {
+  beforeEach(() => clear());
+
+  it("starts empty", () => {
+    expect(format()).to.equal("No commands executed yet.");
+  });
+
+  it("records an entry", () => {
+    record({ timestamp: "a", shell: "pwsh", command: "echo hi", cwd: "/", exitCode: 0, timedOut: false, cancelled: false });
+    expect(entries()).to.have.length(1);
+    expect(entries()[0].command).to.equal("echo hi");
+  });
+
+  it("clear removes all entries", () => {
+    record({ timestamp: "a", shell: "pwsh", command: "c1", cwd: "/", exitCode: 0, timedOut: false, cancelled: false });
+    clear();
+    expect(entries()).to.have.length(0);
+  });
+
+  it("format shows command and exit code", () => {
+    record({ timestamp: "t", shell: "pwsh", command: "echo hi", cwd: "/", exitCode: 0, timedOut: false, cancelled: false });
+    const out = format();
+    expect(out).to.include("echo hi");
+    expect(out).to.include("exit:0");
+  });
+
+  it("format shows timed out flag", () => {
+    record({ timestamp: "a", shell: "cmd", command: "sleep 10", cwd: "/", exitCode: null, timedOut: true, cancelled: false });
+    const out = format();
+    expect(out).to.include("TIMED OUT");
+  });
+
+  it("format shows cancelled flag", () => {
+    record({ timestamp: "a", shell: "cmd", command: "x", cwd: "/", exitCode: null, timedOut: false, cancelled: true });
+    const out = format();
+    expect(out).to.include("CANCELLED");
+  });
+
+  it("truncates long commands", () => {
+    record({ timestamp: "a", shell: "pwsh", command: "x".repeat(500), cwd: "/", exitCode: 0, timedOut: false, cancelled: false });
+    expect(format()).to.include("\u2026");
+  });
+});

package/extensions/test/doctor.test.ts

@@ -0,0 +1,89 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { formatDoctorReport } from "../lib/doctor";
+import type { DoctorReport } from "../lib/doctor";
+
+describe("doctor", () => {
+
+	const sampleReport: DoctorReport = {
+		os: "Windows_NT",
+		osVersion: "10.0.22631",
+		architecture: "x64",
+		defaultShell: "pwsh",
+		tools: [
+			{ name: "pwsh", found: true, path: "C:\\Program Files\\PowerShell\\7\\pwsh.exe", version: "7.4.0" },
+			{ name: "powershell", found: true, path: "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe", version: "5.1.22621" },
+			{ name: "cmd", found: true, path: "C:\\Windows\\System32\\cmd.exe" },
+			{ name: "git", found: true, path: "C:\\Program Files\\Git\\cmd\\git.exe", version: "2.42.0.windows.2" },
+			{ name: "bash (Git Bash)", found: true, path: "C:\\Program Files\\Git\\bin\\bash.exe", version: "5.2.15" },
+			{ name: "wsl", found: true, path: "C:\\Windows\\System32\\wsl.exe" },
+			{ name: "node", found: true, path: "C:\\Program Files\\nodejs\\node.exe", version: "v22.0.0" },
+			{ name: "npm", found: true, path: "C:\\Program Files\\nodejs\\npm.cmd", version: "10.5.0" },
+			{ name: "pnpm", found: false },
+			{ name: "yarn", found: false },
+			{ name: "python", found: true, path: "C:\\Python312\\python.exe", version: "3.12.0" },
+			{ name: "py launcher", found: true, path: "C:\\Windows\\py.exe", version: "3.12" },
+			{ name: "dotnet", found: true, path: "C:\\Program Files\\dotnet\\dotnet.exe", version: "8.0.100" },
+			{ name: "cmake", found: false },
+			{ name: "ninja", found: false },
+			{ name: "winget", found: true, path: "C:\\Users\\me\\AppData\\Local\\Microsoft\\WindowsApps\\winget.exe" },
+			{ name: "choco", found: false },
+			{ name: "scoop", found: false },
+			{ name: "ssh", found: true, path: "C:\\Windows\\System32\\OpenSSH\\ssh.exe" },
+			{ name: "msbuild", found: false },
+			{ name: "cl", found: false },
+			{ name: "devenv", found: false },
+			{ name: "reg", found: true, path: "C:\\Windows\\System32\\reg.exe" },
+			{ name: "sc", found: true, path: "C:\\Windows\\System32\\sc.exe" },
+			{ name: "netsh", found: true, path: "C:\\Windows\\System32\\netsh.exe" },
+		],
+		wslDistros: ["Ubuntu-24.04", "Debian"],
+		longPathsEnabled: true,
+		developerMode: true,
+	};
+
+	it("formatDoctorReport produces expected header", () => {
+		const output = formatDoctorReport(sampleReport);
+		expect(output).to.include("Windows Tools Doctor");
+		expect(output).to.include("OS: Windows_NT 10.0.22631");
+		expect(output).to.include("Architecture: x64");
+	});
+
+	it("includes tool status with ✓ and ✗", () => {
+		const output = formatDoctorReport(sampleReport);
+		expect(output).to.include("✓ pwsh");
+		expect(output).to.include("✗ pnpm");
+	});
+
+	it("includes WSL distros", () => {
+		const output = formatDoctorReport(sampleReport);
+		expect(output).to.include("Ubuntu-24.04");
+		expect(output).to.include("Debian");
+	});
+
+	it("includes long paths and dev mode", () => {
+		const output = formatDoctorReport(sampleReport);
+		expect(output).to.include("Long paths: enabled");
+		expect(output).to.include("Developer Mode: enabled");
+	});
+
+	it("handles empty tools list", () => {
+		const empty: DoctorReport = {
+			os: "Windows_NT",
+			osVersion: "",
+			architecture: "x64",
+			defaultShell: "cmd",
+			tools: [],
+			wslDistros: [],
+			longPathsEnabled: null,
+			developerMode: null,
+		};
+		const output = formatDoctorReport(empty);
+		expect(output).to.include("Long paths: unknown");
+	});
+
+	it("includes version when present", () => {
+		const output = formatDoctorReport(sampleReport);
+		expect(output).to.include("7.4.0");
+	});
+});

package/extensions/test/path-utils.test.ts

@@ -0,0 +1,144 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import {
+	toPosixPath,
+	toWindowsPath,
+	toWslPath,
+	toGitBashPath,
+	normalizeWindowsPath,
+	isWindowsAbsolutePath,
+	quoteForShell,
+} from "../lib/path-utils";
+import type { WindowsShellKind } from "../lib/shell-detect";
+
+describe("path-utils", () => {
+
+	describe("toPosixPath", () => {
+		it("converts C:\\foo\\bar to /c/foo/bar", () => {
+			expect(toPosixPath("C:\\foo\\bar")).to.equal("/c/foo/bar");
+		});
+		it("converts C:/foo/bar to /c/foo/bar", () => {
+			expect(toPosixPath("C:/foo/bar")).to.equal("/c/foo/bar");
+		});
+		it("converts D:\\path with spaces to /d/path with spaces", () => {
+			expect(toPosixPath("D:\\path with spaces")).to.equal("/d/path with spaces");
+		});
+		it("handles lowercase drive letter", () => {
+			expect(toPosixPath("c:\\windows\\system32")).to.equal("/c/windows/system32");
+		});
+		it("strips \\\\?\\ long-path prefix", () => {
+			expect(toPosixPath("\\\\?\\C:\\foo")).to.equal("/c/foo");
+		});
+		it("handles drive-relative path C:foo\\bar", () => {
+			expect(toPosixPath("C:foo\\bar")).to.equal("/c/foo/bar");
+		});
+	});
+
+	describe("toWindowsPath", () => {
+		it("converts /c/foo/bar to C:\\foo\\bar", () => {
+			expect(toWindowsPath("/c/foo/bar")).to.equal("C:\\foo\\bar");
+		});
+		it("converts /mnt/c/foo/bar to C:\\foo\\bar", () => {
+			expect(toWindowsPath("/mnt/c/foo/bar")).to.equal("C:\\foo\\bar");
+		});
+		it("preserves relative paths", () => {
+			expect(toWindowsPath("relative/path")).to.equal("relative\\path");
+		});
+		it("handles lowercase drive", () => {
+			expect(toWindowsPath("/d/work/repo")).to.equal("D:\\work\\repo");
+		});
+		it("preserves Windows-native paths already in C:\\ format", () => {
+			expect(toWindowsPath("C:\\Users\\me")).to.equal("C:\\Users\\me");
+		});
+	});
+
+	describe("toWslPath", () => {
+		it("converts C:\\Users\\me to /mnt/c/Users/me", () => {
+			expect(toWslPath("C:\\Users\\me")).to.equal("/mnt/c/Users/me");
+		});
+		it("converts D:\\work to /mnt/d/work", () => {
+			expect(toWslPath("D:\\work")).to.equal("/mnt/d/work");
+		});
+		it("does not double-wrap already-WSL paths", () => {
+			expect(toWslPath("/mnt/c/Users/me")).to.equal("/mnt/c/Users/me");
+		});
+		it("wraps Git Bash paths to /mnt/", () => {
+			expect(toWslPath("/c/foo")).to.equal("/mnt/c/foo");
+		});
+	});
+
+	describe("toGitBashPath", () => {
+		it("converts C:\\Users to /c/Users", () => {
+			expect(toGitBashPath("C:\\Users")).to.equal("/c/Users");
+		});
+		it("same as toPosixPath", () => {
+			expect(toGitBashPath("D:\\temp")).to.equal(toPosixPath("D:\\temp"));
+		});
+	});
+
+	describe("normalizeWindowsPath", () => {
+		it("converts forward slashes to backslashes", () => {
+			expect(normalizeWindowsPath("C:/foo/bar")).to.equal("C:\\foo\\bar");
+		});
+		it("uppercases drive letter", () => {
+			expect(normalizeWindowsPath("c:\\windows")).to.equal("C:\\windows");
+		});
+		it("resolves . and ..", () => {
+			expect(normalizeWindowsPath("C:\\foo\\.\\bar\\..\\baz")).to.equal("C:\\foo\\baz");
+		});
+		it("deduplicates backslashes", () => {
+			expect(normalizeWindowsPath("C:\\foo\\\\\\bar")).to.equal("C:\\foo\\bar");
+		});
+	});
+
+	describe("isWindowsAbsolutePath", () => {
+		it("detects C:\\ as absolute", () => {
+			expect(isWindowsAbsolutePath("C:\\foo")).to.be.true;
+		});
+		it("detects C:/ as absolute", () => {
+			expect(isWindowsAbsolutePath("C:/foo")).to.be.true;
+		});
+		it("detects UNC as absolute", () => {
+			expect(isWindowsAbsolutePath("\\\\server\\share")).to.be.true;
+		});
+		it("detects \\\\?\\ long path prefix as absolute", () => {
+			expect(isWindowsAbsolutePath("\\\\?\\C:\\foo")).to.be.true;
+		});
+		it("detects \\\\.\\ device paths as absolute", () => {
+			expect(isWindowsAbsolutePath("\\\\.\\COM1")).to.be.true;
+		});
+		it("rejects relative paths", () => {
+			expect(isWindowsAbsolutePath("relative\\path")).to.be.false;
+		});
+		it("rejects POSIX absolute paths", () => {
+			expect(isWindowsAbsolutePath("/c/foo")).to.be.false;
+		});
+	});
+
+	describe("quoteForShell", () => {
+		const shells: WindowsShellKind[] = ["pwsh", "powershell", "cmd", "git-bash", "wsl"];
+
+		it("does not quote paths without spaces", () => {
+			for (const s of shells) {
+				expect(quoteForShell("C:\\foo\\bar", s)).to.equal("C:\\foo\\bar");
+			}
+		});
+		it("quotes paths with spaces for PowerShell", () => {
+			expect(quoteForShell("C:\\Program Files\\Git", "pwsh")).to.include("'");
+		});
+		it("quotes paths with spaces for cmd", () => {
+			expect(quoteForShell("C:\\Program Files\\Git", "cmd")).to.include('"');
+		});
+		it("quotes paths with spaces for git-bash", () => {
+			expect(quoteForShell("/c/Program Files", "git-bash")).to.include("'");
+		});
+		it("quotes paths with spaces for wsl", () => {
+			expect(quoteForShell("/mnt/c/Program Files", "wsl")).to.include("'");
+		});
+		it("handles empty path", () => {
+			for (const s of shells) {
+				expect(quoteForShell("", s)).to.equal('""');
+			}
+		});
+	});
+});