windows-development-sandbox 1.5.0 → 1.7.0

package/dist/cli/commands/launch/launch.js

@@ -6,7 +6,8 @@ import _ from 'lodash';
 import { generateSandbox } from '../../../host/launch/index.js';
 import { findSecretFiles } from '../../../host/profile/index.js';
 import { RepoGuardStore } from '../../../host/guard/index.js';
-import { assertCanLaunch, isSandboxRunning, spawnDetached, startSandbox, probeHost, hideSandboxWindow, } from '../../../host/sandbox/index.js';
+import { hostPublicIp, prepareVpn, readVpnLine, vpnNotes } from '../../../host/vpn/index.js';
+import { assertCanLaunch, isSandboxRunning, spawnDetached, startSandbox, confirmSandboxStarted, probeHost, hideSandboxWindow, } from '../../../host/sandbox/index.js';
 import { KnownProjects, ProjectRegistry } from '../../../host/projects/index.js';
 import { LifeRecord, SessionLedger } from '../../../host/life/index.js';
 import { isWithin } from '../../../shared/paths/index.js';
@@ -19,6 +20,7 @@ import { c, table } from '../../output/index.js';
 import { syncAgentCommands } from '../agent-commands.js';
 import { requireOnPc } from '../context.js';
 import { joinHere } from '../projects/index.js';
+import { offerSetupWhenOff } from '../setup/index.js';
 import { useSharedSandbox } from '../shared-use.js';
 import { beginSharing, currentUserName, currentUserSid, listProcesses, runningOwner, sessionOf, sharingDeps, takeSharingNotice, } from '../../../host/sharing/index.js';
 import { packageVersion } from '../../../core/package-info.js';
@@ -50,6 +52,11 @@ class Launcher {
             requireOnPc('launch');
         if (!generateOnly)
             this.syncAgentCommands();
+        if (!generateOnly) {
+            const setUp = await offerSetupWhenOff(this.ctx);
+            if (setUp !== undefined)
+                return setUp;
+        }
         if (!generateOnly && isSandboxRunning()) {
             // Another user's sandbox: an agent session in a project it has, when it is shared; nothing else.
             const ctx = await useSharedSandbox(this.ctx, options.noAgent ? { kind: 'owner-only', what: 'start a sandbox' } : { kind: 'use' });
@@ -120,6 +127,15 @@ class Launcher {
             await maybeAddRoot(ctx, run);
         const prepared = generateOnly ? null : await prepare(ctx, run);
         const bootWants = await bootWantsFor(ctx, run, extras.extraProjects);
+        // The VPN (vpn.enabled): its server and profile are fetched and checked here, before anything is written.
+        const vpn = generateOnly
+            ? null
+            : await prepareVpn({
+                config,
+                storageRoot: ctx.storageRoot,
+                sandboxRunning: isSandboxRunning(),
+                base: run.workspaceHost,
+            });
         const generated = generateSandbox({
             packageRoot: ctx.packageRoot,
             run,
@@ -128,11 +144,14 @@ class Launcher {
             extraProjects: extras.extraProjects,
             autoSession: extras.autoSession,
             bootWants: bootWants.wants,
+            ...(vpn ? { vpn } : {}),
         });
         const notes = [...run.notes, ...bootWants.notes, ...generated.projects.notes, ...generated.mappingNotes];
         for (const note of notes)
             console.log(note);
         this.warnSecretFiles(run);
+        for (const line of vpnNotes(config.vpn))
+            console.log(c.yellow(line));
         table(launchSummary(run, generated, prepared));
         if (generateOnly)
             return 0;
@@ -141,6 +160,7 @@ class Launcher {
         this.record(run, generated);
         this.share(generated);
         startSandbox(generated.wsbPath);
+        await confirmSandboxStarted(generated.wsbPath);
         this.startWatcher();
         if (reopen.length)
             await this.reopenAfterBoot(generated.launchId, reopen);
@@ -188,8 +208,12 @@ class Launcher {
      */
     share(generated) {
         const deps = sharingDeps(this.ctx.packageRoot);
-        if (!deps)
+        if (!deps) {
+            if (this.ctx.loaded.config.sharing.otherUsers)
+                console.log(c.yellow('This sandbox is not shared: sharing.otherUsers is on, but no all-users install was found on this PC. ' +
+                    'Install for everyone (install.ps1 -Scope AllUsers) to share sandboxes.'));
             return;
+        }
         // Only the shared tree may be opened to the group: never a storage folder of your own (your profile, say).
         const inSharedTree = isWithin(deps.usersDir, this.ctx.dataPath);
         if (this.ctx.loaded.config.sharing.otherUsers && !inSharedTree)
@@ -199,6 +223,9 @@ class Launcher {
                 deps.usersDir +
                 '. Remove storage.root from your config to use the shared folder.'));
         const shared = this.ctx.loaded.config.sharing.otherUsers && inSharedTree;
+        // Only an opened folder has permissions to write; a closed one is checked in a moment and usually needs nothing.
+        if (shared)
+            console.log('Setting folder permissions...');
         const rows = listProcesses();
         beginSharing(deps, {
             user: currentUserName(),
@@ -230,6 +257,26 @@ class Launcher {
         if (!watcherRunning(this.ctx.dataPath))
             spawnDetached(this.ctx.entry, ['_watch', ...(config ? ['--config', path.resolve(config)] : [])]);
     }
+    /** Waits for the boot; the VPN's outcome is said whether the boot worked or not (a failed tunnel can be why). */
+    async bootThenReportVpn(run, launchId, timed) {
+        try {
+            await waitForBoot(this.ctx.dataPath, launchId, timed);
+        }
+        catch (e) {
+            await this.reportVpn(run);
+            throw e;
+        }
+        await this.reportVpn(run);
+    }
+    /** Says whether the VPN came up (the sandbox reports it; its address is compared with this PC's). */
+    async reportVpn(run) {
+        if (!run.config.vpn.enabled)
+            return;
+        const line = readVpnLine(this.ctx.dataPath, await hostPublicIp());
+        if (!line)
+            return;
+        console.log(line.level === 'ok' ? c.green(line.text) : line.level === 'warn' ? c.yellow(line.text) : c.red(line.text));
+    }
     /** Waits for the boot and attaches when asked to; otherwise says where the agent opens. */
     async afterStart(run, generated) {
         const { ctx, options, extras } = this;
@@ -241,7 +288,7 @@ class Launcher {
         if (options.terminal || options.noAgent || extras.waitUntilReady) {
             if (headsUp)
                 console.log(headsUp);
-            await waitForBoot(dataPath, generated.launchId, Boolean(headsUp));
+            await this.bootThenReportVpn(run, generated.launchId, Boolean(headsUp));
             if (extras.waitUntilReady)
                 return 0;
             // Without an agent there is no session to attach to: the sandbox itself is the result.
@@ -253,7 +300,13 @@ class Launcher {
             }
             return attachHere(ctx, await waitForStart(ctx, generated.launchId, 'Starting ' + run.harnessName));
         }
-        if (headsUp)
+        // The VPN's outcome is worth waiting for: a failed tunnel with the kill switch on means no internet.
+        if (config.vpn.enabled) {
+            if (headsUp)
+                console.log(headsUp);
+            await this.bootThenReportVpn(run, generated.launchId, Boolean(headsUp));
+        }
+        else if (headsUp)
             console.log(headsUp + '\nFollow along: sandbox logs -f');
         if (hidden)
             console.log((await hidden)

package/dist/cli/commands/launch/prepare.js

@@ -77,10 +77,12 @@ async function prepareWorkspaceView(ctx, run) {
 export async function prepare(ctx, run) {
     const { options, dataPath, storageRoot } = ctx;
     const { config } = run;
-    const accounts = new AccountStore(storageRoot);
+    const accounts = new AccountStore(storageRoot, config.claudeProfile.sharePluginsAcrossAccounts);
     const account = options.account ?? accounts.defaultName();
     if (account && run.harnessName === 'claude' && account !== accounts.activeFor(dataPath))
         accounts.activate(dataPath, account);
+    else if (run.harnessName === 'claude')
+        accounts.syncPlugins(dataPath);
     const terminal = config.provisioning.terminal.enabled
         ? await ensureTerminal(dataPath, config.provisioning.refresh, { pwsh: config.toolchains.pwsh.enabled !== false })
         : { exe: null, message: 'disabled' };

package/dist/cli/commands/maintenance/audit.js

@@ -28,7 +28,7 @@ export async function audit(ctx) {
     if (!events.length) {
         console.log(settings.enabled
             ? 'Nothing in the audit log for the last ' + ctx.options.days + ' day(s).'
-            : 'The audit log is off. Turn it on in the menu (Settings > Security & privacy > Audit log) or with audit.enabled in your config.');
+            : 'The audit log is off. Turn it on in the menu (Settings > Security & privacy > Audit log) or with: sandbox config set audit.enabled true');
         return 0;
     }
     for (const e of events) {

package/dist/cli/commands/maintenance/clean.d.ts

@@ -1,2 +1,2 @@
 import { type Context } from '../context.js';
-export declare function clean(ctx: Context): number;
+export declare function clean(ctx: Context): Promise<number>;

package/dist/cli/commands/maintenance/clean.js

@@ -1,10 +1,24 @@
+// `sandbox clean`: old launch folders, logs and leftovers. Shows what and how much, then asks (--yes skips).
 import _ from 'lodash';
+import { askRequired } from '../../../core/prompt.js';
 import { describePrune, pruneStorage } from '../../../host/storage/index.js';
 import { isSandboxRunning } from '../../../host/sandbox/index.js';
 import { RunDir } from '../../../shared/channel/index.js';
-export function clean(ctx) {
+import { nextStep } from '../../output/index.js';
+export async function clean(ctx) {
     const running = isSandboxRunning() ? new RunDir(ctx.dataPath).readSandboxStatus()?.launchId : undefined;
-    console.log('Cleanup: ' +
-        describePrune(pruneStorage(ctx.storageRoot, { launchDays: ctx.options.days, keep: _.compact([running]) })));
+    const options = { launchDays: ctx.options.days, keep: _.compact([running]) };
+    const found = pruneStorage(ctx.storageRoot, { ...options, dryRun: true });
+    if (found.launches + found.logs + found.leftovers === 0) {
+        console.log('Nothing to clean.');
+        return 0;
+    }
+    console.log('Can be removed: ' + describePrune(found).replace(' removed', '') + '.');
+    if (!ctx.options.yes && !(await askRequired('Delete them?', 'Add --yes to delete without asking.'))) {
+        console.log('Nothing removed.');
+        return 1;
+    }
+    console.log('Removed ' + describePrune(pruneStorage(ctx.storageRoot, options)).replace(' removed', '') + '.');
+    nextStep('sandbox data   (see what else is saved, and clean it)');
     return 0;
 }

package/dist/cli/commands/maintenance/config.d.ts

@@ -1,2 +1,2 @@
 import { type Context } from '../context.js';
-export declare function config(ctx: Context): number;
+export declare function config(ctx: Context): number | Promise<number>;

package/dist/cli/commands/maintenance/config.js

@@ -1,21 +1,119 @@
+import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import _ from 'lodash';
 import { DEFAULTS, userConfigPath, userDir } from '../../../core/config/index.js';
+import { redactSecrets } from '../../../core/schema/index.js';
 import { allowedAnswer, allowStorePath, applyOverrides, describeOverrides, isTrusted, LOCAL_CONFIG_NAME, loosenedRequests, normalizeOverrides, OUTSIDE_FOLDER, outsideKey, outsideMappings, readLocalConfig, trustStorePath, } from '../../../core/local-config/index.js';
 import { guestWorkspaceOf, previewGuest } from '../../../core/run/index.js';
+import { askChoice } from '../../../core/prompt.js';
 import { dirExists, fail, safeText, writeJson } from '../../../core/util/index.js';
-import { c, table } from '../../output/index.js';
-function initConfig() {
+import { system32 } from '../../../shared/system.js';
+import { refuseInSelfTest } from '../../../host/test-guard.js';
+import { closest } from '../../validate.js';
+import { c, nextStep, table } from '../../output/index.js';
+import { ConfigFile } from '../../menu/settings/index.js';
+/** The settings file exists already: open it, start over, or leave it (no terminal: say how). */
+async function existingFile(file) {
+    return askChoice(file + ' exists already.', [
+        { name: 'Open it', value: 'open' },
+        { name: 'Overwrite it with the defaults (your changes are lost)', value: 'overwrite' },
+        { name: 'Cancel', value: 'cancel' },
+    ], 'Open it with: sandbox config path. To start over, delete it first.');
+}
+async function initConfig() {
     const file = userConfigPath();
-    if (fs.existsSync(file))
-        fail(file + ' already exists.');
+    if (fs.existsSync(file)) {
+        const answer = await existingFile(file);
+        if (answer === 'cancel')
+            return 0;
+        if (answer === 'open') {
+            refuseInSelfTest('open files');
+            spawn(system32('notepad.exe'), [file], { detached: true, stdio: 'ignore' }).unref();
+            console.log('Opened ' + file + '.');
+            return 0;
+        }
+    }
     fs.mkdirSync(path.join(userDir(), 'hooks', 'pre-agent'), { recursive: true });
     // The schema sits next to the file (a local path), so editors trust it and show docs and autocomplete.
     writeJson(file, { $schema: './config.schema.json', ...DEFAULTS });
     console.log('Created ' + file + '. It lists every setting with its default; delete the ones you do not change.');
     console.log('Your own hook scripts go in ' + path.join(userDir(), 'hooks') + '\\{pre-provision,pre-agent,post-agent}.');
-    console.log("For editor help in every project's .sandbox-config.json, run: sandbox config schema");
+    nextStep("sandbox config schema   (editor help in every project's .sandbox-config.json)");
+    return 0;
+}
+/** The setting a key names, as the schema knows it; an unknown key says what is close. */
+function settingNode(key) {
+    const root = ConfigFile.user(null).schema;
+    const keyPath = key.split('.');
+    let node = root;
+    for (const part of keyPath)
+        node = node?.child(part);
+    if (node)
+        return { path: keyPath, node };
+    const known = root.leaves().map((l) => l.key.join('.'));
+    const hint = closest(key, known);
+    return fail('There is no setting "' + key + '".' + (hint ? ' Did you mean ' + hint + '?' : ''), 'Settings are named like sandbox.memoryMb. See them all with: sandbox config show');
+}
+/** What was typed for a setting as the value it stands for: true/false/on/off, a number, JSON, or plain text. */
+function settingValue(node, text) {
+    const word = text.trim().toLowerCase();
+    if (node.type === 'string')
+        return text;
+    if (node.type === 'boolean' || node.options.some((o) => o.type === 'boolean')) {
+        if (['true', 'on', 'yes'].includes(word))
+            return true;
+        if (['false', 'off', 'no'].includes(word))
+            return false;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        // Not JSON: a bare word such as auto or a path is the text itself.
+        return node.type === 'array' ? text.split(',').map((t) => t.trim()) : text;
+    }
+}
+/** What a setting accepts, in words: its fixed values, a number and its range, true or false. */
+function allowedText(node) {
+    const values = node.choiceValues.map((v) => String(v));
+    const open = node.openOption ?? (node.type === 'number' ? node : undefined);
+    const range = (n) => (n.rangeText() ? ' (' + n.rangeText() + ')' : '');
+    const more = open ? (open.type === 'number' ? 'a number' + range(open) : 'text') : '';
+    if (node.type === 'boolean')
+        return 'Use true or false.';
+    const parts = [...values, ...(more ? [more] : [])];
+    return parts.length ? 'Allowed: ' + parts.join(', or ') + '.' : 'Check the value.';
+}
+function setSettingCommand(ctx, key, text) {
+    if (!key || text === undefined)
+        fail('Which setting and value?', 'Usage: sandbox config set <setting> <value>');
+    const { path: keyPath, node } = settingNode(key);
+    if (node.isSection)
+        fail('"' + key + '" is a group of settings.', 'Set one of them, e.g. ' + node.leaves(keyPath)[0]?.key.join('.'));
+    const value = settingValue(node, text);
+    const problem = node.check(value);
+    if (problem !== true) {
+        fail('"' + text + '" does not work for ' + key + ': ' + problem, allowedText(node));
+    }
+    const outcome = ConfigFile.user(ctx.loaded.configPath).set(keyPath, value);
+    if (typeof outcome === 'object')
+        fail('Could not change ' + key + ': ' + outcome.problems.join('; '), 'Nothing was written.');
+    console.log(key +
+        ' is ' +
+        JSON.stringify(_.get(redactSecrets(_.set({}, keyPath, value)), keyPath)) +
+        (outcome === 'unchanged' ? ' (it was already)' : '') +
+        '.');
+    return 0;
+}
+function getSettingCommand(ctx, key) {
+    if (!key)
+        fail('Which setting?', 'Usage: sandbox config get <setting>   (all of them: sandbox config show)');
+    const { path: keyPath } = settingNode(key);
+    // Secret values (an agent's API keys) are never printed.
+    const value = _.get(redactSecrets(ctx.loaded.config), keyPath);
+    console.log(typeof value === 'string' ? value : JSON.stringify(value, null, 2));
     return 0;
 }
 /**
@@ -72,9 +170,9 @@ function previewFolders(ctx, dir, filePath, overrides) {
         if (!outside.includes(m))
             return m.guest ? 'inside the project' : 'inside the project (already in the sandbox there)';
         if (policy === true)
-            return 'outside the project, allowed (projects.allowOutsideMappings is true)';
+            return 'outside the project, allowed (your settings allow it)';
         if (policy === false)
-            return c.red('outside the project: refused (projects.allowOutsideMappings is false)');
+            return c.red('outside the project: refused (your settings do not allow it)');
         return allowedAnswer(store, filePath, OUTSIDE_FOLDER, outsideKey(m)) === true
             ? 'outside the project, allowed (you said yes)'
             : c.yellow('outside the project: the next interactive launch asks you');
@@ -110,7 +208,7 @@ function previewFolders(ctx, dir, filePath, overrides) {
     }
 }
 export function config(ctx) {
-    const [action = 'summary'] = ctx.options.positionals;
+    const [action = 'summary', key, value] = ctx.options.positionals;
     switch (action) {
         case 'summary':
             table([
@@ -133,13 +231,17 @@ export function config(ctx) {
         case 'init':
             return initConfig();
         case 'show':
-            console.log(JSON.stringify(ctx.loaded.config, null, 2));
+            console.log(JSON.stringify(redactSecrets(ctx.loaded.config), null, 2));
             return 0;
+        case 'get':
+            return getSettingCommand(ctx, key);
+        case 'set':
+            return setSettingCommand(ctx, key, value);
         case 'schema':
             return printSchemaSettings();
         case 'check':
             return checkLocalConfig(ctx);
         default:
-            fail('Unknown config action "' + action + '".', 'Use one of: sandbox config show | path | init | schema | check');
+            fail('Unknown config action "' + action + '".', 'Use one of: sandbox config show | get | set | path | init | schema | check');
     }
 }

package/dist/cli/commands/maintenance/doctor.d.ts

@@ -1,2 +1,2 @@
 import { type Context } from '../context.js';
-export declare function doctor(ctx: Context): number;
+export declare function doctor(ctx: Context): Promise<number>;

package/dist/cli/commands/maintenance/doctor.js

@@ -1,6 +1,4 @@
-import { table } from '../../output/index.js';
-import { HealthService } from '../../services/index.js';
+import { runDoctor } from '../repair/index.js';
 export function doctor(ctx) {
-    table(new HealthService(ctx).doctor());
-    return 0;
+    return runDoctor(ctx);
 }

package/dist/cli/commands/maintenance/migrate.d.ts

@@ -1,9 +1,10 @@
 import { MigrateService } from '../../services/index.js';
-import type { Context } from '../context.js';
+import { type Context } from '../context.js';
 /** `sandbox migrate`: the work, with the service and the output given so a test can drive it. */
 export declare function runMigrate(service: MigrateService, options: {
     readonly dryRun: boolean;
     readonly restore?: string;
+    readonly yes?: boolean;
 }, print: (line: string) => void): Promise<number>;
 export declare function migrate(ctx: Context): Promise<number>;
 /**

package/dist/cli/commands/maintenance/migrate.js

@@ -1,15 +1,28 @@
 import { userDir } from '../../../core/config/index.js';
 import { autoMigrates, continuesAfterFailedMigration, MigrateService, } from '../../services/index.js';
+import { askRequired } from '../../../core/prompt.js';
 import { c } from '../../output/index.js';
 import { errMsg, UserError } from '../../../core/util/index.js';
 import { insideSandbox } from '../../../host/sandbox/index.js';
-/** Where this context keeps the saved settings. */
+import { holdsData, oldDefaultRoot } from '../../../host/storage/index.js';
+import { refreshStorage } from '../context.js';
+/**
+ * Where this context keeps the saved settings. Backups go where the data is: an upgrade that has not pinned the old
+ * folder yet would otherwise fill the new, empty default folder with them.
+ */
 function whereOf(ctx) {
-    return { storageRoot: ctx.storageRoot, userDir: userDir(), configPath: ctx.loaded.configPath };
+    const old = oldDefaultRoot();
+    const unpinned = old !== null && !holdsData(ctx.storageRoot) && holdsData(old) && !ctx.loaded.layers?.machine;
+    return { storageRoot: unpinned ? old : ctx.storageRoot, userDir: userDir(), configPath: ctx.loaded.configPath };
 }
 /** `sandbox migrate`: the work, with the service and the output given so a test can drive it. */
 export async function runMigrate(service, options, print) {
     if (options.restore) {
+        if (!options.yes &&
+            !(await askRequired('Put back the files saved in ' + options.restore + '? Your current settings files are replaced.', 'Add --yes to put them back without asking.'))) {
+            print('Nothing was changed.');
+            return 1;
+        }
         service.restore(options.restore);
         print('Put back the files saved in ' + options.restore + '.');
         return 0;
@@ -31,7 +44,7 @@ export async function runMigrate(service, options, print) {
     return 0;
 }
 export function migrate(ctx) {
-    return runMigrate(new MigrateService(whereOf(ctx)), { dryRun: ctx.options.dryRun, restore: ctx.options.restore }, (line) => console.log(line));
+    return runMigrate(new MigrateService(whereOf(ctx)), { dryRun: ctx.options.dryRun, restore: ctx.options.restore, yes: ctx.options.yes }, (line) => console.log(line));
 }
 /**
  * Before a command: brings the settings up to date when the version changed (one small file is read otherwise).
@@ -44,7 +57,9 @@ export async function migrateBeforeCommand(ctx, command) {
     try {
         if (!service.versionChanged())
             return;
-        await service.run((line) => console.error(c.dim(line)));
+        const result = await service.run((line) => console.error(c.dim(line)));
+        if (result.applied.length)
+            refreshStorage(ctx);
     }
     catch (e) {
         if (!continuesAfterFailedMigration(command))

package/dist/cli/commands/maintenance/sync.js

@@ -1,5 +1,6 @@
 import { isSandboxRunning } from '../../../host/sandbox/index.js';
 import { syncBack } from '../../../sync/index.js';
+import { nextStep } from '../../output/index.js';
 export function sync(ctx) {
     const running = isSandboxRunning();
     const result = syncBack(ctx.dataPath, !running);
@@ -8,5 +9,6 @@ export function sync(ctx) {
         ' item(s) synced back. claude-mem: ' +
         result.claudeMem +
         (running ? ' (claude-mem syncs when the sandbox closes)' : ''));
+    nextStep('sandbox claude   (carry on where you left off)');
     return 0;
 }

package/dist/cli/commands/maintenance/update.d.ts

@@ -6,6 +6,8 @@ export interface UpdateRequest {
     readonly rollback: boolean;
     readonly auto?: 'on' | 'off';
     readonly unattended: boolean;
+    /** Do not ask before going back. */
+    readonly yes?: boolean;
 }
 /** One sentence for what an update run did, and whether it counts as done. */
 export declare function describeResult(result: UpdateResult | null, unattended: boolean): {

package/dist/cli/commands/maintenance/update.js

@@ -1,4 +1,5 @@
 import { userDir } from '../../../core/config/index.js';
+import { askRequired } from '../../../core/prompt.js';
 import { errMsg } from '../../../core/util/index.js';
 import { PACKAGE_ROOT } from '../../../core/package-info.js';
 import { insideSandbox, spawnDetached } from '../../../host/sandbox/index.js';
@@ -23,8 +24,14 @@ export function describeResult(result, unattended) {
                 result.version +
                 ' failed: ' +
                 result.reason.replace(/\.?\s*$/, '.') +
-                ' Still on the version you had.' +
-                (result.blocked ? ' It is not tried again; the next release is.' : ' It is tried again later.'),
+                (result.rolledBack
+                    ? ' The change was undone: you are on the version you had.'
+                    : ' Going back to your previous version did not fully work: run sandbox update --rollback or the installer.') +
+                (result.autoUpdateOff
+                    ? ' Automatic updates are off; turn them back on in Maintenance > Updates or with sandbox update --auto on.'
+                    : result.blocked
+                        ? ' It is not tried again; the next release is.'
+                        : ' It is tried again later.'),
             code: 1,
         };
     switch (result.reason) {
@@ -52,12 +59,22 @@ export async function runUpdate(service, request, print) {
         print('This copy was installed with npm. Update it with: ' + NPM_UPDATE_COMMAND);
         return 0;
     }
+    // The scheduled task (it may outlive a removal that needed admin) and background starts only run when updates are on.
+    if (request.unattended && !request.auto && !service.status().autoUpdate)
+        return 0;
     if (request.auto) {
         service.setAuto(request.auto === 'on');
         print('Automatic updates are ' + request.auto + '.');
         return 0;
     }
     if (request.rollback) {
+        const { version, state } = service.status();
+        const target = state.previous ? 'version ' + state.previous : 'the version before the last update';
+        if (!request.yes &&
+            !(await askRequired('Go back from version ' + version + ' to ' + target + '?', 'Add --yes to go back without asking.'))) {
+            print('Nothing was changed.');
+            return 1;
+        }
         print('Went back to version ' + service.rollback() + '.');
         return 0;
     }
@@ -77,10 +94,16 @@ export async function runUpdate(service, request, print) {
 }
 export function update(options) {
     const service = UpdateService.forPackage(PACKAGE_ROOT, options.feed, { userDir: userDir() });
-    return runUpdate(service, { check: options.check, rollback: options.rollback, auto: options.autoUpdate, unattended: options.unattended }, (line) => console.log(line));
+    return runUpdate(service, {
+        check: options.check,
+        rollback: options.rollback,
+        auto: options.autoUpdate,
+        unattended: options.unattended,
+        yes: options.yes,
+    }, (line) => console.log(line));
 }
 /** Commands that never look for updates first: they are how updates run, or they must stay quiet. */
-const NO_STARTUP_UPDATE = ['self-test', 'update', '_watch'];
+const NO_STARTUP_UPDATE = ['self-test', 'update', '_watch', '_web'];
 /**
  * At the start of a command: tells this user once about an update that ran without them, and (current-user installs
  * with automatic updates on) starts the daily check in the background. Never stops the command.

package/dist/cli/commands/projects/here.js

@@ -3,13 +3,13 @@
 // folder a project of the running sandbox when it can without a restart (launch, start, exec, db).
 import path from 'node:path';
 import { select } from '@inquirer/prompts';
-import { describeMissing, missingTip } from '../../../core/local-config/index.js';
+import { describeMissing, missingTip, protectionsOf } from '../../../core/local-config/index.js';
 import { askYesNo } from '../../../core/prompt.js';
 import { fail, isInsideOrEqual } from '../../../core/util/index.js';
 import { ownerName } from '../../../host/sharing/index.js';
 import { resolveRun } from '../../../core/run/index.js';
 import { SandboxChannel } from '../../../host/channel/index.js';
-import { BorrowedRegistry, ProjectRegistry, joinRunning, } from '../../../host/projects/index.js';
+import { BorrowedRegistry, ProjectRegistry, joinRunning, runningRegistry, } from '../../../host/projects/index.js';
 import { c, working } from '../../output/index.js';
 import { describeSessions } from './describe-sessions.js';
 import { guestPathFor } from '../context.js';
@@ -21,17 +21,22 @@ export function registryOf(ctx) {
 export function hereDir(ctx) {
     return path.resolve(ctx.options.workspace ?? process.cwd());
 }
+/**
+ * Your running sandbox's registry, rebuilt from its launch folder when the file is missing, unreadable or an earlier
+ * sandbox's (another copy or version of this tool started it). null only for a sandbox without one at all.
+ */
+function ownRegistry(ctx) {
+    return runningRegistry(ctx.storageRoot, ctx.dataPath, protectionsOf(ctx.loaded.config));
+}
 /** Where this folder is in the running sandbox, if it is in it at all (nothing is registered). */
 export function locateHere(ctx, status) {
     const dir = hereDir(ctx);
+    const own = ctx.borrowed ? null : ownRegistry(ctx);
     const here = registryOf(ctx).here(dir);
     if (here)
         return here;
     // A sandbox started before projects existed: only its launch folder.
-    if (!ctx.borrowed &&
-        !new ProjectRegistry(ctx.storageRoot).read() &&
-        status &&
-        isInsideOrEqual(status.workspaceHost, dir))
+    if (!ctx.borrowed && !own && status && isInsideOrEqual(status.workspaceHost, dir))
         return { project: null, guestDir: guestPathFor(dir, status.workspaceHost, status.guestWorkspace) };
     return { project: null, guestDir: null };
 }
@@ -57,7 +62,7 @@ export async function joinHere(ctx, status, o = {}) {
         return { project: known.project, guestDir: known.guestDir, spec: null, harness: null, notes: [] };
     }
     // A sandbox started before projects existed: only its launch folder (guestPathFor explains why otherwise).
-    if (!new ProjectRegistry(storageRoot).read())
+    if (!ownRegistry(ctx))
         return {
             project: null,
             guestDir: guestPathFor(dir, status.workspaceHost, status.guestWorkspace),