windows-development-sandbox 1.4.1 → 1.5.0

package/dist/guest/toolchains/scripting/php.js

@@ -1,71 +0,0 @@
-// 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'];
-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];
-    if (!release || typeof build !== 'object' || !build.zip)
-        throw new Error('No PHP build for Windows matches "' + spec + '"');
-    return { version: release.version, ...build.zip };
-};
-/** php.ini from the development template with the common extensions switched on (written whole, then renamed). */
-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')
-        .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');
-    fs.writeFileSync(ini + '.tmp', text);
-    fs.renameSync(ini + '.tmp', ini);
-};
-/** Writes `<name>.cmd` into tools\shims (on PATH). */
-const shim = (env, name, command) => {
-    fs.writeFileSync(path.join(mkdirp(tool('shims')), name + '.cmd'), '@echo off\r\n' + command + ' %*\r\n');
-    env.prepend.push(tool('shims'));
-};
-const setupComposer = async (env, php) => {
-    const phar = tool('composer', 'composer.phar');
-    if (!exists(phar)) {
-        log('Downloading Composer (~3 MB once) ...');
-        const sha256 = (await fetchText(COMPOSER + '.sha256sum')).trim().split(/\s+/)[0];
-        await downloadFile(COMPOSER, phar, sha256);
-    }
-    const composerHome = tool('composer-home');
-    env.vars.COMPOSER_HOME = composerHome;
-    env.prepend.push(path.join(composerHome, 'vendor', 'bin'));
-    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) => {
-    const wantedSpec = versionFromFiles(['.php-version']) ?? { spec: config.version, source: 'config' };
-    if (dryRun) {
-        log('(dry run) would provision PHP ' + wantedSpec.spec + (config.composer ? ' + Composer' : ''));
-        return;
-    }
-    // No summary line of its own: the Visual C++ runtime step (which runs first) already reports it.
-    await setupVcRuntime(env, false);
-    const version = await resolveCached('php:' + wantedSpec.spec, async () => (await phpBuild(wantedSpec.spec)).version);
-    const home = tool('php', version);
-    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 });
-    }
-    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/scripting/ruby.d.ts

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

package/dist/guest/toolchains/scripting/ruby.js

@@ -1,47 +0,0 @@
-// Ruby from RubyInstaller. Gems live in persistent storage.
-import path from 'node:path';
-import { fetchJson, installArchive } from '../../../shared/download.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';
-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);
-/** RubyInstaller builds per Ruby version (newest build of each), from its GitHub releases. */
-const rubyBuilds = async () => {
-    const releases = await fetchJson('https://api.github.com/repos/oneclick/rubyinstaller2/releases?per_page=100');
-    const builds = new Map();
-    for (const asset of releases.filter((r) => !r.draft && !r.prerelease).flatMap((r) => r.assets)) {
-        const version = RUBY_ASSET.exec(asset.name)?.[1];
-        if (!version)
-            continue;
-        const known = builds.get(version);
-        if (!known || buildNumber(known) < buildNumber(asset))
-            builds.set(version, asset);
-    }
-    return builds;
-};
-const sha256Of = (asset) => (asset.digest?.startsWith('sha256:') ? asset.digest.slice(7) : null);
-export const setupRuby = async (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 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 });
-    }
-    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)');
-    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 } }));
-};

package/dist/guest/toolchains/scripting/vcruntime.d.ts

@@ -1,7 +0,0 @@
-import { type ToolEnv } from '../common.js';
-/**
- * A real installer (it writes to System32), so it runs on every boot; the installer itself is kept in persistent
- * storage and only run when Microsoft's signature on it checks out. Resolves true when this call ran the installer.
- * Only the "Visual C++ runtime" step reports it (`summary`); PHP calls it again just to be sure.
- */
-export declare const setupVcRuntime: (env: ToolEnv, summary?: boolean) => Promise<boolean>;

package/dist/guest/toolchains/scripting/vcruntime.js

@@ -1,45 +0,0 @@
-// The Visual C++ runtime (vcruntime140.dll & co.) that PHP and other native tools need.
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnAsync } from '../../../shared/download.js';
-import { SYSTEM } from '../../../shared/system.js';
-import { dryRun, execOutput, exists, log } from '../../env.js';
-import { downloadFile, tool } from '../common.js';
-const VC_REDIST = 'https://aka.ms/vs/17/release/vc_redist.x64.exe';
-const MICROSOFT_SIGNER = 'CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US';
-/** 1638: a newer version is already installed; 3010: installed, a restart would finish it (not needed for the DLLs). */
-const OK_EXIT_CODES = [0, 1638, 3010];
-/** The subject of a valid Authenticode signature, or '' when the file is unsigned or tampered with. */
-const signerOf = (file) => execOutput(SYSTEM.powershell(), ['-NoLogo', '-NoProfile', '-Command',
-    "$s = Get-AuthenticodeSignature -LiteralPath '" + file.replace(/'/g, "''") + "'; if ($s.Status -eq 'Valid') { $s.SignerCertificate.Subject }"]).trim();
-/**
- * A real installer (it writes to System32), so it runs on every boot; the installer itself is kept in persistent
- * storage and only run when Microsoft's signature on it checks out. Resolves true when this call ran the installer.
- * Only the "Visual C++ runtime" step reports it (`summary`); PHP calls it again just to be sure.
- */
-export const setupVcRuntime = async (env, summary = true) => {
-    if (dryRun) {
-        log('(dry run) would install the Visual C++ runtime');
-        return false;
-    }
-    const system32 = path.join(process.env.WINDIR ?? 'C:\\Windows', 'System32');
-    const missing = !exists(path.join(system32, 'vcruntime140.dll')) || !exists(path.join(system32, 'msvcp140.dll'));
-    if (missing) {
-        const installer = tool('vcredist', 'vc_redist.x64.exe');
-        if (!exists(installer)) {
-            log('Downloading the Visual C++ runtime (~25 MB once) ...');
-            await downloadFile(VC_REDIST, installer);
-        }
-        if (signerOf(installer) !== MICROSOFT_SIGNER) {
-            fs.rmSync(installer, { force: true });
-            throw new Error('vc_redist.x64.exe is not signed by Microsoft; deleted it (it is downloaded again next boot)');
-        }
-        log('Installing the Visual C++ runtime ...');
-        const code = await spawnAsync(installer, ['/install', '/quiet', '/norestart']);
-        if (!OK_EXIT_CODES.includes(code ?? -1) || !exists(path.join(system32, 'vcruntime140.dll')))
-            throw new Error('the Visual C++ runtime installer failed (exit ' + code + ')');
-    }
-    if (summary)
-        env.summary.push('vc++ runtime: installed');
-    return missing;
-};

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

@@ -1,47 +0,0 @@
-export interface NodeRelease {
-    version: string;
-    lts: string | false;
-}
-/** Turns an .nvmrc-style spec (20, v20.11.1, lts/*, lts/iron, node, latest) into an exact version like 20.11.1. */
-export declare const pickNodeVersion: (releases: NodeRelease[], spec: string) => string | null;
-/**
- * Which of this PC's nvm versions to copy along with `current`: at most `max` in total, current included, the rest
- * spread across the range (newest of each major first, then evenly spaced from oldest to newest).
- */
-export declare const pickSpreadVersions: (available: string[], current: string, max: number) => string[];
-/** Newest stable version matching a prefix spec ("3" -> 3.13.1, "3.12" -> 3.12.10). */
-export declare const pickPackageVersion: (all: string[], spec: string) => string | null;
-/** Version spec from a version file's text (.ruby-version "ruby-3.3.1", .java-version "temurin-21", ...): its first x[.y[.z]]. */
-export declare const specFromVersionFile: (text: string) => string | null;
-/** Java major version from .java-version ("21", "17.0.9", "1.8", "temurin-21") or .sdkmanrc ("java=21.0.2-tem"). */
-export declare const javaMajorFrom: (text: string, sdkmanrc?: boolean) => string | null;
-export interface GoRelease {
-    version: string;
-    stable: boolean;
-    files: {
-        filename: string;
-        os: string;
-        arch: string;
-        kind: string;
-        sha256: string;
-    }[];
-}
-/** "stable" / "latest" -> newest stable release; "1.23" -> newest 1.23.x; "1.23.2" -> exactly that. Returns go.dev's entry. */
-export declare const pickGoRelease: (releases: GoRelease[], spec: string) => GoRelease | null;
-/**
- * Does the project use a language? `entries` are file names in the workspace root and one folder down ("api/go.mod");
- * markers are exact names or "*.ext".
- */
-export declare const projectUses: (entries: readonly string[], markers: readonly string[]) => boolean;
-/** Newest MSVC tools version among VS manifest package ids ("microsoft.vc.14.44.17.14.tools.hostx64.targetx64.base"). */
-export declare const pickMsvcVersion: (packageIds: string[], spec?: string) => string | null;
-/** Newest Windows SDK build among component ids ("microsoft.visualstudio.component.windows11sdk.26100"). */
-export declare const pickWindowsSdk: (packageIds: string[], spec?: string) => {
-    build: string;
-    componentId: string;
-} | null;
-/** The .cab files an SDK .msi refers to (their names are inside the msi as plain "<32 hex>.cab"). */
-export declare const msiCabs: (msi: Buffer) => string[];
-/** The oldest CMake many projects (OpenMoHAA among them) accept. */
-export declare const CMAKE_FLOOR = "3.25";
-export declare const cmakeTooOld: (version: string) => boolean;

package/dist/guest/toolchains/versions.js

@@ -1,77 +0,0 @@
-// Version picking for the toolchains. Pure functions only (no environment, no I/O), so the host and the tests can
-// import them without loading the guest runtime.
-/** Turns an .nvmrc-style spec (20, v20.11.1, lts/*, lts/iron, node, latest) into an exact version like 20.11.1. */
-export const pickNodeVersion = (releases, spec) => {
-    const s = spec.trim().toLowerCase().replace(/^v/, '');
-    const hit = ['node', 'latest', 'current', 'stable'].includes(s) ? releases[0]
-        : s === 'lts' || s === 'lts/*' ? releases.find((r) => r.lts)
-            : s.startsWith('lts/') ? releases.find((r) => typeof r.lts === 'string' && r.lts.toLowerCase() === s.slice(4))
-                : releases.find((r) => r.version === 'v' + s || r.version.startsWith('v' + s + '.'));
-    return hit ? hit.version.slice(1) : null;
-};
-/**
- * Which of this PC's nvm versions to copy along with `current`: at most `max` in total, current included, the rest
- * spread across the range (newest of each major first, then evenly spaced from oldest to newest).
- */
-export const pickSpreadVersions = (available, current, max) => {
-    const byVersion = (a, b) => a.localeCompare(b, undefined, { numeric: true });
-    const exact = available.filter((v) => /^\d+\.\d+\.\d+$/.test(v) && v !== current).sort(byVersion);
-    const newestPerMajor = exact.filter((v, i) => exact[i + 1]?.split('.')[0] !== v.split('.')[0]);
-    const pool = newestPerMajor.filter((v) => v.split('.')[0] !== current.split('.')[0]);
-    const want = Math.max(0, max - 1);
-    const picked = want >= pool.length ? pool
-        : want === 1 ? [pool[pool.length - 1]]
-            : Array.from({ length: want }, (_, i) => pool[Math.round(i * (pool.length - 1) / (want - 1))]);
-    return [current, ...picked];
-};
-/** Newest stable version matching a prefix spec ("3" -> 3.13.1, "3.12" -> 3.12.10). */
-export const pickPackageVersion = (all, spec) => {
-    const s = spec.trim().replace(/^python-?/i, '');
-    const stable = all.filter((v) => /^\d+(\.\d+)*$/.test(v)).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
-    return stable.find((v) => v === s || v.startsWith(s + '.')) ?? null;
-};
-/** Version spec from a version file's text (.ruby-version "ruby-3.3.1", .java-version "temurin-21", ...): its first x[.y[.z]]. */
-export const specFromVersionFile = (text) => /(\d+(?:\.\d+){0,2})/.exec(text.split(/\r?\n/).map((l) => l.replace(/#.*$/, '').trim()).find(Boolean) ?? '')?.[1] ?? null;
-/** Java major version from .java-version ("21", "17.0.9", "1.8", "temurin-21") or .sdkmanrc ("java=21.0.2-tem"). */
-export const javaMajorFrom = (text, sdkmanrc = false) => {
-    const line = sdkmanrc ? /^\s*java\s*=\s*(.+)$/m.exec(text)?.[1] : text;
-    const spec = line ? specFromVersionFile(line) : null;
-    if (!spec)
-        return null;
-    const [major, minor] = spec.split('.');
-    return major === '1' && minor ? minor : major;
-};
-/** "stable" / "latest" -> newest stable release; "1.23" -> newest 1.23.x; "1.23.2" -> exactly that. Returns go.dev's entry. */
-export const pickGoRelease = (releases, spec) => {
-    const s = spec.trim().toLowerCase().replace(/^go/, '');
-    const stable = releases.filter((r) => r.stable);
-    if (s === 'stable' || s === 'latest')
-        return stable[0] ?? null;
-    return stable.find((r) => r.version === 'go' + s || r.version.startsWith('go' + s + '.')) ?? null;
-};
-/**
- * Does the project use a language? `entries` are file names in the workspace root and one folder down ("api/go.mod");
- * markers are exact names or "*.ext".
- */
-export const projectUses = (entries, markers) => entries.some((entry) => {
-    const name = entry.split(/[\/]/).pop().toLowerCase();
-    return markers.some((m) => (m.startsWith('*.') ? name.endsWith(m.slice(1).toLowerCase()) : name === m.toLowerCase()));
-});
-/** Newest MSVC tools version among VS manifest package ids ("microsoft.vc.14.44.17.14.tools.hostx64.targetx64.base"). */
-export const pickMsvcVersion = (packageIds, spec = 'latest') => {
-    const versions = packageIds.map((id) => /^microsoft\.vc\.(\d+\.\d+\.\d+\.\d+)\.tools\.hostx64\.targetx64\.base$/i.exec(id)?.[1]).filter((v) => Boolean(v));
-    const sorted = [...new Set(versions)].sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
-    return (spec === 'latest' ? sorted[0] : sorted.find((v) => v === spec || v.startsWith(spec + '.'))) ?? null;
-};
-/** Newest Windows SDK build among component ids ("microsoft.visualstudio.component.windows11sdk.26100"). */
-export const pickWindowsSdk = (packageIds, spec = 'latest') => {
-    const found = packageIds.map((id) => ({ id, build: /^microsoft\.visualstudio\.component\.windows1[01]sdk\.(\d+)$/i.exec(id)?.[1] })).filter((x) => Boolean(x.build));
-    const sorted = found.sort((a, b) => Number(b.build) - Number(a.build));
-    const hit = spec === 'latest' ? sorted[0] : sorted.find((x) => x.build === spec.replace(/^10\.0\./, '').split('.')[0]);
-    return hit ? { build: hit.build, componentId: hit.id } : null;
-};
-/** The .cab files an SDK .msi refers to (their names are inside the msi as plain "<32 hex>.cab"). */
-export const msiCabs = (msi) => [...new Set([...msi.toString('latin1').matchAll(/([0-9a-f]{32}\.cab)/gi)].map((m) => m[1].toLowerCase()))];
-/** The oldest CMake many projects (OpenMoHAA among them) accept. */
-export const CMAKE_FLOOR = '3.25';
-export const cmakeTooOld = (version) => /^\d+\.\d+/.test(version) && version.localeCompare(CMAKE_FLOOR, undefined, { numeric: true }) < 0;

package/dist/guest/toolchains/vscode-profile.d.ts

@@ -1,30 +0,0 @@
-/** Where the sandbox's tools are (absent = not installed). */
-export interface ToolPaths {
-    javaHome?: string;
-    python?: string;
-    goRoot?: string;
-    go?: string;
-    gcc?: string;
-    cl?: string;
-    cmake?: string;
-    dotnet?: string;
-    node?: string;
-    pwsh?: string;
-    git?: string;
-    bash?: string;
-    php?: string;
-    ruby?: string;
-    deno?: string;
-}
-/** User settings for the sandbox's VS Code. Only keys with a value are set; the caller removes the ones it set before. */
-export declare const vscodeSettings: (p: ToolPaths) => Record<string, unknown>;
-export declare const EXTENSION_ID: RegExp;
-/** The extensions to have: always EditorConfig, then per toolchain and database in use, the project's, and yours. */
-export declare const vscodeExtensions: (o: {
-    toolchains: string[];
-    databases: string[];
-    recommended: string[];
-    extra: string[];
-}) => string[];
-/** Extensions not installed yet, from the names of the folders in VS Code's extensions folder (publisher.name-1.2.3). */
-export declare const missingExtensions: (wanted: string[], folders: string[]) => string[];

package/dist/guest/toolchains/vscode-profile.js

@@ -1,69 +0,0 @@
-// What VS Code is told about the sandbox: the settings that point it at the sandbox's own tools, and the extensions
-// for the languages in use. Pure (tested); vscode.ts finds the paths and writes them.
-/** The JDK's major version from its folder name (jdk-21.0.5+11 -> 21). */
-const javaMajor = (home) => /(?:jdk|jre)?-?(\d{1,2})(?:[.+_-]|$)/i.exec(home.split(/[\\/]/).pop() ?? '')?.[1];
-/** User settings for the sandbox's VS Code. Only keys with a value are set; the caller removes the ones it set before. */
-export const vscodeSettings = (p) => {
-    const profiles = {};
-    if (p.pwsh)
-        profiles['PowerShell 7'] = { path: p.pwsh, args: ['-NoLogo'] };
-    if (p.bash)
-        profiles['Git Bash'] = { path: p.bash, args: ['--login', '-i'] };
-    const settings = {
-        'telemetry.telemetryLevel': 'off',
-        'update.mode': 'none',
-        'workbench.startupEditor': 'none',
-        'git.path': p.git,
-        'terminal.integrated.profiles.windows': Object.keys(profiles).length ? profiles : undefined,
-        'terminal.integrated.defaultProfile.windows': p.pwsh ? 'PowerShell 7' : undefined,
-        'python.defaultInterpreterPath': p.python,
-        'java.jdt.ls.java.home': p.javaHome,
-        'java.configuration.runtimes': p.javaHome ? [{ name: 'JavaSE-' + (javaMajor(p.javaHome) ?? '21'), path: p.javaHome, default: true }] : undefined,
-        'maven.terminal.useJavaHome': p.javaHome ? true : undefined,
-        'go.goroot': p.goRoot,
-        'go.alternateTools': p.go ? { go: p.go } : undefined,
-        'C_Cpp.default.compilerPath': p.cl ?? p.gcc,
-        'cmake.cmakePath': p.cmake,
-        'dotnet.dotnetPath': p.dotnet ? p.dotnet.replace(/[\\/]dotnet\.exe$/i, '') : undefined,
-        'dotnetAcquisitionExtension.existingDotnetPath': p.dotnet ? [{ extensionId: 'ms-dotnettools.csharp', path: p.dotnet }] : undefined,
-        'php.validate.executablePath': p.php,
-        'php.debug.executablePath': p.php,
-        'rubyLsp.rubyVersionManager': p.ruby ? { identifier: 'none' } : undefined,
-        'deno.path': p.deno,
-        'powershell.powerShellAdditionalExePaths': p.pwsh ? { 'PowerShell 7 (sandbox)': p.pwsh } : undefined,
-        'npm.packageManager': 'auto',
-    };
-    return Object.fromEntries(Object.entries(settings).filter(([, v]) => v !== undefined));
-};
-/** Extensions per toolchain (Marketplace ids). */
-const BY_TOOLCHAIN = {
-    node: ['dbaeumer.vscode-eslint', 'esbenp.prettier-vscode'],
-    python: ['ms-python.python', 'ms-python.debugpy'],
-    java: ['redhat.java', 'vscjava.vscode-java-debug', 'vscjava.vscode-java-test', 'vscjava.vscode-maven', 'vscjava.vscode-gradle'],
-    go: ['golang.go'],
-    rust: ['rust-lang.rust-analyzer', 'vadimcn.vscode-lldb'],
-    cpp: ['ms-vscode.cpptools', 'ms-vscode.cmake-tools'],
-    msvc: ['ms-vscode.cpptools', 'ms-vscode.cmake-tools'],
-    dotnet: ['ms-dotnettools.csharp'],
-    ruby: ['shopify.ruby-lsp'],
-    php: ['bmewburn.vscode-intelephense-client', 'xdebug.php-debug'],
-    deno: ['denoland.vscode-deno'],
-    pwsh: ['ms-vscode.powershell'],
-};
-const BY_DATABASE = {
-    postgres: ['mtxr.sqltools', 'mtxr.sqltools-driver-pg'],
-    mysql: ['mtxr.sqltools', 'mtxr.sqltools-driver-mysql'],
-    mongodb: ['mongodb.mongodb-vscode'],
-    redis: ['redis.redis-for-vscode'],
-};
-export const EXTENSION_ID = /^[\w-]+\.[\w-]+$/;
-/** The extensions to have: always EditorConfig, then per toolchain and database in use, the project's, and yours. */
-export const vscodeExtensions = (o) => {
-    const all = ['editorconfig.editorconfig', ...o.toolchains.flatMap((t) => BY_TOOLCHAIN[t] ?? []), ...o.databases.flatMap((d) => BY_DATABASE[d] ?? []), ...o.recommended, ...o.extra];
-    return [...new Set(all.map((e) => e.toLowerCase()))].filter((e) => EXTENSION_ID.test(e));
-};
-/** Extensions not installed yet, from the names of the folders in VS Code's extensions folder (publisher.name-1.2.3). */
-export const missingExtensions = (wanted, folders) => {
-    const have = folders.map((f) => f.toLowerCase());
-    return wanted.filter((id) => !have.some((f) => f.startsWith(id + '-')));
-};

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

@@ -1,19 +0,0 @@
-import type { Toolchains } from '../../core/types.js';
-import { type ToolEnv } from './common.js';
-/**
- * After every toolchain is installed: points VS Code at the sandbox's own JDK, Python, Go, compilers, .NET, Git and
- * terminals (user settings; only the keys this tool manages are changed, your own stay), and installs the extensions
- * for the languages in use in the background (they persist, so only new ones are downloaded).
- */
-export declare const configureVscode: (tools: {
-    vars: Record<string, string>;
-    prepend: string[];
-    append: string[];
-    summary: string[];
-}, o: {
-    toolchains: string[];
-    databases: string[];
-    config: Toolchains["vscode"];
-    workspace: string;
-}) => void;
-export declare const setupVscode: (env: ToolEnv, refresh: boolean) => Promise<void>;

package/dist/guest/toolchains/vscode.js

@@ -1,139 +0,0 @@
-// VS Code for debugging inside the sandbox: the portable zip build, checksum-verified. A `data` folder next to Code.exe
-// switches it to portable mode, so settings and extensions live in C:\AgentData\tools\vscode\data and persist.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { applyEdits, modify, parse as parseJsonc } from 'jsonc-parser';
-import { fetchJson, installArchive } from '../../shared/download.js';
-import { SYSTEM } from '../../shared/system.js';
-import { dryRun, exists, isWin, log, logsDir, mkdirp, powershell } from '../env.js';
-import { arch, tool } from './common.js';
-import { EXTENSION_ID, missingExtensions, vscodeExtensions, vscodeSettings } from './vscode-profile.js';
-/** Newer builds keep their files under a commit-hash folder, so the installed version is recorded here. */
-const VERSION_MARKER = '.agent-sandbox-version';
-const desktopShortcut = (exe) => {
-    if (!isWin)
-        return;
-    const link = path.join(os.homedir(), 'Desktop', 'Visual Studio Code.lnk');
-    const q = (s) => "'" + s.replace(/'/g, "''") + "'";
-    powershell('$s = (New-Object -ComObject WScript.Shell).CreateShortcut(' + q(link) + '); $s.TargetPath = ' + q(exe) + '; $s.Arguments = ' + q('"' + (process.env.AGENT_WORKSPACE ?? '') + '"') + '; $s.Save()');
-};
-/** The first of `names` in one of `dirs`. */
-const findIn = (dirs, ...names) => {
-    for (const dir of dirs)
-        for (const name of names) {
-            const file = path.join(dir, name);
-            if (exists(file))
-                return file;
-        }
-    return undefined;
-};
-/** The project's .vscode/extensions.json recommendations (bounded; anything odd is ignored). */
-const recommendedBy = (workspace) => {
-    const file = path.join(workspace, '.vscode', 'extensions.json');
-    try {
-        if (!exists(file) || fs.statSync(file).size > 64 * 1024)
-            return [];
-        const data = parseJsonc(fs.readFileSync(file, 'utf8'));
-        return Array.isArray(data?.recommendations) ? data.recommendations.filter((r) => typeof r === 'string' && EXTENSION_ID.test(r)).slice(0, 50) : [];
-    }
-    catch {
-        return [];
-    }
-};
-/**
- * After every toolchain is installed: points VS Code at the sandbox's own JDK, Python, Go, compilers, .NET, Git and
- * terminals (user settings; only the keys this tool manages are changed, your own stay), and installs the extensions
- * for the languages in use in the background (they persist, so only new ones are downloaded).
- */
-export const configureVscode = (tools, o) => {
-    const root = tool('vscode');
-    const code = path.join(root, 'bin', 'code.cmd');
-    if (dryRun) {
-        log('(dry run) would set up VS Code for: ' + o.toolchains.join(', '));
-        return;
-    }
-    if (!exists(path.join(root, 'Code.exe')))
-        return;
-    const dirs = [...tools.prepend, ...tools.append];
-    const git = findIn([tool('git', 'cmd'), ...dirs], 'git.exe');
-    const settings = vscodeSettings({
-        javaHome: tools.vars.JAVA_HOME, goRoot: tools.vars.GOROOT, go: findIn(dirs, 'go.exe'), python: findIn(dirs, 'python.exe'), gcc: findIn(dirs, 'gcc.exe'), cl: findIn(dirs, 'cl.exe'),
-        cmake: findIn(dirs, 'cmake.exe'), dotnet: findIn(dirs, 'dotnet.exe'), node: findIn(dirs, 'node.exe'), pwsh: findIn(dirs, 'pwsh.exe'), git,
-        bash: git ? findIn([path.join(path.dirname(path.dirname(git)), 'bin')], 'bash.exe') : undefined, php: findIn(dirs, 'php.exe'), ruby: findIn(dirs, 'ruby.exe'), deno: findIn(dirs, 'deno.exe'),
-    });
-    writeManagedSettings(path.join(root, 'data', 'user-data', 'User', 'settings.json'), path.join(root, 'data', '.agent-sandbox-managed.json'), settings);
-    const wanted = vscodeExtensions({ toolchains: o.toolchains, databases: o.databases, recommended: o.config.recommended ? recommendedBy(o.workspace) : [], extra: o.config.extensions });
-    let folders = [];
-    try {
-        folders = fs.readdirSync(path.join(root, 'data', 'extensions'));
-    }
-    catch { /* none yet */ }
-    const missing = missingExtensions(wanted, folders);
-    tools.summary.push('vscode: set up for ' + (o.toolchains.join(', ') || 'Node') + (missing.length ? '; installing ' + missing.length + ' extension(s) in the background' : '; extensions ready'));
-    if (!missing.length)
-        return;
-    // In the background: the Marketplace can take a minute, and nothing else waits for it.
-    const logFile = fs.openSync(path.join(logsDir, 'vscode-extensions.log'), 'a');
-    spawn(SYSTEM.cmd(), ['/d', '/c', code, ...missing.flatMap((id) => ['--install-extension', id])], { detached: true, stdio: ['ignore', logFile, logFile], windowsHide: true }).unref();
-    fs.closeSync(logFile);
-};
-/**
- * Sets `values` in a settings file, keeping everything else (comments too), and removes keys this tool set last time
- * but no longer has a value for (a toolchain turned off). The keys it manages are remembered in `managedFile`.
- */
-const writeManagedSettings = (file, managedFile, values) => {
-    let text = exists(file) ? fs.readFileSync(file, 'utf8') : '{}';
-    let before = [];
-    try {
-        before = JSON.parse(fs.readFileSync(managedFile, 'utf8'));
-    }
-    catch { /* first time */ }
-    const format = { formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' } };
-    for (const key of before.filter((k) => !(k in values))) {
-        if (parseJsonc(text)?.[key] !== undefined)
-            text = applyEdits(text, modify(text, [key], undefined, format));
-    }
-    for (const [key, value] of Object.entries(values))
-        text = applyEdits(text, modify(text, [key], value, format));
-    mkdirp(path.dirname(file));
-    fs.writeFileSync(file, text);
-    fs.writeFileSync(managedFile, JSON.stringify(Object.keys(values)));
-};
-export const setupVscode = async (env, refresh) => {
-    const root = tool('vscode');
-    const exe = path.join(root, 'Code.exe');
-    if (dryRun) {
-        log('(dry run) would provision VS Code');
-        return;
-    }
-    if (!exists(exe) || refresh) {
-        const release = await fetchJson('https://update.code.visualstudio.com/api/update/win32-' + (arch === 'arm64' ? 'arm64' : 'x64') + '-archive/stable/latest');
-        log('Downloading VS Code ' + release.productVersion + ' (~150 MB once) ...');
-        // Keep settings/extensions across a refresh: move the portable data folder aside and back, also when the install
-        // fails (finally). A folder still parked from an interrupted earlier run is the one to keep.
-        const keep = path.join(root, 'data');
-        const parked = root + '-data';
-        if (exists(keep)) {
-            fs.rmSync(parked, { recursive: true, force: true });
-            fs.renameSync(keep, parked);
-        }
-        try {
-            await installArchive(release.url, root, { sha256: release.sha256hash, locate: 'Code.exe', fileName: 'vscode.zip' });
-            fs.writeFileSync(path.join(root, VERSION_MARKER), release.productVersion);
-        }
-        finally {
-            if (exists(parked)) {
-                mkdirp(root);
-                fs.rmSync(keep, { recursive: true, force: true });
-                fs.renameSync(parked, keep);
-            }
-        }
-    }
-    mkdirp(path.join(root, 'data'));
-    env.prepend.push(path.join(root, 'bin'));
-    desktopShortcut(exe);
-    const version = exists(path.join(root, VERSION_MARKER)) ? fs.readFileSync(path.join(root, VERSION_MARKER), 'utf8').trim() : 'installed';
-    env.summary.push('vscode: ' + version + ' (portable; run code . or use the desktop shortcut)');
-};

package/dist/guest/view.d.ts

@@ -1 +0,0 @@
-export declare const viewSession: (id: string) => Promise<number>;

package/dist/guest/view.js

@@ -1,42 +0,0 @@
-// A terminal tab inside the sandbox that shows one agent session (same pseudo console the host can attach to).
-// Usage: node view.js <sessionId>
-import { connect, runTerminalClient } from '../shared/pty-client.js';
-import { readSession } from '../shared/rundir.js';
-import { dataDir } from './env.js';
-/** A session that is still being set up (its project provisioning, its agent installing): show the progress until it runs. */
-const waitUntilStarted = async (id) => {
-    let last = '';
-    for (let i = 0; i < 3600; i++) {
-        const s = readSession(dataDir, id);
-        if (s && s.phase !== 'starting')
-            return s;
-        if (s && s.message !== last) {
-            console.log('  ' + s.message);
-            last = s.message;
-        }
-        await new Promise((r) => setTimeout(r, 500));
-    }
-    return readSession(dataDir, id);
-};
-export const viewSession = async (id) => {
-    const session = await waitUntilStarted(id);
-    if (session?.phase === 'failed') {
-        console.error('Session ' + id + ' could not start: ' + session.message);
-        await new Promise((r) => setTimeout(r, 30000));
-        return 1;
-    }
-    if (!session?.attach) {
-        console.error('Session ' + id + ' is not running.');
-        return 1;
-    }
-    const socket = await connect({ ...session.attach, addresses: ['127.0.0.1'] });
-    const result = await runTerminalClient(socket, session.attach.token);
-    if (result.reason === 'exit')
-        console.log(session.harness + ' exited with code ' + result.exitCode + '.');
-    else if (result.reason === 'error')
-        console.log('Session error: ' + result.message);
-    return result.reason === 'exit' ? result.exitCode : 1;
-};
-if (process.argv[1]?.endsWith('view.js') && process.argv[2]) {
-    viewSession(process.argv[2]).then((code) => { process.exitCode = code; }, (e) => { console.error(e instanceof Error ? e.message : String(e)); process.exitCode = 1; });
-}