windows-development-sandbox 1.17.3 → 1.18.2

package/dist/host/launch/hints/hint.d.ts

@@ -0,0 +1,2 @@
+import type { AutoToolchain } from '../../../core/detect/index.js';
+export type ToolchainHints = Partial<Record<AutoToolchain, string>>;

package/dist/host/launch/hints/hint.js

@@ -0,0 +1 @@
+export {};

package/dist/host/launch/hints/index.d.ts

@@ -0,0 +1,5 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolchainHints } from './hint.js';
+export type { ToolchainHints } from './hint.js';
+/** Every area's hints for this project; the first reason found for a toolchain wins. A failing area adds none. */
+export declare function areaHints(root: string, settings: Toolchains): ToolchainHints;

package/dist/host/launch/hints/index.js

@@ -0,0 +1,29 @@
+import { androidHints } from './android.js';
+import { engineHints } from './engines.js';
+import { fivemHints } from './fivem.js';
+import { mobileHints } from './mobile.js';
+import { steamHints } from './steam.js';
+const AREAS = [
+    steamHints,
+    engineHints,
+    fivemHints,
+    androidHints,
+    mobileHints,
+];
+/** Every area's hints for this project; the first reason found for a toolchain wins. A failing area adds none. */
+export function areaHints(root, settings) {
+    const all = {};
+    for (const area of AREAS) {
+        let found = {};
+        try {
+            found = area(root, settings);
+        }
+        catch {
+            // A file that cannot be read gives no hint; the toolchain stays as its settings and markers say.
+        }
+        for (const [name, reason] of Object.entries(found))
+            if (reason && !all[name])
+                all[name] = reason;
+    }
+    return all;
+}

package/dist/host/launch/hints/mobile.d.ts

@@ -0,0 +1,3 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolchainHints } from './hint.js';
+export declare function mobileHints(_root: string, _settings: Toolchains): ToolchainHints;

package/dist/host/launch/hints/mobile.js

@@ -0,0 +1,3 @@
+export function mobileHints(_root, _settings) {
+    return {};
+}

package/dist/host/launch/hints/steam.d.ts

@@ -0,0 +1,7 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolchainHints } from './hint.js';
+/** The .vdf files of a project (bounded walk, no links). */
+export declare function projectVdfFiles(root: string): string[];
+/** What a SteamCMD script is for, or null: "AppBuild" (a build upload) or "workshopitem". */
+export declare function steamScriptOf(text: string): 'AppBuild' | 'workshopitem' | null;
+export declare function steamHints(root: string, settings: Toolchains): ToolchainHints;

package/dist/host/launch/hints/steam.js

@@ -0,0 +1,59 @@
+// Steam: toolchain hints from file contents: a .vdf whose first block is "AppBuild" (a ContentBuilder build script) or
+// "workshopitem" (a workshop upload) turns toolchains.steam on. Files are found by name, a few folders deep, and
+// size-checked before they are read; links are not followed (the project may be hostile).
+import fs from 'node:fs';
+import path from 'node:path';
+import { readBoundedFile } from '../../../shared/io/index.js';
+import { parseVdf } from '../../../shared/vdf.js';
+const SKIP = /^(node_modules|\.git|\.hg|\.svn|vendor|target|obj|dist|out|\.next|\.venv|venv|__pycache__|\.gradle|\.idea|\.vs|coverage|Library|Temp|Intermediate|Saved|DerivedDataCache|Binaries)$/i;
+const MAX_DEPTH = 4;
+const MAX_FOLDERS = 1500;
+const MAX_ENTRIES = 2000;
+const MAX_FILES = 40;
+const MAX_BYTES = 64 * 1024;
+/** The .vdf files of a project (bounded walk, no links). */
+export function projectVdfFiles(root) {
+    const found = [];
+    let folders = 0;
+    const queue = [[root, 0]];
+    while (queue.length && found.length < MAX_FILES) {
+        const [dir, depth] = queue.shift();
+        if (++folders > MAX_FOLDERS)
+            break;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true }).slice(0, MAX_ENTRIES);
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (e.isFile() && e.name.toLowerCase().endsWith('.vdf'))
+                found.push(path.join(dir, e.name));
+            else if (e.isDirectory() && depth < MAX_DEPTH && !SKIP.test(e.name))
+                queue.push([path.join(dir, e.name), depth + 1]);
+            if (found.length >= MAX_FILES)
+                break;
+        }
+    }
+    return found;
+}
+/** What a SteamCMD script is for, or null: "AppBuild" (a build upload) or "workshopitem". */
+export function steamScriptOf(text) {
+    const root = parseVdf(text, { maxBytes: MAX_BYTES, escapes: false, maxDepth: 16, maxKeys: 5000 });
+    const first = root ? Object.keys(root)[0]?.toLowerCase() : undefined;
+    return first === 'appbuild' ? 'AppBuild' : first === 'workshopitem' ? 'workshopitem' : null;
+}
+export function steamHints(root, settings) {
+    if (settings.steam.enabled !== 'auto')
+        return {};
+    for (const file of projectVdfFiles(root)) {
+        const bytes = readBoundedFile(file, MAX_BYTES);
+        const kind = bytes ? steamScriptOf(bytes.toString('utf8')) : null;
+        if (!kind)
+            continue;
+        const rel = path.relative(root, file).split(path.sep).join('/');
+        return { steam: rel + (kind === 'AppBuild' ? ' is a Steam build script' : ' is a Steam workshop item') };
+    }
+    return {};
+}

package/dist/host/launch/index.d.ts

@@ -1,5 +1,5 @@
-export { generateSandbox } from './generate.js';
-export { decideProjectToolchains } from './toolchains.js';
+export { generateSandbox, newLaunchId } from './generate.js';
+export { decideProjectToolchains, toolchainsOnForBoot } from './toolchains.js';
 export { hostToolsOf, logonEnv } from './session-file.js';
 export { cappedMemoryMb, decideMemory, GUEST, memoryNote, residentCapMb, residentNote, resolveMemoryMb, } from './wsb-file.js';
 export { GENTLE_NOTE, vgpuSource, vgpuWarning } from './risk-notes.js';

package/dist/host/launch/index.js

@@ -1,5 +1,5 @@
-export { generateSandbox } from './generate.js';
-export { decideProjectToolchains } from './toolchains.js';
+export { generateSandbox, newLaunchId } from './generate.js';
+export { decideProjectToolchains, toolchainsOnForBoot } from './toolchains.js';
 export { hostToolsOf, logonEnv } from './session-file.js';
 export { cappedMemoryMb, decideMemory, GUEST, memoryNote, residentCapMb, residentNote, resolveMemoryMb, } from './wsb-file.js';
 export { GENTLE_NOTE, vgpuSource, vgpuWarning } from './risk-notes.js';

package/dist/host/launch/mappings.js

@@ -113,6 +113,8 @@ export function collectMappings(o, launchPath, boot = { roots: [], projects: [],
         mappings.push({ host: probe.gitDir, guest: GUEST.hostTools + '\\git', readOnly: true });
     if (probe.nvmDir)
         mappings.push({ host: probe.nvmDir, guest: GUEST.hostTools + '\\nvm', readOnly: true });
+    // pcInstalls: this PC's games, engines and editors, read-only under C:\PcInstalls (checked by host/pc-installs).
+    mappings.push(...(o.pcInstalls?.mappings ?? []));
     // Placement keeps extra folders apart; this guards the rest (and where the folders really are: F:\x is
     // C:\Mirror\F\x).
     assertNoGuestOverlap(mappings);

package/dist/host/launch/session-file.js

@@ -71,6 +71,8 @@ export function guestSession(o, parts) {
         agentHomes: Object.assign({}, ...Object.values(config.harnesses).map((h) => h.home?.env ?? {})),
         agentProfileDirs: Object.fromEntries(Object.entries(config.harnesses).flatMap(([name, h]) => h.home?.profileDirs?.length ? [[name, h.home.profileDirs]] : [])),
         agents: Object.fromEntries(Object.entries(config.harnesses).map(([name, h]) => [name, { ...h, environment: {} }])),
+        ...(o.pcInstalls?.manifest.items.length ? { pcInstalls: o.pcInstalls.manifest } : {}),
+        ...(o.accountLeases?.length ? { accountLeases: [...o.accountLeases] } : {}),
     };
 }
 /**

package/dist/host/launch/stage.js

@@ -30,7 +30,16 @@ export function stageScripts(target, scripts) {
         fs.copyFileSync(script, path.join(target, '90-extra-' + index + '-' + path.basename(script)));
     });
 }
-export const RUNTIME_FILES = ['main.js', 'daemon.js', 'view.js', 'gitguard.js', 'db.js', 'netproxy.js', 'agent.js'];
+export const RUNTIME_FILES = [
+    'main.js',
+    'daemon.js',
+    'view.js',
+    'gitguard.js',
+    'db.js',
+    'netproxy.js',
+    'agent.js',
+    'tool.js',
+];
 /** The bundled sandbox runtime (dist/runtime: one self-contained file per entry point) and the sandbox/ scripts. */
 export function copyRuntime(packageRoot, launchPath) {
     const runtime = path.join(packageRoot, 'dist', 'runtime');

package/dist/host/launch/toolchains.d.ts

@@ -1,4 +1,11 @@
+import type { BootWant } from '../../core/local-config/index.js';
 import type { GenerateOptions } from '../../core/types.js';
+import { type UsedBy } from '../../shared/accounts/index.js';
 import { decideToolchains } from '../../core/detect/index.js';
 /** Which toolchains the project needs ("auto" settings follow the project's files and what this PC has). */
 export declare function decideProjectToolchains(o: Pick<GenerateOptions, 'run' | 'pcLanguages'>): ReturnType<typeof decideToolchains>;
+/**
+ * The toolchains a service sign-in may serve that are on for this boot: the launch's own project (its files decide
+ * "auto") and the other boot projects that turn one on in their settings.
+ */
+export declare function toolchainsOnForBoot(o: Pick<GenerateOptions, 'run' | 'pcLanguages'>, others?: readonly BootWant[]): Set<UsedBy>;

package/dist/host/launch/toolchains.js

@@ -1,6 +1,8 @@
+import { USED_BY } from '../../shared/accounts/index.js';
 import { decideToolchains, readPwshScripts, usesPwsh } from '../../core/detect/index.js';
 import { pcLanguages } from './pc-scan.js';
 import { msvcHint, projectEntries, uvHint } from './project-scan.js';
+import { areaHints } from './hints/index.js';
 /** Which toolchains the project needs ("auto" settings follow the project's files and what this PC has). */
 export function decideProjectToolchains(o) {
     const { config, workspaceHost } = o.run;
@@ -12,6 +14,7 @@ export function decideProjectToolchains(o) {
     const uvScript = config.toolchains.uv.enabled === 'auto' ? uvHint(workspaceHost) : undefined;
     const uvText = uvScript ?? memHint;
     const hints = {
+        ...areaHints(workspaceHost, config.toolchains),
         ...(msvcScript ? { msvc: msvcScript } : {}),
         ...(pwshScript ? { pwsh: pwshScript } : {}),
         ...(memHint ? { bun: memHint } : {}),
@@ -19,3 +22,11 @@ export function decideProjectToolchains(o) {
     };
     return decideToolchains(config.toolchains, projectEntries(workspaceHost), o.pcLanguages ?? pcLanguages(), hints);
 }
+/**
+ * The toolchains a service sign-in may serve that are on for this boot: the launch's own project (its files decide
+ * "auto") and the other boot projects that turn one on in their settings.
+ */
+export function toolchainsOnForBoot(o, others = []) {
+    const decisions = decideProjectToolchains(o);
+    return new Set(USED_BY.filter((u) => decisions[u].on || others.some((p) => p.config.toolchains[u].enabled === true)));
+}

package/dist/host/pc-installs/discover.d.ts

@@ -0,0 +1,19 @@
+import type { Config, ResolvedMapping } from '../../core/types.js';
+import { type PcInstallManifest } from '../../shared/paths/index.js';
+import { type PcEnv } from '../accounts/index.js';
+import type { PcInstallSource } from './source.js';
+export type PcInstalls = Config['pcInstalls'];
+/** At most this many installs are mapped (each one is a mapping in the .wsb). */
+export declare const MAX_PC_INSTALLS = 40;
+export declare const PC_INSTALL_SOURCES: readonly PcInstallSource[];
+export interface DiscoverOptions {
+    readonly packageRoot: string;
+    readonly storageRoot: string;
+    readonly sources?: readonly PcInstallSource[];
+}
+export interface DiscoveredInstalls {
+    readonly mappings: ResolvedMapping[];
+    readonly manifest: PcInstallManifest;
+    readonly notes: string[];
+}
+export declare function discoverPcInstalls(s: PcInstalls, o: DiscoverOptions, pc?: PcEnv): DiscoveredInstalls;

package/dist/host/pc-installs/discover.js

@@ -0,0 +1,59 @@
+import { assertSafeMapping } from '../../core/safe-paths.js';
+import { dirExists, errMsg } from '../../core/util/index.js';
+import { pcInstallGuest } from '../../shared/paths/index.js';
+import { pcEnv } from '../accounts/index.js';
+import { epicInstalls } from './epic.js';
+import { steamInstalls } from './steam.js';
+import { unityInstalls } from './unity.js';
+import { unrealInstalls } from './unreal.js';
+/** At most this many installs are mapped (each one is a mapping in the .wsb). */
+export const MAX_PC_INSTALLS = 40;
+export const PC_INSTALL_SOURCES = [
+    steamInstalls,
+    epicInstalls,
+    unrealInstalls,
+    unityInstalls,
+];
+export function discoverPcInstalls(s, o, pc = pcEnv()) {
+    const mappings = [];
+    const items = [];
+    const notes = [];
+    for (const source of o.sources ?? PC_INSTALL_SOURCES) {
+        const wanted = s[source.setting];
+        if (wanted === false || (Array.isArray(wanted) && !wanted.length))
+            continue;
+        let found = [];
+        try {
+            found = source.find(wanted, pc);
+        }
+        catch (e) {
+            notes.push('pcInstalls.' + source.setting + ': could not look on this PC (' + errMsg(e) + ').');
+            continue;
+        }
+        for (const install of found) {
+            if (mappings.length >= MAX_PC_INSTALLS) {
+                notes.push('pcInstalls: only the first ' + MAX_PC_INSTALLS + ' installs are mapped.');
+                break;
+            }
+            try {
+                const guest = pcInstallGuest(install.kind, install.id);
+                if (mappings.some((m) => m.guest.toLowerCase() === guest.toLowerCase()))
+                    continue;
+                if (!dirExists(install.host)) {
+                    notes.push('pcInstalls: ' + install.name + ' is not there any more (' + install.host + ').');
+                    continue;
+                }
+                assertSafeMapping(install.host, o.packageRoot, o.storageRoot);
+                mappings.push({ host: install.host, guest, readOnly: true, label: 'this PC, read-only' });
+                const { host: _host, ...shown } = install;
+                items.push({ ...shown, guest });
+            }
+            catch (e) {
+                notes.push('pcInstalls: ' + install.name + ' is not mapped: ' + errMsg(e));
+            }
+        }
+        if (Array.isArray(wanted) && found.length < wanted.length)
+            notes.push('pcInstalls.' + source.setting + ': some of the listed ones are not installed on this PC.');
+    }
+    return { mappings, manifest: { items }, notes };
+}

package/dist/host/pc-installs/epic.d.ts

@@ -0,0 +1,2 @@
+import type { PcInstallSource } from './source.js';
+export declare const epicInstalls: PcInstallSource;

package/dist/host/pc-installs/epic.js

@@ -0,0 +1,7 @@
+export const epicInstalls = {
+    kind: 'epic-game',
+    setting: 'epicGames',
+    find(_wanted, _pc) {
+        return [];
+    },
+};

package/dist/host/pc-installs/index.d.ts

@@ -0,0 +1,3 @@
+export { discoverPcInstalls, MAX_PC_INSTALLS, PC_INSTALL_SOURCES, type DiscoveredInstalls, type DiscoverOptions, type PcInstalls, } from './discover.js';
+export type { PcInstallSource } from './source.js';
+export type { PcInstall, PcInstallManifest } from '../../shared/paths/index.js';

package/dist/host/pc-installs/index.js

@@ -0,0 +1,2 @@
+// pcInstalls: this PC's games, engines and editors, mapped read-only into sandboxes (host side).
+export { discoverPcInstalls, MAX_PC_INSTALLS, PC_INSTALL_SOURCES, } from './discover.js';

package/dist/host/pc-installs/source.d.ts

@@ -0,0 +1,9 @@
+import type { PcInstall } from '../../shared/paths/index.js';
+import type { PcEnv } from '../accounts/index.js';
+export interface PcInstallSource {
+    readonly kind: PcInstall['kind'];
+    /** The settings key that turns it on (pcInstalls.<setting>). */
+    readonly setting: 'steamGames' | 'epicGames' | 'unrealEngines' | 'unityEditors';
+    /** What is installed: everything (true) or the ones listed. Bounded reads only (registry, manifests). */
+    find(wanted: true | readonly (string | number)[], pc: PcEnv): PcInstall[];
+}

package/dist/host/pc-installs/source.js

@@ -0,0 +1 @@
+export {};

package/dist/host/pc-installs/steam.d.ts

@@ -0,0 +1,16 @@
+import type { PcInstall } from '../../shared/paths/index.js';
+import type { PcInstallSource } from './source.js';
+/** Where Steam is installed on this PC (HKCU SteamPath, else HKLM InstallPath), or null. */
+export declare function steamRootFromRegistry(): string | null;
+export interface SteamLibrary {
+    readonly path: string;
+    /** The app IDs the library lists (empty in the old format: the manifests tell). */
+    readonly apps: readonly string[];
+}
+/** The libraries a libraryfolders.vdf lists (both the current and the old format), in order. */
+export declare function steamLibraries(text: string): SteamLibrary[];
+/** The libraries of a Steam install: its own folder first, then the ones libraryfolders.vdf lists. */
+export declare function librariesOf(steamRoot: string): SteamLibrary[];
+/** What `wanted` maps from a Steam install: every library's steamapps (true), or the listed games. */
+export declare function findSteamInstalls(steamRoot: string, wanted: true | readonly (string | number)[]): PcInstall[];
+export declare const steamInstalls: PcInstallSource;

package/dist/host/pc-installs/steam.js

@@ -0,0 +1,143 @@
+// Steam games of this PC: SteamPath from the registry (reg.exe through system32), libraryfolders.vdf and the app
+// manifests. true maps each library's steamapps (C:\PcInstalls\steam\library<N>), a list of app IDs only those games
+// (C:\PcInstalls\steam\<appid>). Every file is read bounded; names from them never carry a path of this PC.
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { readBoundedFile } from '../../shared/io/index.js';
+import { SYSTEM } from '../../shared/system.js';
+import { parseVdf, vdfObject, vdfText } from '../../shared/vdf.js';
+const MAX_LIBRARIES = 32;
+const MAX_VDF_BYTES = 1024 * 1024;
+const MAX_MANIFEST_BYTES = 256 * 1024;
+const APP_ID = /^[1-9]\d{0,9}$/;
+/** Where Steam is installed on this PC (HKCU SteamPath, else HKLM InstallPath), or null. */
+export function steamRootFromRegistry() {
+    const queries = [
+        ['HKCU\\Software\\Valve\\Steam', 'SteamPath'],
+        ['HKLM\\SOFTWARE\\WOW6432Node\\Valve\\Steam', 'InstallPath'],
+        ['HKLM\\SOFTWARE\\Valve\\Steam', 'InstallPath'],
+    ];
+    for (const [key, name] of queries) {
+        const result = spawnSync(SYSTEM.reg(), ['query', key, '/v', name], {
+            encoding: 'utf8',
+            windowsHide: true,
+            timeout: 10_000,
+        });
+        if (result.status !== 0)
+            continue;
+        const line = String(result.stdout ?? '')
+            .split(/\r?\n/)
+            .slice(0, 50)
+            .find((l) => l
+            .trim()
+            .toLowerCase()
+            .startsWith(name.toLowerCase() + ' '));
+        const value = line
+            ?.trim()
+            .split(/\s+REG_(?:EXPAND_)?SZ\s+/)[1]
+            ?.trim();
+        if (value && path.isAbsolute(value))
+            return path.normalize(value.replace(/\//g, '\\'));
+    }
+    return null;
+}
+/** The libraries a libraryfolders.vdf lists (both the current and the old format), in order. */
+export function steamLibraries(text) {
+    const root = parseVdf(text, { maxBytes: MAX_VDF_BYTES });
+    const folders = vdfObject(root, 'libraryfolders');
+    if (!folders)
+        return [];
+    const found = [];
+    for (const [key, value] of Object.entries(folders)) {
+        if (!/^\d{1,3}$/.test(key))
+            continue;
+        const at = typeof value === 'string' ? value : vdfText(value, 'path');
+        if (!at || !path.win32.isAbsolute(at))
+            continue;
+        const apps = typeof value === 'string' ? [] : Object.keys(vdfObject(value, 'apps') ?? {}).filter((a) => APP_ID.test(a));
+        if (!found.some((l) => l.path.toLowerCase() === at.toLowerCase()))
+            found.push({ path: at, apps });
+        if (found.length >= MAX_LIBRARIES)
+            break;
+    }
+    return found;
+}
+/** The libraries of a Steam install: its own folder first, then the ones libraryfolders.vdf lists. */
+export function librariesOf(steamRoot) {
+    const bytes = readBoundedFile(path.join(steamRoot, 'steamapps', 'libraryfolders.vdf'), MAX_VDF_BYTES);
+    const listed = bytes ? steamLibraries(bytes.toString('utf8')) : [];
+    const own = listed.find((l) => path.resolve(l.path).toLowerCase() === path.resolve(steamRoot).toLowerCase());
+    return [own ?? { path: steamRoot, apps: [] }, ...listed.filter((l) => l !== own)];
+}
+function readManifest(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 || !APP_ID.test(appId) || !installDir)
+        return null;
+    // One folder name under steamapps\common: never a path that climbs out of it.
+    if (/[\\/:]/.test(installDir) || /^\.+$/.test(installDir.trim()))
+        return null;
+    const buildId = vdfText(root, 'AppState', 'buildid');
+    const name = (vdfText(root, 'AppState', 'name') ?? '').replace(/[^\x20-\x7e\u00a0-\uffff]/g, '').slice(0, 100);
+    return {
+        appId,
+        name: name || 'Steam app ' + appId,
+        installDir,
+        ...(buildId && /^\d{1,20}$/.test(buildId) ? { buildId } : {}),
+    };
+}
+/** What `wanted` maps from a Steam install: every library's steamapps (true), or the listed games. */
+export function findSteamInstalls(steamRoot, wanted) {
+    const libraries = librariesOf(steamRoot);
+    if (wanted === true)
+        return libraries.flatMap((lib, i) => {
+            const steamapps = path.join(lib.path, 'steamapps');
+            try {
+                if (!fs.lstatSync(steamapps).isDirectory())
+                    return [];
+            }
+            catch {
+                return [];
+            }
+            return [
+                {
+                    kind: 'steam-library',
+                    id: 'library' + (i + 1),
+                    name: 'Steam library ' + (i + 1),
+                    host: steamapps,
+                    guest: '',
+                },
+            ];
+        });
+    const found = [];
+    for (const id of new Set(wanted.map(String).filter((w) => APP_ID.test(w)))) {
+        for (const lib of libraries) {
+            const manifest = readManifest(path.join(lib.path, 'steamapps', 'appmanifest_' + id + '.acf'));
+            if (!manifest || manifest.appId !== id)
+                continue;
+            found.push({
+                kind: 'steam-game',
+                id,
+                name: manifest.name,
+                ...(manifest.buildId ? { version: manifest.buildId } : {}),
+                host: path.join(lib.path, 'steamapps', 'common', manifest.installDir),
+                guest: '',
+            });
+            break;
+        }
+    }
+    return found;
+}
+export const steamInstalls = {
+    kind: 'steam-game',
+    setting: 'steamGames',
+    find(wanted, _pc) {
+        const root = steamRootFromRegistry();
+        if (!root)
+            throw new Error('Steam is not installed (the registry has no SteamPath)');
+        return findSteamInstalls(root, wanted);
+    },
+};

package/dist/host/pc-installs/unity.d.ts

@@ -0,0 +1,2 @@
+import type { PcInstallSource } from './source.js';
+export declare const unityInstalls: PcInstallSource;

package/dist/host/pc-installs/unity.js

@@ -0,0 +1,7 @@
+export const unityInstalls = {
+    kind: 'unity',
+    setting: 'unityEditors',
+    find(_wanted, _pc) {
+        return [];
+    },
+};

package/dist/host/pc-installs/unreal.d.ts

@@ -0,0 +1,2 @@
+import type { PcInstallSource } from './source.js';
+export declare const unrealInstalls: PcInstallSource;

package/dist/host/pc-installs/unreal.js

@@ -0,0 +1,7 @@
+export const unrealInstalls = {
+    kind: 'unreal',
+    setting: 'unrealEngines',
+    find(_wanted, _pc) {
+        return [];
+    },
+};

package/dist/host/profile/accounts.d.ts

@@ -1,11 +1,15 @@
 import { SecretStore } from '../secrets/index.js';
-import { type LoginFiles } from './claude-login.js';
+import { type CaptureOptions, type LoginFiles, type LoginKind } from './claude-login.js';
 export interface Account {
     readonly name: string;
     readonly savedAt: string;
     readonly email: string | null;
+    readonly kind: LoginKind;
+    /** sk-ant-...abcd for a key; null for a subscription. */
+    readonly keyHint: string | null;
     readonly credentials: unknown;
     readonly oauthAccount: unknown;
+    readonly apiKey?: string;
 }
 export interface AccountRow {
     readonly name: string;
@@ -13,12 +17,17 @@ export interface AccountRow {
     readonly isDefault: boolean;
     readonly isActive: boolean;
     readonly savedAt: string;
+    /** Claude accounts only. */
+    readonly kind?: LoginKind;
+    readonly keyHint?: string | null;
 }
 /** What lists need: no decryption. */
 export interface AccountMeta {
     readonly name: string;
     readonly savedAt: string;
     readonly email: string | null;
+    readonly kind: LoginKind;
+    readonly keyHint: string | null;
 }
 export declare function accountsDir(storageRoot: string): string;
 /** The saved Claude logins under <storage>\accounts, and which one each sandbox data folder uses. */
@@ -36,7 +45,7 @@ export declare class AccountStore {
     private file;
     private seal;
     private store;
-    /** The saved account's name, date and e-mail (nothing is decrypted). */
+    /** The saved account's name, date, e-mail and kind (nothing is decrypted). */
     meta(name: string): AccountMeta | null;
     /**
      * The saved account with its login decrypted. A plain file from an older version is encrypted on the spot (it stays
@@ -49,11 +58,17 @@ export declare class AccountStore {
     /** The account a data folder uses (kept in the index of the storage folder that data folder is in). */
     activeFor(dataPath: string): string | null;
     list(dataPath: string): AccountRow[];
-    /** Saves the sandbox's current login (or this PC's, with fromHost) under `name`. */
-    save(dataPath: string, name: string, fromHost: LoginFiles | null): Account;
     /**
-     * Makes `name` the sandbox's login. Claude refreshes (rotates) tokens while it runs, so the outgoing account's
-     * current tokens are saved back first; otherwise its stored refresh token could already be invalid.
+     * Saves the sandbox's current login (or this PC's, with fromHost) under `name`, whichever kind it is (`how.keyOnly`:
+     * only an API key; `how.envKey`: this PC's ANTHROPIC_API_KEY when nothing else is found).
+     */
+    save(dataPath: string, name: string, fromHost: LoginFiles | null, how?: CaptureOptions): Account;
+    /** Saves an API key you gave (typed in) under `name`. */
+    saveApiKey(dataPath: string, name: string, apiKey: string): Account;
+    private keep;
+    /**
+     * Makes `name` the sandbox's login. Claude refreshes (rotates) subscription tokens while it runs, so the outgoing
+     * subscription's current tokens are saved back first; otherwise its stored refresh token could already be invalid.
      */
     activate(dataPath: string, name: string): Account;
     setDefault(name: string | null): void;