windows-development-sandbox 1.4.1 → 1.4.3

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

@@ -1,9 +1,9 @@
 import type { GitAccess } from '../../core/types.js';
 export type Arch = 'x64' | 'arm64';
 /** PowerShell/PowerShell: the portable zip (PowerShell-7.6.6-win-x64.zip), never the MSI or the fxdependent builds. */
-export declare const pwshAsset: (arch: Arch) => RegExp;
+export declare function pwshAsset(arch: Arch): RegExp;
 /** cargo-bins/cargo-binstall: the plain zip (the .full build adds nothing we use; .sig files are signatures). */
-export declare const binstallAsset: (arch: Arch) => RegExp;
+export declare function binstallAsset(arch: Arch): RegExp;
 /**
  * One portable command-line tool from a GitHub release. The archive is unpacked into tools\cli\<name>; without
  * `subdir` only the folder holding `exe` is kept (and goes on PATH), with `subdir` the whole archive stays and that
@@ -37,7 +37,7 @@ export declare const CLI_TOOLS: readonly [{
 }];
 export type CliName = (typeof CLI_TOOLS)[number]['name'] | 'openssl';
 export declare const CLI_NAMES: readonly CliName[];
-/** toolchains.cli: each tool true, false or "auto" (gh: when the project has a .github folder; zstd: never by itself). */
+/** toolchains.cli: each tool true, false or "auto" (gh: when the project has .github; zstd: never by itself). */
 export type CliSettings = Partial<Record<CliName, boolean | 'auto'>>;
 export interface CliContext {
     gitAccess: GitAccess;
@@ -52,4 +52,4 @@ export interface CliDecision {
  * Which catalogue tools a sandbox gets. gh is never installed unless git access is "full": gh pushes, merges and edits
  * branches through the GitHub API, so it would walk straight past a "readonly" (or "none") git guard.
  */
-export declare const decideCli: (settings: CliSettings, ctx: CliContext) => Record<CliName, CliDecision>;
+export declare function decideCli(settings: CliSettings, ctx: CliContext): Record<CliName, CliDecision>;

package/dist/guest/toolchains/catalogue.js

@@ -1,23 +1,46 @@
 /** PowerShell/PowerShell: the portable zip (PowerShell-7.6.6-win-x64.zip), never the MSI or the fxdependent builds. */
-export const pwshAsset = (arch) => (arch === 'arm64' ? /^PowerShell-\d+\.\d+\.\d+-win-arm64\.zip$/ : /^PowerShell-\d+\.\d+\.\d+-win-x64\.zip$/);
+export function pwshAsset(arch) {
+    return arch === 'arm64' ? /^PowerShell-\d+\.\d+\.\d+-win-arm64\.zip$/ : /^PowerShell-\d+\.\d+\.\d+-win-x64\.zip$/;
+}
 /** cargo-bins/cargo-binstall: the plain zip (the .full build adds nothing we use; .sig files are signatures). */
-export const binstallAsset = (arch) => (arch === 'arm64' ? /^cargo-binstall-aarch64-pc-windows-msvc\.zip$/ : /^cargo-binstall-x86_64-pc-windows-msvc\.zip$/);
+export function binstallAsset(arch) {
+    return arch === 'arm64'
+        ? /^cargo-binstall-aarch64-pc-windows-msvc\.zip$/
+        : /^cargo-binstall-x86_64-pc-windows-msvc\.zip$/;
+}
 export const CLI_TOOLS = [
     // gh_2.102.0_windows_amd64.zip holds bin\gh.exe.
-    { name: 'gh', repo: 'cli/cli', asset: (arch) => (arch === 'arm64' ? /^gh_\d+\.\d+\.\d+_windows_arm64\.zip$/ : /^gh_\d+\.\d+\.\d+_windows_amd64\.zip$/), exe: 'gh.exe', about: 'GitHub CLI', size: '15 MB' },
+    {
+        name: 'gh',
+        repo: 'cli/cli',
+        asset: (arch) => arch === 'arm64' ? /^gh_\d+\.\d+\.\d+_windows_arm64\.zip$/ : /^gh_\d+\.\d+\.\d+_windows_amd64\.zip$/,
+        exe: 'gh.exe',
+        about: 'GitHub CLI',
+        size: '15 MB',
+    },
     // zstd-v1.5.7-win64.zip; there is no arm64 build, and Windows on Arm runs the x64 one.
-    { name: 'zstd', repo: 'facebook/zstd', asset: () => /^zstd-v\d+\.\d+\.\d+-win64\.zip$/, exe: 'zstd.exe', about: 'Zstandard compression', size: '2 MB' },
+    {
+        name: 'zstd',
+        repo: 'facebook/zstd',
+        asset: () => /^zstd-v\d+\.\d+\.\d+-win64\.zip$/,
+        exe: 'zstd.exe',
+        about: 'Zstandard compression',
+        size: '2 MB',
+    },
 ];
 export const CLI_NAMES = [...CLI_TOOLS.map((t) => t.name), 'openssl'];
 /**
  * Which catalogue tools a sandbox gets. gh is never installed unless git access is "full": gh pushes, merges and edits
  * branches through the GitHub API, so it would walk straight past a "readonly" (or "none") git guard.
  */
-export const decideCli = (settings, ctx) => {
+export function decideCli(settings, ctx) {
     const decide = (name) => {
         const setting = settings[name] ?? false;
         if (name === 'gh' && setting !== false && ctx.gitAccess !== 'full')
-            return { on: false, reason: 'needs provisioning.git.access "full" (gh can push and merge through the GitHub API)' };
+            return {
+                on: false,
+                reason: 'needs provisioning.git.access "full" (gh can push and merge through the GitHub API)',
+            };
         if (setting !== 'auto')
             return { on: setting, reason: setting ? 'enabled in config' : 'disabled in config' };
         if (name === 'gh' && ctx.hasGithubDir)
@@ -28,4 +51,4 @@ export const decideCli = (settings, ctx) => {
         return { on: false, reason: 'not listed in toolchains.cli' };
     };
     return Object.fromEntries(CLI_NAMES.map((name) => [name, decide(name)]));
-};
+}

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

@@ -0,0 +1,12 @@
+/** File names in the project's folder and its direct sub-folders ("api/go.mod"); read once per project. */
+export declare function workspaceEntries(): string[];
+/**
+ * true / false as configured. The host already turns "auto" into a decision at launch (core/detect-toolchains.ts);
+ * this only applies when a session file still says "auto": the workspace has one of the marker files.
+ */
+export declare function wanted(setting: boolean | 'auto', toolchain: string): boolean;
+/** The first of these version files in the workspace root, parsed (e.g. .ruby-version "3.3.1"). */
+export declare function versionFromFiles(files: string[], parse?: (text: string, name: string) => string | null): {
+    spec: string;
+    source: string;
+} | null;

package/dist/guest/toolchains/detect.js

@@ -0,0 +1,54 @@
+// Which toolchains a project needs, from the files in its folder.
+import fs from 'node:fs';
+import path from 'node:path';
+import { exists } from '../runtime/fs.js';
+import { projectWorkspace } from '../runtime/project-context.js';
+import { MARKERS } from '../../core/detect/toolchains.js';
+import { projectUses, specFromVersionFile } from '../../core/detect/versions.js';
+const SKIP_DIRS = new Set(['node_modules', '.git', 'target', 'bin', 'obj', 'dist', 'build', 'vendor', '.venv', 'venv']);
+const entries = new Map();
+/** File names in the project's folder and its direct sub-folders ("api/go.mod"); read once per project. */
+export function workspaceEntries() {
+    const workspace = projectWorkspace();
+    const known = entries.get(workspace.toLowerCase());
+    if (known)
+        return known;
+    const list = (dir) => {
+        try {
+            return fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+    };
+    const top = list(workspace);
+    const below = top
+        .filter((d) => d.isDirectory() && !d.name.startsWith('.') && !SKIP_DIRS.has(d.name.toLowerCase()))
+        .flatMap((d) => list(path.join(workspace, d.name))
+        .filter((f) => f.isFile())
+        .map((f) => d.name + '/' + f.name));
+    const found = [...top.filter((d) => d.isFile()).map((d) => d.name), ...below];
+    entries.set(workspace.toLowerCase(), found);
+    return found;
+}
+/**
+ * true / false as configured. The host already turns "auto" into a decision at launch (core/detect-toolchains.ts);
+ * this only applies when a session file still says "auto": the workspace has one of the marker files.
+ */
+export function wanted(setting, toolchain) {
+    return setting === 'auto'
+        ? projectUses(workspaceEntries(), MARKERS[toolchain] ?? [])
+        : setting;
+}
+/** The first of these version files in the workspace root, parsed (e.g. .ruby-version "3.3.1"). */
+export function versionFromFiles(files, parse = (t) => specFromVersionFile(t)) {
+    for (const name of files) {
+        const file = path.join(projectWorkspace(), name);
+        if (!exists(file))
+            continue;
+        const spec = parse(fs.readFileSync(file, 'utf8'), name);
+        if (spec)
+            return { spec, source: name };
+    }
+    return null;
+}

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

@@ -1,17 +1,3 @@
-import type { Toolchains, ToolVersions } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
-import { type ToolchainOptions } from './plan.js';
-export type { ToolEnv } from './common.js';
-export type { ToolchainOptions } from './plan.js';
-export interface RunOptions {
-    /** Progress lines ("Installing Go, Rust (3 of 9 done)"); default: the sandbox's boot status. */
-    report?: (message: string) => void;
-    /** What machine-wide (shared) steps contributed at boot: reused instead of run again. */
-    reuse?: Record<string, ToolEnv>;
-}
-/** The combined environment, plus what each step contributed (the boot keeps it so later projects can reuse shared steps). */
-export interface ToolchainResult extends ToolEnv {
-    steps: Record<string, ToolEnv>;
-}
-/** Provisions every enabled toolchain and database, and returns the combined environment for the agent. */
-export declare const setupToolchains: (config: Toolchains, versions: ToolVersions, options: ToolchainOptions, run?: RunOptions) => Promise<ToolchainResult>;
+export { setupToolchains, type ToolchainResult } from './setup.js';
+export type { ToolEnv } from './tool-env.js';
+export type { ToolchainOptions } from './step.js';

package/dist/guest/toolchains/index.js

@@ -1,106 +1 @@
-// Every developer toolchain and database the sandbox provides (the list is in plan.ts). Installers run in parallel (a
-// few at a time; downloads and installers do not block each other) and each is independent: one failing never blocks
-// the rest. A step that needs another (Rust links with MinGW's gcc, uv installs the Python tools) waits for it.
-// The boot runs it once for the launch folder; the session daemon runs it again for each project registered later,
-// possibly several at once, so the same kind of step (two Node installs, two Go installs) never runs twice at a time.
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { watchDownloads } from '../../shared/download.js';
-import { log, mkdirp, setSandboxStatus } from '../env.js';
-import { emptyEnv, step, tool } from './common.js';
-import { plan } from './plan.js';
-/** How many installers run at once: enough to overlap downloads with installs, few enough not to thrash the disk. */
-const PARALLEL = 4;
-/** The step a download belongs to (several run at once), for its progress. */
-const currentStep = new AsyncLocalStorage();
-/** One lock per kind of step ("Node 20" and "Node 22" share nvm's folders): held while that step runs, in any run. */
-const locks = new Map();
-const lockKey = (name) => name.split(' ')[0].toLowerCase();
-const exclusive = async (name, work) => {
-    const key = lockKey(name);
-    const previous = locks.get(key) ?? Promise.resolve();
-    let release = () => undefined;
-    const mine = new Promise((r) => { release = r; });
-    const chained = previous.then(() => mine);
-    locks.set(key, chained);
-    await previous;
-    try {
-        return await work();
-    }
-    finally {
-        release();
-        if (locks.get(key) === chained)
-            locks.delete(key);
-    }
-};
-/** Runs the steps (each with its own environment) at most PARALLEL at a time, after the steps they depend on. */
-const runSteps = async (steps, o) => {
-    const envs = new Map(steps.map((s) => [s.name, emptyEnv()]));
-    const finished = new Map();
-    const running = new Set();
-    const waiting = [];
-    let done = 0;
-    // The boot (no `report`) also publishes structured progress: what runs now, how far its download is, how many are done.
-    const percent = new Map();
-    const active = () => [...running].map((name) => ({ name, ...(percent.has(name) ? { percent: percent.get(name) } : {}) }));
-    const say = o.report ?? ((message) => setSandboxStatus('provisioning', message, { active: active(), done, total: steps.length }));
-    const report = () => { if (running.size)
-        say('Installing ' + [...running].join(', ') + ' (' + done + ' of ' + steps.length + ' done)'); };
-    if (!o.report)
-        watchDownloads(() => {
-            const name = currentStep.getStore();
-            return name ? (fraction) => { percent.set(name, Math.round(fraction * 100)); report(); } : null;
-        });
-    for (const s of steps) {
-        // Dependencies first (they are earlier in the plan, so their promises exist), then a free slot.
-        finished.set(s.name, (async () => {
-            await Promise.all((s.after ?? []).map((name) => finished.get(name)));
-            const reused = s.shared ? o.reuse?.[s.name] : undefined;
-            if (reused) {
-                envs.set(s.name, structuredClone(reused));
-                done++;
-                return;
-            }
-            while (running.size >= PARALLEL)
-                await new Promise((r) => waiting.push(r));
-            running.add(s.name);
-            report();
-            try {
-                await currentStep.run(s.name, () => exclusive(s.name, () => step(s.name, envs.get(s.name), async () => s.run(envs.get(s.name)))));
-            }
-            finally {
-                running.delete(s.name);
-                percent.delete(s.name);
-                done++;
-                report();
-                waiting.shift()?.();
-            }
-        })());
-    }
-    try {
-        await Promise.all(finished.values());
-    }
-    finally {
-        if (!o.report)
-            watchDownloads(null);
-    }
-    if (!o.report)
-        setSandboxStatus('provisioning', 'Set up ' + steps.length + ' toolchains and databases', { active: [], done, total: steps.length });
-    return envs;
-};
-/** Provisions every enabled toolchain and database, and returns the combined environment for the agent. */
-export const setupToolchains = async (config, versions, options, run = {}) => {
-    const steps = plan(config, versions, options).filter((s) => s.on);
-    const envs = await runSteps(steps, run);
-    // Merged in plan order, so PATH order never depends on which download finished first.
-    const env = { ...emptyEnv(), steps: Object.fromEntries(envs) };
-    env.prepend.push(mkdirp(tool('bin')));
-    for (const part of envs.values()) {
-        Object.assign(env.vars, part.vars);
-        env.prepend.push(...part.prepend);
-        env.append.push(...part.append);
-        env.summary.push(...part.summary);
-    }
-    Object.assign(env.vars, config.environment);
-    log('Set up ' + steps.length + ' toolchains and databases.');
-    return env;
-};
+export { setupToolchains } from './setup.js';

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

@@ -0,0 +1,20 @@
+import { type ReleaseAsset } from '../../shared/download/index.js';
+/**
+ * A single file download that lands as `file` only when complete (and checksum-verified): a cut-off one never looks
+ * finished.
+ */
+export declare function downloadFile(url: string, file: string, sha256?: string | null): Promise<void>;
+interface GithubInstall {
+    /** The folder the archive is unpacked into (replaced atomically). */
+    dest: string;
+    /** What the progress line says is being downloaded, with its size; a function gets the release asset. */
+    what: string | ((asset: ReleaseAsset) => string);
+    /** Look past the latest release for a matching asset. */
+    searchOlder?: boolean;
+    /** downloader.archive's `locate` / `up`: keep only the folder holding this file. */
+    locate?: string;
+    up?: number;
+}
+/** The newest GitHub release asset matching `pattern`, checksum-verified, unpacked into `dest`. */
+export declare function installFromGithub(repo: string, pattern: RegExp, o: GithubInstall): Promise<void>;
+export {};

package/dist/guest/toolchains/install.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import { downloader, githubAsset } from '../../shared/download/index.js';
+import { log } from '../runtime/log.js';
+/**
+ * A single file download that lands as `file` only when complete (and checksum-verified): a cut-off one never looks
+ * finished.
+ */
+export async function downloadFile(url, file, sha256 = null) {
+    const part = file + '.part';
+    try {
+        await downloader.file(url, part, sha256);
+        fs.rmSync(file, { force: true });
+        fs.renameSync(part, file);
+    }
+    finally {
+        fs.rmSync(part, { force: true });
+    }
+}
+/** The newest GitHub release asset matching `pattern`, checksum-verified, unpacked into `dest`. */
+export async function installFromGithub(repo, pattern, o) {
+    const asset = await githubAsset(repo, pattern, o.searchOlder);
+    log('Downloading ' + (typeof o.what === 'string' ? o.what : o.what(asset)) + ' ...');
+    await downloader.archive(asset.url, o.dest, {
+        sha256: asset.sha256,
+        fileName: asset.name,
+        ...(o.locate ? { locate: o.locate } : {}),
+        ...(o.up ? { up: o.up } : {}),
+    });
+}

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

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

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

@@ -2,12 +2,18 @@
 // GOTOOLCHAIN=auto lets a go.mod that needs a newer Go fetch it itself.
 import fs from 'node:fs';
 import path from 'node:path';
-import { fetchJson, installArchive } from '../../shared/download.js';
-import { dryRun, execAsync, exists, log } from '../env.js';
-import { arch, installOnce, resolveCached, tool, versionOf } from './common.js';
-import { pickGoRelease } from './versions.js';
-const findRelease = async (spec) => pickGoRelease(await fetchJson('https://go.dev/dl/?mode=json&include=all'), spec) ?? Promise.reject(new Error('No Go release matches "' + spec + '"'));
-export const setupGo = async (env, config) => {
+import { downloader, fetchJson } from '../../../shared/download/index.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 { arch, tool, versionOf } from '../tool-env.js';
+import { installOnce } from '../package-ledger.js';
+import { resolveCached } from '../version-cache.js';
+import { pickGoRelease } from '../../../core/detect/versions.js';
+const findRelease = async (spec) => pickGoRelease(await fetchJson('https://go.dev/dl/?mode=json&include=all'), spec) ??
+    Promise.reject(new Error('No Go release matches "' + spec + '"'));
+export async function setupGo(env, config) {
     if (dryRun) {
         log('(dry run) would provision Go ' + config.version);
         return;
@@ -20,14 +26,26 @@ export const setupGo = async (env, config) => {
         if (!file)
             throw new Error(version + ' has no Windows ' + goArch + ' zip');
         log('Downloading Go ' + version.replace(/^go/, '') + ' (~80 MB once) ...');
-        await installArchive('https://go.dev/dl/' + file.filename, root, { sha256: file.sha256, locate: 'VERSION', fileName: file.filename });
+        await downloader.archive('https://go.dev/dl/' + file.filename, root, {
+            sha256: file.sha256,
+            locate: 'VERSION',
+            fileName: file.filename,
+        });
     }
     const GOPATH = tool('go-path');
-    const vars = { GOROOT: root, GOPATH, GOBIN: path.join(GOPATH, 'bin'), GOMODCACHE: path.join(GOPATH, 'pkg', 'mod'), GOCACHE: tool('go-cache'), GOTOOLCHAIN: 'auto', GOTELEMETRY: 'off' };
+    const vars = {
+        GOROOT: root,
+        GOPATH,
+        GOBIN: path.join(GOPATH, 'bin'),
+        GOMODCACHE: path.join(GOPATH, 'pkg', 'mod'),
+        GOCACHE: tool('go-cache'),
+        GOTOOLCHAIN: 'auto',
+        GOTELEMETRY: 'off',
+    };
     fs.mkdirSync(vars.GOBIN, { recursive: true });
     Object.assign(env.vars, vars);
     env.prepend.push(path.join(root, 'bin'), vars.GOBIN);
     const go = path.join(root, 'bin', 'go.exe');
     env.summary.push('go: ' + versionOf(go, ['version']));
     await installOnce(env, 'go', config.tools, (pkg) => execAsync(go, ['install', pkg.includes('@') ? pkg : pkg + '@latest'], { env: { ...process.env, ...vars } }));
-};
+}

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

@@ -0,0 +1,8 @@
+import type { Toolchains } from '../../../core/types.js';
+import { type ToolEnv } from '../tool-env.js';
+/**
+ * A JDK for tools that run on Java (DynamoDB Local): the newest one already installed, else the newest LTS. Returns its
+ * folder; the agent's Java on PATH stays whatever toolchains.java says.
+ */
+export declare function ensureJdk(): Promise<string>;
+export declare function setupJava(env: ToolEnv, config: Toolchains['java']): Promise<void>;

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

@@ -2,15 +2,25 @@
 // caches live in persistent storage, so dependencies download once.
 import fs from 'node:fs';
 import path from 'node:path';
-import { fetchJson, fetchText, installArchive } from '../../shared/download.js';
-import { dryRun, errMsg, exists, log, warn } from '../env.js';
-import { arch, emptyEnv, resolveCached, tool, versionFromFiles } from './common.js';
-import { javaMajorFrom, pickPackageVersion } from './versions.js';
+import { downloader, fetchJson, fetchText } from '../../../shared/download/index.js';
+import { dryRun } from '../../runtime/paths.js';
+import { exists } from '../../runtime/fs.js';
+import { log, warn } from '../../runtime/log.js';
+import { errMsg } from '../../../core/util/errors.js';
+import { arch, emptyEnv, tool } from '../tool-env.js';
+import { resolveCached } from '../version-cache.js';
+import { versionFromFiles } from '../detect.js';
+import { javaMajorFrom, pickPackageVersion } from '../../../core/detect/versions.js';
 const ADOPTIUM = 'https://api.adoptium.net/v3';
 const MAVEN = 'https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/';
 const temurin = async (major) => {
-    const assets = await fetchJson(ADOPTIUM + '/assets/latest/' + major + '/hotspot?image_type=jdk&os=windows&vendor=eclipse&architecture=' + (arch === 'arm64' ? 'aarch64' : 'x64'));
-    return assets.find((a) => a.binary.package.name.endsWith('.zip')) ?? Promise.reject(new Error('No Temurin ' + major + ' JDK zip for Windows'));
+    const assets = await fetchJson(ADOPTIUM +
+        '/assets/latest/' +
+        major +
+        '/hotspot?image_type=jdk&os=windows&vendor=eclipse&architecture=' +
+        (arch === 'arm64' ? 'aarch64' : 'x64'));
+    return (assets.find((a) => a.binary.package.name.endsWith('.zip')) ??
+        Promise.reject(new Error('No Temurin ' + major + ' JDK zip for Windows')));
 };
 /** A project's .java-version / .sdkmanrc, else the configured version ("lts" = the newest LTS). */
 const javaMajor = async (config) => {
@@ -30,7 +40,11 @@ const setupJdk = async (env, config) => {
     if (!exists(path.join(home, 'bin', 'java.exe'))) {
         const asset = await temurin(major);
         log('Downloading Java ' + release + ' (JDK, ~200 MB once) ...');
-        await installArchive(asset.binary.package.link, home, { sha256: asset.binary.package.checksum, locate: 'release', fileName: asset.binary.package.name });
+        await downloader.archive(asset.binary.package.link, home, {
+            sha256: asset.binary.package.checksum,
+            locate: 'release',
+            fileName: asset.binary.package.name,
+        });
     }
     env.vars.JAVA_HOME = home;
     env.prepend.push(path.join(home, 'bin'));
@@ -40,15 +54,20 @@ const setupJdk = async (env, config) => {
  * A JDK for tools that run on Java (DynamoDB Local): the newest one already installed, else the newest LTS. Returns its
  * folder; the agent's Java on PATH stays whatever toolchains.java says.
  */
-export const ensureJdk = async () => {
+export async function ensureJdk() {
     const root = tool('java');
-    const installed = exists(root) ? fs.readdirSync(root).filter((d) => exists(path.join(root, d, 'bin', 'java.exe'))).sort((a, b) => b.localeCompare(a, undefined, { numeric: true })) : [];
+    const installed = exists(root)
+        ? fs
+            .readdirSync(root)
+            .filter((d) => exists(path.join(root, d, 'bin', 'java.exe')))
+            .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }))
+        : [];
     if (installed.length)
         return path.join(root, installed[0]);
     const scratch = emptyEnv();
     await setupJdk(scratch, { enabled: true, version: 'lts', maven: false, gradle: false });
     return scratch.vars.JAVA_HOME;
-};
+}
 const setupMaven = async (env) => {
     const version = await resolveCached('maven:3', async () => {
         const versions = [...(await fetchText(MAVEN + 'maven-metadata.xml')).matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1]);
@@ -58,7 +77,10 @@ const setupMaven = async (env) => {
     if (!exists(path.join(home, 'bin', 'mvn.cmd'))) {
         const url = MAVEN + version + '/apache-maven-' + version + '-bin.zip';
         log('Downloading Maven ' + version + ' (~10 MB once) ...');
-        await installArchive(url, home, { sha512: (await fetchText(url + '.sha512')).trim().split(/\s+/)[0], locate: 'LICENSE' });
+        await downloader.archive(url, home, {
+            sha512: (await fetchText(url + '.sha512')).trim().split(/\s+/)[0],
+            locate: 'LICENSE',
+        });
     }
     const repo = tool('maven-repository');
     Object.assign(env.vars, { MAVEN_HOME: home, M2_HOME: home, MAVEN_OPTS: '-Dmaven.repo.local=' + repo });
@@ -73,24 +95,41 @@ const setupGradle = async (env) => {
         if (!current || current.version !== version)
             throw new Error('Gradle ' + version + ' is not installed and cannot be downloaded right now');
         log('Downloading Gradle ' + version + ' (~130 MB once) ...');
-        await installArchive(current.downloadUrl, home, { sha256: (await fetchText(current.checksumUrl)).trim(), locate: 'LICENSE', fileName: 'gradle-' + version + '.zip' });
+        await downloader.archive(current.downloadUrl, home, {
+            sha256: (await fetchText(current.checksumUrl)).trim(),
+            locate: 'LICENSE',
+            fileName: 'gradle-' + version + '.zip',
+        });
     }
     const userHome = tool('gradle-home');
     fs.mkdirSync(userHome, { recursive: true });
     // File-system watching does not work on mapped folders (harmless but noisy "Couldn't add watch" on every build).
-    Object.assign(env.vars, { GRADLE_HOME: home, GRADLE_USER_HOME: userHome, GRADLE_OPTS: '-Dorg.gradle.vfs.watch=false' });
+    Object.assign(env.vars, {
+        GRADLE_HOME: home,
+        GRADLE_USER_HOME: userHome,
+        GRADLE_OPTS: '-Dorg.gradle.vfs.watch=false',
+    });
     env.prepend.push(path.join(home, 'bin'));
     env.summary.push('gradle: ' + version);
 };
-export const setupJava = async (env, config) => {
+export async function setupJava(env, config) {
     if (dryRun) {
-        log('(dry run) would provision Java ' + config.version + (config.maven ? ' + Maven' : '') + (config.gradle ? ' + Gradle' : ''));
+        log('(dry run) would provision Java ' +
+            config.version +
+            (config.maven ? ' + Maven' : '') +
+            (config.gradle ? ' + Gradle' : ''));
         return;
     }
     await setupJdk(env, config);
     // Maven and Gradle are extras: one failing must not take the JDK down with it.
-    for (const [on, name, work] of [[config.maven, 'Maven', setupMaven], [config.gradle, 'Gradle', setupGradle]]) {
+    for (const [on, name, work] of [
+        [config.maven, 'Maven', setupMaven],
+        [config.gradle, 'Gradle', setupGradle],
+    ]) {
         if (on)
-            await work(env).catch((e) => { env.summary.push(name.toLowerCase() + ': FAILED'); warn(name + ' setup failed (continuing without it): ' + errMsg(e)); });
+            await work(env).catch((e) => {
+                env.summary.push(name.toLowerCase() + ': FAILED');
+                warn(name + ' setup failed (continuing without it): ' + errMsg(e));
+            });
     }
-};
+}

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

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