windows-development-sandbox 1.4.1 → 1.4.3

package/dist/guest/toolchains/{node.js → languages/node.js}

@@ -3,19 +3,28 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
-import { fetchJson, githubAsset, installArchive } from '../../shared/download.js';
-import { safeRemove } from '../../shared/safe-remove.js';
-import { copyNode, dryRun, errMsg, execAsync, exists, hostToolsDir, localDir, log, mkdirp, warn } from '../env.js';
-import { arch, installOnce, resolveCached, tool } from './common.js';
-import { duringSession } from '../project-context.js';
-import { pickNodeVersion, pickSpreadVersions } from './versions.js';
+import { downloader, fetchJson, githubAsset } from '../../../shared/download/index.js';
+import { safeRemove } from '../../../shared/io/safe-remove.js';
+import { copyNode, execAsync } from '../../runtime/process.js';
+import { dryRun, hostToolsDir, localDir } from '../../runtime/paths.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log, warn } from '../../runtime/log.js';
+import { errMsg } from '../../../core/util/errors.js';
+import { arch, tool } from '../tool-env.js';
+import { installOnce } from '../package-ledger.js';
+import { resolveCached } from '../version-cache.js';
+import { duringSession } from '../../runtime/project-context.js';
+import { pickNodeVersion, pickSpreadVersions } from '../../../core/detect/versions.js';
 const NVM_HOME = tool('nvm');
 const NVM_SYMLINK = path.join(localDir, 'nodejs');
 const HOST_NVM = path.join(hostToolsDir, 'nvm');
 /** Most Node versions taken from this PC's nvm, the selected one included. */
 const HOST_VERSIONS_MAX = 3;
 const hostNvmVersions = () => exists(HOST_NVM)
-    ? fs.readdirSync(HOST_NVM).filter((d) => /^v\d+\.\d+\.\d+$/.test(d) && exists(path.join(HOST_NVM, d, 'node.exe'))).map((d) => d.slice(1))
+    ? fs
+        .readdirSync(HOST_NVM)
+        .filter((d) => /^v\d+\.\d+\.\d+$/.test(d) && exists(path.join(HOST_NVM, d, 'node.exe')))
+        .map((d) => d.slice(1))
     : [];
 const resolveNode = (spec) => resolveCached('node:' + spec, async () => {
     const exact = spec.replace(/^v/, '');
@@ -29,10 +38,17 @@ const resolveNode = (spec) => resolveCached('node:' + spec, async () => {
 const NVM_TEMP = path.join(NVM_HOME, '.tmp');
 /** nvm, without blocking the event loop (`nvm install` downloads). Resolves with its output. */
 const nvm = (args) => new Promise((resolve) => {
-    const child = spawn(path.join(NVM_HOME, 'nvm.exe'), args, { windowsHide: true, env: { ...process.env, NVM_HOME, NVM_SYMLINK, TEMP: NVM_TEMP, TMP: NVM_TEMP } });
+    const child = spawn(path.join(NVM_HOME, 'nvm.exe'), args, {
+        windowsHide: true,
+        env: { ...process.env, NVM_HOME, NVM_SYMLINK, TEMP: NVM_TEMP, TMP: NVM_TEMP },
+    });
     let out = '';
-    child.stdout.on('data', (d) => { out += d.toString(); });
-    child.stderr.on('data', (d) => { out += d.toString(); });
+    child.stdout.on('data', (d) => {
+        out += d.toString();
+    });
+    child.stderr.on('data', (d) => {
+        out += d.toString();
+    });
     child.once('error', (e) => resolve(out + e.message));
     child.once('close', () => resolve(out));
 });
@@ -44,7 +60,10 @@ const ensureNvm = async () => {
         log('Copying nvm from this PC ...');
         mkdirp(NVM_HOME);
         // nvm.exe last: it is what marks the install as done, so an interrupted copy is redone.
-        const files = fs.readdirSync(HOST_NVM).filter((f) => /\.(exe|cmd|vbs)$/i.test(f)).sort((a, b) => Number(a.toLowerCase() === 'nvm.exe') - Number(b.toLowerCase() === 'nvm.exe'));
+        const files = fs
+            .readdirSync(HOST_NVM)
+            .filter((f) => /\.(exe|cmd|vbs)$/i.test(f))
+            .sort((a, b) => Number(a.toLowerCase() === 'nvm.exe') - Number(b.toLowerCase() === 'nvm.exe'));
         for (const file of files)
             fs.copyFileSync(path.join(HOST_NVM, file), path.join(NVM_HOME, file));
         return;
@@ -52,7 +71,7 @@ const ensureNvm = async () => {
     // nvm-windows 2.x only ships installers; the portable build is the newest 1.x release that has nvm-noinstall.zip.
     const asset = await githubAsset('coreybutler/nvm-windows', /^nvm-noinstall\.zip$/, true);
     log('Downloading nvm-windows (' + asset.url.split('/').slice(-2, -1)[0] + ') ...');
-    await installArchive(asset.url, NVM_HOME, { sha256: asset.sha256, locate: 'nvm.exe', fileName: asset.name });
+    await downloader.archive(asset.url, NVM_HOME, { sha256: asset.sha256, locate: 'nvm.exe', fileName: asset.name });
 };
 /** A Node version: from the host's nvm when it has it (fast, offline), else `nvm install`. */
 const installNodeVersion = async (version) => {
@@ -61,7 +80,7 @@ const installNodeVersion = async (version) => {
     if (exists(path.join(dir, 'node.exe')))
         return;
     if (exists(path.join(fromHost, 'node.exe'))) {
-        log('Copying Node ' + version + ' from this PC\'s nvm (without global packages) ...');
+        log('Copying Node ' + version + " from this PC's nvm (without global packages) ...");
         copyNode(fromHost, dir);
         return;
     }
@@ -84,13 +103,19 @@ const activate = async (version) => {
     fs.rmSync(NVM_SYMLINK, { recursive: true, force: true });
     fs.symlinkSync(path.join(NVM_HOME, 'v' + version), NVM_SYMLINK, 'junction');
 };
-export const setupNode = async (env, versions, config) => {
+export async function setupNode(env, versions, config) {
     if (dryRun) {
         log('(dry run) would provision nvm and Node ' + versions.node.spec + ' (from ' + versions.node.source + ')');
         return;
     }
     await ensureNvm();
-    fs.writeFileSync(path.join(NVM_HOME, 'settings.txt'), ['root: ' + NVM_HOME, 'path: ' + NVM_SYMLINK, 'arch: ' + (arch === 'arm64' ? 'arm64' : '64'), 'proxy: none', ''].join('\r\n'));
+    fs.writeFileSync(path.join(NVM_HOME, 'settings.txt'), [
+        'root: ' + NVM_HOME,
+        'path: ' + NVM_SYMLINK,
+        'arch: ' + (arch === 'arm64' ? 'arm64' : '64'),
+        'proxy: none',
+        '',
+    ].join('\r\n'));
     mkdirp(localDir);
     for (const extra of versions.nodeExtra) {
         try {
@@ -122,12 +147,15 @@ export const setupNode = async (env, versions, config) => {
     }
     env.summary.push('node: ' + main + ' (from ' + versions.node.source + ', switch with nvm use)');
     await packageManagers(env, config, main);
-};
+}
 /** Global npm packages (per Node version, like nvm keeps them) and pnpm/yarn through corepack. */
 const packageManagers = async (env, config, version) => {
     const dir = path.join(NVM_HOME, 'v' + version);
     const nodeEnv = { ...process.env, PATH: dir + path.delimiter + (process.env.PATH ?? '') };
-    const npm = (args) => execAsync(path.join(dir, 'node.exe'), [path.join(dir, 'node_modules', 'npm', 'bin', 'npm-cli.js'), ...args], { env: nodeEnv, stdio: 'ignore' });
+    const npm = (args) => execAsync(path.join(dir, 'node.exe'), [path.join(dir, 'node_modules', 'npm', 'bin', 'npm-cli.js'), ...args], {
+        env: nodeEnv,
+        stdio: 'ignore',
+    });
     const corepackJs = path.join(dir, 'node_modules', 'corepack', 'dist', 'corepack.js');
     // Versions copied from this PC come without their global packages, corepack included, and Node 25+ dropped it.
     const extra = config.corepack && !exists(corepackJs) ? ['corepack'] : [];
@@ -136,7 +164,12 @@ const packageManagers = async (env, config, version) => {
         return;
     // Without a packageManager pin, corepack's own known-good versions: the newest pnpm can be one this corepack cannot
     // start. Mapped folders allow no symlinks, so pnpm uses a flat (hoisted) node_modules instead of its linked layout.
-    Object.assign(env.vars, { COREPACK_HOME: tool('corepack'), COREPACK_ENABLE_DOWNLOAD_PROMPT: '0', COREPACK_DEFAULT_TO_LATEST: '0', npm_config_node_linker: 'hoisted' });
+    Object.assign(env.vars, {
+        COREPACK_HOME: tool('corepack'),
+        COREPACK_ENABLE_DOWNLOAD_PROMPT: '0',
+        COREPACK_DEFAULT_TO_LATEST: '0',
+        npm_config_node_linker: 'hoisted',
+    });
     // The shims are shared by every session: a project added later keeps the ones made at boot.
     if (duringSession() && exists(tool('bin', 'pnpm.cmd'))) {
         env.summary.push('pnpm, yarn: via corepack');

package/dist/guest/toolchains/languages/php.d.ts

@@ -0,0 +1,3 @@
+import type { Toolchains } from '../../../core/types.js';
+import { type ToolEnv } from '../tool-env.js';
+export declare function setupPhp(env: ToolEnv, config: Toolchains['php']): Promise<void>;

package/dist/guest/toolchains/{scripting → languages}/php.js

@@ -1,19 +1,39 @@
 // PHP from windows.php.net, with Composer. Composer's global packages live in persistent storage.
 import fs from 'node:fs';
 import path from 'node:path';
-import { fetchJson, fetchText, installArchive } from '../../../shared/download.js';
-import { dryRun, execOutput, exists, log, mkdirp } from '../../env.js';
-import { downloadFile, resolveCached, tool, versionFromFiles } from '../common.js';
-import { pickPackageVersion } from '../versions.js';
-import { setupVcRuntime } from './vcruntime.js';
-const PHP_EXTENSIONS = ['curl', 'fileinfo', 'gd', 'intl', 'mbstring', 'openssl', 'pdo_mysql', 'pdo_pgsql', 'pdo_sqlite', 'sodium', 'sqlite3', 'zip'];
+import { downloader, fetchJson, fetchText } from '../../../shared/download/index.js';
+import { dryRun } from '../../runtime/paths.js';
+import { execOutput } from '../../runtime/process.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { downloadFile } from '../install.js';
+import { resolveCached } from '../version-cache.js';
+import { tool } from '../tool-env.js';
+import { versionFromFiles } from '../detect.js';
+import { pickPackageVersion } from '../../../core/detect/versions.js';
+import { setupVcRuntime } from '../native/vcruntime.js';
+const PHP_EXTENSIONS = [
+    'curl',
+    'fileinfo',
+    'gd',
+    'intl',
+    'mbstring',
+    'openssl',
+    'pdo_mysql',
+    'pdo_pgsql',
+    'pdo_sqlite',
+    'sodium',
+    'sqlite3',
+    'zip',
+];
 const COMPOSER = 'https://getcomposer.org/download/latest-stable/composer.phar';
 /** The non-thread-safe x64 zip of the newest release matching `spec` ("8" -> newest 8.x, "8.3" -> newest 8.3.x). */
 const phpBuild = async (spec) => {
     const releases = await fetchJson('https://windows.php.net/downloads/releases/releases.json');
     const pick = pickPackageVersion(Object.values(releases).map((r) => r.version), spec);
     const release = Object.values(releases).find((r) => r.version === pick);
-    const build = release && Object.entries(release).find(([key, value]) => /^nts-vs\d+-x64$/.test(key) && typeof value === 'object' && value.zip)?.[1];
+    const build = release &&
+        Object.entries(release).find(([key, value]) => /^nts-vs\d+-x64$/.test(key) && typeof value === 'object' && value.zip)?.[1];
     if (!release || typeof build !== 'object' || !build.zip)
         throw new Error('No PHP build for Windows matches "' + spec + '"');
     return { version: release.version, ...build.zip };
@@ -23,7 +43,8 @@ const writePhpIni = (home) => {
     const ini = path.join(home, 'php.ini');
     if (exists(ini) || !exists(path.join(home, 'php.ini-development')))
         return;
-    let text = fs.readFileSync(path.join(home, 'php.ini-development'), 'utf8')
+    let text = fs
+        .readFileSync(path.join(home, 'php.ini-development'), 'utf8')
         .replace(/^;\s*extension_dir\s*=\s*"ext"/m, 'extension_dir = "' + path.join(home, 'ext') + '"');
     for (const ext of PHP_EXTENSIONS.filter((e) => exists(path.join(home, 'ext', 'php_' + e + '.dll'))))
         text = text.replace(new RegExp('^;(extension=' + ext + ')\\s*$', 'm'), '$1');
@@ -48,7 +69,7 @@ const setupComposer = async (env, php) => {
     shim(env, 'composer', '"' + php + '" "' + phar + '"');
     env.summary.push('composer: ' + (/\d+\.\d+\.\d+/.exec(execOutput(php, [phar, '--version', '--no-ansi']))?.[0] ?? 'installed'));
 };
-export const setupPhp = async (env, config) => {
+export async function setupPhp(env, config) {
     const wantedSpec = versionFromFiles(['.php-version']) ?? { spec: config.version, source: 'config' };
     if (dryRun) {
         log('(dry run) would provision PHP ' + wantedSpec.spec + (config.composer ? ' + Composer' : ''));
@@ -61,11 +82,15 @@ export const setupPhp = async (env, config) => {
     if (!exists(path.join(home, 'php.exe'))) {
         const build = await phpBuild(version);
         log('Downloading PHP ' + version + ' (~30 MB once) ...');
-        await installArchive('https://windows.php.net/downloads/releases/' + build.path, home, { sha256: build.sha256, locate: 'php.exe', fileName: build.path });
+        await downloader.archive('https://windows.php.net/downloads/releases/' + build.path, home, {
+            sha256: build.sha256,
+            locate: 'php.exe',
+            fileName: build.path,
+        });
     }
     writePhpIni(home);
     env.prepend.push(home);
     env.summary.push('php: ' + version + ' (from ' + wantedSpec.source + ')');
     if (config.composer)
         await setupComposer(env, path.join(home, 'php.exe'));
-};
+}

package/dist/guest/toolchains/languages/python-tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolEnv } from '../tool-env.js';
+/** Python command-line tools through uv (each in its own environment, commands in uv's bin folder on PATH). */
+export declare function setupPythonTools(env: ToolEnv, tools: string[]): Promise<void>;

package/dist/guest/toolchains/languages/python-tools.js

@@ -0,0 +1,12 @@
+import { execAsync } from '../../runtime/process.js';
+import { exists } from '../../runtime/fs.js';
+import { tool } from '../tool-env.js';
+import { installOnce } from '../package-ledger.js';
+import { uvVars } from '../runtimes.js';
+/** Python command-line tools through uv (each in its own environment, commands in uv's bin folder on PATH). */
+export async function setupPythonTools(env, tools) {
+    const uv = tool('uv', 'uv.exe');
+    if (!exists(uv))
+        throw new Error('toolchains.python.tools needs uv (toolchains.uv.enabled)');
+    await installOnce(env, 'uv tool', tools, (pkg) => execAsync(uv, ['tool', 'install', pkg], { env: { ...process.env, ...uvVars() } }));
+}

package/dist/guest/toolchains/languages/python.d.ts

@@ -0,0 +1,3 @@
+import type { Toolchains, ToolVersions } from '../../../core/types.js';
+import { type ToolEnv } from '../tool-env.js';
+export declare function setupPython(env: ToolEnv, config: Toolchains['python'], versions: ToolVersions): Promise<void>;

package/dist/guest/toolchains/{python.js → languages/python.js}

@@ -1,21 +1,25 @@
 // Python 3 and Python 2: full CPython from the official NuGet packages (portable, with pip).
 import fs from 'node:fs';
 import path from 'node:path';
-import { fetchJson, installArchive } from '../../shared/download.js';
-import { dryRun, execAsync, exists, log, mkdirp } from '../env.js';
-import { resolveCached, tool } from './common.js';
-import { pickPackageVersion } from './versions.js';
-import { duringSession } from '../project-context.js';
+import { downloader, fetchJson } from '../../../shared/download/index.js';
+import { dryRun } from '../../runtime/paths.js';
+import { execAsync } from '../../runtime/process.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { resolveCached } from '../version-cache.js';
+import { tool } from '../tool-env.js';
+import { pickPackageVersion } from '../../../core/detect/versions.js';
+import { duringSession } from '../../runtime/project-context.js';
 const installPython = async (pkg, spec) => {
     const version = await resolveCached(pkg + ':' + spec, async () => {
         const { versions } = await fetchJson('https://api.nuget.org/v3-flatcontainer/' + pkg + '/index.json');
-        return pickPackageVersion(versions, spec) ?? Promise.reject(new Error('No ' + pkg + ' release matches "' + spec + '"'));
+        return (pickPackageVersion(versions, spec) ?? Promise.reject(new Error('No ' + pkg + ' release matches "' + spec + '"')));
     });
     const dir = tool('python', pkg + '-' + version);
     const exe = path.join(dir, 'python.exe');
     if (!exists(exe)) {
         log('Downloading Python ' + version + (pkg === 'python2' ? ' (Python 2, ' : ' (') + '~30 MB once) ...');
-        await installArchive('https://api.nuget.org/v3-flatcontainer/' + pkg + '/' + version + '/' + pkg + '.' + version + '.nupkg', dir, { locate: 'python.exe', fileName: pkg + '.' + version + '.zip' });
+        await downloader.archive('https://api.nuget.org/v3-flatcontainer/' + pkg + '/' + version + '/' + pkg + '.' + version + '.nupkg', dir, { locate: 'python.exe', fileName: pkg + '.' + version + '.zip' });
     }
     if (!exists(path.join(dir, 'Scripts', 'pip.exe')) && !exists(path.join(dir, 'Scripts', 'pip2.exe')))
         await execAsync(exe, ['-m', 'ensurepip', '--default-pip'], { stdio: 'ignore' });
@@ -26,14 +30,20 @@ const installPython = async (pkg, spec) => {
  * so the boot project's python3.cmd keeps pointing at its own version.
  */
 const shimDir = (dir) => (duringSession() ? tool('shims', path.basename(dir)) : tool('shims'));
-/** Writes `<name>.cmd` into the shims folder, e.g. python2.cmd. */
-const shim = (folder, name, command) => {
-    fs.writeFileSync(path.join(mkdirp(folder), name + '.cmd'), '@echo off\r\n' + command + ' %*\r\n');
+/**
+ * Writes `<name>.cmd` (cmd, PowerShell) and `<name>` (Git Bash, which runs neither .cmd nor .bat by bare name) into
+ * the shims folder, both running `program` with `args` and then the caller's arguments, e.g. python2.
+ */
+const shim = (folder, name, program, args = []) => {
+    const fixed = [program, ...args];
+    fs.writeFileSync(path.join(mkdirp(folder), name + '.cmd'), '@echo off\r\n' + fixed.map((a) => '"' + a + '"').join(' ') + ' %*\r\n');
+    const sh = fixed.map((a) => "'" + a.replace(/\\/g, '/').replace(/'/g, "'\\''") + "'").join(' ');
+    fs.writeFileSync(path.join(folder, name), '#!/bin/sh\nexec ' + sh + ' "$@"\n');
 };
 const shimPair = (folder, version, dir) => {
-    const python = '"' + path.join(dir, 'python.exe') + '"';
+    const python = path.join(dir, 'python.exe');
     shim(folder, 'python' + version, python);
-    shim(folder, 'pip' + version, python + ' -m pip');
+    shim(folder, 'pip' + version, python, ['-m', 'pip']);
 };
 /**
  * `py` like the Python launcher Windows installs: `py -3 x.py`, `py -3.12 ...`, `py -2 ...`, `py x.py`. The launcher
@@ -43,7 +53,10 @@ const pyLauncher = (folder, py3, py2) => {
     const script = path.join(mkdirp(folder), 'py-launcher.py');
     fs.writeFileSync(script, [
         'import subprocess, sys',
-        'PY3, PY2 = ' + JSON.stringify(path.join(py3, 'python.exe')) + ', ' + JSON.stringify(py2 ? path.join(py2, 'python.exe') : null),
+        'PY3, PY2 = ' +
+            JSON.stringify(path.join(py3, 'python.exe')) +
+            ', ' +
+            JSON.stringify(py2 ? path.join(py2, 'python.exe') : null),
         'args = sys.argv[1:]',
         'exe = PY3',
         "if args and args[0].startswith('-2'):",
@@ -54,9 +67,9 @@ const pyLauncher = (folder, py3, py2) => {
         'sys.exit(subprocess.call([exe] + args))',
         '',
     ].join('\n'));
-    shim(folder, 'py', '"' + path.join(py3, 'python.exe') + '" "' + script + '"');
+    shim(folder, 'py', path.join(py3, 'python.exe'), [script]);
 };
-export const setupPython = async (env, config, versions) => {
+export async function setupPython(env, config, versions) {
     if (dryRun) {
         log('(dry run) would provision Python ' + versions.python.spec + (config.python2 ? ' and Python 2.7' : ''));
         return;
@@ -75,4 +88,4 @@ export const setupPython = async (env, config, versions) => {
     shimPair(shims, '2', py2);
     pyLauncher(shims, py3, py2);
     env.summary.push('python2: ' + path.basename(py2).replace('python2-', ''));
-};
+}

package/dist/guest/toolchains/languages/ruby.d.ts

@@ -0,0 +1,3 @@
+import type { Toolchains } from '../../../core/types.js';
+import { type ToolEnv } from '../tool-env.js';
+export declare function setupRuby(env: ToolEnv, config: Toolchains['ruby']): Promise<void>;

package/dist/guest/toolchains/{scripting → languages}/ruby.js

@@ -1,10 +1,16 @@
 // Ruby from RubyInstaller. Gems live in persistent storage.
 import path from 'node:path';
-import { fetchJson, installArchive } from '../../../shared/download.js';
+import { downloader, fetchJson } from '../../../shared/download/index.js';
 import { SYSTEM } from '../../../shared/system.js';
-import { dryRun, execAsync, exists, log } from '../../env.js';
-import { installOnce, resolveCached, tool, versionFromFiles, versionOf } from '../common.js';
-import { pickPackageVersion } from '../versions.js';
+import { dryRun } from '../../runtime/paths.js';
+import { execAsync } from '../../runtime/process.js';
+import { exists } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { installOnce } from '../package-ledger.js';
+import { resolveCached } from '../version-cache.js';
+import { tool, versionOf } from '../tool-env.js';
+import { versionFromFiles } from '../detect.js';
+import { pickPackageVersion } from '../../../core/detect/versions.js';
 const RUBY_ASSET = /^rubyinstaller-(\d+\.\d+\.\d+)-(\d+)-x64\.7z$/;
 /** The build number after the version in a RubyInstaller file name (rubyinstaller-3.3.1-1-x64.7z -> 1). */
 const buildNumber = (asset) => Number(RUBY_ASSET.exec(asset.name)?.[2] ?? 0);
@@ -23,25 +29,37 @@ const rubyBuilds = async () => {
     return builds;
 };
 const sha256Of = (asset) => (asset.digest?.startsWith('sha256:') ? asset.digest.slice(7) : null);
-export const setupRuby = async (env, config) => {
+export async function setupRuby(env, config) {
     const wantedSpec = versionFromFiles(['.ruby-version']) ?? { spec: config.version, source: 'config' };
     if (dryRun) {
         log('(dry run) would provision Ruby ' + wantedSpec.spec);
         return;
     }
-    const version = await resolveCached('ruby:' + wantedSpec.spec, async () => pickPackageVersion([...(await rubyBuilds()).keys()], wantedSpec.spec) ?? Promise.reject(new Error('No RubyInstaller build matches "' + wantedSpec.spec + '"')));
+    const version = await resolveCached('ruby:' + wantedSpec.spec, async () => pickPackageVersion([...(await rubyBuilds()).keys()], wantedSpec.spec) ??
+        Promise.reject(new Error('No RubyInstaller build matches "' + wantedSpec.spec + '"')));
     const home = tool('ruby', version);
     if (!exists(path.join(home, 'bin', 'ruby.exe'))) {
         const asset = (await rubyBuilds()).get(version);
         if (!asset)
             throw new Error('RubyInstaller ' + version + ' is no longer published');
         log('Downloading Ruby ' + version + ' (~100 MB once) ...');
-        await installArchive(asset.browser_download_url, home, { sha256: sha256Of(asset), locate: 'ruby.exe', up: 1, fileName: asset.name });
+        await downloader.archive(asset.browser_download_url, home, {
+            sha256: sha256Of(asset),
+            locate: 'ruby.exe',
+            up: 1,
+            fileName: asset.name,
+        });
     }
     const gems = tool('ruby-gems', version.split('.').slice(0, 2).join('.'));
     Object.assign(env.vars, { GEM_HOME: gems, BUNDLE_USER_HOME: tool('bundle-home') });
     env.prepend.push(path.join(home, 'bin'), path.join(gems, 'bin'));
-    env.summary.push('ruby: ' + versionOf(path.join(home, 'bin', 'ruby.exe')) + ' (from ' + wantedSpec.source + '; gems with C extensions need MSYS2, not included)');
+    env.summary.push('ruby: ' +
+        versionOf(path.join(home, 'bin', 'ruby.exe')) +
+        ' (from ' +
+        wantedSpec.source +
+        '; gems with C extensions need MSYS2, not included)');
     const gem = path.join(home, 'bin', 'gem.cmd');
-    await installOnce(env, 'gem@' + version, config.gems, (pkg) => execAsync(SYSTEM.cmd(), ['/d', '/c', gem, 'install', pkg, '--no-document'], { env: { ...process.env, GEM_HOME: gems } }));
-};
+    await installOnce(env, 'gem@' + version, config.gems, (pkg) => execAsync(SYSTEM.cmd(), ['/d', '/c', gem, 'install', pkg, '--no-document'], {
+        env: { ...process.env, GEM_HOME: gems },
+    }));
+}

package/dist/guest/toolchains/leftovers.d.ts

@@ -1,2 +1,2 @@
 /** Removes helper builds older versions left in persistent storage, and interrupted installs' staging folders. */
-export declare const pruneToolLeftovers: () => void;
+export declare function pruneToolLeftovers(): void;

package/dist/guest/toolchains/leftovers.js

@@ -1,20 +1,22 @@
 // Clean-up of what interrupted or older installs left in the tools folder.
 import fs from 'node:fs';
 import path from 'node:path';
-import { safeRemove } from '../../shared/safe-remove.js';
-import { toolsDir } from '../env.js';
+import { safeRemove } from '../../shared/io/safe-remove.js';
+import { toolsDir } from '../runtime/paths.js';
 const STAGING = /\.staging-[0-9a-f]+$/i;
-const entries = (dir) => { try {
-    return fs.readdirSync(dir, { withFileTypes: true });
-}
-catch {
-    return [];
-} };
+const entries = (dir) => {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+};
 /** Removes helper builds older versions left in persistent storage, and interrupted installs' staging folders. */
-export const pruneToolLeftovers = () => {
+export function pruneToolLeftovers() {
     for (const legacy of ['ptyhost', 'gitshim'])
         safeRemove(path.join(toolsDir, legacy), toolsDir);
-    // Staging folders sit next to their destination: tools\x.staging-ab12 and one level down (tools\nvm\v22.staging-ab12).
+    // Staging folders sit next to their destination: tools\x.staging-ab12 and a level down (tools\nvm\v22.staging-ab12).
     for (const top of entries(toolsDir)) {
         const dir = path.join(toolsDir, top.name);
         if (STAGING.test(top.name))
@@ -23,4 +25,4 @@ export const pruneToolLeftovers = () => {
             for (const sub of entries(dir).filter((e) => STAGING.test(e.name)))
                 safeRemove(path.join(dir, sub.name), dir);
     }
-};
+}

package/dist/guest/toolchains/managers.d.ts

@@ -1,16 +1,16 @@
 import type { Toolchains } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
+import { type ToolEnv } from './tool-env.js';
 /** The "volta" block of the workspace's package.json ({ node, npm, yarn, pnpm }), if any. */
-export declare const voltaPins: () => Record<string, string>;
-export declare const wantsVolta: (setting: Toolchains["node"]["volta"]) => boolean;
-export declare const wantsPyenv: (setting: Toolchains["python"]["pyenv"]) => boolean;
+export declare function voltaPins(): Record<string, string>;
+export declare function wantsVolta(setting: Toolchains['node']['volta']): boolean;
+export declare function wantsPyenv(setting: Toolchains['python']['pyenv']): boolean;
 /**
  * Volta from its portable zip. With pins, its shims go first on PATH (the project gets exactly what package.json says,
  * fetched ahead of time); without, Volta is just available and nvm's Node stays the default.
  */
-export declare const setupVolta: (env: ToolEnv) => Promise<void>;
+export declare function setupVolta(env: ToolEnv): Promise<void>;
 /**
  * pyenv-win from its source archive (it ships no release assets). Its versions persist in tools\pyenv. It comes after
  * the Python step on PATH, so `python` is the sandbox's own until you `pyenv install` / `pyenv local`.
  */
-export declare const setupPyenv: (env: ToolEnv) => Promise<void>;
+export declare function setupPyenv(env: ToolEnv): Promise<void>;

package/dist/guest/toolchains/managers.js

@@ -2,27 +2,38 @@
 // the Python step still provide the default versions; these come along when the project or this PC uses them.
 import fs from 'node:fs';
 import path from 'node:path';
-import { installArchive, latestGithubTag } from '../../shared/download.js';
-import { dryRun, errMsg, execAsync, exists, log, mkdirp, session, warn } from '../env.js';
-import { projectWorkspace } from '../project-context.js';
-import { arch, installFromGithub, resolveCached, tool, versionOf } from './common.js';
+import { downloader, latestGithubTag } from '../../shared/download/index.js';
+import { dryRun } from '../runtime/paths.js';
+import { execAsync } from '../runtime/process.js';
+import { exists, mkdirp } from '../runtime/fs.js';
+import { log, warn } from '../runtime/log.js';
+import { session } from '../runtime/session.js';
+import { errMsg } from '../../core/util/errors.js';
+import { projectWorkspace } from '../runtime/project-context.js';
+import { arch, tool, versionOf } from './tool-env.js';
+import { installFromGithub } from './install.js';
+import { resolveCached } from './version-cache.js';
 /** The "volta" block of the workspace's package.json ({ node, npm, yarn, pnpm }), if any. */
-export const voltaPins = () => {
+export function voltaPins() {
     try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(projectWorkspace(), 'package.json'), 'utf8').replace(/^/, ''));
+        const pkg = JSON.parse(fs.readFileSync(path.join(projectWorkspace(), 'package.json'), 'utf8').replace(/^\uFEFF/, ''));
         return Object.fromEntries(Object.entries(pkg.volta ?? {}).filter((e) => ['node', 'npm', 'yarn', 'pnpm'].includes(e[0]) && typeof e[1] === 'string'));
     }
     catch {
         return {};
     }
-};
-export const wantsVolta = (setting) => setting === 'auto' ? Object.keys(voltaPins()).length > 0 || Boolean(session.hostTools.volta) : setting;
-export const wantsPyenv = (setting) => setting === 'auto' ? Boolean(session.hostTools.pyenv) : setting;
+}
+export function wantsVolta(setting) {
+    return setting === 'auto' ? Object.keys(voltaPins()).length > 0 || Boolean(session.hostTools.volta) : setting;
+}
+export function wantsPyenv(setting) {
+    return setting === 'auto' ? Boolean(session.hostTools.pyenv) : setting;
+}
 /**
  * Volta from its portable zip. With pins, its shims go first on PATH (the project gets exactly what package.json says,
  * fetched ahead of time); without, Volta is just available and nvm's Node stays the default.
  */
-export const setupVolta = async (env) => {
+export async function setupVolta(env) {
     if (dryRun) {
         log('(dry run) would provision Volta');
         return;
@@ -30,7 +41,11 @@ export const setupVolta = async (env) => {
     const dir = tool('volta');
     if (!exists(path.join(dir, 'volta.exe'))) {
         const pattern = arch === 'arm64' ? /^volta-[\d.]+-windows-arm64\.zip$/ : /^volta-[\d.]+-windows\.zip$/;
-        await installFromGithub('volta-cli/volta', pattern, { dest: dir, what: 'Volta (~15 MB once)', locate: 'volta.exe' });
+        await installFromGithub('volta-cli/volta', pattern, {
+            dest: dir,
+            what: 'Volta (~15 MB once)',
+            locate: 'volta.exe',
+        });
     }
     // The MSI puts these shims (copies of volta-shim.exe) next to volta.exe; the portable zip leaves that to us.
     for (const shim of ['node', 'npm', 'npx', 'pnpm', 'pnpx', 'yarn', 'yarnpkg']) {
@@ -51,21 +66,27 @@ export const setupVolta = async (env) => {
     // `volta install` fetches the pinned versions now (not on the agent's first `node`) and makes them the defaults.
     for (const [toolName, version] of Object.entries(pins)) {
         try {
-            await execAsync(volta, ['install', toolName + '@' + version], { env: { ...process.env, ...vars }, cwd: projectWorkspace(), stdio: 'ignore' });
+            await execAsync(volta, ['install', toolName + '@' + version], {
+                env: { ...process.env, ...vars },
+                cwd: projectWorkspace(),
+                stdio: 'ignore',
+            });
         }
         catch (e) {
             warn('Volta could not install ' + toolName + '@' + version + ': ' + errMsg(e));
         }
     }
     const pinned = Object.entries(pins).map(([k, v]) => k + '@' + v);
-    const note = pinned.length ? ' (pins from package.json: ' + pinned.join(', ') + ')' : ' (no pins in this project; nvm\'s node is the default)';
+    const note = pinned.length
+        ? ' (pins from package.json: ' + pinned.join(', ') + ')'
+        : " (no pins in this project; nvm's node is the default)";
     env.summary.push('volta: ' + versionOf(volta) + note);
-};
+}
 /**
  * pyenv-win from its source archive (it ships no release assets). Its versions persist in tools\pyenv. It comes after
  * the Python step on PATH, so `python` is the sandbox's own until you `pyenv install` / `pyenv local`.
  */
-export const setupPyenv = async (env) => {
+export async function setupPyenv(env) {
     if (dryRun) {
         log('(dry run) would provision pyenv-win');
         return;
@@ -75,10 +96,10 @@ export const setupPyenv = async (env) => {
         const tag = await resolveCached('pyenv-win', () => latestGithubTag('pyenv-win/pyenv-win'));
         log('Downloading pyenv-win ' + tag + ' (~5 MB once) ...');
         // GitHub's tag archive: no published checksum, but HTTPS from github.com for the project's own tag.
-        await installArchive('https://github.com/pyenv-win/pyenv-win/archive/refs/tags/' + encodeURIComponent(tag) + '.zip', root, { locate: 'pyenv.bat', up: 1, fileName: 'pyenv-win.zip' });
+        await downloader.archive('https://github.com/pyenv-win/pyenv-win/archive/refs/tags/' + encodeURIComponent(tag) + '.zip', root, { locate: 'pyenv.bat', up: 1, fileName: 'pyenv-win.zip' });
     }
     const home = root + path.sep;
     Object.assign(env.vars, { PYENV: home, PYENV_ROOT: home, PYENV_HOME: home });
     env.append.push(path.join(root, 'bin'), path.join(root, 'shims'));
     env.summary.push('pyenv-win: pyenv install <version> / pyenv local <version> (versions persist)');
-};
+}

package/dist/guest/toolchains/native/binstall.d.ts

@@ -2,6 +2,7 @@ import type { SpawnOptions } from 'node:child_process';
 /**
  * Returns the installer for one crate: `cargo binstall` (prebuilt only: its own compile fallback is off, so a crate
  * without a Windows build is compiled by our `cargo install` with the linker settings in `cargoEnv`), then
- * `cargo install --locked`. cargo-binstall is fetched on first use, so boots with every crate installed download nothing.
+ * `cargo install --locked`. cargo-binstall is fetched on first use, so boots with every crate installed download
+ * nothing.
  */
-export declare const crateInstaller: (cargoHome: string, cargoEnv: SpawnOptions) => ((crate: string) => Promise<void>);
+export declare function crateInstaller(cargoHome: string, cargoEnv: SpawnOptions): (crate: string) => Promise<void>;