windows-development-sandbox 1.5.0 → 1.7.0

package/dist/host/health/system.d.ts

@@ -0,0 +1,37 @@
+import { type TaskRow } from '../sharing/index.js';
+/** The mandatory-level SID of an elevated (admin) token. */
+export declare const HIGH_INTEGRITY_SID = "S-1-16-12288";
+export { SHARING_GROUP } from './acl-read.js';
+export interface SystemProbe {
+    processes(): TaskRow[];
+    pidAlive(pid: number): boolean;
+    /** Ends one process (the caller has checked it is the right one). */
+    stop(pid: number): void;
+    /** The unexpanded PATH of this user or of the PC, or null when it cannot be read. */
+    registryPath(scope: 'user' | 'machine'): string | null;
+    /** Is the automatic-update task there? null when it cannot be asked. */
+    updateTaskExists(): boolean | null;
+    /** `icacls <folder>` output, or null. */
+    icacls(dir: string): string | null;
+    /** The accounts in the sharing group, or null when it cannot be read (no such group included). */
+    groupMembers(): string[] | null;
+    /** Is this SID in the token of this very process? null when whoami fails. */
+    tokenHasGroup(sid: string): boolean | null;
+    /** Does an HTTPS request to the address answer within `ms`? */
+    reachable(url: string, ms: number): Promise<boolean>;
+}
+/** The PATH value in `reg query ... /v Path` output, or null. */
+export declare function parseRegPath(text: string): string | null;
+/** The accounts listed by `net localgroup <name>`: the lines between the dashes and the closing sentence. */
+export declare function parseGroupMembers(text: string): string[] | null;
+export declare class WindowsProbe implements SystemProbe {
+    processes(): TaskRow[];
+    pidAlive(pid: number): boolean;
+    stop(pid: number): void;
+    registryPath(scope: 'user' | 'machine'): string | null;
+    updateTaskExists(): boolean | null;
+    icacls(dir: string): string | null;
+    groupMembers(): string[] | null;
+    tokenHasGroup(sid: string): boolean | null;
+    reachable(url: string, ms: number): Promise<boolean>;
+}

package/dist/host/health/system.js

@@ -0,0 +1,87 @@
+// What the health checks ask Windows (the processes, your PATH, the update task, folder permissions, the network). One
+// interface so tests give their own answers on temp folders; the real one only reads, apart from stop().
+import { spawnSync } from 'node:child_process';
+import { SYSTEM, system32 } from '../../shared/system.js';
+import { refuseInSelfTest } from '../test-guard.js';
+import { listProcesses } from '../sharing/index.js';
+import { SHARING_GROUP } from './acl-read.js';
+const HELPER_TIMEOUT_MS = 15000;
+const USER_ENVIRONMENT = 'HKCU\\Environment';
+const MACHINE_ENVIRONMENT = 'HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment';
+/** The mandatory-level SID of an elevated (admin) token. */
+export const HIGH_INTEGRITY_SID = 'S-1-16-12288';
+export { SHARING_GROUP } from './acl-read.js';
+/** The PATH value in `reg query ... /v Path` output, or null. */
+export function parseRegPath(text) {
+    const m = /^\s+Path\s+REG_(?:EXPAND_)?SZ\s+(.*)$/im.exec(text);
+    return m ? m[1].trim() : null;
+}
+/** The accounts listed by `net localgroup <name>`: the lines between the dashes and the closing sentence. */
+export function parseGroupMembers(text) {
+    const lines = text.split(/\r?\n/);
+    const start = lines.findIndex((l) => /^-{5,}\s*$/.test(l));
+    if (start < 0)
+        return null;
+    const rest = lines.slice(start + 1);
+    const end = rest.findIndex((l) => l.trim() === '' || /^\S.*\.$/.test(l.trim()));
+    return rest
+        .slice(0, end < 0 ? rest.length : end)
+        .map((l) => l.trim())
+        .filter(Boolean);
+}
+function run(exe, args) {
+    const r = spawnSync(exe, args, { encoding: 'utf8', windowsHide: true, timeout: HELPER_TIMEOUT_MS });
+    return { out: (r.stdout ?? '') + (r.stderr ?? ''), status: r.error ? null : r.status };
+}
+export class WindowsProbe {
+    processes() {
+        return listProcesses();
+    }
+    pidAlive(pid) {
+        if (!Number.isInteger(pid) || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (e) {
+            return e.code === 'EPERM';
+        }
+    }
+    stop(pid) {
+        refuseInSelfTest('stop programs');
+        if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
+            throw new Error('Not a process to stop: ' + pid);
+        process.kill(pid);
+    }
+    registryPath(scope) {
+        const r = run(SYSTEM.reg(), ['query', scope === 'user' ? USER_ENVIRONMENT : MACHINE_ENVIRONMENT, '/v', 'Path']);
+        return r.status === 0 ? parseRegPath(r.out) : null;
+    }
+    updateTaskExists() {
+        const r = run(system32('schtasks.exe'), ['/Query', '/TN', '\\WindowsDevelopmentSandbox\\Update']);
+        return r.status === null ? null : r.status === 0;
+    }
+    icacls(dir) {
+        const r = run(SYSTEM.icacls(), [dir]);
+        return r.status === 0 ? r.out : null;
+    }
+    groupMembers() {
+        const r = run(system32('net.exe'), ['localgroup', SHARING_GROUP]);
+        return r.status === 0 ? parseGroupMembers(r.out) : null;
+    }
+    tokenHasGroup(sid) {
+        const r = run(SYSTEM.whoami(), ['/groups', '/fo', 'csv', '/nh']);
+        return r.status === 0 ? r.out.includes('"' + sid + '"') : null;
+    }
+    async reachable(url, ms) {
+        try {
+            const response = await fetch(url, { method: 'HEAD', signal: AbortSignal.timeout(ms) });
+            return response.status < 500;
+        }
+        catch {
+            // Any failure (DNS, proxy, timeout) means "not reachable"; the caller words what to do.
+            return false;
+        }
+    }
+}

package/dist/host/install/copies.d.ts

@@ -0,0 +1,13 @@
+import { InstallLayout } from './layout.js';
+/** The install for everyone (%ProgramFiles%\WindowsDevelopmentSandbox), or null. */
+export declare function machineInstall(env?: NodeJS.ProcessEnv): InstallLayout | null;
+/** The install for just this user (%LOCALAPPDATA%\WindowsDevelopmentSandbox), or null. */
+export declare function userInstall(env?: NodeJS.ProcessEnv): InstallLayout | null;
+/** The installs that exist, the one for everyone first (it comes first on the PATH too). */
+export declare function managedInstalls(env?: NodeJS.ProcessEnv): InstallLayout[];
+/** Where this copy runs from, for `--version`: "all users, <folder>", "just you, <folder>", "npm copy, <folder>". */
+export declare function describeCopy(packageRoot: string): string;
+/** The line to print when this copy is not a managed install but one exists (it is hidden by this one), else null. */
+export declare function hiddenInstallLine(packageRoot: string, env?: NodeJS.ProcessEnv): string | null;
+/** hiddenInstallLine, but once per version (null afterwards). `storageRoot` holds the note that it was shown. */
+export declare function takeHiddenInstallNotice(storageRoot: string, packageRoot: string, version: string, env?: NodeJS.ProcessEnv): string | null;

package/dist/host/install/copies.js

@@ -0,0 +1,63 @@
+// Which managed installs exist on this PC, and what a copy that runs from somewhere else should say about them. A
+// managed install (<ProgramFiles or %LOCALAPPDATA%>\WindowsDevelopmentSandbox) is found from any copy of the program,
+// so an npm copy or a checkout still sees the machine install that shares sandboxes with other users.
+import path from 'node:path';
+import { z } from 'zod';
+import { fileExists } from '../../core/util/index.js';
+import { JsonFile } from '../../shared/io/index.js';
+import { InstallLayout } from './layout.js';
+const FOLDER = 'WindowsDevelopmentSandbox';
+function installAt(base, scope) {
+    if (!base || !path.isAbsolute(base))
+        return null;
+    const root = path.join(base, FOLDER);
+    if (!fileExists(path.join(root, 'active-version')) && !fileExists(path.join(root, 'install.json')))
+        return null;
+    return InstallLayout.at(root, scope);
+}
+/** The install for everyone (%ProgramFiles%\WindowsDevelopmentSandbox), or null. */
+export function machineInstall(env = process.env) {
+    return installAt(env.ProgramFiles, 'machine');
+}
+/** The install for just this user (%LOCALAPPDATA%\WindowsDevelopmentSandbox), or null. */
+export function userInstall(env = process.env) {
+    return installAt(env.LOCALAPPDATA, 'user');
+}
+/** The installs that exist, the one for everyone first (it comes first on the PATH too). */
+export function managedInstalls(env = process.env) {
+    return [machineInstall(env), userInstall(env)].filter((l) => l !== null);
+}
+/** Where this copy runs from, for `--version`: "all users, <folder>", "just you, <folder>", "npm copy, <folder>". */
+export function describeCopy(packageRoot) {
+    const layout = InstallLayout.detect(packageRoot);
+    if (layout)
+        return (layout.scope === 'machine' ? 'all users, ' : 'just you, ') + layout.root;
+    const resolved = path.resolve(packageRoot);
+    const npm = path.basename(path.dirname(resolved)).toLowerCase() === 'node_modules';
+    return (npm ? 'npm copy, ' : 'from ') + resolved;
+}
+/** The line to print when this copy is not a managed install but one exists (it is hidden by this one), else null. */
+export function hiddenInstallLine(packageRoot, env = process.env) {
+    if (InstallLayout.detect(packageRoot))
+        return null;
+    const installed = managedInstalls(env)[0];
+    if (!installed)
+        return null;
+    return ('Running the copy in ' +
+        path.resolve(packageRoot) +
+        '; the installed one in ' +
+        installed.root +
+        ' is hidden. sandbox doctor explains.');
+}
+const NoticeSchema = z.object({ version: z.string() });
+/** hiddenInstallLine, but once per version (null afterwards). `storageRoot` holds the note that it was shown. */
+export function takeHiddenInstallNotice(storageRoot, packageRoot, version, env = process.env) {
+    const line = hiddenInstallLine(packageRoot, env);
+    if (!line)
+        return null;
+    const file = new JsonFile(NoticeSchema, path.join(storageRoot, 'copy-notice.json'));
+    if (file.read()?.version === version)
+        return null;
+    file.write({ version });
+    return line;
+}

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

@@ -2,3 +2,4 @@ export { type InstallScope, InstallLayout, compareVersions, VERSION_PATTERN, NOD
 export { shimText, readBins, writeShims } from './shims.js';
 export { InstallRecordFile, InstallRecordSchema, type InstallRecord } from './install-record.js';
 export { UpdateTask } from './scheduled-task.js';
+export { machineInstall, userInstall, managedInstalls, describeCopy, hiddenInstallLine, takeHiddenInstallNotice, } from './copies.js';

package/dist/host/install/index.js

@@ -2,3 +2,4 @@ export { InstallLayout, compareVersions, VERSION_PATTERN, NODE_PATTERN } from '.
 export { shimText, readBins, writeShims } from './shims.js';
 export { InstallRecordFile, InstallRecordSchema } from './install-record.js';
 export { UpdateTask } from './scheduled-task.js';
+export { machineInstall, userInstall, managedInstalls, describeCopy, hiddenInstallLine, takeHiddenInstallNotice, } from './copies.js';

package/dist/host/launch/generate.js

@@ -6,6 +6,7 @@ import crypto from 'node:crypto';
 import { widenForProjects } from '../../core/local-config/index.js';
 import { dirExists, ensureDir, fail, writeJson } from '../../core/util/index.js';
 import { capturePersonalization, stageClaudeProfile } from '../profile/index.js';
+import { clearSecrets, writeSecrets } from '../secrets/index.js';
 import { assertTestWritable } from '../test-guard.js';
 import { planBootProjects } from './boot-projects.js';
 import { planDatabases } from './database-plan.js';
@@ -15,6 +16,15 @@ import { copyRuntime, stageGitIdentity, stageHooks } from './stage.js';
 import { decideProjectToolchains } from './toolchains.js';
 import { buildWsb, resolveMemoryMb } from './wsb-file.js';
 const NO_PROFILE = { hostDir: null, staged: [], skipped: [], credentials: false, secretsRemoved: [] };
+/** Moves the staged copy of this PC's Claude login out of the launch folder; its text goes in the one-shot file. */
+function takeStagedCredentials(launchPath) {
+    const file = path.join(launchPath, 'claude-profile', '.credentials.json');
+    if (!fs.existsSync(file))
+        return undefined;
+    const text = fs.readFileSync(file, 'utf8');
+    fs.rmSync(file, { force: true });
+    return text;
+}
 export function generateSandbox(given) {
     // Several projects at boot: the sandbox also gets what the others want and you allowed (core/local-config).
     const others = given.bootWants?.projects ?? [];
@@ -39,20 +49,34 @@ export function generateSandbox(given) {
     const memoryMb = Math.max(resolveMemoryMb(config.sandbox, o.freeMemoryBytes), ...others.map((p) => (typeof p.config.sandbox.memoryMb === 'number' ? p.config.sandbox.memoryMb : 0)));
     const launchId = Date.now() + '-' + crypto.randomBytes(3).toString('hex');
     const launchPath = path.join(storageRoot, 'launches', launchId);
-    ensureDir(launchPath);
+    // Whatever must stay secret goes in a one-shot file in the data folder, never into the launch folder (the sandbox
+    // maps it read-only and it is kept for days). Leftovers of earlier launches go first.
     ensureDir(dataPath);
+    clearSecrets(storageRoot, dataPath);
+    ensureDir(launchPath);
     const mappingNotes = [];
     const mappings = collectMappings(o, launchPath, boot, mappingNotes);
     const profile = harnessName === 'claude'
         ? stageClaudeProfile(config.claudeProfile, launchPath, workspaceHost, config.secrets)
         : NO_PROFILE;
+    // This PC's Claude login leaves the launch folder for the one-shot file (with the agent environment and VPN login).
+    const claudeCredentials = takeStagedCredentials(launchPath);
     stageGitIdentity(launchPath);
     const personalization = config.personalization.enabled ? capturePersonalization(launchPath) : 'disabled';
     const databases = o.databases ?? planDatabases(config.databases, workspaceHost);
     const toolchains = decideProjectToolchains(o);
+    if (o.vpn) {
+        ensureDir(path.join(launchPath, 'vpn'));
+        fs.writeFileSync(path.join(launchPath, 'vpn', 'server.ovpn'), o.vpn.profile, 'utf8');
+    }
     const session = guestSession(o, { launchId, launchPath, harness, boot, mappings, profile, databases, toolchains });
     const sessionPath = path.join(launchPath, 'session.json');
     writeJson(sessionPath, session);
+    writeSecrets(dataPath, launchId, {
+        ...(harness && Object.keys(harness.environment).length ? { harnessEnvironment: harness.environment } : {}),
+        ...(claudeCredentials ? { claudeCredentials } : {}),
+        ...(o.vpn ? { vpn: o.vpn.credentials } : {}),
+    });
     fs.writeFileSync(path.join(launchPath, 'env.cmd'), logonEnv(session.workspace), 'utf8');
     copyRuntime(o.packageRoot, launchPath);
     stageHooks(o.packageRoot, launchPath, o.run.scripts);

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

@@ -32,7 +32,8 @@ export function guestSession(o, parts) {
         roots: [...parts.boot.roots, ...parts.boot.projects].map((r) => r.guest),
         ...(o.autoSession === false ? { autoSession: false } : {}),
         harnessName,
-        harness: parts.harness,
+        // The environment (it may hold API keys) travels in a one-shot file in <data>\secrets, never in this file.
+        harness: parts.harness ? { ...parts.harness, environment: {} } : null,
         harnessArguments: o.harnessArgs,
         persistAgentState: config.storage.persistAgentState,
         networking: config.sandbox.networking,
@@ -47,6 +48,7 @@ export function guestSession(o, parts) {
         attach: config.attach,
         hooks: config.hooks,
         downloads: config.downloads,
+        ...(o.vpn ? { vpn: o.vpn.session } : {}),
         hostTools: hostToolsOf(o.probe),
         claudeProfile: {
             overwrite: config.claudeProfile.overwrite,
@@ -63,6 +65,7 @@ export function guestSession(o, parts) {
         auditProcesses: config.audit.enabled && config.audit.processes,
         agentHomes: Object.assign({}, ...Object.values(config.harnesses).map((h) => h.home?.env ?? {})),
         agentProfileDirs: Object.fromEntries(Object.entries(config.harnesses).flatMap(([name, h]) => h.home?.profileDirs?.length ? [[name, h.home.profileDirs]] : [])),
+        agents: Object.fromEntries(Object.entries(config.harnesses).map(([name, h]) => [name, { ...h, environment: {} }])),
     };
 }
 /**

package/dist/host/launch/stage.js

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

package/dist/host/migrate/backup.js

@@ -6,6 +6,8 @@ import path from 'node:path';
 import { z } from 'zod';
 import { assertNoLinks, fail, isInsideOrEqual, isLink } from '../../core/util/index.js';
 import { JsonFile } from '../../shared/io/index.js';
+import { protectPrivateFolder } from '../sharing/index.js';
+import { ensureStorageRoot } from '../storage/index.js';
 const ManifestSchema = z.object({
     entries: z.array(z.object({ original: z.string(), copy: z.string(), existed: z.boolean() })),
 });
@@ -56,6 +58,7 @@ export class MigrationBackup {
     }
     /** Copies each existing file or folder (and records the ones that do not exist yet, to remove them on restore). */
     save(paths) {
+        ensureStorageRoot(this.storageRoot, protectPrivateFolder);
         const dataRoot = path.join(this.storageRoot, 'data');
         const entries = this.manifest.read()?.entries ?? [];
         for (const target of paths) {

package/dist/host/migrate/migrations/config-file.d.ts

@@ -6,3 +6,5 @@ export declare function readFileObject(file: string | null): Json | null;
 export declare function fullSnapshots(file: Json): DefaultsSnapshot[];
 /** Removes these values from the file, comments and the rest untouched, noting `why: <key>` for each. */
 export declare function removeValues(file: string, paths: readonly string[][], why: string, note: (line: string) => void): void;
+/** Sets one value in the file (created when missing), comments and the rest untouched. */
+export declare function setValue(file: string, path: string[], value: unknown): void;

package/dist/host/migrate/migrations/config-file.js

@@ -1,5 +1,6 @@
 // Reading and editing a config.json (JSON with comments) for the migrations: removing a value keeps every comment.
 import fs from 'node:fs';
+import nodePath from 'node:path';
 import { applyEdits, modify, parse } from 'jsonc-parser';
 import _ from 'lodash';
 import { writeFileAtomic } from '../../../shared/io/index.js';
@@ -26,3 +27,9 @@ export function removeValues(file, paths, why, note) {
     }
     writeFileAtomic(file, text);
 }
+/** Sets one value in the file (created when missing), comments and the rest untouched. */
+export function setValue(file, path, value) {
+    const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '{}\n';
+    fs.mkdirSync(nodePath.dirname(file), { recursive: true });
+    writeFileAtomic(file, applyEdits(text, modify(text, path, value, FORMAT)));
+}

package/dist/host/migrate/migrations/follow-machine-storage.js

@@ -1,8 +1,11 @@
 // An all-users install keeps everyone's data under %ProgramData%\AgentSandbox (its machine config says where), so a
 // sandbox can be shared. A config.json written by an old `config init` pins storage.root to the old per-user default,
 // which wins over the machine config. Removes that pin, and only that: a storage.root you chose yourself stays.
+import path from 'node:path';
 import _ from 'lodash';
 import { DEFAULTS, machineConfigPath } from '../../../core/config/index.js';
+import { expandPath } from '../../../core/util/index.js';
+import { holdsData } from '../../storage/root.js';
 import { fullSnapshots, readFileObject, removeValues } from './config-file.js';
 const ROOT = ['storage', 'root'];
 /** True when the machine config sets the storage folder and the user's file only pins a default of an old init. */
@@ -15,7 +18,12 @@ function pinnedOverMachine(configPath) {
         return false;
     const value = _.get(file, ROOT);
     const defaults = [_.get(DEFAULTS, ROOT), ...fullSnapshots(file).map((s) => _.get(s.defaults, ROOT))];
-    return defaults.some((d) => _.isEqual(d, value));
+    if (!defaults.some((d) => _.isEqual(d, value)))
+        return false;
+    // A pin that holds your saved data while the shared folder has none is kept: sandbox storage offers the move.
+    const pinned = typeof value === 'string' ? expandPath(value, path.dirname(configPath ?? '')) : '';
+    const shared = expandPath(String(_.get(machine, ROOT)), path.dirname(machineConfigPath()));
+    return !(holdsData(pinned) && !holdsData(shared));
 }
 export const followMachineStorage = {
     id: '2026-10-follow-machine-storage',

package/dist/host/migrate/migrations/pin-storage-root.d.ts

@@ -0,0 +1,4 @@
+import type { Migration } from '../migration.js';
+/** All the conditions of the migration, as a pure check on what is on disk. */
+export declare function needsPin(file: string, machineFile: string, oldRoot: string | null): boolean;
+export declare const pinStorageRoot: Migration;

package/dist/host/migrate/migrations/pin-storage-root.js

@@ -0,0 +1,46 @@
+// 1.6 moves the default storage folder to %ProgramData%\AgentSandbox\users\<you>. Nobody's data may seem to vanish: a
+// user with no storage.root of their own, no all-users install, and saved data in the old per-user folder keeps that
+// folder, pinned in config.json. Moving it to the new default is offered later (sandbox storage).
+import fs from 'node:fs';
+import path from 'node:path';
+import _ from 'lodash';
+import { machineConfigPath } from '../../../core/config/index.js';
+import { holdsData, OLD_DEFAULT_ROOT, oldDefaultRoot } from '../../storage/root.js';
+import { readFileObject, setValue } from './config-file.js';
+const ROOT = ['storage', 'root'];
+/** The file the pin goes in: the user's config, or the one it would be (not created until the pin is written). */
+function targetFile(ctx) {
+    return ctx.configPath ?? path.join(ctx.userDir, 'config.json');
+}
+/** All the conditions of the migration, as a pure check on what is on disk. */
+export function needsPin(file, machineFile, oldRoot) {
+    if (!oldRoot || !holdsData(oldRoot))
+        return false;
+    const machine = readFileObject(machineFile);
+    if (machine && _.has(machine, ROOT))
+        return false;
+    if (!fs.existsSync(file))
+        return true;
+    const parsed = readFileObject(file);
+    // A file that cannot be read is left alone: editing it blindly could lose the user's settings.
+    return parsed !== null && !_.has(parsed, ROOT);
+}
+export const pinStorageRoot = {
+    id: '2026-10-pin-storage-root',
+    introducedIn: '1.6.0',
+    scope: 'user',
+    needsIdleSandbox: false,
+    summary: 'Keeps your saved data where it is (the old per-user folder), now that the default folder is a new one.',
+    applies(ctx) {
+        return needsPin(targetFile(ctx), machineConfigPath(), oldDefaultRoot());
+    },
+    touches() {
+        return [];
+    },
+    async run(ctx, note) {
+        if (!needsPin(targetFile(ctx), machineConfigPath(), oldDefaultRoot()))
+            return;
+        setValue(targetFile(ctx), ROOT, OLD_DEFAULT_ROOT);
+        note('Your saved data stays in ' + OLD_DEFAULT_ROOT + ' (storage.root)');
+    },
+};

package/dist/host/migrate/migrations/unpin-config-defaults.js

@@ -4,6 +4,8 @@
 import _ from 'lodash';
 import { DEFAULTS } from '../../../core/config/index.js';
 import { fullSnapshots, readFileObject, removeValues } from './config-file.js';
+/** storage.root is never unpinned: the old default now names the old folder, and following today's would hide it. */
+const KEEP_PINNED = ['storage', 'root'];
 /** Paths of the leaves of a JSON object (arrays and scalars are leaves). */
 function leafPaths(value, prefix = []) {
     if (!_.isPlainObject(value))
@@ -15,7 +17,8 @@ function pinnedLeaves(file) {
     const snapshots = fullSnapshots(file);
     return leafPaths(file).filter((path) => {
         const value = _.get(file, path);
-        return (_.has(DEFAULTS, path) &&
+        return (!_.isEqual(path, KEEP_PINNED) &&
+            _.has(DEFAULTS, path) &&
             !_.isEqual(value, _.get(DEFAULTS, path)) &&
             snapshots.some((snapshot) => _.has(snapshot.defaults, path) && _.isEqual(_.get(snapshot.defaults, path), value)));
     });

package/dist/host/migrate/registry.js

@@ -1,3 +1,4 @@
 import { followMachineStorage } from './migrations/follow-machine-storage.js';
+import { pinStorageRoot } from './migrations/pin-storage-root.js';
 import { unpinConfigDefaults } from './migrations/unpin-config-defaults.js';
-export const MIGRATIONS = [unpinConfigDefaults, followMachineStorage];
+export const MIGRATIONS = [unpinConfigDefaults, followMachineStorage, pinStorageRoot];

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

@@ -1,3 +1,4 @@
+import { SecretStore } from '../secrets/index.js';
 import { type LoginFiles } from './claude-login.js';
 export interface Account {
     readonly name: string;
@@ -13,14 +14,37 @@ export interface AccountRow {
     readonly isActive: boolean;
     readonly savedAt: string;
 }
+/** What lists need: no decryption. */
+export interface AccountMeta {
+    readonly name: string;
+    readonly savedAt: string;
+    readonly email: string | null;
+}
 export declare function accountsDir(storageRoot: string): string;
 /** The saved Claude logins under <storage>\accounts, and which one each sandbox data folder uses. */
 export declare class AccountStore {
     private readonly storageRoot;
-    constructor(storageRoot: string);
+    private readonly sharePlugins;
+    private readonly secrets;
+    /** What the last activate() did with the shared plugins (a problem there never stops the switch). */
+    pluginNote: string | null;
+    /** @param sharePlugins claudeProfile.sharePluginsAcrossAccounts: carry Claude plugins to the account switched to */
+    constructor(storageRoot: string, sharePlugins?: boolean, secrets?: SecretStore);
+    /** With the setting on: refreshes the shared plugin set from this data set, or fills this data set from it. */
+    syncPlugins(dataPath: string): void;
+    private shareStep;
     private file;
+    private seal;
     private store;
+    /** The saved account's name, date and e-mail (nothing is decrypted). */
+    meta(name: string): AccountMeta | null;
+    /**
+     * The saved account with its login decrypted. A plain file from an older version is encrypted on the spot (it stays
+     * readable when that fails).
+     */
     read(name: string): Account | null;
+    /** Encrypts every account still saved as plain text (older versions); returns how many it did. */
+    sealLegacy(): number;
     defaultName(): string | null;
     /** The account a data folder uses (kept in the index of the storage folder that data folder is in). */
     activeFor(dataPath: string): string | null;