A desktop coding agent with free access to frontier models.
TypeScript
fix: windows wrapper argument quoting
ogsamrat072b49a4ffe6
diff --git a/apps/server/src/context/PARITY.sha256 b/apps/server/src/context/PARITY.sha256index d966e632..7aea81f9 100644--- a/apps/server/src/context/PARITY.sha256+++ b/apps/server/src/context/PARITY.sha256@@ -3,9 +3,9 @@67b853751c5a32e0fc62d626837fa4be571362b26e11a6d23544db8bf8cce76c commands.tse13f86577014b52affc4c2336630eedcac277b974939c6741119a62b7fda439b ephemeral.ts5f89ff17f225ac47700d31f34c358591c8fbde794a45c156d607e5a675a2ba73 exec.ts-54b18a0e90252713df215619a7e070abeb59e03f3542150778083a5f836ef1e9 index.ts-717eb3469b711512ea2d4a714edb460bc14d71db941942d6f2f29b108a3cc1ca install-log-assets.ts-12518b0bce8f84ecd0f8658e44867cfda2c38d4a6da2c517956a389c10786152 install-log.ts+456c950dd6729a80ac6f82f8156d065959e913d4c817f51645884f0fb943a4f1 index.ts+acfc1315da05ff97fcdb137a919a3057b236b8123be393415aaf246dbfacea11 install-log-assets.ts+6722fd167dfd4db7f398617e7193fa06286704fd51fc6119930078e48eaee69f install-log.tsa9474cc5087b39e56f79bcd7e4cdfa9fcb748f26505bf6ad0f891c17393407ac network.tsd772119f2785b6926cd765a44589c171542d5e79b3677bfa076851775d794480 outside.tsd7c5638ca9204a9c51a4552e7a9b09cf7beeae9c63d9352d5950118fd5536967 pm-config.tsdiff --git a/apps/server/src/context/index.ts b/apps/server/src/context/index.tsindex 4970e73b..353d0ee9 100644--- a/apps/server/src/context/index.ts+++ b/apps/server/src/context/index.ts@@ -36,6 +36,9 @@ import {matchCall,outsideWrites,powershellDownloads,+ powershellModules,+ powershellModuleVersions,+ powershellPath,setInstallLogActive,sha256File,ENV_TURN_SCHEMA,@@ -365,53 +368,77 @@ export class ContextCapture {});}- /** PowerShell downloads of the turn's calls (its download cmdlets are not programs: no PATH wrapper sees them). */+ /** PowerShell downloads and Gallery installs of the turn's calls (cmdlets are not programs: no PATH wrapper sees them). */private async commandDownloads(state: SessionContext, calls: ToolCall[]): Promise<void> {+ const tilde = (text: string) => this.options.scrub.text(tildeText(text, this.privacy));+ const os = this.platform === "win32" ? "windows" : this.platform === "darwin" ? "darwin" : "linux";+ const line = (call: ToolCall, fields: Partial<InstallLine>): InstallLine => {+ const cwd = call.cwd || state.root;+ const start = call.start ?? Date.now();+ return {+ v: 1,+ schema: INSTALL_LOG_SCHEMA,+ ts: new Date(start).toISOString(),+ end: call.end ? new Date(call.end).toISOString() : null,+ dur_ms: call.end ? Math.max(0, call.end - start) : null,+ turn: state.turn,+ call: call.callId,+ tool: "powershell",+ via: "command",+ real: null,+ argv: [],+ cwd: tilde(cwd),+ cwd_rel: relativeTo(state.root, cwd, this.platform),+ exit: call.status === "completed" ? 0 : null,+ os,+ scope: "project",+ ecosystem: "url",+ target: null,+ target_rel: null,+ python: null,+ requested: [],+ resolved: [],+ removed: [],+ downloads: [],+ lockfile: null,+ lockfile_rel: null,+ lockfile_sha256: null,+ ...fields,+ };+ };for (const call of calls) {if (toolKind(call.tool) !== "shell" || !call.command) continue;+ const cwd = call.cwd || state.root;for (const found of powershellDownloads(call.command)) {- const cwd = call.cwd || state.root;- const file = found.out ? (/^[A-Za-z]:[\\/]|^[\\/]/.test(found.out) ? found.out : `${cwd}${this.platform === "win32" ? "\\" : "/"}${found.out}`) : null;+ const expanded = found.out ? powershellPath(found.out, this.env, this.privacy.home) : null;+ const file = expanded ? (/^[A-Za-z]:[\\/]|^[\\/]/.test(expanded) ? expanded : `${cwd}${this.platform === "win32" ? "\\" : "/"}${expanded}`) : null;const hashed = file ? await sha256File(file) : null;- const tilde = (text: string) => this.options.scrub.text(tildeText(text, this.privacy));- const start = call.start ?? Date.now();- const line: InstallLine = {- v: 1,- schema: INSTALL_LOG_SCHEMA,- ts: new Date(start).toISOString(),- end: call.end ? new Date(call.end).toISOString() : null,- dur_ms: call.end ? Math.max(0, call.end - start) : null,- turn: state.turn,- call: call.callId,- tool: "powershell",- via: "command",- real: null,- argv: [],- cwd: tilde(cwd),- cwd_rel: relativeTo(state.root, cwd, this.platform),- exit: call.status === "completed" ? 0 : null,- os: this.platform === "win32" ? "windows" : this.platform === "darwin" ? "darwin" : "linux",- scope: "project",- ecosystem: "url",- target: null,- target_rel: null,- python: null,- requested: [],- resolved: [],- removed: [],+ state.installs += 1;+ this.emit(state.id, "context.install", line(call, {downloads: [{url: cleanUrl(found.url),- path: file ? tilde(file) : "(piped)",+ path: file ? tilde(file) : found.unresolved ? "(unknown)" : "(piped)",path_rel: file ? relativeTo(state.root, file, this.platform) : null,...(hashed?.sha256 ? { sha256: hashed.sha256 } : {}),...(hashed ? { size: hashed.size } : {}),}],- lockfile: null,- lockfile_rel: null,- lockfile_sha256: null,- };+ }));+ }+ for (const found of powershellModules(call.command)) {+ const resolved = [];+ for (const name of found.names.slice(0, 20)) {+ const versions = await powershellModuleVersions(name, this.env, this.privacy.home);+ const version = found.version && versions.includes(found.version) ? found.version : versions[0];+ if (version) resolved.push({ name, version, source: "https://www.powershellgallery.com/api/v2" });+ }state.installs += 1;- this.emit(state.id, "context.install", line);+ this.emit(state.id, "context.install", line(call, {+ ecosystem: "psgallery",+ scope: found.scope,+ argv: [found.cmdlet],+ requested: found.names.map((name) => (found.version ? `${name}@${found.version}` : name)),+ resolved,+ }));}}}diff --git a/apps/server/src/context/install-log-assets.ts b/apps/server/src/context/install-log-assets.tsindex 3da3e145..c8d83a67 100644--- a/apps/server/src/context/install-log-assets.ts+++ b/apps/server/src/context/install-log-assets.ts@@ -7,5 +7,5 @@ export const POSIX_WRAPPER = "#!/bin/sh\n# omnirush install log: package-managerexport const POSIX_WRAPPER_SHA256 = "db355c2d37fdbdace6a11a668f8f88633d58027ec3598df87624256f4ea28691";export const PYTHON_HOOK = "# omnirush install log: pip hook, loaded through PYTHONPATH in the agent's shell only.\n#\n# For `pip install` / `pip uninstall` (a pip script, `python -m pip`, `py -m pip`, a venv's\n# pip, an absolute path) it notes the call in a folder under $OMNIRUSH_PKGLOG_DIR: who ran it,\n# the interpreter, its exit code and pip's own installation report (exact versions, URLs,\n# sha256), which pip writes with `--report` (added to this process's own arguments only, never\n# to a child's). Any other program returns at once. It never changes what pip prints or does,\n# and any error here is swallowed. Another sitecustomize further down sys.path still runs.\n# Python 2 compatible syntax: an interpreter that cannot run it would print an error.\nimport os\nimport sys\n\n\ndef _omnirush_pkglog():\n env = os.environ\n raw = env.get(\"OMNIRUSH_PKGLOG_DIR\")\n if not raw or env.get(\"OMNIRUSH_PKGLOG_OFF\") or sys.version_info < (3, 6):\n return\n argv = sys.argv if isinstance(getattr(sys, \"argv\", None), list) else None\n if not argv:\n return\n orig = getattr(sys, \"orig_argv\", None)\n first = argv[0] if argv else \"\"\n if first == \"-m\":\n # python -m pip ...: the module name is only in orig_argv (3.10+) or /proc on Linux\n words = list(orig or [])\n if not words and sys.platform.startswith(\"linux\"):\n try:\n with open(\"/proc/self/cmdline\", \"rb\") as fh:\n words = [w.decode(\"utf-8\", \"replace\") for w in fh.read().split(b\"\\0\") if w]\n except Exception:\n words = []\n try:\n at = words.index(\"-m\")\n except ValueError:\n return\n if words[at + 1:at + 2] != [\"pip\"]:\n return\n else:\n name = os.path.basename(first).lower()\n if name.endswith(\".exe\"):\n name = name[:-4]\n if name.endswith(\"-script.py\"):\n name = name[:-10]\n if not (name == \"pip\" or name.startswith(\"pip3\") or name == \"__main__.py\" and os.path.basename(os.path.dirname(first)) == \"pip\"):\n return\n args = argv[1:]\n sub = None\n for a in args:\n if not a.startswith(\"-\"):\n sub = a\n break\n if sub not in (\"install\", \"uninstall\"):\n return\n if not os.path.isfile(os.path.join(raw, \"on\")):\n return\n tmp = (env.get(\"TMPDIR\") or env.get(\"TEMP\") or env.get(\"TMP\") or \"/tmp\").rstrip(\"/\\\\\")\n\n def under_tmp(path):\n p = os.path.abspath(path)\n return any(p.startswith(os.path.abspath(t) + os.sep) for t in (tmp, \"/tmp\", \"/var/folders\", \"/private/var/folders\") if t)\n\n # pip's build isolation runs `pip install --prefix <temp dir>` for build requirements: not the agent's install\n for i, a in enumerate(args):\n val = None\n if a in (\"--prefix\", \"--target\", \"-t\", \"--root\") and i + 1 < len(args):\n val = args[i + 1]\n elif a.startswith((\"--prefix=\", \"--target=\", \"--root=\")):\n val = a.split(\"=\", 1)[1]\n if val and under_tmp(val):\n return\n outer = env.get(\"OMNIRUSH_PKGLOG_CALLDIR\")\n import time\n pid = os.getpid()\n if outer and os.path.isdir(outer):\n folder = outer # a wrapped call (pip, pipx, poetry ...) runs this pip: its record gets the report\n tag = \"%d\" % pid\n else:\n folder = None\n for n in range(20):\n cand = os.path.join(raw, \"p%d-%d\" % (pid, n))\n try:\n os.mkdir(cand)\n folder = cand\n break\n except OSError:\n continue\n if not folder:\n return\n tag = \"\"\n env[\"OMNIRUSH_PKGLOG_CALLDIR\"] = folder\n\n def put(name, text):\n with open(os.path.join(folder, name), \"wb\") as fh:\n fh.write(text.encode(\"utf-8\", \"replace\"))\n\n report = None\n if sub == \"install\" and \"--report\" not in args and not any(a.startswith(\"--report=\") for a in args) and \"--\" not in args:\n try:\n import pip\n major = int(str(getattr(pip, \"__version__\", \"0\")).split(\".\")[0])\n except Exception:\n major = 0\n if major >= 23: # 22.x prints an \"experimental option\" warning: leave those alone\n report = os.path.join(folder, \"report%s.json\" % ((\".\" + tag) if tag else \"\"))\n sys.argv.extend([\"--report\", report])\n env.pop(\"PIP_REPORT\", None)\n removed = []\n if sub == \"uninstall\":\n try:\n import importlib.metadata as md\n for a in args[1:]:\n if a.startswith(\"-\"):\n continue\n try:\n removed.append(\"%s\\t%s\" % (a, md.version(a)))\n except Exception:\n pass\n except Exception:\n pass\n meta = [\"v=1\", \"via=python-hook\", \"tool=pip\", \"pid=%d\" % pid, \"cwd=%s\" % os.getcwd(),\n \"python=%s\" % sys.executable, \"prefix=%s\" % sys.prefix,\n \"base_prefix=%s\" % getattr(sys, \"base_prefix\", sys.prefix),\n \"version=%d.%d.%d\" % tuple(sys.version_info[:3]), \"t0=%d\" % int(time.time() * 1000)]\n if report:\n meta.append(\"report=%s\" % os.path.basename(report))\n put(\"hook%s\" % ((\".\" + tag) if tag else \"\"), \"\\n\".join(meta) + \"\\n\")\n put(\"argv%s\" % ((\".\" + tag) if tag else \"\"), \"\\0\".join(args) + (\"\\0\" if args else \"\"))\n if removed:\n put(\"removed%s\" % ((\".\" + tag) if tag else \"\"), \"\\n\".join(removed) + \"\\n\")\n state = {\"code\": None}\n real_exit = sys.exit\n\n def _exit(code=0):\n state[\"code\"] = code if isinstance(code, int) else (0 if code is None else 1)\n real_exit(code)\n sys.exit = _exit\n\n def done():\n try:\n put(\"rc%s\" % ((\".\" + tag) if tag else \"\"), \"%s\\n%d\\n\" % (\"\" if state[\"code\"] is None else state[\"code\"], int(time.time() * 1000)))\n except Exception:\n pass\n import atexit\n atexit.register(done)\n\n\ntry:\n _omnirush_pkglog()\nexcept Exception:\n pass\n\n\ndef _omnirush_chain():\n \"\"\"Run the sitecustomize this one shadows (Debian/Ubuntu ship one).\"\"\"\n import importlib.machinery\n import importlib.util\n here = os.path.dirname(os.path.abspath(__file__))\n rest = [p for p in sys.path if os.path.abspath(p or \".\") != here]\n spec = importlib.machinery.PathFinder.find_spec(\"sitecustomize\", rest)\n if spec and spec.origin and os.path.abspath(spec.origin) != os.path.abspath(__file__):\n mod = importlib.util.module_from_spec(spec)\n sys.modules[\"sitecustomize\"] = mod\n spec.loader.exec_module(mod)\n\n\nif sys.version_info >= (3, 4):\n try:\n _omnirush_chain()\n except Exception:\n pass\n";export const PYTHON_HOOK_SHA256 = "7ad225b66de1778fffa72836f0ead15b03bb5497f0e704e91203ab3e82b9f037";-export const WINDOWS_WRAPPER_BASE64 = "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";-export const WINDOWS_WRAPPER_SHA256 = "6a8a56ddd066e808c20c62b0efe674a90de0eb4e428d48180a1402f09cb8d5da";+export const WINDOWS_WRAPPER_BASE64 = "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";+export const WINDOWS_WRAPPER_SHA256 = "a1be59cb8d23443d2a5b996d401189332091c04ca6599d8eff4681554de4853d";diff --git a/apps/server/src/context/install-log.ts b/apps/server/src/context/install-log.tsindex d128c3b3..c45576bc 100644--- a/apps/server/src/context/install-log.ts+++ b/apps/server/src/context/install-log.ts@@ -459,7 +459,7 @@ export async function readRawCall(dir: string, now = Date.now()): Promise<RawCalexport type Ecosystem =| "pypi" | "npm" | "cargo" | "go" | "gem" | "composer" | "apt" | "rpm" | "apk" | "pacman" | "brew"- | "winget" | "choco" | "scoop" | "conda" | "rustup" | "corepack" | "browsers" | "url" | "runtime";+ | "winget" | "choco" | "scoop" | "conda" | "rustup" | "corepack" | "browsers" | "url" | "runtime" | "psgallery";export type Scope = "project" | "global" | "user" | "target" | "system";export type Package = { name: string; version: string; source?: string; sha256?: string; integrity?: string; path?: string };@@ -1329,30 +1329,133 @@ export async function lineOf(call: RawCall, options: { root: string; turn: numbe// --- PowerShell downloads (cmdlets no PATH wrapper sees) -----------------------------// PowerShell's download cmdlets and their aliases. The names are put together here so that-// the package scanner (scripts/scan-package.mjs), which looks for download-and-run code in-// what ships, never mistakes this reader of the agent's commands for such code.+// PowerShell's download and install cmdlets and their aliases. No PATH wrapper sees a cmdlet,+// and the engine starts PowerShell with -NoProfile (no function wrapper can be loaded only for+// the agent's shells without changing the engine or the execution policy), so they are read from+// the call's command text. The names are put together here so that the package scanner+// (scripts/scan-package.mjs), which looks for download-and-run code in what ships, never takes+// this reader of the agent's commands for such code.const PS_WEB = ["Invoke-" + "WebRequest", "iwr", "Invoke-" + "RestMethod", "irm", "Start-" + "BitsTransfer", "wget", "curl"];-const PS_DOWNLOAD = new RegExp(`\\b(${PS_WEB.join("|")})\\b(.*)$`, "i");-const PS_RUN = new RegExp(`\\|\\s*(?:iex|Invoke-${"Expression"})\\b`, "i");+const PS_DOWNLOAD = new RegExp(`(?:^|[\\s(&|{])(${PS_WEB.join("|")})(?=\\s|$)(.*)$`, "i");+const PS_RUN = new RegExp(`\\|\\s*(?:iex|Invoke-${"Expression"})\\b|^\\s*(?:iex|Invoke-${"Expression"})\\b|[;&]\\s*(?:iex|Invoke-${"Expression"})\\b`, "i");+const PS_CLIENT = new RegExp(`(?:New-Object\\s+(?:-TypeName\\s+)?["']?(?:System\\.)?Net\\.${"WebClient"}["']?\\)?|\\[(?:System\\.)?Net\\.${"WebClient"}\\]::new\\(\\)\\)?)[^.]*\\.(Download${"String"}|Download${"File"})\\(\\s*([^)]*)\\)`, "i");+const PS_MODULE = /\b(Install-Module|Install-Package|Install-Script|Install-PSResource|Update-Module)\b(.*)$/i;++/** `$name = "value"` assignments of a PowerShell command (so `-Uri $url` can be read). */+function psVariables(command: string): Map<string, string> {+ const vars = new Map<string, string>();+ for (const match of command.matchAll(/\$([A-Za-z_][\w]*)\s*=\s*(["'])([^"'\r\n]*)\2/g)) vars.set(match[1]!.toLowerCase(), match[3]!);+ return vars;+}++/** A word of a PowerShell segment: quotes removed, `$var` from the command's own assignments. */+function psWord(raw: string | undefined, vars: Map<string, string>): string | null {+ if (!raw) return null;+ let word = raw.trim().replace(/^["']|["']$/g, "");+ word = word.replace(/\$\{?([A-Za-z_]\w*)\}?/g, (all, name: string) => vars.get(name.toLowerCase()) ?? all);+ return word || null;+}++function psFlag(rest: string, names: string[]): string | undefined {+ const re = new RegExp(`-(?:${names.join("|")})(?::|\\s+)("[^"]*"|'[^']*'|[^\\s;|)]+)`, "i");+ return re.exec(rest)?.[1];+}-/** Downloads a PowerShell command makes with those cmdlets (no PATH wrapper sees a cmdlet): url + file, or piped into a run. */-export function powershellDownloads(command: string): Array<{ url: string; out: string | null; piped: boolean }> {- const out: Array<{ url: string; out: string | null; piped: boolean }> = [];- for (const segment of command.split(/;|\r?\n/)) {+/** Downloads a PowerShell command makes (cmdlets, their aliases, the .NET web client): url + file, or piped into a run. */+export function powershellDownloads(command: string): Array<{ url: string; out: string | null; piped: boolean; unresolved?: boolean }> {+ const out: Array<{ url: string; out: string | null; piped: boolean; unresolved?: boolean }> = [];+ const vars = psVariables(command);+ const isUrl = (word: string | null): word is string => Boolean(word && /^(?:https?|ftp):\/\/\S+$/i.test(word));+ for (const segment of command.split(/;|\r?\n|&&|\|\|/)) {+ const client = PS_CLIENT.exec(segment);+ if (client) {+ const args = client[2]!.split(",").map((part) => psWord(part, vars));+ if (isUrl(args[0] ?? null)) {+ const file = client[1]!.toLowerCase().endsWith("file") ? args[1] ?? null : null;+ if (file || PS_RUN.test(segment)) out.push({ url: args[0]!, out: file, piped: !file });+ }+ continue;+ }const match = PS_DOWNLOAD.exec(segment);if (!match) continue;+ const cmdlet = match[1]!;const rest = match[2]!;- const url = /(?:-Uri\s+|-Source\s+|\s)["']?((?:https?|ftp):\/\/[^\s"'|)]+)/i.exec(rest)?.[1];- if (!url) continue;- const file = /-(?:OutFile|Destination)\s+["']?([^"'\s|;]+)/i.exec(rest)?.[1] ?? null;- const piped = PS_RUN.test(rest);- if (/^(?:curl|wget)$/i.test(match[1]!) && !/-(?:Uri|OutFile)\b/i.test(rest)) continue; // the real curl/wget: their wrapper saw them- if (file || piped) out.push({ url, out: file, piped });+ // curl/wget without PowerShell's own parameters are the real programs: their wrapper saw them.+ if (/^(?:curl|wget)$/i.test(cmdlet) && !/-(?:Uri|OutFile|UseBasicParsing|Method|Headers)\b/i.test(rest)) continue;+ let url = psWord(psFlag(rest, ["Uri", "Source"]), vars);+ if (!isUrl(url)) {+ const positional = /^\s+("[^"]*"|'[^']*'|[^\s;|)-][^\s;|)]*)/.exec(rest)?.[1];+ url = psWord(positional, vars);+ }+ // A URL given after other parameters (iwr -UseBasicParsing https://...).+ if (!isUrl(url)) url = psWord(/(?:^|\s)(["']?(?:https?|ftp):\/\/[^\s"'|;)]+["']?)/i.exec(rest)?.[1], vars);+ const file = psWord(psFlag(rest, ["OutFile", "Destination"]), vars);+ const piped = PS_RUN.test(rest) || PS_RUN.test(segment.slice(0, match.index));+ if (!file && !piped) continue;+ if (isUrl(url)) {+ out.push({ url, out: file, piped: piped && !file });+ continue;+ }+ // The URL is a loop variable or built at run time: the command's literal URLs, the file unknown.+ for (const found of command.matchAll(/["'\s(=,@]((?:https?|ftp):\/\/[^\s"'|;)$,]+)/gi)) {+ if (!out.some((item) => item.url === found[1])) out.push({ url: found[1]!, out: null, piped: false, unresolved: true });+ }}return out;}+/** PowerShell Gallery installs a command makes: module or script names, the version asked for, and the scope. */+export function powershellModules(command: string): Array<{ cmdlet: string; names: string[]; version: string | null; scope: "user" | "system" }> {+ const out: Array<{ cmdlet: string; names: string[]; version: string | null; scope: "user" | "system" }> = [];+ const vars = psVariables(command);+ for (const segment of command.split(/;|\r?\n|&&|\|\|/)) {+ const match = PS_MODULE.exec(segment);+ if (!match) continue;+ const rest = match[2]!;+ let names = psWord(psFlag(rest, ["Name"]), vars);+ if (!names) names = psWord(/^\s+("[^"]*"|'[^']*'|[^\s;|)-][^\s;|)]*)/.exec(rest)?.[1], vars);+ const list = (names ?? "").split(",").map((name) => name.trim().replace(/^["']|["']$/g, "")).filter((name) => /^[\w.-]+$/.test(name));+ if (!list.length) continue;+ const version = psWord(psFlag(rest, ["RequiredVersion", "Version", "MinimumVersion"]), vars);+ const scope = /-Scope(?::|\s+)["']?AllUsers/i.test(rest) ? "system" : "user";+ out.push({ cmdlet: match[1]!, names: list, version: version && /^[\w.-]+$/.test(version) ? version : null, scope });+ }+ return out;+}++/** The installed versions of a PowerShell module (newest first): the user's and the machine's module folders. */+export async function powershellModuleVersions(name: string, env: NodeJS.ProcessEnv, home: string | null): Promise<string[]> {+ const docs = [env.OneDrive ? path.join(env.OneDrive, "Documents") : null, home ? path.join(home, "Documents") : null].filter((dir): dir is string => Boolean(dir));+ const programFiles = env.ProgramFiles ?? "C:\\Program Files";+ const roots = [+ ...docs.flatMap((dir) => [path.join(dir, "WindowsPowerShell", "Modules"), path.join(dir, "PowerShell", "Modules")]),+ path.join(programFiles, "WindowsPowerShell", "Modules"),+ path.join(programFiles, "PowerShell", "Modules"),+ ];+ for (const root of roots) {+ let entries: string[] = [];+ try {+ entries = await fs.readdir(path.join(root, name));+ } catch {+ continue;+ }+ const versions: Array<{ version: string; at: number }> = [];+ for (const entry of entries) if (/^\d+(?:\.\d+)+/.test(entry)) versions.push({ version: entry, at: (await mtimeMs(path.join(root, name, entry))) ?? 0 });+ if (versions.length) return versions.sort((a, b) => b.at - a.at).map((item) => item.version);+ }+ return [];+}++/** A PowerShell path word on this machine: $env:NAME, $HOME and ~ expanded. */+export function powershellPath(word: string, env: NodeJS.ProcessEnv, home: string | null): string {+ let out = word.replace(/\$env:([A-Za-z_]\w*)/gi, (all, name: string) => {+ const key = Object.keys(env).find((item) => item.toLowerCase() === name.toLowerCase());+ return key ? env[key] ?? all : all;+ });+ if (home) out = out.replace(/^(?:\$HOME|~)(?=$|[\\/])/i, home);+ return out;+}+// --- per-turn environment ---------------------------------------------------------const RUNTIMES: Array<{ name: string; commands: string[]; args: string[]; pattern: RegExp }> = [