windows-development-sandbox 1.17.0 → 1.18.0

package/dist/cli/menu/pages/accounts-page.js

@@ -1,6 +1,8 @@
-// Section 6: the saved logins of every agent, as the accounts view shows them (src/app/features/accounts). One category
-// per agent: its save rows and its logins. Keys and Enter act on the open agent only; what they do is the operation's.
-import { agentPage, listAccounts } from '../../../app/features/accounts/index.js';
+// Section 6: the saved logins of every agent and the service sign-ins, as the accounts view shows them
+// (src/app/features/accounts). One category per agent (its save rows and its logins), then one per service (its
+// state, its warnings, share / import / sign in / forget). Keys and Enter act on the open category only; what they do
+// is the operation's.
+import { agentPage, listAccounts, serviceCategory, servicePage, } from '../../../app/features/accounts/index.js';
 import { readQuery } from '../../../app/registry.js';
 import { MenuOperations } from '../io-menu.js';
 import { menuView } from '../render-view.js';
@@ -8,23 +10,36 @@ import { ListPage } from './list-page.js';
 /** The menu's rows, keys and Enter labels of one agent's category. */
 function viewOf(m, category) {
     const agent = m.agents.find((a) => a.name === category);
-    return agent
-        ? menuView(agentPage(agent), { category: agent.name, refresh: false })
-        : menuView({ title: 'Accounts', sections: [] }, { refresh: false });
+    if (agent)
+        return menuView(agentPage(agent), { category: agent.name, refresh: false });
+    const service = m.services.find((s) => serviceCategory(s.kind) === category);
+    if (service)
+        return menuView(servicePage(service), { category: serviceCategory(service.kind), refresh: false });
+    return menuView({ title: 'Accounts', sections: [] }, { refresh: false });
 }
 /** The list for the accounts tab. Pure. */
 export function accountsOptions(m) {
     return {
         path: [],
-        intro: 'Logins saved on this PC, per agent. Use puts one into the sandbox; new launches start with the default.',
-        categories: m.agents.map((a) => ({
-            id: a.name,
-            label: a.name,
-            description: a.kept
-                ? 'Saved ' + a.name + ' logins.'
-                : "This agent's login is not kept between sandboxes: it cannot be pointed at a folder we control.",
-        })),
-        items: m.agents.flatMap((a) => menuView(agentPage(a), { category: a.name, refresh: false }).items),
+        intro: 'Logins saved on this PC, per agent (Use puts one into the sandbox; new launches start with the default), and the service sign-ins sandboxes may get.',
+        categories: [
+            ...m.agents.map((a) => ({
+                id: a.name,
+                label: a.name,
+                description: a.kept
+                    ? 'Saved ' + a.name + ' logins.'
+                    : "This agent's login is not kept between sandboxes: it cannot be pointed at a folder we control.",
+            })),
+            ...m.services.map((s) => ({
+                id: serviceCategory(s.kind),
+                label: s.label,
+                description: 'Your ' + s.label + ' sign-in for sandboxes that use ' + s.usedBy.join(' or ') + '.',
+            })),
+        ],
+        items: [
+            ...m.agents.flatMap((a) => menuView(agentPage(a), { category: a.name, refresh: false }).items),
+            ...m.services.flatMap((s) => menuView(servicePage(s), { category: serviceCategory(s.kind), refresh: false }).items),
+        ],
         empty: 'No agents.',
         actions: (category) => viewOf(m, category).actions,
         enterLabel: (category, id) => viewOf(m, category).enterLabel(category, id),
@@ -33,7 +48,7 @@ export function accountsOptions(m) {
 export class AccountsPage extends ListPage {
     ctx;
     label = 'Accounts';
-    model = { agent: 'claude', agents: [] };
+    model = { agent: 'claude', agents: [], services: [] };
     operations;
     constructor(app, ctx) {
         super(app);

package/dist/cli/services/accounts-service.d.ts

@@ -1,4 +1,4 @@
-import { type AccountRow } from '../../host/profile/index.js';
+import { type AccountRow, type LoginKind } from '../../host/profile/index.js';
 import type { Context } from '../commands/context.js';
 export type AccountsContext = Pick<Context, 'storageRoot' | 'dataPath' | 'loaded'>;
 /** An agent in the Accounts tab. */
@@ -15,11 +15,16 @@ export interface AccountRef {
     readonly email: string | null;
     /** Something worth telling after a switch (e.g. plugins were copied, or could not be). */
     readonly note?: string;
+    /** Claude: which kind of login, and sk-ant-...abcd for a key. */
+    readonly kind?: LoginKind;
+    readonly keyHint?: string | null;
 }
 export declare class AccountsService {
     private readonly ctx;
+    private readonly env;
     private readonly claude;
-    constructor(ctx: AccountsContext);
+    /** @param env where this PC's ANTHROPIC_API_KEY is read (save --from-host) */
+    constructor(ctx: AccountsContext, env?: Readonly<Record<string, string | undefined>>);
     /** Claude first, then the other agents that keep a login, then the ones that cannot. */
     agents(): AgentAccounts[];
     /** The store, the sandbox folder of the agent's login, and its login files (non-Claude agents). */
@@ -27,8 +32,13 @@ export declare class AccountsService {
     list(agent?: string): AccountRow[];
     /** Name of the login the sandbox uses now for this agent, if any. */
     activeName(agent?: string): string | null;
-    /** Saves the sandbox's login, or this PC's when fromHost. */
-    save(name: string, fromHost: boolean, agent?: string): AccountRef;
+    /**
+     * Saves the sandbox's login, or this PC's when fromHost (its subscription, else its Console key, else
+     * ANTHROPIC_API_KEY of this PC). `keyOnly` (Claude): only an API key, never a subscription found next to it.
+     */
+    save(name: string, fromHost: boolean, agent?: string, keyOnly?: boolean): AccountRef;
+    /** Saves an Anthropic API key you typed as a Claude account (it is checked, never shown). */
+    saveApiKey(name: string, apiKey: string): AccountRef;
     /** Makes the sandbox use a saved login. Running sessions keep the old one until restart(). */
     activate(name: string, agent?: string): AccountRef;
     /** The agent's default login, if it keeps logins and one is set. */

package/dist/cli/services/accounts-service.js

@@ -7,11 +7,17 @@ import { SandboxChannel } from '../../host/channel/index.js';
 import { isSandboxRunning } from '../../host/sandbox/index.js';
 import { expandPath, fail } from '../../core/util/index.js';
 const CLAUDE = 'claude';
+function claudeRef(a) {
+    return { name: a.name, email: a.email, kind: a.kind, keyHint: a.keyHint };
+}
 export class AccountsService {
     ctx;
+    env;
     claude;
-    constructor(ctx) {
+    /** @param env where this PC's ANTHROPIC_API_KEY is read (save --from-host) */
+    constructor(ctx, env = process.env) {
         this.ctx = ctx;
+        this.env = env;
         this.claude = new AccountStore(ctx.storageRoot, ctx.loaded.config.claudeProfile.sharePluginsAcrossAccounts);
     }
     /** Claude first, then the other agents that keep a login, then the ones that cannot. */
@@ -52,11 +58,14 @@ export class AccountsService {
             ? this.claude.activeFor(this.ctx.dataPath)
             : this.other(agent).store.activeFor(this.ctx.dataPath);
     }
-    /** Saves the sandbox's login, or this PC's when fromHost. */
-    save(name, fromHost, agent = CLAUDE) {
+    /**
+     * Saves the sandbox's login, or this PC's when fromHost (its subscription, else its Console key, else
+     * ANTHROPIC_API_KEY of this PC). `keyOnly` (Claude): only an API key, never a subscription found next to it.
+     */
+    save(name, fromHost, agent = CLAUDE, keyOnly = false) {
         if (agent === CLAUDE) {
-            const saved = this.claude.save(this.ctx.dataPath, name, fromHost ? this.hostLogin() : null);
-            return { name: saved.name, email: saved.email };
+            const saved = this.claude.save(this.ctx.dataPath, name, fromHost ? this.hostLogin() : null, fromHost ? { keyOnly, envKey: this.env.ANTHROPIC_API_KEY ?? null } : { keyOnly });
+            return claudeRef(saved);
         }
         const { store, stateDir, hostDir } = this.other(agent);
         if (fromHost && !hostDir)
@@ -64,11 +73,15 @@ export class AccountsService {
         store.save(this.ctx.dataPath, name, fromHost && hostDir ? hostDir : stateDir, !fromHost);
         return { name, email: null };
     }
+    /** Saves an Anthropic API key you typed as a Claude account (it is checked, never shown). */
+    saveApiKey(name, apiKey) {
+        return claudeRef(this.claude.saveApiKey(this.ctx.dataPath, name, apiKey));
+    }
     /** Makes the sandbox use a saved login. Running sessions keep the old one until restart(). */
     activate(name, agent = CLAUDE) {
         if (agent === CLAUDE) {
             const a = this.claude.activate(this.ctx.dataPath, name);
-            return { name: a.name, email: a.email, note: this.claude.pluginNote ?? undefined };
+            return { ...claudeRef(a), note: this.claude.pluginNote ?? undefined };
         }
         const { store, stateDir } = this.other(agent);
         store.activate(this.ctx.dataPath, name, stateDir);

package/dist/cli/services/data-collect.js

@@ -4,6 +4,8 @@ import path from 'node:path';
 import _ from 'lodash';
 import { sizeOf } from '../../core/disk.js';
 import { dirExists, isLink } from '../../core/util/index.js';
+import { readValid } from '../../shared/io/index.js';
+import { INSTALL_RECORDS_FILE, InstallRecordsSchema } from '../../shared/installs.js';
 const AREA_ORDER = ['tools', 'databases', 'state', 'logs', 'data', 'host'];
 /** Folders of the data folder that get one row per child; anything else at the top level is listed as itself. */
 const PER_CHILD = ['tools', 'databases', 'state'];
@@ -13,11 +15,34 @@ function entriesOf(dir) {
         ? fs.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.isSymbolicLink())
         : [];
 }
+/**
+ * A tool folder's size from tools\installs.json, when every version folder in it has a recorded size (engines and
+ * editors of 60 GB are then not walked); null otherwise. The sandbox wrote the file: it only ever stands in for a walk.
+ */
+function recordedSize(dir, name, records) {
+    const versions = entriesOf(dir).filter((d) => d.isDirectory() && !d.name.startsWith('.'));
+    if (!versions.length)
+        return null;
+    let total = 0;
+    for (const v of versions) {
+        const known = records.find((r) => r.name === name && r.version === v.name);
+        if (known?.sizeBytes === null || known === undefined)
+            return null;
+        total += known.sizeBytes;
+    }
+    return total;
+}
 function toolRows(toolsDir) {
     const entries = entriesOf(toolsDir);
     const folders = entries.filter((d) => d.isDirectory());
     const files = entries.filter((d) => !d.isDirectory());
-    const row = (name, p) => ({ area: 'tools', name, path: p, bytes: sizeOf(p) });
+    const records = readValid(InstallRecordsSchema, path.join(toolsDir, INSTALL_RECORDS_FILE))?.installs ?? [];
+    const row = (name, p) => ({
+        area: 'tools',
+        name,
+        path: p,
+        bytes: recordedSize(p, name, records) ?? sizeOf(p),
+    });
     return [
         ...folders.flatMap((d) => d.name.toLowerCase() === 'agents'
             ? entriesOf(path.join(toolsDir, d.name)).map((a) => row('agents/' + a.name, path.join(toolsDir, d.name, a.name)))

package/dist/core/config/defaults.js

@@ -38,6 +38,17 @@ export const DEFAULTS = {
     network: { blockPrivateRanges: true, allowOnly: [], blockHosts: [], forwardPorts: [], dns: [], proxy: '' },
     vpn: { enabled: false, provider: 'nordvpn', protocol: 'udp', country: '', configFile: '', killSwitch: true },
     github: { shareToken: false },
+    accounts: {
+        epic: { share: false },
+        steam: { share: false },
+        unity: { share: false },
+        cfx: { share: false },
+        keystore: { share: false },
+        play: { share: false },
+        expo: { share: false },
+        appstore: { share: false },
+    },
+    pcInstalls: { steamGames: false, epicGames: false, unrealEngines: false, unityEditors: false },
     provisioning: {
         copyFromHost: true,
         fallbackToInstall: true,
@@ -62,7 +73,37 @@ export const DEFAULTS = {
             linkSlots: 'auto',
         },
         msvc: { enabled: 'auto', acceptLicense: false, msvcVersion: 'latest', sdkVersion: 'latest' },
-        unreal: { enabled: 'auto', acceptLicense: false, components: [], keepInstallFiles: true },
+        unreal: {
+            enabled: 'auto',
+            acceptLicense: false,
+            components: [],
+            keepInstallFiles: true,
+            persistEngines: true,
+            derivedDataCache: 'persisted',
+        },
+        unity: { enabled: 'auto', acceptLicense: false, version: 'project', modules: [], hub: false, keepVersions: 2 },
+        godot: { enabled: 'auto', version: 'project', dotnet: 'auto', exportTemplates: true, keepVersions: 2 },
+        steam: { enabled: 'auto', client: false, sdkFolder: '' },
+        fivem: {
+            enabled: 'auto',
+            acceptLicense: false,
+            game: 'gta5',
+            artifact: 'recommended',
+            txAdmin: true,
+            keepVersions: 2,
+        },
+        android: {
+            enabled: 'auto',
+            acceptLicense: false,
+            platforms: ['project'],
+            buildTools: 'latest',
+            ndk: 'auto',
+            cmake: 'auto',
+            packages: [],
+        },
+        flutter: { enabled: 'auto', version: 'project', windowsDesktop: false, precache: ['android', 'web'] },
+        dart: { enabled: 'auto', version: 'stable' },
+        reactNative: { enabled: 'auto', easCli: true },
         cpp: { enabled: 'auto', flexBison: true },
         dotnet: {
             enabled: 'auto',
@@ -71,10 +112,11 @@ export const DEFAULTS = {
             workloads: [],
             frameworkTargets: ['net48', 'net472'],
             netfx35: false,
+            templates: [],
         },
         // Bigger downloads only for projects that use them.
         go: { enabled: 'auto', version: 'stable', tools: [] },
-        java: { enabled: 'auto', version: 'lts', maven: true, gradle: true },
+        java: { enabled: 'auto', version: 'lts', maven: true, gradle: true, kotlin: false },
         ruby: { enabled: 'auto', version: '3', gems: [] },
         php: { enabled: 'auto', version: '8', composer: true },
         deno: { enabled: 'auto' },
@@ -144,8 +186,9 @@ export const DEFAULTS = {
             home: { env: { CODEX_HOME: 'codex' }, loginFiles: ['auth.json'], hostDir: '~/.codex' },
             localState: { CODEX_SQLITE_HOME: 'sqlite' },
             // Its own command sandbox keeps local users' passwords sealed with DPAPI: unreadable in the next sandbox
-            // ("CryptUnprotectData" on every command), so it sets that sandbox up again at each boot.
-            bootReset: ['.sandbox-secrets', '.sandbox\\setup_marker.json', '.sandbox\\deny_read_acl_state.json'],
+            // ("CryptUnprotectData" on every command), so it sets that sandbox up again at each boot. tmp\arg0: folders
+            // Codex cannot remove in a mapped folder (os error 145, a warning at every start); nothing holds them at boot.
+            bootReset: ['.sandbox-secrets', '.sandbox\\setup_marker.json', '.sandbox\\deny_read_acl_state.json', 'tmp\\arg0'],
             resumeArguments: ['resume', '--last'],
         },
         gemini: {

package/dist/core/detect/toolchains.d.ts

@@ -5,10 +5,18 @@ export declare const MARKERS: {
     readonly rust: readonly ["Cargo.toml", "rust-toolchain", "rust-toolchain.toml"];
     readonly msvc: readonly ["*.vcxproj", "CMakePresets.json", "CMakeUserPresets.json"];
     readonly unreal: readonly ["*.uproject", "*.uplugin"];
+    readonly unity: readonly ["ProjectVersion.txt"];
+    readonly godot: readonly ["project.godot"];
+    readonly steam: readonly ["steam_appid.txt", "steam_api64.dll", "steam_api.dll"];
+    readonly fivem: readonly ["fxmanifest.lua", "__resource.lua"];
+    readonly android: readonly [];
+    readonly flutter: readonly [];
+    readonly dart: readonly [];
+    readonly reactNative: readonly [];
     readonly cpp: readonly ["CMakeLists.txt", "Makefile", "meson.build", "premake5.lua", "Cargo.toml", "*.vcxproj", "*.c", "*.cpp", "*.cc", "*.h", "*.hpp"];
     readonly dotnet: readonly ["*.sln", "*.slnx", "*.csproj", "*.fsproj", "*.vbproj", "global.json", "*.cs"];
     readonly go: readonly ["go.mod", "go.work", "*.go"];
-    readonly java: readonly ["pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts", "mvnw", "gradlew", ".java-version", ".sdkmanrc", "*.java"];
+    readonly java: readonly ["pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts", "mvnw", "gradlew", ".java-version", ".sdkmanrc", "*.java", "*.kt"];
     readonly ruby: readonly ["Gemfile", "*.gemspec", ".ruby-version", "*.rb"];
     readonly php: readonly ["composer.json", "artisan", ".php-version", "*.php"];
     readonly deno: readonly ["deno.json", "deno.jsonc", "deno.lock"];
@@ -19,6 +27,12 @@ export declare const MARKERS: {
 };
 export type AutoToolchain = keyof typeof MARKERS;
 export declare const AUTO_TOOLCHAINS: AutoToolchain[];
+/**
+ * Toolchains that come under licence terms and are big downloads (1-60 GB): "auto" installs them only once you accept
+ * the licence (toolchains.<name>.acceptLicense). A project file can never accept one for you (local-config policy).
+ */
+export declare const LICENSED_TOOLCHAINS: readonly ["msvc", "unreal", "unity", "fivem", "android"];
+export type LicensedToolchain = (typeof LICENSED_TOOLCHAINS)[number];
 export interface ToolchainDecision {
     on: boolean;
     reason: string;

package/dist/core/detect/toolchains.js

@@ -16,6 +16,16 @@ export const MARKERS = {
     rust: ['Cargo.toml', 'rust-toolchain', 'rust-toolchain.toml'],
     msvc: ['*.vcxproj', 'CMakePresets.json', 'CMakeUserPresets.json'],
     unreal: ['*.uproject', '*.uplugin'],
+    unity: ['ProjectVersion.txt'],
+    godot: ['project.godot'],
+    steam: ['steam_appid.txt', 'steam_api64.dll', 'steam_api.dll'],
+    fivem: ['fxmanifest.lua', '__resource.lua'],
+    // Decided from file contents (host/launch/hints): Gradle's com.android plugin, an AndroidManifest.xml deeper down,
+    // <UseMaui>, a pubspec's flutter: section, react-native / expo in package.json.
+    android: [],
+    flutter: [],
+    dart: [],
+    reactNative: [],
     cpp: [
         'CMakeLists.txt',
         'Makefile',
@@ -42,6 +52,7 @@ export const MARKERS = {
         '.java-version',
         '.sdkmanrc',
         '*.java',
+        '*.kt',
     ],
     ruby: ['Gemfile', '*.gemspec', '.ruby-version', '*.rb'],
     php: ['composer.json', 'artisan', '.php-version', '*.php'],
@@ -54,6 +65,11 @@ export const MARKERS = {
     pwsh: [],
 };
 export const AUTO_TOOLCHAINS = Object.keys(MARKERS);
+/**
+ * Toolchains that come under licence terms and are big downloads (1-60 GB): "auto" installs them only once you accept
+ * the licence (toolchains.<name>.acceptLicense). A project file can never accept one for you (local-config policy).
+ */
+export const LICENSED_TOOLCHAINS = ['msvc', 'unreal', 'unity', 'fivem', 'android'];
 /** Files of any ecosystem: a folder with none of them is no project yet. */
 const PROJECT_FILES = [...new Set([...Object.values(MARKERS).flat(), 'package.json', 'deno.json', '*.ts', '*.js'])];
 /**
@@ -81,18 +97,7 @@ export function decideToolchains(settings, entries, pcHas, hints = {}) {
     // Rust links with MSVC when this PC does (its rustup host is *-msvc), otherwise with MinGW's gcc.
     if (result.rust.on && settings.msvc.enabled === 'auto' && !result.msvc.on && pcHas.includes('msvc'))
         result.msvc = { on: true, reason: 'Rust on this PC builds with MSVC' };
-    // MSVC is a 1-2 GB licensed download: "auto" only installs it once its licence is accepted.
-    if (settings.msvc.enabled === 'auto' && result.msvc.on && !settings.msvc.acceptLicense)
-        result.msvc = {
-            on: false,
-            reason: 'would be used (' + result.msvc.reason + '); set toolchains.msvc.acceptLicense to install it',
-        };
-    // Unreal is a ~10 GB licensed install every boot: "auto" only installs it once its licence is accepted.
-    if (settings.unreal.enabled === 'auto' && result.unreal.on && !settings.unreal.acceptLicense)
-        result.unreal = {
-            on: false,
-            reason: 'would be used (' + result.unreal.reason + '); set toolchains.unreal.acceptLicense to install it',
-        };
+    applyImplications(settings, result);
     if (result.rust.on && !result.msvc.on && !result.cpp.on && settings.cpp.enabled !== false)
         result.cpp = { on: true, reason: 'the linker for Rust' };
     // uv installs the Python tools (`uv tool install`), so Python tools turn an "auto" uv on.
@@ -102,6 +107,34 @@ export function decideToolchains(settings, entries, pcHas, hints = {}) {
         result.vscode = { on: true, reason: 'installed on this PC' };
     return result;
 }
+/** An "auto" toolchain another one needs is turned on (with the reason), unless you turned it off. */
+function imply(settings, result, name, reason) {
+    if (settings[name].enabled === 'auto' && !result[name].on)
+        result[name] = { on: true, reason };
+}
+/**
+ * What one toolchain brings along (Android for Flutter and React Native, a JDK for Android, .NET for Godot's C#
+ * build), and the licence gates: a licensed "auto" toolchain is off until its licence is accepted. Android is implied
+ * before its gate (Flutter alone never accepts the Android licence) and the JDK after it.
+ */
+function applyImplications(settings, result) {
+    if (result.flutter.on)
+        imply(settings, result, 'android', 'Flutter builds for Android');
+    if (result.reactNative.on)
+        imply(settings, result, 'android', 'React Native builds for Android');
+    if (result.godot.on && settings.godot.dotnet === true)
+        imply(settings, result, 'dotnet', "Godot's .NET build");
+    for (const name of LICENSED_TOOLCHAINS) {
+        if (settings[name].enabled !== 'auto' || !result[name].on || settings[name].acceptLicense)
+            continue;
+        result[name] = {
+            on: false,
+            reason: 'would be used (' + result[name].reason + '); set toolchains.' + name + '.acceptLicense to install it',
+        };
+    }
+    if (result.android.on)
+        imply(settings, result, 'java', 'the Android SDK needs a JDK (17 or newer)');
+}
 /** The settings with every "auto" replaced by the decision (what the sandbox receives). */
 export function resolveToolchains(settings, decisions) {
     const out = structuredClone(settings);

package/dist/core/local-config/overrides.js

@@ -4,6 +4,8 @@ import _ from 'lodash';
 import { mergeConfig } from '../config/index.js';
 import { describeIssues, LocalOverridesSchema } from '../schema/index.js';
 import { expandPath, fail, fileExists, isInsideOrEqual } from '../util/index.js';
+import { SERVICE_KINDS } from '../../shared/accounts/kinds.js';
+import { LICENSED_TOOLCHAINS } from '../detect/toolchains.js';
 /** Validates a folder's settings and resolves its relative paths against that folder. */
 export function normalizeOverrides(data, dir, source) {
     const parsed = LocalOverridesSchema.safeParse(data);
@@ -64,6 +66,10 @@ export const OFF_IS_SAFER = [
     'sandbox.printerRedirection',
     'sandbox.vGpu',
     'claudeProfile.copyCredentials',
+    // Hands your saved service sign-ins (Epic, Steam, signing keys ...) to the sandbox.
+    ...SERVICE_KINDS.map((kind) => 'accounts.' + kind + '.share'),
+    // A licence (and a 10-60 GB install) is yours to accept, never a repo's.
+    ...LICENSED_TOOLCHAINS.map((name) => 'toolchains.' + name + '.acceptLicense'),
     'claudeProfile.enabled',
     'claudeProfile.syncHistory',
     'claudeProfile.syncClaudeMem',

package/dist/core/schema/accounts.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const AccountsSchema: z.ZodObject<{
+    epic: z.ZodObject<{
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+    steam: z.ZodObject<{
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+    unity: z.ZodObject<{
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+    cfx: z.ZodObject<{
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+    keystore: z.ZodObject<{
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+    play: z.ZodObject<{
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+    expo: z.ZodObject<{
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+    appstore: z.ZodObject<{
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/core/schema/accounts.js

@@ -0,0 +1,32 @@
+// accounts: which saved service sign-ins sandboxes get (the sign-ins themselves are not settings: they are kept
+// encrypted by `sandbox account import|login`, or come back from a sandbox you signed in in).
+import { z } from 'zod';
+import { SERVICE_SPECS } from '../../shared/accounts/kinds.js';
+function share(kind, how) {
+    const spec = SERVICE_SPECS[kind];
+    return z.strictObject({
+        share: z
+            .boolean()
+            .describe('Hand your saved ' +
+            spec.label +
+            ' sign-in to sandboxes that use ' +
+            spec.usedBy.join(' or ') +
+            ' (' +
+            how +
+            '). Kept encrypted on this PC; ' +
+            spec.warnings.join(' ') +
+            ' Yours only: a project file can only turn it off.'),
+    });
+}
+export const AccountsSchema = z
+    .strictObject({
+    epic: share('epic', "sign in to the launcher once in a sandbox, or take this PC's: sandbox account import epic"),
+    steam: share('steam', 'sign in once with sbx-steam login, or: sandbox account import steam --from <steamcmd folder>'),
+    unity: share('unity', "sign in once in a sandbox, or take this PC's licence: sandbox account import unity"),
+    cfx: share('cfx', 'sandbox account login cfx'),
+    keystore: share('keystore', 'sandbox account import keystore --from <upload.jks>'),
+    play: share('play', 'sandbox account import play --from <service-account.json>'),
+    expo: share('expo', 'sandbox account login expo'),
+    appstore: share('appstore', 'sandbox account import appstore --from <AuthKey.p8>'),
+})
+    .describe('Service sign-ins for sandboxes (game stores, engines, app signing). Manage them in Accounts: sandbox account status.');