windows-development-sandbox 1.0.5 → 1.1.0

package/dist/cli/commands/setup.js

@@ -1,152 +0,0 @@
-// `sandbox setup`: checks this PC can run Windows Sandbox and offers to turn the feature on.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import _ from 'lodash';
-import { z } from 'zod';
-import { askYesNo } from '../../core/workspace.js';
-import { fail, fileExists, isWin } from '../../core/util.js';
-import { SYSTEM, system32 } from '../../shared/system.js';
-import { table } from './context.js';
-const FEATURE = 'Containers-DisposableClientVM';
-export const ENABLE_COMMAND = 'Enable-WindowsOptionalFeature -Online -FeatureName ' + FEATURE + ' -All -NoRestart';
-const GB = 1024 ** 3;
-/** `reg query <key>` output to { valueName: data }. */
-export const parseRegQuery = (text) => Object.fromEntries(_.compact(text.split(/\r?\n/).map((line) => /^\s+(\S+)\s+REG_\w+\s+(.*)$/.exec(line)?.slice(1, 3))));
-/** Windows Sandbox needs Pro, Enterprise or Education (build 18305+); Home ("Core*") and Server cannot run it. */
-export const editionSupport = (edition) => {
-    if (!edition)
-        return 'unknown';
-    if (/^Core/i.test(edition))
-        return 'home';
-    if (/^Server/i.test(edition))
-        return 'unsupported';
-    return /^(Professional|Enterprise|Education|IoTEnterprise)/i.test(edition) ? 'supported' : 'unknown';
-};
-/** The "State : ..." line of `Dism /Get-FeatureInfo` (English output only; anything else is unknown). */
-export const parseDismState = (text) => {
-    const state = /^State\s*:\s*(.+?)\s*$/im.exec(text)?.[1].toLowerCase() ?? '';
-    if (state === 'enabled')
-        return 'enabled';
-    if (state.includes('pending'))
-        return 'pending';
-    return state.startsWith('disabled') ? 'disabled' : 'unknown';
-};
-/** Win32_OptionalFeature.InstallState: 1 enabled, 2 disabled, 3 absent. */
-export const featureFromInstallState = (state) => state === 1 ? 'enabled' : state === 2 || state === 3 ? 'disabled' : 'unknown';
-export const nodeMajor = (version) => Number(/^v?(\d+)/.exec(version.trim())?.[1] ?? 0);
-/** Offer to enable the feature only when it is off and this edition can have it. */
-export const canEnableFeature = (f) => f.feature !== 'enabled' && f.feature !== 'pending' && !f.sandboxExe && ['supported', 'unknown'].includes(editionSupport(f.edition));
-const formatGb = (bytes) => (bytes / GB).toFixed(1) + ' GB';
-/** Turns what we learnt about the PC into the checklist (pure, so it can be tested). */
-export const buildChecks = (f) => {
-    const support = editionSupport(f.edition);
-    const edition = (f.edition ?? 'unknown edition') + (f.build ? ', build ' + f.build : '');
-    const virt = f.hypervisorPresent || f.virtualizationFirmware;
-    const featureReady = f.feature === 'enabled' && f.sandboxExe;
-    return [
-        support === 'supported' && (f.build ?? 18305) >= 18305 ? { name: 'Windows edition', status: 'ok', detail: edition }
-            : support === 'home' ? { name: 'Windows edition', status: 'action', detail: edition + ': Windows Home cannot run Windows Sandbox. Upgrade to Pro (Settings > System > Activation).' }
-                : support === 'unsupported' ? { name: 'Windows edition', status: 'action', detail: edition + ': Windows Sandbox needs Windows 10/11 Pro, Enterprise or Education.' }
-                    : support === 'supported' ? { name: 'Windows edition', status: 'action', detail: edition + ': too old; Windows Sandbox needs Windows 10 version 1903 or newer.' }
-                        : { name: 'Windows edition', status: 'warn', detail: edition + ': not sure this edition has Windows Sandbox (it needs Pro, Enterprise or Education).' },
-        virt ? { name: 'CPU virtualization', status: 'ok', detail: f.hypervisorPresent ? 'on (hypervisor running)' : 'on' }
-            : virt === false ? { name: 'CPU virtualization', status: 'action', detail: 'off. Turn on Intel VT-x / AMD-V (SVM) in your PC\'s BIOS/UEFI settings, then run this again.' }
-                : { name: 'CPU virtualization', status: 'warn', detail: 'could not tell; if Windows Sandbox will not start, turn on VT-x / AMD-V in the BIOS/UEFI.' },
-        featureReady ? { name: 'Windows Sandbox feature', status: 'ok', detail: 'enabled' }
-            : f.feature === 'pending' || (f.feature === 'enabled' && !f.sandboxExe) ? { name: 'Windows Sandbox feature', status: 'action', detail: 'enabled, but Windows needs a restart to finish.' }
-                : f.sandboxExe ? { name: 'Windows Sandbox feature', status: 'ok', detail: 'installed' }
-                    : { name: 'Windows Sandbox feature', status: 'action', detail: 'not enabled. In an admin PowerShell: ' + ENABLE_COMMAND + ', then restart.' },
-        { name: 'Memory', status: f.totalRamBytes < 4 * GB ? 'action' : f.totalRamBytes < 8 * GB ? 'warn' : 'ok', detail: formatGb(f.totalRamBytes) + (f.totalRamBytes < 4 * GB ? ': Windows Sandbox needs at least 4 GB.' : f.totalRamBytes < 8 * GB ? ': works, but 8 GB or more is recommended.' : '') },
-        f.freeDiskBytes === null ? { name: 'Free disk', status: 'warn', detail: 'could not check the drive of ' + f.storageRoot }
-            : { name: 'Free disk', status: f.freeDiskBytes < 5 * GB ? 'action' : f.freeDiskBytes < 20 * GB ? 'warn' : 'ok', detail: formatGb(f.freeDiskBytes) + ' free for ' + f.storageRoot + (f.freeDiskBytes < 5 * GB ? ': free up space (toolchains need several GB).' : f.freeDiskBytes < 20 * GB ? ': getting low; toolchains and caches can use several GB.' : '') },
-        nodeMajor(f.nodeVersion) >= 20 ? { name: 'Node.js', status: 'ok', detail: f.nodeVersion } : { name: 'Node.js', status: 'action', detail: f.nodeVersion + ': needs 20 or newer (winget install OpenJS.NodeJS.LTS).' },
-    ];
-};
-// Fixed script (no outside data): CPU/hypervisor facts and the feature state, readable without admin rights.
-const PROBE = [
-    '$ErrorActionPreference = "SilentlyContinue"',
-    '$cpu = @(Get-CimInstance Win32_Processor)',
-    '$cs = Get-CimInstance Win32_ComputerSystem',
-    '$f = Get-CimInstance Win32_OptionalFeature -Filter "Name=\'' + FEATURE + '\'"',
-    '$v = $null; if ($cpu.Count) { $v = [bool]($cpu | Where-Object { $_.VirtualizationFirmwareEnabled }) }',
-    '$h = $null; if ($cs) { $h = [bool]$cs.HypervisorPresent }',
-    '$s = $null; if ($f) { $s = [int]$f.InstallState }',
-    '@{ virtualizationFirmware = $v; hypervisorPresent = $h; installState = $s } | ConvertTo-Json -Compress',
-].join('; ');
-const Probe = z.object({ virtualizationFirmware: z.boolean().nullable(), hypervisorPresent: z.boolean().nullable(), installState: z.number().nullable() }).partial();
-export const parseProbe = (text) => {
-    try {
-        return Probe.parse(JSON.parse(_.last(text.trim().split(/\r?\n/)) ?? ''));
-    }
-    catch {
-        return {};
-    }
-};
-const run = (exe, args) => {
-    const r = spawnSync(exe, args, { encoding: 'utf8', windowsHide: true, timeout: 60000 });
-    return r.status === 0 ? r.stdout : '';
-};
-const freeDisk = (dir) => {
-    let at = path.resolve(dir);
-    while (!fs.existsSync(at) && path.dirname(at) !== at)
-        at = path.dirname(at);
-    try {
-        const s = fs.statfsSync(at);
-        return s.bavail * s.bsize;
-    }
-    catch {
-        return null;
-    }
-};
-const gatherFacts = (storageRoot) => {
-    const reg = parseRegQuery(run(SYSTEM.reg(), ['query', 'HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion']));
-    const probe = parseProbe(run(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', PROBE]));
-    // DISM knows about a pending restart but needs admin rights; the CIM state works for everyone.
-    const dism = parseDismState(run(SYSTEM.dism(), ['/English', '/Online', '/Get-FeatureInfo', '/FeatureName:' + FEATURE]));
-    return {
-        edition: reg.EditionID ?? null,
-        build: Number(reg.CurrentBuildNumber ?? reg.CurrentBuild) || null,
-        feature: dism === 'unknown' ? featureFromInstallState(probe.installState) : dism,
-        sandboxExe: fileExists(system32('WindowsSandbox.exe')),
-        virtualizationFirmware: probe.virtualizationFirmware ?? null,
-        hypervisorPresent: probe.hypervisorPresent ?? null,
-        totalRamBytes: os.totalmem(),
-        freeDiskBytes: freeDisk(storageRoot),
-        storageRoot,
-        nodeVersion: process.version,
-    };
-};
-const LABEL = { ok: '\x1b[32mOK\x1b[0m', warn: '\x1b[33mWARNING\x1b[0m', action: '\x1b[31mACTION NEEDED\x1b[0m' };
-const print = (checks) => table(checks.map((c) => [LABEL[c.status], c.name, c.detail]));
-/** Runs the enable command in an elevated PowerShell (Windows asks for permission); true if it worked. */
-const enableFeature = () => {
-    const inner = "'-NoProfile','-Command','" + ENABLE_COMMAND + " | Out-Null'";
-    const outer = "try { $p = Start-Process -FilePath '" + SYSTEM.powershell() + "' -Verb RunAs -Wait -PassThru -WindowStyle Hidden -ArgumentList " + inner + '; exit $p.ExitCode } catch { exit 1 }';
-    return spawnSync(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', outer], { stdio: 'inherit' }).status === 0;
-};
-export const setup = async (ctx) => {
-    if (!isWin)
-        fail('Windows Sandbox only runs on Windows.', 'Run sandbox setup on a Windows 10/11 Pro, Enterprise or Education PC.');
-    console.log('Checking this PC for Windows Sandbox...\n');
-    const facts = gatherFacts(ctx.storageRoot);
-    let checks = buildChecks(facts);
-    print(checks);
-    if (canEnableFeature(facts)) {
-        console.log('');
-        if (await askYesNo('Turn on Windows Sandbox now? Windows will ask for admin permission.')) {
-            console.log('Enabling Windows Sandbox (this can take a minute)...');
-            if (!enableFeature())
-                fail('Windows Sandbox could not be enabled (or the admin prompt was declined).', 'In an admin PowerShell run: ' + ENABLE_COMMAND + ', then restart Windows.');
-            console.log('Done. Restart Windows to finish, then run sandbox setup again.\n');
-            checks = buildChecks(gatherFacts(ctx.storageRoot));
-            print(checks);
-        }
-        else
-            console.log('To do it yourself, in an admin PowerShell run:\n  ' + ENABLE_COMMAND + '\nthen restart Windows.');
-    }
-    const todo = checks.filter((c) => c.status === 'action').length;
-    console.log('\n' + (todo ? todo + ' thing(s) to fix before the sandbox can start (see ACTION NEEDED above).' : 'This PC is ready. cd into a project and run sandbox claude (or sandbox for no agent).'));
-    return todo ? 1 : 0;
-};

package/dist/cli/settings.d.ts

@@ -1,11 +0,0 @@
-/**
- * Applies one change (undefined = back to the default) to the config text and returns the new text, or the problems
- * that make the result invalid. Pure: the caller writes the file.
- */
-export declare const editConfigText: (text: string, key: string[], value: unknown) => {
-    text: string;
-} | {
-    problems: string[];
-};
-/** The settings screen. Changes are saved to the user config file (created when missing). */
-export declare const settingsMenu: (configPath: string | null) => Promise<void>;

package/dist/cli/settings.js

@@ -1,156 +0,0 @@
-// The settings screen in the menu: every setting, generated from the zod schema (so nothing needs to be listed by
-// hand), shown with its current value and description, edited with a fitting prompt and saved to the user config
-// file. Edits go through jsonc-parser, so comments and formatting in the file are kept, and nothing is written unless
-// the whole config is still valid.
-import fs from 'node:fs';
-import path from 'node:path';
-import { input, select, Separator } from '@inquirer/prompts';
-import { applyEdits, modify, parse } from 'jsonc-parser';
-import _ from 'lodash';
-import { DEFAULTS, loadConfig, mergeConfig, userConfigPath } from '../core/config.js';
-import { Config as ConfigSchema, describeIssues } from '../core/schema.js';
-const c = { dim: (s) => '\x1b[2m' + s + '\x1b[0m', cyan: (s) => '\x1b[36m' + s + '\x1b[0m', green: (s) => '\x1b[32m' + s + '\x1b[0m', yellow: (s) => '\x1b[33m' + s + '\x1b[0m', red: (s) => '\x1b[31m' + s + '\x1b[0m' };
-/** optional()/default() wrappers hide the real type. */
-const unwrap = (s) => (['optional', 'default', 'nullable'].includes(s._zod.def.type) && s._zod.def.innerType ? unwrap(s._zod.def.innerType) : s);
-const kind = (s) => unwrap(s)._zod.def.type;
-const isSection = (s) => kind(s) === 'object' && Boolean(unwrap(s).shape);
-/** Settings not worth editing here (the schema link) or better edited in the file (agent definitions). */
-const HIDDEN = new Set(['$schema']);
-/** A value in one short line: maps as their keys, long lists shortened. */
-const show = (value) => {
-    if (value === undefined)
-        return c.dim('(not set)');
-    if (typeof value === 'string')
-        return value;
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-        const keys = Object.keys(value);
-        return keys.length ? '{ ' + _.truncate(keys.join(', '), { length: 60 }) + ' }' : '{}';
-    }
-    return _.truncate(JSON.stringify(value), { length: 70 });
-};
-/** What the value is in the file the user owns (undefined when it comes from the built-in defaults). */
-const fileValue = (text, key) => _.get(parse(text) ?? {}, key);
-/**
- * Applies one change (undefined = back to the default) to the config text and returns the new text, or the problems
- * that make the result invalid. Pure: the caller writes the file.
- */
-export const editConfigText = (text, key, value) => {
-    const edits = modify(text || '{}', key, value, { formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' } });
-    const next = applyEdits(text || '{}', edits);
-    const parsed = ConfigSchema.safeParse(mergeConfig(DEFAULTS, parse(next) ?? {}));
-    return parsed.success ? { text: next.endsWith('\n') ? next : next + '\n' } : { problems: describeIssues(parsed.error) };
-};
-/** A prompt that fits the setting's type; returns the new value, or undefined to change nothing. */
-const askValue = async (schema, label, current, config) => {
-    const s = unwrap(schema);
-    // The default agent is one of the configured ones: a list, not free text.
-    if (label === 'defaultHarness' && config) {
-        const v = await select({ message: label, choices: [...Object.keys(config.harnesses).map((h) => ({ name: h, value: h })), { name: c.dim('< cancel'), value: '@cancel' }], default: current });
-        return v === '@cancel' ? undefined : { value: v };
-    }
-    const t = s._zod.def.type;
-    const back = { name: c.dim('< cancel'), value: '@cancel' };
-    const pick = async (choices) => {
-        const v = await select({ message: label, choices: [...choices, back], default: current });
-        return v === '@cancel' ? undefined : { value: v };
-    };
-    if (t === 'boolean')
-        return pick([{ name: 'true', value: true }, { name: 'false', value: false }]);
-    if (t === 'enum')
-        return pick(Object.values(s._zod.def.entries ?? {}).map((v) => ({ name: String(v), value: v })));
-    if (t === 'union') {
-        const options = s._zod.def.options ?? [];
-        const literals = options.filter((o) => kind(o) === 'literal').flatMap((o) => unwrap(o)._zod.def.values ?? []);
-        const hasBool = options.some((o) => kind(o) === 'boolean');
-        const other = options.find((o) => !['literal', 'boolean'].includes(kind(o)));
-        const choices = [...(hasBool ? [{ name: 'true', value: true }, { name: 'false', value: false }] : []), ...literals.map((v) => ({ name: String(v), value: v }))];
-        if (!other)
-            return pick(choices);
-        const chosen = await pick([...choices, { name: 'a ' + kind(other) + ' ...', value: '@other' }]);
-        return chosen?.value === '@other' ? askValue(other, label, current) : chosen;
-    }
-    const typed = async (validate, convert) => {
-        const answer = await input({ message: label + c.dim(' (empty = cancel)'), default: current === undefined ? '' : typeof current === 'string' ? current : JSON.stringify(current), validate: (v) => (v === '' ? true : validate(v)) });
-        return answer === '' ? undefined : { value: convert(answer) };
-    };
-    if (t === 'number')
-        return typed((v) => (Number.isFinite(Number(v)) ? true : 'a number'), Number);
-    if (t === 'string')
-        return typed(() => true, (v) => v);
-    if (t === 'array' && kind(s._zod.def.element) === 'string') {
-        return typed(() => true, (v) => (v.trim() === '[]' ? [] : v.split(',').map((x) => x.trim()).filter(Boolean)));
-    }
-    // Lists of objects and maps (mappings, harnesses, environment): edited as JSON.
-    return typed((v) => { try {
-        JSON.parse(v);
-        return true;
-    }
-    catch {
-        return 'valid JSON';
-    } }, (v) => JSON.parse(v));
-};
-/** Edits one setting: shows it, asks, saves (or resets it to the default). */
-const editSetting = async (schema, key, config, file) => {
-    const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-    const inFile = fileValue(text, key);
-    console.log('\n' + c.cyan(key.join('.')) + (schema.description ? '\n' + c.dim(schema.description) : ''));
-    console.log('Now: ' + show(_.get(config, key)) + (inFile === undefined ? c.dim('  (built-in default)') : c.dim('  (set in ' + file + ')')));
-    const action = inFile === undefined ? 'change' : await select({ message: 'What now?', choices: [{ name: 'Change it', value: 'change' }, { name: 'Reset to the default (' + show(_.get(DEFAULTS, key)) + ')', value: 'reset' }, { name: c.dim('< back'), value: 'back' }] });
-    if (action === 'back')
-        return;
-    const answer = action === 'reset' ? { value: undefined } : await askValue(schema, key.join('.'), _.get(config, key), config);
-    if (!answer)
-        return;
-    // The default needs no line in the file; an unchanged value needs no save.
-    const value = _.isEqual(answer.value, _.get(DEFAULTS, key)) ? undefined : answer.value;
-    if (value === inFile && _.isEqual(answer.value, _.get(config, key))) {
-        console.log(c.dim('Unchanged.'));
-        return;
-    }
-    const result = editConfigText(text, key, value);
-    if ('problems' in result) {
-        console.log(c.red('Not saved: ') + result.problems.join('; '));
-        return;
-    }
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, result.text, 'utf8');
-    console.log(c.green('Saved') + c.dim(' to ' + file + '. New sandboxes use it.'));
-};
-const SECTION_TITLES = {
-    toolchains: 'Languages and tools', databases: 'Databases', sandbox: 'The sandbox machine (memory, window, GPU, network)', attach: 'Attaching (auto attach, auto hide)',
-    provisioning: 'Provisioning and git', secrets: 'Secrets', claudeProfile: 'Your Claude settings and history', storage: 'Storage', network: 'Network', hooks: 'Hooks', personalization: 'Desktop look',
-};
-/** Browses one level of settings; sections open, leaves are edited. */
-const browse = async (schema, key, file) => {
-    for (;;) {
-        const config = loadConfig().config;
-        const entries = Object.entries(unwrap(schema).shape ?? {}).filter(([name]) => !HIDDEN.has(name));
-        const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-        const pickName = await select({
-            message: key.length ? key.join('.') : 'Settings ' + c.dim('(saved to ' + file + ')'),
-            pageSize: 18,
-            choices: [
-                ...entries.map(([name, s]) => {
-                    const full = [...key, name];
-                    const changed = fileValue(text, full) !== undefined;
-                    const label = isSection(s) ? (key.length ? name : SECTION_TITLES[name] ?? name) + c.dim(' ...') : name.padEnd(18) + ' ' + (changed ? c.yellow(show(_.get(config, full))) : show(_.get(config, full)));
-                    return { name: label, value: name, description: s.description };
-                }),
-                new Separator(),
-                { name: c.dim('< back'), value: '@back' },
-            ],
-        });
-        if (pickName === '@back')
-            return;
-        const child = unwrap(schema).shape[pickName];
-        if (isSection(child))
-            await browse(child, [...key, pickName], file);
-        else
-            await editSetting(child, [...key, pickName], config, file);
-    }
-};
-/** The settings screen. Changes are saved to the user config file (created when missing). */
-export const settingsMenu = async (configPath) => {
-    const file = configPath ?? userConfigPath();
-    await browse(ConfigSchema, [], file);
-};

package/dist/guest/toolchains/databases.js

@@ -1,226 +0,0 @@
-// Databases inside the sandbox: PostgreSQL, MariaDB (MySQL-compatible), MongoDB and Redis. Binaries live in
-// C:\AgentData\tools, data in C:\AgentData\databases (both persist), and every server listens on localhost only.
-// Which ones run was decided on the host (session.databases): only what the project needs.
-import fs from 'node:fs';
-import net from 'node:net';
-import path from 'node:path';
-import { spawn, spawnSync } from 'node:child_process';
-import { fetchJson, fetchText, githubAsset, installArchive } from '../../shared/download.js';
-import { SYSTEM } from '../../shared/system.js';
-import { ensureJdk } from './java.js';
-import { dataDir, dryRun, execAsync, exists, log, logsDir, mkdirp } from '../env.js';
-import { resolveCached, tool } from './common.js';
-const dataFor = (name) => path.join(dataDir, 'databases', name);
-export const portOpen = (port) => new Promise((resolve) => {
-    const socket = net.connect({ host: '127.0.0.1', port }, () => { socket.destroy(); resolve(true); });
-    socket.once('error', () => resolve(false));
-});
-const waitForPort = async (port, seconds) => {
-    for (const end = Date.now() + seconds * 1000; Date.now() < end;) {
-        if (await portOpen(port))
-            return true;
-        await new Promise((r) => setTimeout(r, 300));
-    }
-    return false;
-};
-/** Starts a server detached (it outlives the boot script) with its output in logs\<name>.log, and waits for its port. */
-const startServer = async (name, exe, args, port) => {
-    if (await portOpen(port))
-        throw new Error('port ' + port + ' is already in use (change databases.' + name + '.port)');
-    const logFile = path.join(logsDir, name + '.log');
-    const out = fs.openSync(logFile, 'a');
-    spawn(exe, args, { detached: true, stdio: ['ignore', out, out], windowsHide: true }).unref();
-    fs.closeSync(out);
-    if (!(await waitForPort(port, 60)))
-        throw new Error(name + ' did not start listening on port ' + port + '; see ' + logFile);
-};
-/** Lock files a sandbox that was closed without shutting the server down leaves behind (this VM never ran it). */
-const clearStaleLocks = (dir, files) => { for (const f of files)
-    fs.rmSync(path.join(dir, f), { force: true }); };
-const setupPostgres = async (env, plan) => {
-    const exact = await resolveCached('postgres:' + plan.version, async () => {
-        const versions = (await fetchJson('https://www.postgresql.org/versions.json')).filter((v) => v.supported);
-        const hit = plan.version === 'latest' ? versions.find((v) => v.current) ?? versions[versions.length - 1] : versions.find((v) => v.major === plan.version.split('.')[0]);
-        return hit ? hit.major + '.' + hit.latestMinor : Promise.reject(new Error('No supported PostgreSQL ' + plan.version));
-    });
-    const home = tool('postgres', exact);
-    const bin = path.join(home, 'bin');
-    if (!exists(path.join(bin, 'pg_ctl.exe'))) {
-        log('Downloading PostgreSQL ' + exact + ' (~330 MB once) ...');
-        // EDB publishes no checksums; the download is HTTPS from EnterpriseDB, PostgreSQL's official Windows packager.
-        await installArchive('https://get.enterprisedb.com/postgresql/postgresql-' + exact + '-1-windows-x64-binaries.zip', home, { locate: 'pg_ctl.exe', up: 1, fileName: 'postgresql-' + exact + '.zip', members: ['pgsql/bin', 'pgsql/lib', 'pgsql/share', 'pgsql/include'] });
-    }
-    const data = dataFor('postgres-' + exact.split('.')[0]);
-    if (!exists(path.join(data, 'PG_VERSION'))) {
-        log('Creating the PostgreSQL database cluster ...');
-        mkdirp(path.dirname(data));
-        await execAsync(path.join(bin, 'initdb.exe'), ['-D', data, '-U', 'postgres', '-A', 'trust', '-E', 'UTF8', '--locale=C'], { stdio: 'ignore' });
-    }
-    clearStaleLocks(data, ['postmaster.pid']);
-    // postgres.exe refuses to run as an administrator (the sandbox user is one); pg_ctl drops the rights first.
-    if (await portOpen(plan.port))
-        throw new Error('port ' + plan.port + ' is already in use (change databases.postgres.port)');
-    await execAsync(path.join(bin, 'pg_ctl.exe'), ['start', '-D', data, '-w', '-t', '60', '-l', path.join(logsDir, 'postgres.log'), '-o', '-p ' + plan.port + ' -c listen_addresses=localhost'], { stdio: 'ignore' });
-    Object.assign(env.vars, { PGHOST: 'localhost', PGPORT: String(plan.port), PGUSER: 'postgres' });
-    env.prepend.push(bin);
-    env.summary.push('postgres ' + exact + ': localhost:' + plan.port + ', user postgres, no password (postgres://postgres@localhost:' + plan.port + '/postgres)');
-};
-const MARIA = 'https://downloads.mariadb.org/rest-api/mariadb/';
-const setupMysql = async (env, plan) => {
-    const series = await resolveCached('mariadb:' + plan.version, async () => {
-        if (plan.version !== 'lts')
-            return plan.version;
-        const { major_releases: all } = await fetchJson(MARIA);
-        return all.find((r) => r.release_status === 'Stable' && r.release_support_type === 'Long Term Support')?.release_id ?? Promise.reject(new Error('No MariaDB LTS release found'));
-    });
-    const latest = async () => {
-        const { releases } = await fetchJson(MARIA + series + '/latest/');
-        const [version, release] = Object.entries(releases)[0] ?? [];
-        const zip = release?.files.find((f) => /-winx64\.zip$/.test(f.file_name));
-        return zip ? { version, zip } : Promise.reject(new Error('No MariaDB ' + series + ' zip for Windows'));
-    };
-    const version = await resolveCached('mariadb-version:' + series, async () => (await latest()).version);
-    const home = tool('mariadb', version);
-    const bin = path.join(home, 'bin');
-    if (!exists(path.join(bin, 'mariadbd.exe'))) {
-        const { zip } = await latest();
-        log('Downloading MariaDB ' + version + ' ...');
-        await installArchive(zip.file_download_url.replace(/^http:/, 'https:'), home, { sha256: zip.checksum?.sha256sum ?? null, locate: 'mariadbd.exe', up: 1, fileName: zip.file_name });
-    }
-    const data = dataFor('mariadb');
-    if (!exists(path.join(data, 'mysql'))) {
-        log('Creating the MariaDB data folder ...');
-        mkdirp(path.dirname(data));
-        await execAsync(path.join(bin, 'mariadb-install-db.exe'), ['--datadir=' + data, '--port=' + plan.port], { stdio: 'ignore' });
-    }
-    await startServer('mysql', path.join(bin, 'mariadbd.exe'), ['--datadir=' + data, '--port=' + plan.port, '--bind-address=127.0.0.1', '--console'], plan.port);
-    Object.assign(env.vars, { MYSQL_HOST: '127.0.0.1', MYSQL_TCP_PORT: String(plan.port) });
-    env.prepend.push(bin);
-    env.summary.push('mysql (MariaDB ' + version + '): 127.0.0.1:' + plan.port + ', user root, no password (mysql://root@127.0.0.1:' + plan.port + ')');
-};
-const setupMongo = async (env, plan) => {
-    const find = async () => {
-        const { versions } = await fetchJson('https://downloads.mongodb.org/full.json');
-        const prod = versions.filter((v) => v.production_release);
-        const hit = plan.version === 'latest' ? prod[0] : prod.find((v) => v.version === plan.version || v.version.startsWith(plan.version + '.'));
-        const archive = hit?.downloads.find((d) => d.target === 'windows' && d.arch === 'x86_64' && d.edition === 'base')?.archive;
-        return hit && archive ? { version: hit.version, archive } : Promise.reject(new Error('No MongoDB ' + plan.version + ' for Windows'));
-    };
-    const version = await resolveCached('mongodb:' + plan.version, async () => (await find()).version);
-    const home = tool('mongodb', version);
-    if (!exists(path.join(home, 'bin', 'mongod.exe'))) {
-        const { archive } = await find();
-        log('Downloading MongoDB ' + version + ' ...');
-        await installArchive(archive.url, home, { sha256: archive.sha256, locate: 'mongod.exe', up: 1 });
-    }
-    const shell = tool('mongosh');
-    if (!exists(path.join(shell, 'mongosh.exe'))) {
-        const asset = await githubAsset('mongodb-js/mongosh', /^mongosh-[\d.]+-win32-x64\.zip$/);
-        log('Downloading mongosh ...');
-        await installArchive(asset.url, shell, { sha256: asset.sha256, locate: 'mongosh.exe', fileName: asset.name });
-    }
-    const data = mkdirp(dataFor('mongodb'));
-    clearStaleLocks(data, ['mongod.lock']);
-    await startServer('mongodb', path.join(home, 'bin', 'mongod.exe'), ['--dbpath', data, '--bind_ip', '127.0.0.1', '--port', String(plan.port)], plan.port);
-    env.prepend.push(path.join(home, 'bin'), shell);
-    env.summary.push('mongodb ' + version + ': mongodb://127.0.0.1:' + plan.port + ' (mongosh on PATH)');
-};
-// ---- Redis -------------------------------------------------------------------------------------------------------
-const setupRedis = async (env, plan) => {
-    const home = tool('redis');
-    if (!exists(path.join(home, 'redis-server.exe'))) {
-        // Redis has no official Windows build; this is the maintained community build of upstream Redis (MSYS2).
-        const asset = await githubAsset('redis-windows/redis-windows', /^Redis-[\d.]+-Windows-x64-msys2\.zip$/);
-        log('Downloading ' + asset.name + ' ...');
-        await installArchive(asset.url, home, { sha256: asset.sha256, locate: 'redis-server.exe', fileName: asset.name });
-    }
-    const data = mkdirp(dataFor('redis'));
-    await startServer('redis', path.join(home, 'redis-server.exe'), ['--port', String(plan.port), '--bind', '127.0.0.1', '--dir', data.replace(/\\/g, '/'), '--appendonly', 'yes'], plan.port);
-    env.prepend.push(home);
-    env.summary.push('redis: redis://127.0.0.1:' + plan.port + ' (redis-cli on PATH)');
-};
-// ---- DynamoDB Local + dynamodb-admin -------------------------------------------------------------------------------
-const DYNAMO_ZIP = 'https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_latest.zip';
-/**
- * Amazon's DynamoDB Local (a Java program; the Java toolchain step runs first, else this installs the LTS JDK) and
- * dynamodb-admin, the web UI to browse and edit tables, installed with the runner's own npm. Every AWS SDK picks the
- * local endpoint up from AWS_ENDPOINT_URL_DYNAMODB, with dummy credentials (real ones never reach the sandbox).
- */
-const setupDynamo = async (env, plan) => {
-    const java = path.join(await ensureJdk(), 'bin', 'java.exe');
-    const home = tool('dynamodb-local');
-    if (!exists(path.join(home, 'DynamoDBLocal.jar'))) {
-        log('Downloading DynamoDB Local ...');
-        const sha256 = (await fetchText(DYNAMO_ZIP + '.sha256')).trim().split(/\s+/)[0];
-        await installArchive(DYNAMO_ZIP, home, { sha256, locate: 'DynamoDBLocal.jar', fileName: 'dynamodb_local.zip' });
-    }
-    const data = mkdirp(dataFor('dynamodb'));
-    // -sharedDb: one database whatever region/credentials a client uses, so the admin UI and the app see the same tables.
-    await startServer('dynamodb', java, ['-Djava.library.path=' + path.join(home, 'DynamoDBLocal_lib'), '-jar', path.join(home, 'DynamoDBLocal.jar'), '-sharedDb', '-dbPath', data, '-port', String(plan.port)], plan.port);
-    const endpoint = 'http://localhost:' + plan.port;
-    const aws = { AWS_ENDPOINT_URL_DYNAMODB: endpoint, DYNAMO_ENDPOINT: endpoint, AWS_ACCESS_KEY_ID: 'local', AWS_SECRET_ACCESS_KEY: 'local', AWS_REGION: 'us-east-1', AWS_DEFAULT_REGION: 'us-east-1' };
-    Object.assign(env.vars, aws);
-    env.summary.push('dynamodb (DynamoDB Local): ' + endpoint + ' (AWS SDKs use it automatically via AWS_ENDPOINT_URL_DYNAMODB; dummy credentials)');
-    if (!plan.adminPort)
-        return;
-    const prefix = tool('dynamodb-admin');
-    const script = path.join(prefix, 'node_modules', 'dynamodb-admin', 'dist', 'dynamodb-admin.js');
-    if (!exists(script)) {
-        log('Installing dynamodb-admin (web UI for DynamoDB) ...');
-        const npmCli = path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
-        await execAsync(process.execPath, [npmCli, 'install', '--global', '--prefix', prefix, 'dynamodb-admin', '--no-fund', '--no-audit'], { stdio: 'ignore' });
-    }
-    const admin = { ...process.env, ...aws, DYNAMO_ENDPOINT: endpoint };
-    // The database matters more than its UI: a taken port is reported, not fatal.
-    if (await portOpen(plan.adminPort)) {
-        env.summary.push('dynamodb-admin: NOT started, port ' + plan.adminPort + ' is in use (change databases.dynamodb.adminPort)');
-        return;
-    }
-    const out = fs.openSync(path.join(logsDir, 'dynamodb-admin.log'), 'a');
-    spawn(process.execPath, [script, '--port', String(plan.adminPort), '--dynamo-endpoint', endpoint, '--skip-default-credentials'], { detached: true, stdio: ['ignore', out, out], windowsHide: true, env: admin }).unref();
-    fs.closeSync(out);
-    if (!(await waitForPort(plan.adminPort, 30)))
-        throw new Error('dynamodb-admin did not start; see ' + path.join(logsDir, 'dynamodb-admin.log'));
-    env.summary.push('dynamodb-admin: http://localhost:' + plan.adminPort + ' (browse and edit tables in the sandbox\'s browser)');
-};
-const SETUP = { postgres: setupPostgres, mysql: setupMysql, mongodb: setupMongo, redis: setupRedis, dynamodb: setupDynamo };
-export const DATABASE_NAMES = { postgres: 'PostgreSQL', mysql: 'MySQL (MariaDB)', mongodb: 'MongoDB', redis: 'Redis', dynamodb: 'DynamoDB Local', sqlserver: 'SQL Server' };
-/** The process listening on a local TCP port (netstat: no PowerShell start-up cost), or null. */
-const listenerPid = (port) => {
-    const out = spawnSync(SYSTEM.netstat(), ['-ano', '-p', 'TCP'], { encoding: 'utf8', windowsHide: true }).stdout ?? '';
-    const hit = out.split(/\r?\n/).map((l) => /^\s*TCP\s+\S+:(\d+)\s+\S+\s+LISTENING\s+(\d+)/.exec(l)).find((m) => m && Number(m[1]) === port);
-    return hit ? Number(hit[2]) : null;
-};
-/** Stops a database (and DynamoDB's admin UI). PostgreSQL shuts down cleanly through pg_ctl; the others are ended. */
-export const stopDatabase = async (plan) => {
-    if (!(await portOpen(plan.port)))
-        return false;
-    if (plan.database === 'postgres' && exists(tool('postgres'))) {
-        for (const version of fs.readdirSync(tool('postgres'))) {
-            const data = dataFor('postgres-' + version.split('.')[0]);
-            const pgCtl = path.join(tool('postgres', version), 'bin', 'pg_ctl.exe');
-            if (exists(path.join(data, 'postmaster.pid')) && exists(pgCtl))
-                await execAsync(pgCtl, ['stop', '-D', data, '-m', 'fast', '-w'], { stdio: 'ignore' });
-        }
-    }
-    for (const port of [plan.port, plan.adminPort ?? 0]) {
-        const pid = port && listenerPid(port);
-        if (pid)
-            try {
-                process.kill(pid);
-            }
-            catch { /* already gone */ }
-    }
-    return true;
-};
-export const setupDatabase = async (env, plan) => {
-    if (plan.database === 'sqlserver') {
-        env.summary.push('sqlserver: NOT available (SQL Server cannot start inside Windows Sandbox). Use the one on the PC via hostAccess.forwards, or switch the project to Postgres/SQLite for local work');
-        return;
-    }
-    if (dryRun) {
-        log('(dry run) would run ' + DATABASE_NAMES[plan.database] + ' on port ' + plan.port + ' (' + plan.reasons.join('; ') + ')');
-        return;
-    }
-    await SETUP[plan.database](env, plan);
-};

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

@@ -1,10 +0,0 @@
-import type { Toolchains } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
-/** Variables vcvars64.bat would set for this tree (host x64, target x64). */
-export declare const vcvars: (root: string, msvc: string, sdk: string) => {
-    vars: Record<string, string>;
-    path: string[];
-};
-/** The vcvars environment of an installed tree (for steps that run before the agent's environment exists). */
-export declare const installedMsvcEnv: () => ReturnType<typeof vcvars> | null;
-export declare const setupMsvc: (env: ToolEnv, config: Toolchains["msvc"]) => Promise<void>;