windows-development-sandbox 1.17.0 → 1.18.0

package/dist/guest/toolchains/persisted.js

@@ -0,0 +1,159 @@
+// Large installs kept between sandboxes in C:\AgentData\tools (engines, editors, SDKs: 1-60 GB each). One version is
+// a folder tools\<name>\<version>; it counts as installed only with its .complete.json and its marker file. A new one
+// is checked for room first, built in a staging folder next to it (with TEMP inside it: moving from the sandbox's own
+// disk into a mapped folder fails silently) and moved into place when done. Every install's size and last use go in
+// tools\installs.json, so `sandbox data` shows them without walking 60 GB, and versions beyond keepVersions go (the
+// least recently used first). No runtime imports: the self-test loads this file with its own folders.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { readValid, writeJsonAtomic } from '../../shared/io/json.js';
+import { safeRemove } from '../../shared/io/safe-remove.js';
+import { dataDir } from '../runtime/paths.js';
+import { INSTALL_RECORDS_FILE, InstallRecordsSchema } from '../../shared/installs.js';
+const GB = 1024 ** 3;
+/** What stays free on the sandbox's own disk after a real installer: the paging file and every build need it. */
+export const LOCAL_RESERVE_BYTES = 13 * GB;
+const MARKER = '.complete.json';
+const MAX_WALK = 2_000_000;
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+export { InstallRecordsSchema } from '../../shared/installs.js';
+const toolsOf = (deps) => deps.toolsDir ?? path.join(dataDir, 'tools');
+const recordsFile = (deps) => path.join(toolsOf(deps), INSTALL_RECORDS_FILE);
+function checkSpec(spec) {
+    const parts = spec.name.split('/');
+    if (parts.length > 2 || !parts.every((p) => NAME.test(p)) || !NAME.test(spec.version))
+        throw new Error('not a usable install name: ' + spec.name + ' ' + spec.version);
+}
+/** Free bytes for this user on the disk holding `dir` (0 when it cannot be told). */
+export function freeBytes(dir, deps = {}) {
+    try {
+        const s = (deps.statfs ?? fs.statfsSync)(dir);
+        return s.bavail * s.bsize;
+    }
+    catch {
+        return 0;
+    }
+}
+const gb = (bytes) => (bytes / GB).toFixed(1) + ' GB';
+/** Throws (with the fix) when the disk holding `dir` has less than `needBytes` free. */
+export function assertRoom(dir, needBytes, what, fix, deps = {}) {
+    const free = freeBytes(dir, deps);
+    if (free < needBytes)
+        throw new Error('not installing ' + what + ': ' + gb(free) + ' free where it goes, it needs ' + gb(needBytes) + '. ' + fix);
+}
+/** A real installer on the sandbox's own disk (C:): its size plus 13 GB must stay free (paging file, builds). */
+export function assertLocalRoom(needBytes, what, deps = {}) {
+    const drive = deps.localDir ?? (process.env.SystemDrive ?? 'C:') + '\\';
+    assertRoom(drive, needBytes + LOCAL_RESERVE_BYTES, what, "The sandbox's own disk also holds the paging file and every build: give the sandbox less to install, or a smaller sandbox.pageFileMb.", deps);
+}
+export function installRecords(deps = {}) {
+    return readValid(InstallRecordsSchema, recordsFile(deps))?.installs ?? [];
+}
+function writeRecords(records, deps) {
+    fs.mkdirSync(toolsOf(deps), { recursive: true });
+    writeJsonAtomic(recordsFile(deps), { installs: [...records] });
+}
+/** Notes that a version was used now (it is kept over ones used longer ago). */
+export function recordUse(name, version, deps = {}) {
+    const now = new Date().toISOString();
+    const all = installRecords(deps);
+    const known = all.find((r) => r.name === name && r.version === version);
+    writeRecords(known
+        ? all.map((r) => (r === known ? { ...r, usedAt: now } : r))
+        : [...all, { name, version, sizeBytes: null, installedAt: now, usedAt: now }], deps);
+}
+/** The bytes under a folder (links not followed), or null when there are too many files to count. */
+function folderSize(dir) {
+    let total = 0;
+    let seen = 0;
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (++seen > MAX_WALK)
+                return null;
+            const full = path.join(current, e.name);
+            if (e.isDirectory())
+                stack.push(full);
+            else if (e.isFile())
+                try {
+                    total += fs.statSync(full).size;
+                }
+                catch {
+                    // Gone while counting: not counted.
+                }
+        }
+    }
+    return total;
+}
+function complete(dir, marker) {
+    return fs.existsSync(path.join(dir, MARKER)) && fs.existsSync(path.join(dir, marker));
+}
+/** Removes versions of a tool beyond `keep` (the least recently used first), never `current`. */
+function prune(spec, deps) {
+    if (!spec.keepVersions)
+        return;
+    const root = path.join(toolsOf(deps), ...spec.name.split('/'));
+    const mine = installRecords(deps)
+        .filter((r) => r.name === spec.name && r.version !== spec.version)
+        .sort((a, b) => b.usedAt.localeCompare(a.usedAt));
+    const gone = mine.slice(Math.max(0, spec.keepVersions - 1));
+    for (const r of gone) {
+        if (!NAME.test(r.version))
+            continue;
+        safeRemove(path.join(root, r.version), root);
+        deps.log?.('Removed ' + spec.name + ' ' + r.version + ' (keepVersions ' + spec.keepVersions + ')');
+    }
+    const isGone = (r) => r.name === spec.name && gone.some((g) => g.version === r.version);
+    if (gone.length)
+        writeRecords(installRecords(deps).filter((r) => !isGone(r)), deps);
+}
+/**
+ * The version's folder, installed by `install(staging, temp)` when it is not there yet. The installer puts the
+ * version's files in `staging` and its temporary files in `temp` (inside staging); a failed install leaves nothing.
+ */
+export async function ensurePersisted(spec, install, deps = {}) {
+    checkSpec(spec);
+    const root = path.join(toolsOf(deps), ...spec.name.split('/'));
+    const dir = path.join(root, spec.version);
+    if (complete(dir, spec.marker)) {
+        recordUse(spec.name, spec.version, deps);
+        const known = installRecords(deps).find((r) => r.name === spec.name && r.version === spec.version);
+        return { dir, fresh: false, sizeBytes: known?.sizeBytes ?? null };
+    }
+    fs.mkdirSync(root, { recursive: true });
+    assertRoom(root, spec.needBytes, spec.what, 'Free room on that disk (with contained storage: raise storage.containedMaxGb), or keep fewer versions.', deps);
+    const staging = path.join(root, '.staging-' + spec.version + '-' + crypto.randomBytes(3).toString('hex'));
+    const temp = path.join(staging, '.temp');
+    fs.mkdirSync(temp, { recursive: true });
+    try {
+        await install(staging, temp);
+        if (!fs.existsSync(path.join(staging, spec.marker)))
+            throw new Error(spec.what + ': the install finished without ' + spec.marker);
+        safeRemove(temp, staging);
+        const sizeBytes = folderSize(staging);
+        writeJsonAtomic(path.join(staging, MARKER), { name: spec.name, version: spec.version, sizeBytes });
+        if (fs.existsSync(dir))
+            safeRemove(dir, root);
+        fs.renameSync(staging, dir);
+        const now = new Date().toISOString();
+        writeRecords([
+            ...installRecords(deps).filter((r) => !(r.name === spec.name && r.version === spec.version)),
+            { name: spec.name, version: spec.version, sizeBytes, installedAt: now, usedAt: now },
+        ], deps);
+        prune(spec, deps);
+        return { dir, fresh: true, sizeBytes };
+    }
+    finally {
+        if (fs.existsSync(staging))
+            safeRemove(staging, root);
+    }
+}

package/dist/guest/toolchains/plan.js

@@ -21,6 +21,17 @@ import { setupPhp } from './languages/php.js';
 import { setupRuby } from './languages/ruby.js';
 import { setupVcRuntime } from './native/vcruntime.js';
 import { setupVscode } from './tools/vscode.js';
+import { ensureVisualStudio, visualStudioWanted } from './native/visual-studio.js';
+import { duringSession } from '../runtime/project-context.js';
+import { setupSteam } from './steam/steam.js';
+import { setupGodot } from './engines/godot.js';
+import { setupUnity } from './engines/unity.js';
+import { setupFivem } from './fivem/fivem.js';
+import { setupAndroid } from './mobile/android.js';
+import { setupFlutter } from './mobile/flutter.js';
+import { setupDart } from './mobile/dart.js';
+import { setupReactNative } from './mobile/react-native.js';
+import { setupKotlin } from './languages/kotlin.js';
 import { rustHost, rustCaches, cargoDefaults, cargoShim, linkGate } from './native/rust-extras.js';
 import { setupPythonTools } from './languages/python-tools.js';
 export function plan(config, versions, o) {
@@ -28,6 +39,14 @@ export function plan(config, versions, o) {
     const java = wanted(config.java.enabled, 'java');
     const python = wanted(config.python.enabled, 'python');
     const unreal = wanted(config.unreal.enabled, 'unreal');
+    const android = wanted(config.android.enabled, 'android');
+    // One Visual Studio for every toolchain that needs the real one (Unreal, Flutter desktop, Unity IL2CPP).
+    const vs = visualStudioWanted(config, (setting, name) => wanted(setting, name));
+    const ctx = {
+        refresh: o.refresh,
+        pcInstalls: o.pcInstalls ?? { items: [] },
+        duringSession: duringSession(),
+    };
     return [
         {
             name: 'Git',
@@ -45,18 +64,32 @@ export function plan(config, versions, o) {
             enabled: wanted(config.cpp.enabled, 'cpp') || wanted(config.rust.enabled, 'rust'),
             install: (env) => setupCpp(env, config.cpp),
         },
-        // Unreal's Visual Studio brings MSVC and the real vswhere: the portable MSVC (and its stand-in vswhere) stays out.
-        { name: 'Unreal', enabled: unreal, shared: true, install: (env) => setupUnreal(env, config.unreal) },
+        // Visual Studio brings MSVC and the real vswhere: the portable MSVC (and its stand-in vswhere) stays out.
+        {
+            name: 'Visual Studio',
+            enabled: vs !== null,
+            shared: true,
+            install: async (env) => {
+                await ensureVisualStudio(env, vs, { keepInstallFiles: config.unreal.keepInstallFiles });
+            },
+        },
+        {
+            name: 'Unreal',
+            enabled: unreal,
+            shared: true,
+            after: ['Visual Studio'],
+            install: (env) => setupUnreal(env, config.unreal, ctx),
+        },
         {
             name: 'MSVC',
-            enabled: wanted(config.msvc.enabled, 'msvc') && !unreal,
+            enabled: wanted(config.msvc.enabled, 'msvc') && vs === null,
             install: (env) => setupMsvc(env, config.msvc),
         },
         // Rust links with MSVC (msvc host) or MinGW's gcc (GNU host): whichever it uses goes first.
         {
             name: 'Rust',
             enabled: wanted(config.rust.enabled, 'rust'),
-            after: ['C/C++', 'MSVC', 'Unreal'],
+            after: ['C/C++', 'MSVC', 'Visual Studio', 'Unreal'],
             install: async (env) => {
                 await setupRust(env, { ...config.rust, host: rustHost(config) }, o.refresh);
                 Object.assign(env.vars, rustCaches(config.rust));
@@ -74,6 +107,49 @@ export function plan(config, versions, o) {
         },
         { name: 'Go', enabled: wanted(config.go.enabled, 'go'), install: (env) => setupGo(env, config.go) },
         { name: 'Java', enabled: java, install: (env) => setupJava(env, config.java) },
+        { name: 'Kotlin', enabled: java && config.java.kotlin, after: ['Java'], install: (env) => setupKotlin(env, ctx) },
+        // Game engines, stores and mobile: each module keeps its big installs in tools (persisted.ts).
+        {
+            name: 'Android SDK',
+            enabled: android,
+            after: ['Java'],
+            install: (env) => setupAndroid(env, config.android, ctx),
+        },
+        {
+            name: 'Steam',
+            enabled: wanted(config.steam.enabled, 'steam'),
+            install: (env) => setupSteam(env, config.steam, ctx),
+        },
+        {
+            name: 'Unity',
+            enabled: wanted(config.unity.enabled, 'unity'),
+            after: ['Visual Studio', 'Android SDK'],
+            install: (env) => setupUnity(env, config.unity, ctx),
+        },
+        {
+            name: 'Godot',
+            enabled: wanted(config.godot.enabled, 'godot'),
+            after: ['.NET', 'Android SDK'],
+            install: (env) => setupGodot(env, config.godot, ctx),
+        },
+        {
+            name: 'FiveM server',
+            enabled: wanted(config.fivem.enabled, 'fivem'),
+            install: (env) => setupFivem(env, config.fivem, ctx),
+        },
+        {
+            name: 'Flutter',
+            enabled: wanted(config.flutter.enabled, 'flutter'),
+            after: ['Visual Studio', 'Android SDK'],
+            install: (env) => setupFlutter(env, config.flutter, ctx),
+        },
+        { name: 'Dart', enabled: wanted(config.dart.enabled, 'dart'), install: (env) => setupDart(env, config.dart, ctx) },
+        {
+            name: 'React Native',
+            enabled: wanted(config.reactNative.enabled, 'reactNative'),
+            after: ['Android SDK'],
+            install: (env) => setupReactNative(env, config.reactNative, ctx),
+        },
         { name: 'Ruby', enabled: wanted(config.ruby.enabled, 'ruby'), install: (env) => setupRuby(env, config.ruby) },
         // PHP installs the Visual C++ runtime itself: one installer at a time.
         // Many apps (bat, delta, Neovim, most GUIs, your own programs) are built against it too.

package/dist/guest/toolchains/steam/apps.d.ts

@@ -0,0 +1,27 @@
+import { type PersistedDeps } from '../persisted.js';
+/** The room sbx-steam app wants free when you do not say (--need-gb). */
+export declare const DEFAULT_APP_NEED_BYTES: number;
+/** The name apps are recorded under in tools\installs.json (the version is the app ID). */
+export declare const STEAM_APPS_RECORD = "steam-apps";
+/** Throws (with the fix) when the disk that gets the app has less than `needBytes` free. */
+export declare function assertAppRoom(dir: string, needBytes: number, what: string, deps?: PersistedDeps): void;
+/** The bytes under a folder (links not followed), or null when there are too many files to count. */
+export declare function folderSize(dir: string): number | null;
+/** Records an app's size (and that it was used now) in tools\installs.json. */
+export declare function recordApp(appId: string, sizeBytes: number | null, deps?: PersistedDeps): void;
+export interface AppManifest {
+    readonly appId: string;
+    readonly name: string;
+    readonly installDir: string;
+    readonly buildId?: string;
+}
+/** An appmanifest_<id>.acf (bounded), or null. */
+export declare function readAppManifest(file: string): AppManifest | null;
+export interface InstalledApp {
+    readonly appId: string;
+    readonly name: string;
+    readonly dir: string;
+    readonly sizeBytes: number | null;
+}
+/** The apps in tools\steam-apps, with their names (from SteamCMD's manifest) and recorded sizes. */
+export declare function installedApps(deps?: PersistedDeps): InstalledApp[];

package/dist/guest/toolchains/steam/apps.js

@@ -0,0 +1,112 @@
+// Games and dedicated servers that sbx-steam app downloads into tools\steam-apps\<appid> (kept between sandboxes):
+// the room check before, the size afterwards in tools\installs.json (so `sandbox data` shows it without walking the
+// folder), and what is there. No runtime imports: the self-test loads this file with its own folders.
+import fs from 'node:fs';
+import path from 'node:path';
+import { INSTALL_RECORDS_FILE } from '../../../shared/installs.js';
+import { readBoundedFile } from '../../../shared/io/bounded.js';
+import { writeJsonAtomic } from '../../../shared/io/json.js';
+import { parseVdf, vdfText } from '../../../shared/vdf.js';
+import { toolsDir } from '../../runtime/paths.js';
+import { assertRoom, installRecords } from '../persisted.js';
+import { checkAppId, steamAppsRoot } from './commands.js';
+const GB = 1024 ** 3;
+/** The room sbx-steam app wants free when you do not say (--need-gb). */
+export const DEFAULT_APP_NEED_BYTES = 5 * GB;
+/** The name apps are recorded under in tools\installs.json (the version is the app ID). */
+export const STEAM_APPS_RECORD = 'steam-apps';
+const MAX_WALK = 2_000_000;
+const MAX_MANIFEST_BYTES = 256 * 1024;
+const toolsOf = (deps) => deps.toolsDir ?? toolsDir;
+/** Throws (with the fix) when the disk that gets the app has less than `needBytes` free. */
+export function assertAppRoom(dir, needBytes, what, deps = {}) {
+    let probe = dir;
+    while (!fs.existsSync(probe) && path.dirname(probe) !== probe)
+        probe = path.dirname(probe);
+    assertRoom(probe, needBytes, what, 'Free room on that disk (with contained storage: raise storage.containedMaxGb), or ask for less with --need-gb.', deps);
+}
+/** The bytes under a folder (links not followed), or null when there are too many files to count. */
+export function folderSize(dir) {
+    let total = 0;
+    let seen = 0;
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (++seen > MAX_WALK)
+                return null;
+            const full = path.join(current, e.name);
+            if (e.isDirectory())
+                stack.push(full);
+            else if (e.isFile())
+                try {
+                    total += fs.lstatSync(full).size;
+                }
+                catch {
+                    // Gone while counting: not counted.
+                }
+        }
+    }
+    return total;
+}
+/** Records an app's size (and that it was used now) in tools\installs.json. */
+export function recordApp(appId, sizeBytes, deps = {}) {
+    checkAppId(appId);
+    const now = new Date().toISOString();
+    const all = installRecords(deps);
+    const known = all.find((r) => r.name === STEAM_APPS_RECORD && r.version === appId);
+    const record = {
+        name: STEAM_APPS_RECORD,
+        version: appId,
+        sizeBytes,
+        installedAt: known?.installedAt ?? now,
+        usedAt: now,
+    };
+    const installs = [...all.filter((r) => r !== known), record];
+    fs.mkdirSync(toolsOf(deps), { recursive: true });
+    writeJsonAtomic(path.join(toolsOf(deps), INSTALL_RECORDS_FILE), { installs });
+}
+/** An appmanifest_<id>.acf (bounded), or null. */
+export function readAppManifest(file) {
+    const bytes = readBoundedFile(file, MAX_MANIFEST_BYTES);
+    const root = bytes ? parseVdf(bytes.toString('utf8'), { maxBytes: MAX_MANIFEST_BYTES }) : null;
+    const appId = vdfText(root, 'AppState', 'appid');
+    const installDir = vdfText(root, 'AppState', 'installdir');
+    if (!appId || !/^\d{1,10}$/.test(appId) || !installDir)
+        return null;
+    const buildId = vdfText(root, 'AppState', 'buildid');
+    return {
+        appId,
+        name: (vdfText(root, 'AppState', 'name') ?? appId).slice(0, 200),
+        installDir,
+        ...(buildId && /^\d{1,20}$/.test(buildId) ? { buildId } : {}),
+    };
+}
+/** The apps in tools\steam-apps, with their names (from SteamCMD's manifest) and recorded sizes. */
+export function installedApps(deps = {}) {
+    const root = steamAppsRoot(toolsOf(deps));
+    let ids;
+    try {
+        ids = fs
+            .readdirSync(root)
+            .filter((n) => /^[1-9]\d{0,9}$/.test(n))
+            .slice(0, 1000);
+    }
+    catch {
+        return [];
+    }
+    const records = installRecords(deps);
+    return ids.map((appId) => {
+        const dir = path.join(root, appId);
+        const manifest = readAppManifest(path.join(dir, 'steamapps', 'appmanifest_' + appId + '.acf'));
+        const record = records.find((r) => r.name === STEAM_APPS_RECORD && r.version === appId);
+        return { appId, name: manifest?.name ?? '(not downloaded yet)', dir, sizeBytes: record?.sizeBytes ?? null };
+    });
+}

package/dist/guest/toolchains/steam/client.d.ts

@@ -0,0 +1,5 @@
+import { type ToolEnv } from '../tool-env.js';
+/** steam.exe in tools\steam when it is there and Valve-signed, else null. */
+export declare function installedSteamClient(): string | null;
+/** steam.exe ready to start, or null when it could not be set up (the reason is in the log and the summary). */
+export declare function ensureSteamClient(env: ToolEnv): Promise<string | null>;

package/dist/guest/toolchains/steam/client.js

@@ -0,0 +1,67 @@
+// The Steam client (toolchains.steam.client): SteamSetup.exe (Valve-signed) unpacked silently into tools\steam once;
+// steam.exe then fetches and updates the rest of itself in place when you start it (sbx-steam client). You sign in to
+// it in each sandbox: its login is very likely tied to the Windows user, so it does not carry over.
+import fs from 'node:fs';
+import path from 'node:path';
+import { errMsg } from '../../../core/util/errors.js';
+import { moveIntoPlace, spawnAsync, stagingFolder } from '../../../shared/download/index.js';
+import { safeRemove } from '../../../shared/io/safe-remove.js';
+import { exists } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { toolsDir } from '../../runtime/paths.js';
+import { SIGNERS, signedBy, signedInstaller } from '../installers.js';
+import { assertRoom } from '../persisted.js';
+import { tool } from '../tool-env.js';
+import { STEAM_CLIENT_URL, steamClientDir } from './commands.js';
+const GB = 1024 ** 3;
+/** The client grows to 1-1.5 GB once it has updated itself (games come on top). */
+const CLIENT_NEED_BYTES = 2 * GB;
+const SETUP_TIMEOUT_MS = 10 * 60 * 1000;
+/** steam.exe in tools\steam when it is there and Valve-signed, else null. */
+export function installedSteamClient() {
+    const exe = path.join(steamClientDir(), 'steam.exe');
+    return exists(exe) && signedBy(exe, SIGNERS.valve) ? exe : null;
+}
+async function installSteamClient() {
+    const dir = steamClientDir();
+    const exe = path.join(dir, 'steam.exe');
+    if (exists(exe)) {
+        if (!signedBy(exe, SIGNERS.valve))
+            throw new Error('tools\\steam\\steam.exe is not signed by Valve');
+        return exe;
+    }
+    fs.mkdirSync(toolsDir, { recursive: true });
+    assertRoom(toolsDir, CLIENT_NEED_BYTES, 'the Steam client', 'Free room on the data disk.');
+    const setup = await signedInstaller(STEAM_CLIENT_URL, path.join(tool('steam-setup'), 'SteamSetup.exe'), 'the Steam client installer (~2 MB once)', SIGNERS.valve);
+    const work = stagingFolder(dir);
+    fs.mkdirSync(work, { recursive: true });
+    try {
+        log('Unpacking the Steam client into tools\\steam ...');
+        // NSIS: /S silent, /D= the folder (last, unquoted: the staging path has no spaces).
+        const code = await spawnAsync(setup, ['/S', '/D=' + work], { timeout: SETUP_TIMEOUT_MS });
+        const unpacked = path.join(work, 'steam.exe');
+        if (!exists(unpacked))
+            throw new Error('SteamSetup.exe did not unpack steam.exe (exit code ' + code + ')');
+        if (!signedBy(unpacked, SIGNERS.valve))
+            throw new Error('the unpacked steam.exe is not signed by Valve');
+        moveIntoPlace(work, dir);
+    }
+    finally {
+        if (fs.existsSync(work))
+            safeRemove(work, path.dirname(work));
+    }
+    return exe;
+}
+/** steam.exe ready to start, or null when it could not be set up (the reason is in the log and the summary). */
+export async function ensureSteamClient(env) {
+    try {
+        const exe = await installSteamClient();
+        env.summary.push('steam client: tools\\steam (start it with sbx-steam client; sign in there in each sandbox)');
+        return exe;
+    }
+    catch (e) {
+        log('Steam client: not set up: ' + errMsg(e));
+        env.summary.push('steam client: not set up (' + errMsg(e) + ')');
+        return null;
+    }
+}

package/dist/guest/toolchains/steam/commands.d.ts

@@ -0,0 +1,58 @@
+/** Where SteamCMD runs from in the sandbox (its own disk: its config\ holds the login). */
+export declare const STEAMCMD_DIR = "C:\\SteamCMD";
+/** Valve publishes no checksum for it: steamcmd.exe inside must be Valve-signed. */
+export declare const STEAMCMD_URL = "https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip";
+export declare const STEAM_CLIENT_URL = "https://steamcdn-a.akamaihd.net/client/installer/SteamSetup.exe";
+/** SteamCMD's binaries, kept between sandboxes (never its config\ or sentry files). */
+export declare function steamCmdStore(tools?: string): string;
+/** Games and dedicated servers that sbx-steam app downloads: tools\steam-apps\<appid>. */
+export declare function steamAppsRoot(tools?: string): string;
+export declare function steamAppDir(appId: string, tools?: string): string;
+/** Workshop items that sbx-steam workshop get downloads (a cache on the data disk). */
+export declare function workshopCache(data?: string): string;
+/** Where a downloaded workshop item is. */
+export declare function workshopItemDir(cache: string, appId: string, item: string): string;
+/** The Steam client (toolchains.steam.client), which updates itself in place. */
+export declare function steamClientDir(tools?: string): string;
+export declare const checkAppId: (v: string) => string;
+export declare const checkItemId: (v: string) => string;
+export declare const checkBranch: (v: string) => string;
+/** A Steam account name, or "anonymous" (dedicated servers and free tools). */
+export declare const checkLogin: (v: string) => string;
+/** A full path SteamCMD can take as one value: no quotes, no `+` at the start of a part, no line breaks. */
+export declare function checkPathValue(p: string, what: string): string;
+export interface AppUpdate {
+    readonly appId: string;
+    readonly dir: string;
+    readonly login: string;
+    readonly beta?: string;
+    readonly validate?: boolean;
+}
+/** Downloads or updates an app (a game, a dedicated server) into a folder. force_install_dir comes before login. */
+export declare function appUpdateArgs(o: AppUpdate): string[];
+export interface WorkshopGet {
+    readonly appId: string;
+    readonly items: readonly string[];
+    readonly dir: string;
+    readonly login: string;
+    readonly validate?: boolean;
+}
+/** Downloads workshop items of an app into <dir>\steamapps\workshop\content\<app>\<item>. */
+export declare function workshopGetArgs(o: WorkshopGet): string[];
+/** Uploads a workshop item described by a workshop_item .vdf (a real account: not anonymous). */
+export declare function workshopPushArgs(login: string, script: string): string[];
+/** Uploads a build described by an app_build .vdf (ContentBuilder). */
+export declare function appBuildArgs(login: string, script: string): string[];
+/** Signs in (SteamCMD asks for the password and the Steam Guard code itself) and keeps the login. */
+export declare function loginArgs(login: string): string[];
+/** At most this much of a build or workshop script is read. */
+export declare const MAX_SCRIPT_BYTES: number;
+/** What a SteamCMD script is: its root block ("AppBuild" or "workshopitem"), or null. */
+export declare function scriptKind(text: string): 'appbuild' | 'workshopitem' | null;
+/** An app_build script's text with Preview on and/or a description (null when it is not an app_build script). */
+export declare function withBuildSettings(text: string, o: {
+    readonly preview?: boolean;
+    readonly desc?: string;
+}): string | null;
+/** The script's text (bounded), or an error a person can act on. */
+export declare function readScript(file: string): string;