windows-development-sandbox 1.0.5 → 1.1.0

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const Port: z.ZodNumber;
+export declare const dbEnabled: (name: string) => z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+export declare const Databases: z.ZodObject<{
+    postgres: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        version: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>;
+    mysql: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        version: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>;
+    mongodb: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        version: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>;
+    redis: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        port: z.ZodNumber;
+    }, z.core.$strict>;
+    dynamodb: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        port: z.ZodNumber;
+        adminPort: z.ZodNumber;
+        admin: z.ZodBoolean;
+    }, z.core.$strict>;
+    sqlserver: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/core/schema/databases.js

@@ -0,0 +1,35 @@
+// Databases that run inside the sandbox.
+import { z } from 'zod';
+import { Enabled } from './common.js';
+export const Port = z.number().int().min(1024).max(65535);
+export const dbEnabled = (name) => Enabled.describe(name + ': true, false, or "auto" = only when the project needs it (found from compose files, dependencies of every language, Prisma/ORM config and connection strings).');
+export const Databases = z.strictObject({
+    postgres: z.strictObject({
+        enabled: dbEnabled('PostgreSQL (with psql, pg_dump). User postgres, no password, localhost only'),
+        version: z.string().min(1).describe('"latest" or a major version such as "16". A compose file pinning postgres:<major> wins.'),
+        port: Port.describe('Port inside the sandbox.'),
+    }),
+    mysql: z.strictObject({
+        enabled: dbEnabled('MySQL-compatible database (MariaDB). User root, no password, localhost only'),
+        version: z.string().min(1).describe('"lts" (newest MariaDB LTS) or a MariaDB series such as "11.4".'),
+        port: Port.describe('Port inside the sandbox.'),
+    }),
+    mongodb: z.strictObject({
+        enabled: dbEnabled('MongoDB with mongosh, localhost only'),
+        version: z.string().min(1).describe('"latest" or a version prefix such as "8.0".'),
+        port: Port.describe('Port inside the sandbox.'),
+    }),
+    redis: z.strictObject({
+        enabled: dbEnabled('Redis (community Windows build), localhost only'),
+        port: Port.describe('Port inside the sandbox.'),
+    }),
+    dynamodb: z.strictObject({
+        enabled: dbEnabled('DynamoDB Local (Amazon\'s official emulator, on the Java toolchain) with dynamodb-admin, a web UI to browse and edit tables'),
+        port: Port.describe('DynamoDB endpoint port inside the sandbox (http://localhost:<port>).'),
+        adminPort: Port.describe('dynamodb-admin web UI port (open http://localhost:<adminPort> in the sandbox\'s browser).'),
+        admin: z.boolean().describe('Run dynamodb-admin next to DynamoDB Local.'),
+    }),
+    sqlserver: z.strictObject({
+        enabled: dbEnabled('SQL Server. It cannot run inside Windows Sandbox; when a project needs it you get a note to use Postgres or SQLite for local work'),
+    }),
+});

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const Harness: z.ZodObject<{
+    hostExecutable: z.ZodOptional<z.ZodString>;
+    hostDir: z.ZodOptional<z.ZodString>;
+    npmPackage: z.ZodOptional<z.ZodString>;
+    npmBin: z.ZodOptional<z.ZodString>;
+    uvPackage: z.ZodOptional<z.ZodString>;
+    uvBin: z.ZodOptional<z.ZodString>;
+    arguments: z.ZodArray<z.ZodString>;
+    environment: z.ZodRecord<z.ZodString, z.ZodString>;
+    resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;

package/dist/core/schema/harness.js

@@ -0,0 +1,17 @@
+// An agent (claude, codex, ...) the sandbox can run.
+import { z } from 'zod';
+import { Strings } from './common.js';
+export const Harness = z.strictObject({
+    hostExecutable: z.string().optional().describe('Executable copied from this PC when installed here (e.g. claude.exe).'),
+    hostDir: z.string().optional().describe('Folder of hostExecutable on this PC, or "auto" to search PATH and ~/.local/bin.'),
+    npmPackage: z.string().optional().describe('npm package installed inside the sandbox when there is no host copy.'),
+    npmBin: z.string().optional().describe('Command the npm package provides.'),
+    uvPackage: z.string().optional().describe('Python package installed with `uv tool install` inside the sandbox (e.g. aider-chat).'),
+    uvBin: z.string().optional().describe('Command the uv package provides.'),
+    arguments: Strings.describe('Arguments always passed to the agent.'),
+    environment: z.record(z.string(), z.string()).describe('Environment variables for the agent.'),
+    resumeArguments: Strings.optional().describe('Arguments used when the agent is restarted in place (e.g. after an account switch) so it resumes the conversation.'),
+})
+    .refine((h) => h.hostExecutable || h.npmPackage || h.uvPackage, 'needs hostExecutable, npmPackage or uvPackage')
+    .refine((h) => !h.uvPackage || h.uvBin, 'needs uvBin when uvPackage is set')
+    .refine((h) => !h.npmPackage || h.npmBin, 'needs npmBin when npmPackage is set');

package/dist/core/schema/json-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+/** One readable line per problem: "sandbox.memoryMb: Too small: expected number to be >=2048". */
+export declare const describeIssues: (error: z.ZodError) => string[];
+/** JSON Schema documents for editors. The user config only lists what it changes, so nothing in it is required. */
+export declare const jsonSchemas: () => Record<string, object>;

package/dist/core/schema/json-schema.js

@@ -0,0 +1,25 @@
+// Readable validation messages and the JSON Schema documents generated from the settings schemas.
+import { z } from 'zod';
+import { Config, LocalOverrides } from './config.js';
+/** One readable line per problem: "sandbox.memoryMb: Too small: expected number to be >=2048". */
+export const describeIssues = (error) => error.issues.map((issue) => {
+    const at = issue.path.join('.');
+    if (issue.code === 'unrecognized_keys')
+        return issue.keys.map((k) => (at ? at + '.' : '') + k + ' is not allowed here').join('; ');
+    return (at || 'value') + ': ' + issue.message;
+});
+/** JSON Schema documents for editors. The user config only lists what it changes, so nothing in it is required. */
+export const jsonSchemas = () => {
+    const dropRequired = (node) => {
+        if (Array.isArray(node))
+            return node.map(dropRequired);
+        if (typeof node !== 'object' || node === null)
+            return node;
+        return Object.fromEntries(Object.entries(node).filter(([k]) => k !== 'required').map(([k, v]) => [k, dropRequired(v)]));
+    };
+    const toSchema = (schema, title) => ({ title, ...z.toJSONSchema(schema, { io: 'input', unrepresentable: 'any' }) });
+    return {
+        'config.schema.json': dropRequired(toSchema(Config, 'windows-development-sandbox user config (~/.agent-sandbox/config.json)')),
+        'sandbox-config.schema.json': toSchema(LocalOverrides, 'windows-development-sandbox project config (.sandbox-config.json)'),
+    };
+};

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const Secrets: z.ZodObject<{
+    strip: z.ZodBoolean;
+    allow: z.ZodArray<z.ZodString>;
+    patterns: z.ZodArray<z.ZodString>;
+    warnFiles: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const Attach: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    reuseSession: z.ZodBoolean;
+    auto: z.ZodBoolean;
+    autoHide: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgentCommands: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    agents: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodArray<z.ZodString>]>;
+}, z.core.$strict>;
+export declare const ClaudeProfile: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    hostDir: z.ZodString;
+    include: z.ZodArray<z.ZodString>;
+    globalStateFile: z.ZodString;
+    copyCredentials: z.ZodBoolean;
+    overwrite: z.ZodBoolean;
+    syncHistory: z.ZodBoolean;
+    syncClaudeMem: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/core/schema/profile.js

@@ -0,0 +1,29 @@
+// What is copied from this PC, and how the terminal attaches.
+import { z } from 'zod';
+import { Name, Strings } from './common.js';
+export const Secrets = z.strictObject({
+    strip: z.boolean().describe('Remove credentials from everything copied into the sandbox (your Claude settings.json "env" and credential helpers, MCP servers\' env, headers and arguments): AWS, Azure, Google Cloud, Cloudflare, hosting, CI, registries, payment, AI API keys, database URLs, anything named *_TOKEN / *_SECRET / *PASSWORD* / *_KEY or *PROD*, and values that look like keys.'),
+    allow: Strings.describe('Variable names that may go in anyway; * matches anything, e.g. ["AWS_REGION", "AWS_PROFILE", "MY_APP_*"].'),
+    patterns: Strings.describe('More variable names to treat as secrets; * matches anything, e.g. ["ACME_*", "*_INTERNAL_URL"].'),
+    warnFiles: z.boolean().describe('Warn at launch about files in the workspace that usually hold secrets (.env, *.pem, credentials.json, ...). The agent CAN read them: Windows Sandbox maps the whole folder.'),
+});
+export const Attach = z.strictObject({
+    enabled: z.boolean().describe('Allow sandbox claude --terminal / sandbox attach from this PC.'),
+    reuseSession: z.boolean().describe('sandbox claude -t in a running sandbox reattaches to this folder\'s session when no terminal on this PC is attached to it (--new always starts another).'),
+    auto: z.boolean().describe('Starting an agent attaches this terminal automatically, as if you passed -t (only in an interactive terminal).'),
+    autoHide: z.boolean().describe('Hide the Windows Sandbox window whenever this terminal attaches; it keeps running (sandbox show brings it back).'),
+});
+export const AgentCommands = z.strictObject({
+    enabled: z.boolean().describe('(Beta) Typing an agent\'s own command on this PC (claude, codex, ...) starts it in a hidden sandbox for the folder you are in and attaches that terminal. Adds one folder to the start of YOUR PATH; off removes it. SANDBOX_AGENT_DIRECT=1 runs the real agent instead.'),
+    agents: z.union([z.literal('auto'), z.array(Name)]).describe('"auto" = every agent installed on this PC, or a list of agent names, e.g. ["claude", "codex"].'),
+});
+export const ClaudeProfile = z.strictObject({
+    enabled: z.boolean().describe('Copy selected Claude settings from this PC into the sandbox.'),
+    hostDir: z.string().describe('Your Claude folder, or "auto" (~/.claude or CLAUDE_CONFIG_DIR).'),
+    include: z.array(z.string().regex(/^[A-Za-z0-9._-]+$/)).describe('Files and folders copied from it.'),
+    globalStateFile: z.string().describe('Your .claude.json, or "auto". Empty string = do not copy.'),
+    copyCredentials: z.boolean().describe('Copy your Claude LOGIN into the sandbox. Prefer sandbox account instead.'),
+    overwrite: z.boolean().describe('Refresh these settings from this PC on every launch.'),
+    syncHistory: z.boolean().describe('Bring all conversation history in, and sync new history back (path-translated).'),
+    syncClaudeMem: z.boolean().describe('Bring claude-mem data in, and its database back when the sandbox closes.'),
+});

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const Projects: z.ZodObject<{
+    all: z.ZodBoolean;
+    exclude: z.ZodArray<z.ZodString>;
+    roots: z.ZodArray<z.ZodString>;
+    askToAddRoot: z.ZodBoolean;
+    declinedRoots: z.ZodArray<z.ZodString>;
+    wsbShare: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/core/schema/projects.js

@@ -0,0 +1,11 @@
+// Several projects in one running sandbox. User config only: these settings map folders of this PC into the sandbox,
+// so a project's .sandbox-config.json can never set them (LocalOverrides has no `projects`).
+import { z } from 'zod';
+export const Projects = z.strictObject({
+    all: z.boolean().describe('Map every project you have started before (and every folder in your roots) at every start, except those in exclude, so all of them open in the running sandbox without a restart. Every agent in the sandbox can then see all of them. Each one is still only set up when you first use it.'),
+    exclude: z.array(z.string().min(1)).describe('Projects left out when "all" is on (folders on this PC).'),
+    roots: z.array(z.string().min(1)).describe('Folders whose subfolders are your projects (e.g. "F:\\\\Code"), mapped read/write at every start. Any project inside one, including ones you create later, opens in the running sandbox at once, without a restart. Every agent in the sandbox can see all of them.'),
+    askToAddRoot: z.boolean().describe('When you start a project whose parent folder is not a root yet, ask once whether to add it.'),
+    declinedRoots: z.array(z.string().min(1)).describe('Parent folders you said no to (not asked again).'),
+    wsbShare: z.boolean().describe('On Windows 11 24H2+ with the Windows Sandbox command line (wsb), add other folders to the running sandbox with `wsb share` (untested). Otherwise starting a project outside every root offers a restart.'),
+});

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export declare const GuestWorkspace: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"mirror">, z.ZodString]>;
+export declare const Mapping: z.ZodObject<{
+    host: z.ZodString;
+    guest: z.ZodString;
+    readOnly: z.ZodBoolean;
+    optional: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const Sandbox: z.ZodObject<{
+    memoryMb: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>;
+    maxMemoryMb: z.ZodNumber;
+    maxMemoryPercent: z.ZodNumber;
+    cpuLimit: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodNumber]>;
+    reserveHostMb: z.ZodNumber;
+    vGpu: z.ZodBoolean;
+    networking: z.ZodBoolean;
+    clipboard: z.ZodBoolean;
+    audioInput: z.ZodBoolean;
+    videoInput: z.ZodBoolean;
+    printerRedirection: z.ZodBoolean;
+    protectedClient: z.ZodBoolean;
+    headless: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const Git: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    access: z.ZodEnum<{
+        readonly: "readonly";
+        full: "full";
+        none: "none";
+    }>;
+}, z.core.$strict>;
+export declare const Provisioning: z.ZodObject<{
+    copyFromHost: z.ZodBoolean;
+    fallbackToInstall: z.ZodBoolean;
+    refresh: z.ZodBoolean;
+    git: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        access: z.ZodEnum<{
+            readonly: "readonly";
+            full: "full";
+            none: "none";
+        }>;
+    }, z.core.$strict>;
+    terminal: z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const Downloads: z.ZodObject<{
+    requireChecksum: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/core/schema/sandbox.js

@@ -0,0 +1,36 @@
+// The sandbox machine, folders mapped into it, and what is provisioned (Git, terminal).
+import { z } from 'zod';
+import { GitAccess, GuestPath, toggle } from './common.js';
+export const GuestWorkspace = z.union([z.literal('auto'), z.literal('mirror'), GuestPath]).describe('Where the workspace appears inside the sandbox. "auto" = C:\\Workspace\\<folder name>. "mirror" = the same path as on this PC, so absolute paths in configs and build caches match (another drive letter such as F: is a subst drive onto C:\\Mirror\\F); paths the sandbox reserves (C:\\Users\\..., C:\\Program Files\\...) fall back to "auto".');
+export const Mapping = z.strictObject({
+    host: z.string().min(1).describe('Folder on this PC (relative paths are relative to the config file).'),
+    guest: GuestPath.describe('Where it appears inside the sandbox, e.g. C:\\Assets, or on another drive letter (D: to Z:) such as F:\\SteamLibrary\\steamapps\\common\\Game: mapped to C:\\Mirror\\F\\... and shown as F: (subst) at boot.'),
+    readOnly: z.boolean().describe('true = the agent can only read it.'),
+    optional: z.boolean().optional().describe('true = skip it quietly when the host folder does not exist.'),
+});
+export const Sandbox = z.strictObject({
+    memoryMb: z.union([z.literal('auto'), z.number().int().min(2048)]).describe('Sandbox RAM in MB (>= 2048), or "auto": free RAM minus reserveHostMb, capped at maxMemoryMb.'),
+    maxMemoryMb: z.number().int().positive().describe('Upper limit for memoryMb "auto".'),
+    maxMemoryPercent: z.number().int().min(10).max(100).describe('memoryMb "auto" never takes more than this share of this PC\'s total RAM (percent).'),
+    cpuLimit: z.union([z.literal('none'), z.number().int().min(5).max(100)]).describe('Most of this PC\'s CPU the sandbox may use, in percent (5-100), e.g. 50 keeps half free for you; "none" = no cap (Windows Sandbox would take every processor). Covers everything this tool starts in the sandbox (agents, installs, builds, its terminal).'),
+    reserveHostMb: z.number().int().nonnegative().describe('RAM always left for this PC when memoryMb is "auto".'),
+    vGpu: z.boolean().describe('Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface.'),
+    networking: z.boolean().describe('Internet access. false is the only hard network isolation Windows Sandbox offers.'),
+    clipboard: z.boolean().describe('Shared clipboard between this PC and the sandbox.'),
+    audioInput: z.boolean().describe('Microphone access.'),
+    videoInput: z.boolean().describe('Camera access.'),
+    printerRedirection: z.boolean().describe('Printers from this PC.'),
+    protectedClient: z.boolean().describe('Run the sandbox window in Protected Client mode (recommended).'),
+    headless: z.boolean().describe('Hide the sandbox window (sbx-show brings it back). A headless sandbox shuts down when its last session ends.'),
+});
+export const Git = z.strictObject({ enabled: z.boolean().describe('Provide Git for Windows (and Git Bash, which Claude Code needs).'), access: GitAccess });
+export const Provisioning = z.strictObject({
+    copyFromHost: z.boolean().describe('Copy Node, Git, nvm and the agent from this PC when they are installed here.'),
+    fallbackToInstall: z.boolean().describe('Download anything that cannot be copied from this PC.'),
+    refresh: z.boolean().describe('Re-copy / re-download everything on the next launch.'),
+    git: Git,
+    terminal: toggle('Windows Terminal as the sandbox window (downloaded once).'),
+});
+export const Downloads = z.strictObject({
+    requireChecksum: z.boolean().describe('Refuse any toolchain, database or tool download that has no published checksum (SHA-256/SHA-512) to verify it against. false = allow those, as before. Downloads that do have a published checksum are always verified. A project\'s .sandbox-config.json can only turn this on.'),
+});

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

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+export declare const Toolchains: z.ZodObject<{
+    node: z.ZodObject<{
+        version: z.ZodString;
+        extraVersions: z.ZodArray<z.ZodString>;
+        corepack: z.ZodBoolean;
+        volta: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        globalPackages: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    python: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        version: z.ZodString;
+        python2: z.ZodBoolean;
+        pyenv: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        tools: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    rust: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        toolchain: z.ZodString;
+        host: z.ZodString;
+        components: z.ZodArray<z.ZodString>;
+        targets: z.ZodArray<z.ZodString>;
+        crates: z.ZodArray<z.ZodString>;
+        targetDir: z.ZodString;
+    }, z.core.$strict>;
+    msvc: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        acceptLicense: z.ZodBoolean;
+        msvcVersion: z.ZodString;
+        sdkVersion: z.ZodString;
+    }, z.core.$strict>;
+    cpp: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        flexBison: z.ZodBoolean;
+    }, z.core.$strict>;
+    dotnet: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        channels: z.ZodArray<z.ZodString>;
+        tools: z.ZodArray<z.ZodString>;
+        workloads: z.ZodArray<z.ZodString>;
+        frameworkTargets: z.ZodArray<z.ZodString>;
+        netfx35: z.ZodBoolean;
+    }, z.core.$strict>;
+    go: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        version: z.ZodString;
+        tools: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    java: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        version: z.ZodString;
+        maven: z.ZodBoolean;
+        gradle: z.ZodBoolean;
+    }, z.core.$strict>;
+    ruby: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        version: z.ZodString;
+        gems: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    php: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        version: z.ZodString;
+        composer: z.ZodBoolean;
+    }, z.core.$strict>;
+    deno: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+    }, z.core.$strict>;
+    pwsh: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+    }, z.core.$strict>;
+    cli: z.ZodObject<{
+        gh: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        zstd: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        openssl: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+    }, z.core.$strict>;
+    bun: z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strict>;
+    uv: z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strict>;
+    vcRuntime: z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strict>;
+    mesa: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        vulkan: z.ZodBoolean;
+    }, z.core.$strict>;
+    vscode: z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strict>;
+    environment: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;

package/dist/core/schema/toolchains.js

@@ -0,0 +1,83 @@
+// Languages and tools installed inside the sandbox.
+import { z } from 'zod';
+import { enabled, Enabled, Packages, Strings, toggle } from './common.js';
+export const Toolchains = z.strictObject({
+    node: z.strictObject({
+        version: z.string().min(1).describe('Default Node version for nvm. "host" = the Node on this PC. A project\'s .nvmrc / .node-version wins.'),
+        extraVersions: Strings.describe('More Node versions to install (switch with nvm use). On top of the up to 3 versions copied from this PC\'s nvm, not counted towards that limit.'),
+        corepack: z.boolean().describe('pnpm and yarn through corepack (a project\'s "packageManager" in package.json picks the version).'),
+        volta: Enabled.describe('Volta: true, false, or "auto" = when the project\'s package.json has "volta" pins or this PC uses Volta. With pins, Volta\'s node/npm/yarn/pnpm come first on PATH.'),
+        globalPackages: Packages('npm packages installed globally into the default Node version', '["typescript", "npm-check-updates"]'),
+    }),
+    python: z.strictObject({
+        enabled: enabled('Python 3 (CPython with pip).', 'pyproject.toml, requirements.txt, setup.py, Pipfile or .python-version'),
+        version: z.string().min(1).describe('Python 3 version prefix, e.g. "3" or "3.12". A project\'s .python-version wins.'),
+        python2: z.boolean().describe('Also install Python 2.7 as python2 / pip2.'),
+        pyenv: Enabled.describe('pyenv-win (pyenv install / local / global): true, false, or "auto" = when this PC uses pyenv. .python-version is honoured either way, and `uv python install` always works.'),
+        tools: Packages('Python command-line tools installed with `uv tool install` (needs uv)', '["poetry", "ruff", "pre-commit"]'),
+    }),
+    rust: z.strictObject({
+        enabled: enabled('Rust via rustup (cargo, rustc).', 'Cargo.toml or rust-toolchain(.toml)'),
+        toolchain: z.string().min(1).describe('Default toolchain, e.g. "stable". rust-toolchain.toml in a project wins.'),
+        host: z.string().min(1).describe('Host triple, or "auto": x86_64-pc-windows-msvc when the MSVC toolchain is on (like most PCs), else x86_64-pc-windows-gnu (MinGW is its linker).'),
+        components: Packages('Extra rustup components', '["rust-src", "llvm-tools"]'),
+        targets: Packages('Extra rustup targets', '["wasm32-unknown-unknown"]'),
+        crates: Packages('Binaries for cargo: prebuilt via cargo-binstall when the crate publishes a Windows build, else compiled with `cargo install --locked` (slow the first time)', '["sccache", "cargo-nextest", "cargo-deny"]'),
+        targetDir: z.string().min(1).describe('"shared": cargo\'s default target\\ (shared with builds on this PC, so builds on either side invalidate the other), "separate": <workspace>\\target\\sandbox (kept, no cross-talk), "local": on the sandbox\'s own disk (fastest, lost every boot), or a guest path.'),
+    }),
+    msvc: z.strictObject({
+        enabled: enabled('MSVC (cl, link) and the Windows SDK, portable from Microsoft\'s Visual Studio manifest (~1-2 GB once), with vcvars64.bat and vswhere.', 'a .vcxproj, CMakePresets.json, a script calling vcvars/vswhere, or a Rust project when this PC builds Rust with MSVC'),
+        acceptLicense: z.boolean().describe('Required to install MSVC: you accept the Visual Studio licence terms (https://visualstudio.microsoft.com/license-terms/), which need a Visual Studio licence.'),
+        msvcVersion: z.string().min(1).describe('"latest" or an MSVC tools version prefix, e.g. "14.44".'),
+        sdkVersion: z.string().min(1).describe('"latest" or a Windows SDK build, e.g. "26100" or "10.0.22621".'),
+    }),
+    cpp: z.strictObject({
+        enabled: enabled('MinGW-w64 GCC with CMake, Ninja, premake5 and mingw32-make (also Rust\'s linker).', 'CMakeLists.txt, Makefile, meson.build, premake5.lua or Cargo.toml'),
+        flexBison: z.boolean().describe('win_flex / win_bison, the parser generators many C/C++ projects (game engines among them) need; CMake finds them.'),
+    }),
+    dotnet: z.strictObject({
+        enabled: enabled('.NET SDK (C#, F#).', 'a .sln, .slnx, .csproj, .fsproj or global.json'),
+        channels: Strings.describe('SDK channels, e.g. ["LTS", "8.0"]. A project\'s global.json is installed too.'),
+        tools: Packages('Global .NET tools (`dotnet tool install -g`)', '["dotnet-ef", "csharpier"]'),
+        workloads: Packages('SDK workloads (`dotnet workload install`)', '["aspire", "wasm-tools"]'),
+        frameworkTargets: Strings.describe('.NET Framework reference assemblies (targeting packs) from NuGet, so net4x and old-style .csproj projects build without Visual Studio, e.g. ["net48", "net472", "net462"]. The 4.8 runtime itself ships with Windows.'),
+        netfx35: z.boolean().describe('.NET Framework 3.5 runtime (a Windows feature, enabled from Windows Update on every boot; a few minutes).'),
+    }),
+    go: z.strictObject({
+        enabled: enabled('Go.', 'go.mod or go.work'),
+        version: z.string().min(1).describe('"stable" or a version prefix such as "1.23". A go.mod asking for newer fetches it itself (GOTOOLCHAIN=auto).'),
+        tools: Packages('Go tools (`go install <path>@<version>`)', '["golang.org/x/tools/gopls@latest"]'),
+    }),
+    java: z.strictObject({
+        enabled: enabled('Java: Eclipse Temurin JDK.', 'pom.xml, build.gradle(.kts), settings.gradle(.kts), mvnw, gradlew or .java-version'),
+        version: z.string().min(1).describe('"lts" (newest LTS) or a major version such as "21". A project\'s .java-version or .sdkmanrc wins.'),
+        maven: z.boolean().describe('Apache Maven (mvn). A project\'s mvnw works either way.'),
+        gradle: z.boolean().describe('Gradle (gradle). A project\'s gradlew works either way.'),
+    }),
+    ruby: z.strictObject({
+        enabled: enabled('Ruby (RubyInstaller, with gem and bundler). Gems with C extensions need MSYS2, which is not included.', 'Gemfile, a .gemspec or .ruby-version'),
+        version: z.string().min(1).describe('Version prefix, e.g. "3" or "3.3". A project\'s .ruby-version wins.'),
+        gems: Packages('Gems installed globally', '["rubocop"]'),
+    }),
+    php: z.strictObject({
+        enabled: enabled('PHP (with the Visual C++ runtime it needs, installed on every boot).', 'composer.json, artisan or .php-version'),
+        version: z.string().min(1).describe('Version prefix, e.g. "8" or "8.3". A project\'s .php-version wins.'),
+        composer: z.boolean().describe('Composer.'),
+    }),
+    deno: z.strictObject({ enabled: enabled('Deno.', 'deno.json, deno.jsonc or deno.lock') }),
+    pwsh: z.strictObject({ enabled: Enabled.describe('PowerShell 7 (pwsh), portable (~110 MB once); `powershell` stays Windows PowerShell 5.1. true, false, or "auto" = when a .ps1 at the root or one folder down has #Requires -Version 7 / -PSEdition Core or a `pwsh ...` usage line, or, in a folder that is no project yet, when this PC has PowerShell 7.') }),
+    cli: z.strictObject({
+        gh: Enabled.describe('GitHub CLI (gh). Only with provisioning.git.access "full": gh can push and merge through the GitHub API, past a read-only git. Your PC\'s gh login is never copied; `gh auth login` inside persists (GH_CONFIG_DIR). "auto" = when the project has a .github folder.'),
+        zstd: Enabled.describe('Zstandard (zstd). "auto" = off; set true to get it.'),
+        openssl: Enabled.describe('`openssl` on PATH, from the copy Git for Windows ships (its mingw64\\bin is not put on PATH, so it cannot shadow MinGW\'s gcc). "auto" = on.'),
+    }).describe('Small portable command-line tools from their GitHub releases, installed once into tools\\cli.'),
+    bun: toggle('Bun runtime (claude-mem needs it).'),
+    uv: toggle('uv, the Python package manager (claude-mem needs it).'),
+    vcRuntime: toggle('Microsoft Visual C++ runtime for tools that need it (a real installer, so it runs on every boot, ~15 s). PHP installs it regardless.'),
+    mesa: z.strictObject({
+        enabled: z.boolean().describe('Mesa 3D (llvmpipe): OpenGL 4.5 in software for games and apps when there is no GPU (sandbox.vGpu off). Copy opengl32.dll and libgallium_wgl.dll from %MESA_DIR% next to the program\'s .exe.'),
+        vulkan: z.boolean().describe('Also software Vulkan 1.4 (Mesa lavapipe) with the Khronos loader, registered for every program; for wgpu set WGPU_BACKEND=vulkan.'),
+    }),
+    vscode: toggle('Portable VS Code inside the sandbox (code on PATH, desktop shortcut); its settings and extensions persist.'),
+    environment: z.record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/, 'letters, digits and _ only'), z.string()).describe('Extra environment variables for the agent and every terminal, e.g. registry mirrors: {"NPM_CONFIG_REGISTRY": "https://...", "PIP_INDEX_URL": "https://..."}.'),
+});