windows-development-sandbox 1.4.1 → 1.5.0

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/languages/go.js

@@ -0,0 +1,51 @@
+// Go from go.dev (checksum-verified zip). Modules, build cache and `go install` binaries live in persistent storage;
+// 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 { 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;
+    }
+    const version = await resolveCached('go:' + config.version, async () => (await findRelease(config.version)).version);
+    const root = tool('go', version);
+    if (!exists(path.join(root, 'bin', 'go.exe'))) {
+        const goArch = arch === 'arm64' ? 'arm64' : 'amd64';
+        const file = (await findRelease(version)).files.find((f) => f.os === 'windows' && f.arch === goArch && f.kind === 'archive');
+        if (!file)
+            throw new Error(version + ' has no Windows ' + goArch + ' zip');
+        log('Downloading Go ' + version.replace(/^go/, '') + ' (~80 MB once) ...');
+        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',
+    };
+    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/languages/java.js

@@ -0,0 +1,135 @@
+// Java: Eclipse Temurin JDK (Adoptium), plus Maven and Gradle. All checksum-verified; the Maven repository and Gradle
+// caches live in persistent storage, so dependencies download once.
+import fs from 'node:fs';
+import path from 'node:path';
+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')));
+};
+/** A project's .java-version / .sdkmanrc, else the configured version ("lts" = the newest LTS). */
+const javaMajor = async (config) => {
+    const fromProject = versionFromFiles(['.java-version', '.sdkmanrc'], (text, name) => javaMajorFrom(text, name === '.sdkmanrc'));
+    if (fromProject)
+        return { major: fromProject.spec, source: fromProject.source };
+    const spec = config.version.trim().toLowerCase();
+    if (spec !== 'lts')
+        return { major: javaMajorFrom(spec) ?? spec, source: 'config' };
+    const lts = await resolveCached('java:lts', async () => String((await fetchJson(ADOPTIUM + '/info/available_releases')).most_recent_lts));
+    return { major: lts, source: 'newest LTS' };
+};
+const setupJdk = async (env, config) => {
+    const { major, source } = await javaMajor(config);
+    const release = await resolveCached('java:' + major, async () => (await temurin(major)).release_name);
+    const home = tool('java', release.replace(/[^A-Za-z0-9.-]/g, '_'));
+    if (!exists(path.join(home, 'bin', 'java.exe'))) {
+        const asset = await temurin(major);
+        log('Downloading Java ' + release + ' (JDK, ~200 MB once) ...');
+        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'));
+    env.summary.push('java: ' + release + ' (Temurin, from ' + source + ')');
+};
+/**
+ * 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 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 }))
+        : [];
+    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]);
+        return pickPackageVersion(versions, '3') ?? Promise.reject(new Error('No Maven 3 release found'));
+    });
+    const home = tool('maven', version);
+    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 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 });
+    env.prepend.push(path.join(home, 'bin'));
+    env.summary.push('maven: ' + version);
+};
+const setupGradle = async (env) => {
+    const current = await fetchJson('https://services.gradle.org/versions/current').catch(() => null);
+    const version = await resolveCached('gradle', async () => current?.version ?? Promise.reject(new Error('Gradle version lookup failed')));
+    const home = tool('gradle', version);
+    if (!exists(path.join(home, 'bin', 'gradle.bat'))) {
+        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 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',
+    });
+    env.prepend.push(path.join(home, 'bin'));
+    env.summary.push('gradle: ' + version);
+};
+export async function setupJava(env, config) {
+    if (dryRun) {
+        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],
+    ]) {
+        if (on)
+            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>;