windows-development-sandbox 1.4.1 → 1.4.3

package/dist/core/schema/common.js

@@ -1,15 +1,21 @@
 // Building blocks shared by the settings schemas.
 import { z } from 'zod';
-import { isValidGuestPath } from '../../shared/guest-paths.js';
+import { isValidGuestPath } from '../../shared/paths/index.js';
 // Rules (and RESERVED_GUEST) live in shared/guest-paths.ts: the host re-checks them before writing the .wsb.
-export const GuestPath = z.string().refine(isValidGuestPath, 'reserved or invalid guest path (a folder under C:\\ other than Windows, Program Files, Users, AgentData, Mirror, ..., or on drive D: to Z:)');
-export const Name = z.string().regex(/^[A-Za-z0-9_-]+$/, 'letters, numbers, - and _ only');
-export const Strings = z.array(z.string());
+export const GuestPathSchema = z
+    .string()
+    .refine(isValidGuestPath, 'reserved or invalid guest path (a folder under C:\\ other than Windows, Program Files, Users, AgentData, Mirror, ..., or on drive D: to Z:)');
+export const NameSchema = z.string().regex(/^[A-Za-z0-9_-]+$/, 'letters, numbers, - and _ only');
+export const StringsSchema = z.array(z.string());
 export const toggle = (description) => z.strictObject({ enabled: z.boolean().describe(description) });
-export const SchemaRef = z.string().describe('Path or URL of the JSON Schema for editor autocomplete and docs.');
-export const GitAccess = z.enum(['full', 'readonly', 'none'])
+export const SchemaRefSchema = z.string().describe('Path or URL of the JSON Schema for editor autocomplete and docs.');
+export const GitAccessSchema = z
+    .enum(['full', 'readonly', 'none'])
     .describe('full: normal git. readonly: status/log/diff/show/blame only (no commit, push, checkout, ...). none: no git at all; .git is hidden from the agent.');
-/** true, false, or "auto": only when the project uses it (found from files like go.mod in the workspace or one level down). */
-export const Enabled = z.union([z.boolean(), z.literal('auto')]);
-export const enabled = (what, markers) => Enabled.describe(what + ' true, false, or "auto" = only when the project has ' + markers + '.');
-export const Packages = (what, example) => Strings.describe(what + ', installed once and kept (e.g. ' + example + ').');
+/**
+ * true, false, or "auto": only when the project uses it (found from files like go.mod in the workspace or one level
+ * down).
+ */
+export const EnabledSchema = z.union([z.boolean(), z.literal('auto')]);
+export const enabled = (what, markers) => EnabledSchema.describe(what + ' true, false, or "auto" = only when the project has ' + markers + '.');
+export const Packages = (what, example) => StringsSchema.describe(what + ', installed once and kept (e.g. ' + example + ').');

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const Config: z.ZodObject<{
+export declare const ConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
     defaultHarness: z.ZodString;
     guestWorkspace: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"mirror">, z.ZodString]>;
@@ -65,8 +65,8 @@ export declare const Config: z.ZodObject<{
             enabled: z.ZodBoolean;
             access: z.ZodEnum<{
                 readonly: "readonly";
-                full: "full";
                 none: "none";
+                full: "full";
             }>;
         }, z.core.$strict>;
         terminal: z.ZodObject<{
@@ -102,6 +102,11 @@ export declare const Config: z.ZodObject<{
             targets: z.ZodArray<z.ZodString>;
             crates: z.ZodArray<z.ZodString>;
             targetDir: z.ZodString;
+            linker: z.ZodEnum<{
+                lld: "lld";
+                gnu: "gnu";
+            }>;
+            linkSlots: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>;
         }, z.core.$strict>;
         msvc: z.ZodObject<{
             enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
@@ -286,7 +291,7 @@ export declare const Config: z.ZodObject<{
  * What a project's .sandbox-config.json may change. A repo can ship this file, so it can NOT touch storage, agent
  * executables, host folders for tools or Claude settings, or anything else outside this list.
  */
-export declare const LocalOverrides: z.ZodObject<{
+export declare const LocalOverridesSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
     harness: z.ZodOptional<z.ZodString>;
     guestWorkspace: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"mirror">, z.ZodString]>>;
@@ -329,8 +334,8 @@ export declare const LocalOverrides: z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
             access: z.ZodOptional<z.ZodEnum<{
                 readonly: "readonly";
-                full: "full";
                 none: "none";
+                full: "full";
             }>>;
         }, z.core.$strict>>;
         terminal: z.ZodOptional<z.ZodObject<{
@@ -357,7 +362,7 @@ export declare const LocalOverrides: z.ZodObject<{
             zstd: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
             openssl: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
         }, z.core.$strict>>;
-        python: z.ZodOptional<z.ZodObject<{
+        go: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -372,7 +377,7 @@ export declare const LocalOverrides: z.ZodObject<{
             zstd: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
             openssl: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
         }, z.core.$strict>>;
-        rust: z.ZodOptional<z.ZodObject<{
+        python: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -387,7 +392,7 @@ export declare const LocalOverrides: z.ZodObject<{
             zstd: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
             openssl: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
         }, z.core.$strict>>;
-        msvc: z.ZodOptional<z.ZodObject<{
+        rust: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -402,7 +407,7 @@ export declare const LocalOverrides: z.ZodObject<{
             zstd: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
             openssl: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
         }, z.core.$strict>>;
-        cpp: z.ZodOptional<z.ZodObject<{
+        msvc: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -417,7 +422,7 @@ export declare const LocalOverrides: z.ZodObject<{
             zstd: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
             openssl: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
         }, z.core.$strict>>;
-        dotnet: z.ZodOptional<z.ZodObject<{
+        cpp: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -432,7 +437,7 @@ export declare const LocalOverrides: z.ZodObject<{
             zstd: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
             openssl: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
         }, z.core.$strict>>;
-        go: z.ZodOptional<z.ZodObject<{
+        dotnet: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;

package/dist/core/schema/config.js

@@ -2,74 +2,99 @@
 // schemas, and the JSON Schema files in schemas/ are generated from them at build time.
 import _ from 'lodash';
 import { z } from 'zod';
-import { Name, SchemaRef, Strings, toggle } from './common.js';
-import { Databases } from './databases.js';
-import { Harness } from './harness.js';
-import { AgentCommands, Attach, ClaudeProfile, Secrets } from './profile.js';
-import { Audit, Downloads, Git, GuestWorkspace, Mapping, Network, Provisioning, Sandbox, WorkspaceFilter } from './sandbox.js';
-import { Toolchains } from './toolchains.js';
-import { Apps } from './apps.js';
-import { Projects } from './projects.js';
-export const Config = z.strictObject({
-    $schema: SchemaRef.optional(),
-    defaultHarness: Name.describe('Agent started by `sandbox launch` (sandbox claude always runs claude).'),
-    guestWorkspace: GuestWorkspace,
+import { NameSchema, SchemaRefSchema, StringsSchema, toggle } from './common.js';
+import { DatabasesSchema } from './databases.js';
+import { HarnessSchema } from './harness.js';
+import { AgentCommandsSchema, AttachSchema, ClaudeProfileSchema, SecretsSchema } from './profile.js';
+import { AuditSchema, DownloadsSchema, GitSchema, GuestWorkspaceSchema, MappingSchema, NetworkSchema, ProvisioningSchema, SandboxSchema, WorkspaceFilterSchema, } from './sandbox.js';
+import { ToolchainsSchema } from './toolchains.js';
+import { AppsSchema } from './apps.js';
+import { ProjectsSchema } from './projects.js';
+export const ConfigSchema = z
+    .strictObject({
+    $schema: SchemaRefSchema.optional(),
+    defaultHarness: NameSchema.describe('Agent started by `sandbox launch` (sandbox claude always runs claude).'),
+    guestWorkspace: GuestWorkspaceSchema,
     readOnly: z.boolean().describe('Map the workspace read-only.'),
-    workspaceFilter: WorkspaceFilter,
-    audit: Audit,
-    mappings: z.array(Mapping).describe('Extra folders from this PC.'),
-    sandbox: Sandbox,
+    workspaceFilter: WorkspaceFilterSchema,
+    audit: AuditSchema,
+    mappings: z.array(MappingSchema).describe('Extra folders from this PC.'),
+    sandbox: SandboxSchema,
     storage: z.strictObject({
         root: z.string().min(1).describe('Where everything is kept on this PC (tools, databases, logins, launches).'),
         persistAgentState: z.boolean().describe('Keep agent logins and history between sandboxes.'),
-        dataName: Name.describe('Name of the persistent data set (C:\\AgentData) shared by all workspaces.'),
-        markSandboxFiles: z.boolean().describe('Programs and scripts (.exe, .ps1, .bat, .cmd, .msi, .lnk ...) that appear or change in your project while a sandbox runs get Windows\' "downloaded from the internet" mark, so SmartScreen and PowerShell ask before they run on this PC.'),
-        warnDataGb: z.number().min(0).describe('Say at launch when the persisted data (tools, databases, logins) is bigger than this many GB; 0 = never. sandbox data shows what takes the space.'),
+        dataName: NameSchema.describe('Name of the persistent data set (C:\\AgentData) shared by all workspaces.'),
+        markSandboxFiles: z
+            .boolean()
+            .describe('Programs and scripts (.exe, .ps1, .bat, .cmd, .msi, .lnk ...) that appear or change in your project while a sandbox runs get Windows\' "downloaded from the internet" mark, so SmartScreen and PowerShell ask before they run on this PC.'),
+        warnDataGb: z
+            .number()
+            .min(0)
+            .describe('Say at launch when the persisted data (tools, databases, logins) is bigger than this many GB; 0 = never. sandbox data shows what takes the space.'),
     }),
-    network: Network,
-    provisioning: Provisioning,
-    downloads: Downloads,
-    toolchains: Toolchains,
-    databases: Databases.describe('Databases running inside the sandbox. Data persists in C:\\AgentData\\databases; each one starts at boot.'),
-    attach: Attach,
-    agentCommands: AgentCommands,
-    secrets: Secrets,
+    network: NetworkSchema,
+    provisioning: ProvisioningSchema,
+    downloads: DownloadsSchema,
+    toolchains: ToolchainsSchema,
+    databases: DatabasesSchema.describe('Databases running inside the sandbox. Data persists in C:\\AgentData\\databases; each one starts at boot.'),
+    attach: AttachSchema,
+    agentCommands: AgentCommandsSchema,
+    secrets: SecretsSchema,
     personalization: toggle('Copy your desktop look (theme, accent, taskbar, wallpaper, ...) into the sandbox.'),
-    apps: Apps,
-    claudeProfile: ClaudeProfile,
-    harnesses: z.record(Name, Harness).describe('Agents that can run in the sandbox.'),
+    apps: AppsSchema,
+    claudeProfile: ClaudeProfileSchema,
+    harnesses: z.record(NameSchema, HarnessSchema).describe('Agents that can run in the sandbox.'),
     hooks: z.strictObject({ failFast: z.boolean().describe('Stop when a hook script fails.') }),
-    projects: Projects.describe('Several projects in one sandbox: folders of projects mapped at every start, and adding folders while it runs.'),
-}).refine((c) => c.harnesses[c.defaultHarness] !== undefined, { message: 'defaultHarness must be one of the configured harnesses', path: ['defaultHarness'] });
+    projects: ProjectsSchema.describe('Several projects in one sandbox: folders of projects mapped at every start, and adding folders while it runs.'),
+})
+    .refine((c) => c.harnesses[c.defaultHarness] !== undefined, {
+    message: 'defaultHarness must be one of the configured harnesses',
+    path: ['defaultHarness'],
+});
 /**
  * What a project's .sandbox-config.json may change. A repo can ship this file, so it can NOT touch storage, agent
  * executables, host folders for tools or Claude settings, or anything else outside this list.
  */
-export const LocalOverrides = z.strictObject({
-    $schema: SchemaRef,
-    harness: Name.describe('Agent for this project.'),
-    guestWorkspace: GuestWorkspace,
+export const LocalOverridesSchema = z
+    .strictObject({
+    $schema: SchemaRefSchema,
+    harness: NameSchema.describe('Agent for this project.'),
+    guestWorkspace: GuestWorkspaceSchema,
     readOnly: z.boolean().describe('Map this project read-only.'),
     // A project may turn the filter on and keep more out, never let ignored files in.
-    workspaceFilter: WorkspaceFilter.pick({ enabled: true, exclude: true }).partial(),
-    mappings: z.array(Mapping).describe('Extra folders (relative paths are relative to this file), e.g. a read-only data folder at another place in the sandbox. Folders outside the project are used only as your projects.allowOutsideMappings setting allows (by default you are asked once).'),
-    scripts: Strings.describe('Scripts (.ps1 / .mjs / .cmd, relative to this file) run inside the sandbox before the agent.'),
+    workspaceFilter: WorkspaceFilterSchema.pick({ enabled: true, exclude: true }).partial(),
+    mappings: z
+        .array(MappingSchema)
+        .describe('Extra folders (relative paths are relative to this file), e.g. a read-only data folder at another place in the sandbox. Folders outside the project are used only as your projects.allowOutsideMappings setting allows (by default you are asked once).'),
+    scripts: StringsSchema.describe('Scripts (.ps1 / .mjs / .cmd, relative to this file) run inside the sandbox before the agent.'),
     // This PC's resources are yours to share: CPU and paging file (this PC's disk) are not a project's to set.
-    sandbox: Sandbox.omit({ cpuLimit: true, pageFileMb: true }).partial(),
+    sandbox: SandboxSchema.omit({ cpuLimit: true, pageFileMb: true }).partial(),
     // A project may block more (the LAN, hosts); it never opens hosts, ports, DNS or a proxy.
-    network: Network.pick({ blockPrivateRanges: true, blockHosts: true }).partial(),
-    provisioning: Provisioning.pick({ copyFromHost: true, fallbackToInstall: true, refresh: true }).extend({ git: Git.partial(), terminal: toggle('Windows Terminal as the sandbox window.').partial() }).partial(),
-    downloads: Downloads.partial(),
+    network: NetworkSchema.pick({ blockPrivateRanges: true, blockHosts: true }).partial(),
+    provisioning: ProvisioningSchema.pick({ copyFromHost: true, fallbackToInstall: true, refresh: true })
+        .extend({ git: GitSchema.partial(), terminal: toggle('Windows Terminal as the sandbox window.').partial() })
+        .partial(),
+    downloads: DownloadsSchema.partial(),
     // Every toolchain setting, each one optional (a project usually only switches languages on or pins a version).
-    toolchains: z.strictObject({
-        ..._.mapValues(_.omit(Toolchains.shape, 'environment'), (shape) => shape.partial()),
-        environment: Toolchains.shape.environment,
-    }).partial(),
-    databases: z.strictObject(_.mapValues(Databases.shape, (shape) => shape.partial())).partial(),
-    attach: Attach.partial(),
+    toolchains: z
+        .strictObject({
+        ..._.mapValues(_.omit(ToolchainsSchema.shape, 'environment'), (shape) => shape.partial()),
+        environment: ToolchainsSchema.shape.environment,
+    })
+        .partial(),
+    databases: z.strictObject(_.mapValues(DatabasesSchema.shape, (shape) => shape.partial())).partial(),
+    attach: AttachSchema.partial(),
     personalization: toggle('Copy your desktop look into the sandbox.').partial(),
-    // Catalogue apps only (a vetted list): your own programs (apps.custom) download anything, so a repo cannot add them.
-    apps: Apps.pick({ install: true }).partial(),
-    claudeProfile: ClaudeProfile.pick({ enabled: true, overwrite: true, copyCredentials: true, syncHistory: true, syncClaudeMem: true }).partial(),
+    // Catalogue apps only (a vetted list): your own programs (apps.custom) download anything, so a repo cannot add
+    // them.
+    apps: AppsSchema.pick({ install: true }).partial(),
+    claudeProfile: ClaudeProfileSchema.pick({
+        enabled: true,
+        overwrite: true,
+        copyCredentials: true,
+        syncHistory: true,
+        syncClaudeMem: true,
+    }).partial(),
     hooks: z.strictObject({ failFast: z.boolean() }).partial(),
-}).partial();
+})
+    .partial();

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

@@ -1,7 +1,8 @@
 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<{
+import { EnabledSchema } from './common.js';
+export declare const PortSchema: z.ZodNumber;
+export declare const dbEnabled: (name: string) => typeof EnabledSchema;
+export declare const DatabasesSchema: z.ZodObject<{
     postgres: z.ZodObject<{
         enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
         version: z.ZodString;

package/dist/core/schema/databases.js

@@ -1,32 +1,36 @@
 // 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({
+import { EnabledSchema } from './common.js';
+export const PortSchema = z.number().int().min(1024).max(65535);
+export const dbEnabled = (name) => EnabledSchema.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 DatabasesSchema = 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.'),
+        version: z
+            .string()
+            .min(1)
+            .describe('"latest" or a major version such as "16". A compose file pinning postgres:<major> wins.'),
+        port: PortSchema.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.'),
+        port: PortSchema.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.'),
+        port: PortSchema.describe('Port inside the sandbox.'),
     }),
     redis: z.strictObject({
         enabled: dbEnabled('Redis (community Windows build), localhost only'),
-        port: Port.describe('Port inside the sandbox.'),
+        port: PortSchema.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).'),
+        enabled: dbEnabled("DynamoDB Local (Amazon's official emulator, on the Java toolchain) with dynamodb-admin, a web UI to browse and edit tables"),
+        port: PortSchema.describe('DynamoDB endpoint port inside the sandbox (http://localhost:<port>).'),
+        adminPort: PortSchema.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({

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const Harness: z.ZodObject<{
+export declare const HarnessSchema: z.ZodObject<{
     hostExecutable: z.ZodOptional<z.ZodString>;
     hostDir: z.ZodOptional<z.ZodString>;
     npmPackage: z.ZodOptional<z.ZodString>;

package/dist/core/schema/harness.js

@@ -1,16 +1,26 @@
 // 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.'),
+import { StringsSchema } from './common.js';
+export const HarnessSchema = 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).'),
+    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.'),
+    arguments: StringsSchema.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.'),
+    resumeArguments: StringsSchema.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')

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

@@ -0,0 +1,6 @@
+export { GitAccessSchema } from './common.js';
+export { ConfigSchema, LocalOverridesSchema } from './config.js';
+export { HarnessSchema } from './harness.js';
+export { describeIssues, jsonSchemas } from './json-schema.js';
+export { MappingSchema } from './sandbox.js';
+export { ToolchainsSchema } from './toolchains.js';

package/dist/core/schema/index.js

@@ -0,0 +1,8 @@
+// Every setting, defined once with zod, split by area in schema/. This file is the one place the rest of the code (and
+// scripts/schemas.mjs, which generates the JSON Schema files) imports them from.
+export { GitAccessSchema } from './common.js';
+export { ConfigSchema, LocalOverridesSchema } from './config.js';
+export { HarnessSchema } from './harness.js';
+export { describeIssues, jsonSchemas } from './json-schema.js';
+export { MappingSchema } from './sandbox.js';
+export { ToolchainsSchema } from './toolchains.js';

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

@@ -1,6 +1,6 @@
 // Readable validation messages and the JSON Schema documents generated from the settings schemas.
 import { z } from 'zod';
-import { Config, LocalOverrides } from './config.js';
+import { ConfigSchema, LocalOverridesSchema } 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('.');
@@ -15,11 +15,16 @@ export const jsonSchemas = () => {
             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)]));
+        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' }) });
+    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)'),
+        'config.schema.json': dropRequired(toSchema(ConfigSchema, 'windows-development-sandbox user config (~/.agent-sandbox/config.json)')),
+        'sandbox-config.schema.json': toSchema(LocalOverridesSchema, 'windows-development-sandbox project config (.sandbox-config.json)'),
     };
 };

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

@@ -1,21 +1,21 @@
 import { z } from 'zod';
-export declare const Secrets: z.ZodObject<{
+export declare const SecretsSchema: 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<{
+export declare const AttachSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     reuseSession: z.ZodBoolean;
     auto: z.ZodBoolean;
     autoHide: z.ZodBoolean;
 }, z.core.$strict>;
-export declare const AgentCommands: z.ZodObject<{
+export declare const AgentCommandsSchema: 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<{
+export declare const ClaudeProfileSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     hostDir: z.ZodString;
     include: z.ZodArray<z.ZodString>;

package/dist/core/schema/profile.js

@@ -1,23 +1,37 @@
 // 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.'),
+import { NameSchema, StringsSchema } from './common.js';
+export const SecretsSchema = 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: StringsSchema.describe('Variable names that may go in anyway; * matches anything, e.g. ["AWS_REGION", "AWS_PROFILE", "MY_APP_*"].'),
+    patterns: StringsSchema.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({
+export const AttachSchema = 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).'),
+    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 AgentCommandsSchema = 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(NameSchema)])
+        .describe('"auto" = every agent installed on this PC, or a list of agent names, e.g. ["claude", "codex"].'),
 });
-export const ClaudeProfile = z.strictObject({
+export const ClaudeProfileSchema = 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.'),
@@ -25,7 +39,13 @@ export const ClaudeProfile = z.strictObject({
     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 conversation history in, and sync new history back (path-translated).'),
-    historyScope: z.enum(['project', 'all']).describe('Which history comes in: "project" = only the projects in this sandbox (other projects\' conversations, file backups and prompts stay on this PC), "all" = everything. Only this sandbox\'s projects ever sync back.'),
-    syncClaudeMem: z.boolean().describe('Bring claude-mem data into the sandbox (its settings and backups stay on this PC).'),
-    syncClaudeMemBack: z.boolean().describe('Also copy claude-mem\'s database back to this PC when the sandbox closes. Off by default: what is in it is loaded into every Claude session on this PC, so a compromised agent could plant instructions there.'),
+    historyScope: z
+        .enum(['project', 'all'])
+        .describe('Which history comes in: "project" = only the projects in this sandbox (other projects\' conversations, file backups and prompts stay on this PC), "all" = everything. Only this sandbox\'s projects ever sync back.'),
+    syncClaudeMem: z
+        .boolean()
+        .describe('Bring claude-mem data into the sandbox (its settings and backups stay on this PC).'),
+    syncClaudeMemBack: z
+        .boolean()
+        .describe("Also copy claude-mem's database back to this PC when the sandbox closes. Off by default: what is in it is loaded into every Claude session on this PC, so a compromised agent could plant instructions there."),
 });

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const Projects: z.ZodObject<{
+export declare const ProjectsSchema: z.ZodObject<{
     all: z.ZodBoolean;
     exclude: z.ZodArray<z.ZodString>;
     roots: z.ZodArray<z.ZodString>;

package/dist/core/schema/projects.js

@@ -1,12 +1,22 @@
 // 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.'),
+export const ProjectsSchema = 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.'),
+    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).'),
-    allowOutsideMappings: z.union([z.literal('ask'), z.boolean()]).describe('A project\'s .sandbox-config.json may map folders from outside the project (e.g. a game folder on another drive). "ask" = an interactive launch asks once per project and set of folders, and remembers your answer; true = always allowed (still listed when you approve the file); false = never (the launch stops and says which folders). Only your own settings decide this, never a project file.'),
-    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.'),
+    allowOutsideMappings: z
+        .union([z.literal('ask'), z.boolean()])
+        .describe('A project\'s .sandbox-config.json may map folders from outside the project (e.g. a game folder on another drive). "ask" = an interactive launch asks once per project and set of folders, and remembers your answer; true = always allowed (still listed when you approve the file); false = never (the launch stops and says which folders). Only your own settings decide this, never a project file.'),
+    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.'),
 });