windows-development-sandbox 1.4.3 → 1.7.0

package/dist/core/run/guest-workspace.js

@@ -1,6 +1,9 @@
 import { autoGuestFolder, deriveGuest, guestConflict, guestFix, planMirrorWorkspace, PROJECTS_GUEST, rootGuestDir, tidyGuestPath, usableRoots, } from '../../shared/paths/index.js';
 import { dirExists, isInsideOrEqual } from '../util/index.js';
-/** 'auto' guest workspace: C:\Workspace\<folder name> (shared/paths/projects.ts, where every project's place is decided). */
+/**
+ * 'auto' guest workspace: C:\Workspace\<folder name> (shared/paths/projects.ts, where every project's place is
+ * decided).
+ */
 export const autoGuestWorkspace = autoGuestFolder;
 /**
  * A launch folder inside a project root appears under the root's folder (C:\Projects\<root>\<name>, or its PC path

package/dist/core/run/resolve-run.d.ts

@@ -1,3 +1,6 @@
 import type { ResolvedRun, RunRequest } from '../types.js';
-/** Precedence (lowest to highest): built-in defaults, user config, .sandbox-config.json in the workspace, command-line flags. */
-export declare const resolveRun: (req: RunRequest, hostNodeVersion?: string) => Promise<ResolvedRun>;
+/**
+ * Precedence (lowest to highest): built-in defaults, user config, .sandbox-config.json in the workspace, command-line
+ * flags.
+ */
+export declare function resolveRun(req: RunRequest, hostNodeVersion?: string): Promise<ResolvedRun>;

package/dist/core/run/resolve-run.js

@@ -5,8 +5,11 @@ import { assertSafeWorkspace } from '../safe-paths.js';
 import { dirExists, expandPath, fail, plainText } from '../util/index.js';
 import { guestWorkspaceOf, placeInRoot, previewGuest } from './guest-workspace.js';
 import { resolveVersions } from './versions.js';
-/** Precedence (lowest to highest): built-in defaults, user config, .sandbox-config.json in the workspace, command-line flags. */
-export const resolveRun = async (req, hostNodeVersion = process.version) => {
+/**
+ * Precedence (lowest to highest): built-in defaults, user config, .sandbox-config.json in the workspace, command-line
+ * flags.
+ */
+export async function resolveRun(req, hostNodeVersion = process.version) {
     const notes = [];
     // Mappings from the user config are relative to that config file; expand them before anything else uses them.
     const expand = (list) => list.map((p) => expandPath(p, req.loaded.base));
@@ -97,7 +100,7 @@ export const resolveRun = async (req, hostNodeVersion = process.version) => {
         mirror,
         outsideMappings: outsideAllowed,
     };
-};
+}
 /**
  * A project may only tighten. What it asks for beyond that (a looser setting, a folder outside the project) is used
  * only if you allowed it for this project: asked once, in one question, at an interactive launch, never by

package/dist/core/run/versions.d.ts

@@ -2,12 +2,12 @@ import type { Config, Overrides, ToolVersions } from '../types.js';
 /**
  * The Node version a Volta project pins ("volta": { "node": "20.11.1" } in package.json), so nvm defaults to it too.
  */
-export declare const voltaNode: (workspace: string) => string | null;
+export declare function voltaNode(workspace: string): string | null;
 /**
  * Picks tool versions. Highest priority first: command line, the folder's .sandbox-config.json,
  * version files in the workspace (.nvmrc, .node-version, .python-version), the tool config, this PC's node version.
  */
-export declare const resolveVersions: (config: Config, workspace: string, local: Overrides, req: {
+export declare function resolveVersions(config: Config, workspace: string, local: Overrides, req: {
     nodeVersion?: string;
     pythonVersion?: string;
-}, hostNodeVersion: string) => ToolVersions;
+}, hostNodeVersion: string): ToolVersions;

package/dist/core/run/versions.js

@@ -27,7 +27,7 @@ const PackageJsonSchema = z.object({
 /**
  * The Node version a Volta project pins ("volta": { "node": "20.11.1" } in package.json), so nvm defaults to it too.
  */
-export const voltaNode = (workspace) => {
+export function voltaNode(workspace) {
     const file = path.join(workspace, 'package.json');
     if (!fileExists(file))
         return null;
@@ -38,12 +38,12 @@ export const voltaNode = (workspace) => {
     catch {
         return null;
     }
-};
+}
 /**
  * Picks tool versions. Highest priority first: command line, the folder's .sandbox-config.json,
  * version files in the workspace (.nvmrc, .node-version, .python-version), the tool config, this PC's node version.
  */
-export const resolveVersions = (config, workspace, local, req, hostNodeVersion) => {
+export function resolveVersions(config, workspace, local, req, hostNodeVersion) {
     const localTools = (local.toolchains ?? {});
     const pick = (cli, localValue, files, configured) => {
         if (cli)
@@ -62,4 +62,4 @@ export const resolveVersions = (config, workspace, local, req, hostNodeVersion)
         node = { spec: hostNodeVersion.replace(/^v/, ''), source: 'this PC' };
     const python = pick(req.pythonVersion, localTools.python?.version, ['.python-version'], config.toolchains.python.version);
     return { node, nodeExtra: config.toolchains.node.extraVersions, python };
-};
+}

package/dist/core/safe-paths.d.ts

@@ -1,4 +1,7 @@
 /** A read/write folder mapped into the sandbox must not contain, or sit inside, any protected folder. */
-export declare const assertSafeMapping: (folder: string, packageRoot: string, storageRoot: string) => void;
-/** The agent gets read/write access to the workspace, so refuse folders that would let it reach the tool itself, its storage, or the OS. */
-export declare const assertSafeWorkspace: (workspace: string, packageRoot: string, storageRoot: string) => void;
+export declare function assertSafeMapping(folder: string, packageRoot: string, storageRoot: string): void;
+/**
+ * The agent gets read/write access to the workspace, so refuse folders that would let it reach the tool itself, its
+ * storage, or the OS.
+ */
+export declare function assertSafeWorkspace(workspace: string, packageRoot: string, storageRoot: string): void;

package/dist/core/safe-paths.js

@@ -9,16 +9,19 @@ const protectedFolders = (packageRoot, storageRoot) => [
     ['your sandbox settings folder', userDir()],
 ];
 /** A read/write folder mapped into the sandbox must not contain, or sit inside, any protected folder. */
-export const assertSafeMapping = (folder, packageRoot, storageRoot) => {
+export function assertSafeMapping(folder, packageRoot, storageRoot) {
     if (isRootPath(folder) || isUserProfile(folder))
         fail('A whole drive or user profile cannot be mapped into the sandbox: ' + folder, 'Map a specific folder instead.');
     for (const [label, dir] of protectedFolders(packageRoot, storageRoot)) {
         if (isInsideOrEqual(dir, folder) || isInsideOrEqual(folder, dir))
             fail(folder + ' cannot be mapped into the sandbox: it overlaps ' + label + ' (' + dir + ').', 'Map a folder that is not inside (and does not contain) ' + dir + '.');
     }
-};
-/** The agent gets read/write access to the workspace, so refuse folders that would let it reach the tool itself, its storage, or the OS. */
-export const assertSafeWorkspace = (workspace, packageRoot, storageRoot) => {
+}
+/**
+ * The agent gets read/write access to the workspace, so refuse folders that would let it reach the tool itself, its
+ * storage, or the OS.
+ */
+export function assertSafeWorkspace(workspace, packageRoot, storageRoot) {
     if (isRootPath(workspace))
         fail('A whole drive cannot be the workspace: ' + workspace, 'Run sandbox claude from a project folder (or pass --workspace <folder>).');
     if (isUserProfile(workspace))
@@ -46,4 +49,4 @@ export const assertSafeWorkspace = (workspace, packageRoot, storageRoot) => {
         if (dir && isInsideOrEqual(dir, workspace))
             fail('A system folder cannot be the workspace: ' + workspace, 'Run sandbox claude from a project folder.');
     }
-};
+}

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

@@ -2,7 +2,7 @@ import { z } from 'zod';
 export declare const GuestPathSchema: z.ZodString;
 export declare const NameSchema: z.ZodString;
 export declare const StringsSchema: z.ZodArray<z.ZodString>;
-export declare const toggle: (description: string) => z.ZodObject<{
+export declare function toggle(description: string): z.ZodObject<{
     enabled: z.ZodBoolean;
 }, z.core.$strict>;
 export declare const SchemaRefSchema: z.ZodString;
@@ -16,5 +16,11 @@ export declare const GitAccessSchema: z.ZodEnum<{
  * down).
  */
 export declare const EnabledSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
-export declare const enabled: (what: string, markers: string) => typeof EnabledSchema;
-export declare const Packages: (what: string, example: string) => typeof StringsSchema;
+export declare function enabled(what: string, markers: string): typeof EnabledSchema;
+export declare function Packages(what: string, example: string): typeof StringsSchema;
+/**
+ * Marks a setting whose value is a secret (an API key in an agent's environment): config show / get, the menu, doctor
+ * and every --json print *** for it (core/schema/redact.ts), and it is never written to session.json or the launch
+ * folder (it travels in a one-shot file, see shared/channel/secrets.ts).
+ */
+export declare function secret<T extends z.ZodType>(schema: T): T;

package/dist/core/schema/common.js

@@ -7,7 +7,9 @@ export const GuestPathSchema = z
     .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 function toggle(description) {
+    return z.strictObject({ enabled: z.boolean().describe(description) });
+}
 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'])
@@ -17,5 +19,17 @@ export const GitAccessSchema = z
  * 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 + ').');
+export function enabled(what, markers) {
+    return EnabledSchema.describe(what + ' true, false, or "auto" = only when the project has ' + markers + '.');
+}
+export function Packages(what, example) {
+    return StringsSchema.describe(what + ', installed once and kept (e.g. ' + example + ').');
+}
+/**
+ * Marks a setting whose value is a secret (an API key in an agent's environment): config show / get, the menu, doctor
+ * and every --json print *** for it (core/schema/redact.ts), and it is never written to session.json or the launch
+ * folder (it travels in a one-shot file, see shared/channel/secrets.ts).
+ */
+export function secret(schema) {
+    return schema.meta({ secret: true });
+}

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

@@ -39,6 +39,9 @@ export declare const ConfigSchema: z.ZodObject<{
         headless: z.ZodBoolean;
         keepAwake: z.ZodBoolean;
     }, z.core.$strict>;
+    sharing: z.ZodObject<{
+        otherUsers: z.ZodBoolean;
+    }, z.core.$strict>;
     storage: z.ZodObject<{
         root: z.ZodString;
         persistAgentState: z.ZodBoolean;
@@ -57,6 +60,20 @@ export declare const ConfigSchema: z.ZodObject<{
         dns: z.ZodArray<z.ZodString>;
         proxy: z.ZodString;
     }, z.core.$strict>;
+    vpn: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        provider: z.ZodEnum<{
+            nordvpn: "nordvpn";
+            "openvpn-file": "openvpn-file";
+        }>;
+        protocol: z.ZodEnum<{
+            udp: "udp";
+            tcp: "tcp";
+        }>;
+        country: z.ZodString;
+        configFile: z.ZodString;
+        killSwitch: z.ZodBoolean;
+    }, z.core.$strict>;
     provisioning: z.ZodObject<{
         copyFromHost: z.ZodBoolean;
         fallbackToInstall: z.ZodBoolean;
@@ -159,10 +176,10 @@ export declare const ConfigSchema: z.ZodObject<{
             openssl: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
         }, z.core.$strict>;
         bun: z.ZodObject<{
-            enabled: z.ZodBoolean;
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
         }, z.core.$strict>;
         uv: z.ZodObject<{
-            enabled: z.ZodBoolean;
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
         }, z.core.$strict>;
         vcRuntime: z.ZodObject<{
             enabled: z.ZodBoolean;
@@ -172,7 +189,7 @@ export declare const ConfigSchema: z.ZodObject<{
             vulkan: z.ZodBoolean;
         }, z.core.$strict>;
         vscode: z.ZodObject<{
-            enabled: z.ZodBoolean;
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
             setup: z.ZodBoolean;
             recommended: z.ZodBoolean;
             extensions: z.ZodArray<z.ZodString>;
@@ -215,6 +232,10 @@ export declare const ConfigSchema: z.ZodObject<{
         auto: z.ZodBoolean;
         autoHide: z.ZodBoolean;
     }, z.core.$strict>;
+    web: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        port: z.ZodNumber;
+    }, z.core.$strict>;
     agentCommands: z.ZodObject<{
         enabled: z.ZodBoolean;
         agents: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodArray<z.ZodString>]>;
@@ -255,6 +276,7 @@ export declare const ConfigSchema: z.ZodObject<{
         globalStateFile: z.ZodString;
         copyCredentials: z.ZodBoolean;
         overwrite: z.ZodBoolean;
+        sharePluginsAcrossAccounts: z.ZodBoolean;
         syncHistory: z.ZodBoolean;
         historyScope: z.ZodEnum<{
             project: "project";
@@ -272,7 +294,15 @@ export declare const ConfigSchema: z.ZodObject<{
         uvBin: z.ZodOptional<z.ZodString>;
         arguments: z.ZodArray<z.ZodString>;
         environment: z.ZodRecord<z.ZodString, z.ZodString>;
+        home: z.ZodOptional<z.ZodObject<{
+            env: z.ZodRecord<z.ZodString, z.ZodString>;
+            profileDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            loginFiles: z.ZodArray<z.ZodString>;
+            hostDir: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        localState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        resumeOneArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     hooks: z.ZodObject<{
         failFast: z.ZodBoolean;
@@ -286,6 +316,15 @@ export declare const ConfigSchema: z.ZodObject<{
         allowOutsideMappings: z.ZodUnion<readonly [z.ZodLiteral<"ask">, z.ZodBoolean]>;
         wsbShare: z.ZodBoolean;
     }, z.core.$strict>;
+    resume: z.ZodObject<{
+        sessions: z.ZodEnum<{
+            never: "never";
+            ask: "ask";
+            always: "always";
+            afterCrash: "afterCrash";
+        }>;
+        restartAfterCrash: z.ZodBoolean;
+    }, z.core.$strict>;
 }, z.core.$strict>;
 /**
  * What a project's .sandbox-config.json may change. A repo can ship this file, so it can NOT touch storage, agent
@@ -326,6 +365,9 @@ export declare const LocalOverridesSchema: z.ZodObject<{
         blockPrivateRanges: z.ZodOptional<z.ZodBoolean>;
         blockHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
+    vpn: z.ZodOptional<z.ZodObject<{
+        killSwitch: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
     provisioning: z.ZodOptional<z.ZodObject<{
         copyFromHost: z.ZodOptional<z.ZodBoolean>;
         fallbackToInstall: z.ZodOptional<z.ZodBoolean>;
@@ -512,7 +554,7 @@ export declare const LocalOverridesSchema: 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>>;
-        pwsh: z.ZodOptional<z.ZodObject<{
+        bun: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -527,7 +569,7 @@ export declare const LocalOverridesSchema: 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>>;
-        cli: z.ZodOptional<z.ZodObject<{
+        uv: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -542,7 +584,7 @@ export declare const LocalOverridesSchema: 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>>;
-        bun: z.ZodOptional<z.ZodObject<{
+        vscode: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -557,7 +599,7 @@ export declare const LocalOverridesSchema: 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>>;
-        uv: z.ZodOptional<z.ZodObject<{
+        pwsh: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -572,7 +614,7 @@ export declare const LocalOverridesSchema: 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>>;
-        vcRuntime: z.ZodOptional<z.ZodObject<{
+        cli: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -587,7 +629,7 @@ export declare const LocalOverridesSchema: 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>>;
-        mesa: z.ZodOptional<z.ZodObject<{
+        vcRuntime: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{
             version: z.ZodOptional<z.ZodString>;
@@ -602,7 +644,7 @@ export declare const LocalOverridesSchema: 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>>;
-        vscode: z.ZodOptional<z.ZodObject<{
+        mesa: 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

@@ -6,10 +6,13 @@ 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 { AuditSchema, DownloadsSchema, SharingSchema, 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';
+import { ResumeSchema } from './resume.js';
+import { WebSchema } from './web.js';
+import { VpnSchema } from './vpn.js';
 export const ConfigSchema = z
     .strictObject({
     $schema: SchemaRefSchema.optional(),
@@ -20,8 +23,12 @@ export const ConfigSchema = z
     audit: AuditSchema,
     mappings: z.array(MappingSchema).describe('Extra folders from this PC.'),
     sandbox: SandboxSchema,
+    sharing: SharingSchema,
     storage: z.strictObject({
-        root: z.string().min(1).describe('Where everything is kept on this PC (tools, databases, logins, launches).'),
+        root: z
+            .string()
+            .min(1)
+            .describe('Where everything is kept on this PC (tools, databases, logins, launches). The default is a private folder for you under %ProgramData%\\AgentSandbox\\users, which works for installs for one user and for everyone. sandbox storage move <folder> moves it.'),
         persistAgentState: z.boolean().describe('Keep agent logins and history between sandboxes.'),
         dataName: NameSchema.describe('Name of the persistent data set (C:\\AgentData) shared by all workspaces.'),
         markSandboxFiles: z
@@ -33,11 +40,13 @@ export const ConfigSchema = z
             .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: NetworkSchema,
+    vpn: VpnSchema,
     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,
+    web: WebSchema,
     agentCommands: AgentCommandsSchema,
     secrets: SecretsSchema,
     personalization: toggle('Copy your desktop look (theme, accent, taskbar, wallpaper, ...) into the sandbox.'),
@@ -46,6 +55,7 @@ export const ConfigSchema = z
     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: ProjectsSchema.describe('Several projects in one sandbox: folders of projects mapped at every start, and adding folders while it runs.'),
+    resume: ResumeSchema.describe('Reopening the sessions of the last sandbox when a new one starts.'),
 })
     .refine((c) => c.harnesses[c.defaultHarness] !== undefined, {
     message: 'defaultHarness must be one of the configured harnesses',
@@ -71,6 +81,8 @@ export const LocalOverridesSchema = z
     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: NetworkSchema.pick({ blockPrivateRanges: true, blockHosts: true }).partial(),
+    // A project may turn the kill switch on, never off, and never choose a VPN, a server, a file or a login.
+    vpn: VpnSchema.pick({ killSwitch: 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(),

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

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

package/dist/core/schema/databases.js

@@ -2,8 +2,10 @@
 import { z } from 'zod';
 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 function dbEnabled(name) {
+    return 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'),

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

@@ -1,4 +1,11 @@
 import { z } from 'zod';
+/** Where an agent keeps its login and settings inside the sandbox, so logins can be saved and switched. */
+export declare const HarnessHomeSchema: z.ZodObject<{
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+    profileDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    loginFiles: z.ZodArray<z.ZodString>;
+    hostDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 export declare const HarnessSchema: z.ZodObject<{
     hostExecutable: z.ZodOptional<z.ZodString>;
     hostDir: z.ZodOptional<z.ZodString>;
@@ -8,5 +15,13 @@ export declare const HarnessSchema: z.ZodObject<{
     uvBin: z.ZodOptional<z.ZodString>;
     arguments: z.ZodArray<z.ZodString>;
     environment: z.ZodRecord<z.ZodString, z.ZodString>;
+    home: z.ZodOptional<z.ZodObject<{
+        env: z.ZodRecord<z.ZodString, z.ZodString>;
+        profileDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        loginFiles: z.ZodArray<z.ZodString>;
+        hostDir: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    localState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    resumeOneArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;

package/dist/core/schema/harness.js

@@ -1,6 +1,28 @@
 // An agent (claude, codex, ...) the sandbox can run.
 import { z } from 'zod';
-import { StringsSchema } from './common.js';
+import { secret, StringsSchema } from './common.js';
+/** A folder below the agent's state folder: plain names only, no drive, no "..". */
+const SubfolderSchema = z
+    .string()
+    .regex(/^(?!.*(^|[\\/])\.\.([\\/]|$))[A-Za-z0-9._ -]+([\\/][A-Za-z0-9._ -]+)*$/, 'a plain relative folder');
+/** Where an agent keeps its login and settings inside the sandbox, so logins can be saved and switched. */
+export const HarnessHomeSchema = z.strictObject({
+    env: z
+        .record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), SubfolderSchema)
+        .describe('Environment variable -> folder (below the sandbox state folder) the agent keeps its data in.'),
+    profileDirs: z
+        .array(SubfolderSchema.refine((d) => !d.split(/[\\/]/).includes('.'), 'a plain relative folder'))
+        .max(8)
+        .optional()
+        .describe("Folders below the sandbox's user profile (e.g. .qwen, .config/opencode) the agent keeps its data in: each becomes a link to state\\<agent>\\profile\\<folder>, so it survives between sandboxes."),
+    loginFiles: z
+        .array(SubfolderSchema)
+        .describe("Files that make up the login, relative to the agent's own state folder (state\\<agent>)."),
+    hostDir: z
+        .string()
+        .optional()
+        .describe("The agent's own folder on this PC (e.g. ~/.codex): loginFiles are read from it to save this PC's login."),
+});
 export const HarnessSchema = z
     .strictObject({
     hostExecutable: z
@@ -19,9 +41,18 @@ export const HarnessSchema = z
         .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: StringsSchema.describe('Arguments always passed to the agent.'),
-    environment: z.record(z.string(), z.string()).describe('Environment variables for the agent.'),
+    environment: z
+        .record(z.string(), secret(z.string()))
+        .describe('Environment variables for the agent (API keys go here). Their values are shown as *** and are handed to the sandbox in a one-shot file, never kept in the launch folder. The agent can read its own environment.'),
+    home: HarnessHomeSchema.optional().describe('Where its login lives inside the sandbox; leave out when the agent cannot be pointed at a folder (then its login is not kept between sandboxes).'),
+    localState: z
+        .record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), SubfolderSchema)
+        .optional()
+        .describe("Environment variable -> folder below the agent's own state folder (state\\<agent>) for SQLite databases. SQLite cannot run in a mapped folder, so the agent runs from a copy on the sandbox's disk (the variable points to it) that is copied from and back to that folder."),
     resumeArguments: StringsSchema.optional().describe('Arguments used when the agent is restarted in place (e.g. after an account switch) so it resumes the conversation.'),
+    resumeOneArguments: StringsSchema.optional().describe('Arguments that reopen one conversation, with {id} where its id goes (claude: --resume {id}). Used instead of resumeArguments when the conversation of a session is known.'),
 })
+    .refine((h) => !h.resumeOneArguments || h.resumeOneArguments.some((a) => a.includes('{id}')), 'needs {id} in resumeOneArguments')
     .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/index.d.ts

@@ -1,6 +1,8 @@
-export { GitAccessSchema } from './common.js';
+export { GitAccessSchema, NameSchema, secret } from './common.js';
+export { REDACTED, redactSecrets, scrubSecrets, secretPaths, secretValues } from './redact.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';
+export { VpnSchema, VPN_PROVIDERS, type VpnProvider } from './vpn.js';

package/dist/core/schema/index.js

@@ -1,8 +1,10 @@
 // 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 { GitAccessSchema, NameSchema, secret } from './common.js';
+export { REDACTED, redactSecrets, scrubSecrets, secretPaths, secretValues } from './redact.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';
+export { VpnSchema, VPN_PROVIDERS } from './vpn.js';

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

@@ -1,5 +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[];
+export declare function 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>;
+export declare function jsonSchemas(): Record<string, object>;

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

@@ -2,14 +2,16 @@
 import { z } from 'zod';
 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('.');
-    if (issue.code === 'unrecognized_keys')
-        return issue.keys.map((k) => (at ? at + '.' : '') + k + ' is not allowed here').join('; ');
-    return (at || 'value') + ': ' + issue.message;
-});
+export function describeIssues(error) {
+    return 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 = () => {
+export function jsonSchemas() {
     const dropRequired = (node) => {
         if (Array.isArray(node))
             return node.map(dropRequired);
@@ -27,4 +29,4 @@ export const jsonSchemas = () => {
         '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

@@ -22,6 +22,7 @@ export declare const ClaudeProfileSchema: z.ZodObject<{
     globalStateFile: z.ZodString;
     copyCredentials: z.ZodBoolean;
     overwrite: z.ZodBoolean;
+    sharePluginsAcrossAccounts: z.ZodBoolean;
     syncHistory: z.ZodBoolean;
     historyScope: z.ZodEnum<{
         project: "project";

package/dist/core/schema/profile.js

@@ -38,6 +38,9 @@ export const ClaudeProfileSchema = z.strictObject({
     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.'),
+    sharePluginsAcrossAccounts: z
+        .boolean()
+        .describe('When you switch Claude accounts, copy your Claude plugins (and which ones are enabled) into a data set that has none yet. Off by default: plugins are code that runs in your sessions.'),
     syncHistory: z.boolean().describe('Bring conversation history in, and sync new history back (path-translated).'),
     historyScope: z
         .enum(['project', 'all'])

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

@@ -0,0 +1,13 @@
+/** What is printed instead of a secret. */
+export declare const REDACTED = "***";
+/** A path through a config; "*" stands for any key of a map or any item of a list. */
+type SecretPath = readonly string[];
+/** Every setting marked secret, found from the schema itself (so a new secret setting needs no list). */
+export declare function secretPaths(): readonly SecretPath[];
+/** A copy of `config` with every secret value replaced by ***. */
+export declare function redactSecrets<T>(config: T): T;
+/** The secret values in `config` (for scrubbing text that was built from it). */
+export declare function secretValues(config: unknown): string[];
+/** `text` with every secret value of `config` replaced by *** (a last safety net for output built from a config). */
+export declare function scrubSecrets(text: string, config: unknown): string;
+export {};