windows-development-sandbox 1.9.0 → 1.11.3

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

@@ -9,6 +9,8 @@ import { generateSandbox, GUEST, vgpuSource, vgpuWarning } from '../../../host/l
 import { findSecretFiles } from '../../../host/profile/index.js';
 import { RepoGuardStore } from '../../../host/guard/index.js';
 import { hostPublicIp, prepareVpn, readVpnLine, vpnNotes } from '../../../host/vpn/index.js';
+import { prepareGithubToken } from '../../../host/github/index.js';
+import { clearSecrets } from '../../../host/secrets/index.js';
 import { assertCanLaunch, isSandboxRunning, spawnDetached, probeHost, hideSandboxWindow, realContainedDeps, } from '../../../host/sandbox/index.js';
 import { KnownProjects, ProjectRegistry } from '../../../host/projects/index.js';
 import { LifeRecord, pageFileRisk, readHostMemory, SessionLedger, takePageFileHint } from '../../../host/life/index.js';
@@ -29,6 +31,7 @@ import { packageVersion } from '../../../core/package-info.js';
 import { reopenedText, reopenSessions } from '../sessions/reopen.js';
 import { sessionsToResume } from './resume-offer.js';
 import { startIntoRunning, launchIntoRunning, contextFor, waitForBoot, attachHere, waitForStart, openSession, readySandbox, } from './running.js';
+import { startWebOnLaunch } from '../web.js';
 import { maybeAddRoot } from './add-root.js';
 import { prepare, firstBootNotice } from './prepare.js';
 import { bootWantsFor } from './boot-wants.js';
@@ -166,6 +169,10 @@ class Launcher {
                 sandboxRunning: isSandboxRunning(),
                 base: run.workspaceHost,
             });
+        // github.shareToken: the saved token, read only for this launch's one-shot file (a note says when it is not).
+        const github = generateOnly
+            ? null
+            : prepareGithubToken(config, ctx.storageRoot, undefined, bootWants.wants.projects);
         // This PC's commit (RAM plus paging file) bounds the sandbox's memory as much as free RAM does.
         const hostMemory = generateOnly ? null : readHostMemory(ctx.storageRoot);
         const generated = generateSandbox({
@@ -178,6 +185,7 @@ class Launcher {
             autoSession: extras.autoSession,
             bootWants: bootWants.wants,
             ...(vpn ? { vpn } : {}),
+            ...(github?.token ? { githubToken: github.token } : {}),
             ...(dataMappings ? { dataMappings } : {}),
         }, engine);
         const notes = [...run.notes, ...bootWants.notes, ...generated.projects.notes, ...generated.mappingNotes];
@@ -193,15 +201,26 @@ class Launcher {
         this.warnSecretFiles(run);
         for (const line of vpnNotes(config.vpn))
             console.log(c.yellow(line));
+        for (const line of github?.notes ?? [])
+            console.log(c.yellow(line));
         table(launchSummary(run, generated, prepared));
         if (generateOnly)
             return 0;
         // A restart or sandbox resume reopens sessions itself (they pass the projects they keep).
-        const reopen = extras.extraProjects ? [] : await sessionsToResume(ctx, run);
-        this.record(run, generated);
-        this.share(generated);
-        await engine.start(generated.enginePlan);
+        let reopen;
+        try {
+            reopen = extras.extraProjects ? [] : await sessionsToResume(ctx, run);
+            this.record(run, generated);
+            this.share(generated);
+            await engine.start(generated.enginePlan);
+        }
+        catch (e) {
+            // No sandbox will read the one-shot file (logins, the GitHub token): it does not wait for the next launch.
+            clearSecrets(ctx.storageRoot, run.dataPath);
+            throw e;
+        }
         this.startWatcher();
+        await startWebOnLaunch(this.ctx);
         if (reopen.length)
             await this.reopenAfterBoot(generated.launchId, reopen);
         return this.afterStart(run, generated);

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

@@ -18,7 +18,10 @@ export function attachHere(ctx, session) {
     if (ctx.loaded.config.attach.autoHide && !insideSandbox())
         void hideSandboxWindow(ctx.storageRoot, 120).catch(() => false);
     // A copy in the agent reaches this PC's clipboard only when sandbox.clipboard already shares it with the sandbox.
-    return attachTerminal(session, { clipboardWrites: ctx.loaded.config.sandbox.clipboard });
+    return attachTerminal(session, {
+        clipboardWrites: ctx.loaded.config.sandbox.clipboard,
+        confirmCtrlC: ctx.loaded.config.attach.confirmCtrlC,
+    });
 }
 /** The sandbox writes sandbox.json a few seconds into its boot; a second launch right after the first waits for it. */
 export async function runningSandboxStatus(dataPath) {

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

@@ -11,7 +11,6 @@ import { dirExists, fail, safeText, writeJson } from '../../../core/util/index.j
 import { system32 } from '../../../shared/system.js';
 import { refuseInSelfTest } from '../../../host/test-guard.js';
 import { c, nextStep, table } from '../../output/index.js';
-import { exportCommand, importCommand } from './config-share.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.', [
@@ -134,7 +133,7 @@ function previewFolders(ctx, dir, filePath, overrides) {
 }
 export function config(ctx) {
     // get, set, reset and list are the settings feature's operations (cli/operations runs them before this).
-    const [action = 'summary', key] = ctx.options.positionals;
+    const [action = 'summary'] = ctx.options.positionals;
     switch (action) {
         case 'summary':
             table([
@@ -159,10 +158,6 @@ export function config(ctx) {
         case 'show':
             console.log(JSON.stringify(redactSecrets(ctx.loaded.config), null, 2));
             return 0;
-        case 'export':
-            return exportCommand(ctx, key);
-        case 'import':
-            return importCommand(ctx, key);
         case 'schema':
             return printSchemaSettings();
         case 'check':

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

@@ -1,6 +1,5 @@
 export * from './sync.js';
 export * from './logs.js';
-export * from './clean.js';
 export * from './config.js';
 export * from './doctor.js';
 export * from './host-claude.js';

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

@@ -1,7 +1,6 @@
-// sync, logs, clean, config, doctor, host-claude and the internal sync watcher.
+// sync, logs, config, doctor, host-claude and the internal sync watcher.
 export * from './sync.js';
 export * from './logs.js';
-export * from './clean.js';
 export * from './config.js';
 export * from './doctor.js';
 export * from './host-claude.js';

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

@@ -1,38 +1,33 @@
-import { sleep } from '../../../core/util/index.js';
-import { newestCrashReport } from '../../../host/life/index.js';
-import { LogsService } from '../../services/index.js';
-/** The newest crash report (written by the background sync when the sandbox or this PC went down). */
-function printCrashReport(ctx) {
-    const report = newestCrashReport(ctx.storageRoot);
-    if (!report) {
+// `sandbox logs`: the end of the newest log, the last crash report (--crash), and with --follow the new text until
+// Ctrl+C. It reads through the logs feature's queries (readQuery) and only prints and loops: --follow cannot be a
+// one-shot operation (see logs.def.ts).
+import { CRASH, listLogs, tailLog } from '../../../app/features/logs/index.js';
+import { readQuery } from '../../../app/registry.js';
+import { fail, sleep } from '../../../core/util/index.js';
+export async function logs(ctx) {
+    const crash = Boolean(ctx.options.crash);
+    if (crash && !(await readQuery(listLogs, ctx)).crash) {
         console.log('No crash report yet: no sandbox has ended in a crash since this was installed.');
         return 0;
     }
-    console.log('== ' + report.file + ' ==');
-    console.log(report.text);
-    return 0;
-}
-export async function logs(ctx) {
-    if (ctx.options.crash)
-        return printCrashReport(ctx);
-    const service = new LogsService(ctx);
-    const file = service.newest();
-    console.log('== ' + file + ' ==');
-    let printed = 0;
-    // The log is written inside the sandbox: read only its tail, and make it safe for your terminal.
-    const print = () => {
-        const chunk = service.read(file, printed);
-        if (!chunk)
-            return;
-        process.stdout.write(printed === 0 ? chunk.text.split('\n').slice(-120).join('\n') : chunk.text);
-        printed = chunk.next;
-    };
-    print();
-    if (ctx.options.follow)
-        console.error('(following; Ctrl+C to stop)');
-    while (ctx.options.follow) {
+    let tail = await readQuery(tailLog, ctx, { name: crash ? CRASH : undefined });
+    if (!tail.file) {
+        const listed = await readQuery(listLogs, ctx);
+        fail('No sandbox logs yet in ' + listed.folder + '.', 'Logs appear after the first start (sandbox claude).');
+    }
+    console.log('== ' + tail.file + ' ==');
+    if (crash) {
+        console.log(tail.text);
+        return 0;
+    }
+    process.stdout.write(tail.text);
+    if (!ctx.options.follow)
+        return 0;
+    console.error('(following; Ctrl+C to stop)');
+    for (;;) {
         await sleep(1000);
-        print();
+        const more = await readQuery(tailLog, ctx, { name: tail.name, from: tail.next });
+        process.stdout.write(more.text);
+        tail = { ...tail, next: more.next };
     }
-    return 0;
 }

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

@@ -1,12 +1,4 @@
-import { MigrateService } from '../../services/index.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>;
 /**
  * Before a command: brings the settings up to date when the version changed (one small file is read otherwise).
  * A failure stops the command (throws), except for doctor, which prints it and goes on.

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

@@ -1,51 +1,9 @@
-import { userDir } from '../../../core/config/index.js';
-import { autoMigrates, continuesAfterFailedMigration, MigrateService, } from '../../services/index.js';
-import { askRequired } from '../../../core/prompt.js';
+import { autoMigrates, continuesAfterFailedMigration, MigrateService } from '../../services/index.js';
 import { c } from '../../output/index.js';
 import { errMsg, UserError } from '../../../core/util/index.js';
 import { insideSandbox } from '../../../host/sandbox/index.js';
-import { holdsData, oldDefaultRoot } from '../../../host/storage/index.js';
+import { whereOf } from '../../../app/features/updates/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) {
-    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;
-    }
-    if (options.dryRun) {
-        const plan = service.plan();
-        print(plan.length ? 'Would update:' : 'Nothing to update.');
-        for (const line of plan)
-            print('  ' + line);
-        return 0;
-    }
-    const result = await service.run((line) => print(c.dim(line)));
-    if (result.applied.length)
-        print('Updated: ' + result.applied.join(', ') + '.');
-    else if (!result.postponed.length)
-        print('Nothing to update.');
-    if (result.postponed.length)
-        print('Waiting for no sandbox to run: ' + result.postponed.join(', ') + '.');
-    return 0;
-}
-export function migrate(ctx) {
-    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).
  * A failure stops the command (throws), except for doctor, which prints it and goes on.

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

@@ -1,22 +1,3 @@
-import type { UpdateResult } from '../../../host/update/index.js';
-import type { CliOptions } from '../../args.js';
-import { UpdateService } from '../../services/index.js';
-export interface UpdateRequest {
-    readonly check: boolean;
-    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): {
-    line: string;
-    code: number;
-};
-/** `sandbox update`: the work, with the service and the output given so a test can drive it. */
-export declare function runUpdate(service: UpdateService, request: UpdateRequest, print: (line: string) => void): Promise<number>;
-export declare function update(options: CliOptions): Promise<number>;
 /**
  * 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/maintenance/update.js

@@ -1,107 +1,9 @@
 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';
 import { c } from '../../output/index.js';
-import { NPM_UPDATE_COMMAND, UpdateService } from '../../services/index.js';
-/** One sentence for what an update run did, and whether it counts as done. */
-export function describeResult(result, unattended) {
-    if (!result)
-        return { line: 'Another update is running right now.', code: 0 };
-    if (result.kind === 'installed')
-        return {
-            line: 'Updated ' +
-                (result.previous ? 'from ' + result.previous + ' ' : '') +
-                'to ' +
-                result.version +
-                '. Open a new terminal to use it.',
-            code: 0,
-        };
-    if (result.kind === 'failed')
-        return {
-            line: 'Update to ' +
-                result.version +
-                ' failed: ' +
-                result.reason.replace(/\.?\s*$/, '.') +
-                (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) {
-        case 'up-to-date':
-            return { line: 'You have the newest version (' + result.current + ').', code: 0 };
-        case 'sandbox-running':
-            return {
-                line: 'A Windows Sandbox is running, so nothing was installed. Close it (sandbox stop), then update again.',
-                code: unattended ? 0 : 1,
-            };
-        case 'failed-before':
-            return {
-                line: 'The newest version failed to install before. It is not tried again until a newer one is released.',
-                code: 0,
-            };
-        case 'no-release':
-            return { line: 'No release was found.', code: 0 };
-        case 'too-soon':
-            return { line: 'Looked a short while ago; nothing to do yet.', code: 0 };
-    }
-}
-/** `sandbox update`: the work, with the service and the output given so a test can drive it. */
-export async function runUpdate(service, request, print) {
-    if (!service.managed) {
-        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;
-    }
-    if (request.check) {
-        const found = await service.check();
-        if (found.available && found.latest)
-            print('Version ' + found.latest.version + ' is available (you have ' + found.current + '). Run: sandbox update');
-        else if (found.blocked)
-            print('A newer version exists but failed to install before; you have ' + found.current + '.');
-        else
-            print('You have the newest version (' + found.current + ').');
-        return 0;
-    }
-    const done = describeResult(await service.run(), request.unattended);
-    print(done.line);
-    return done.code;
-}
-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,
-        yes: options.yes,
-    }, (line) => console.log(line));
-}
+import { UpdateService } from '../../services/index.js';
 /** 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', '_web'];
 /**

package/dist/cli/commands/projects/index.d.ts

@@ -1,4 +1,3 @@
 export * from './here.js';
-export * from './projects.js';
 export * from './restart.js';
 export * from './describe-sessions.js';

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

@@ -1,4 +1,3 @@
 export * from './here.js';
-export * from './projects.js';
 export * from './restart.js';
 export * from './describe-sessions.js';

package/dist/cli/commands/registry.d.ts

@@ -1,3 +1,3 @@
-import type { Context } from './context.js';
+import { type Context } from './context.js';
 export type Handler = (ctx: Context) => number | Promise<number | void>;
 export declare const HANDLERS: Readonly<Partial<Record<string, Handler>>>;

package/dist/cli/commands/registry.js

@@ -1,15 +1,19 @@
+import { requireOnPc } from './context.js';
 import { launch } from './launch/index.js';
 import { setup } from './setup/index.js';
-import { data } from './data/index.js';
-import { storage } from './storage/index.js';
+import { cleanData, showData } from '../../app/features/data/index.js';
 import { attach, db, exec } from './sessions/index.js';
-import { account } from './accounts.js';
-import { projects } from './projects/index.js';
-import { audit, claudeHost, clean, config, doctor, hostCommand, logs, migrate, sync, watcher, } from './maintenance/index.js';
+import { listAccounts } from '../../app/features/accounts/index.js';
+import { containedStatus, showStorage } from '../../app/features/storage/index.js';
+import { listProjects } from '../../app/features/projects/index.js';
+import { definitionHandler } from '../operations/index.js';
+import { fail } from '../../core/util/index.js';
+import { audit, claudeHost, config, doctor, hostCommand, logs, sync, watcher } from './maintenance/index.js';
 import { engine } from './engine.js';
 import { resume } from './resume.js';
 import { agentCommandsCommand } from './agent-commands.js';
 import { vpn } from './vpn.js';
+import { github } from './github.js';
 import { web, webServer } from './web.js';
 export const HANDLERS = {
     launch: (ctx) => launch(ctx),
@@ -19,23 +23,37 @@ export const HANDLERS = {
     'agent-commands': agentCommandsCommand,
     db: db,
     resume: resume,
-    account: account,
-    projects: projects,
+    // The bare command lists; its actions (save, use ...) are the operations' hints.
+    account: definitionHandler(listAccounts),
+    // The bare command lists; its actions (add, remove, roots ...) are the operations' hints.
+    projects: definitionHandler(listProjects),
     sync: sync,
     logs: logs,
     audit: audit,
-    clean: clean,
     config: config,
     doctor: doctor,
-    migrate: migrate,
     setup: setup,
-    data: data,
-    storage: storage,
+    // `data`, `data info` and `data list` show; `data remove` is `data clean` (its actions are the operations' hints).
+    data: (ctx) => ctx.options.positionals[0] === 'remove' ? definitionHandler(cleanData)(ctx) : definitionHandler(showData)(ctx),
+    // The bare command and `info` show; `contained` alone shows the beta status (the other actions are the operations'
+    // hints in src/app/features/storage).
+    storage: (ctx) => {
+        requireOnPc('storage');
+        const [action = 'show', mode] = ctx.options.positionals;
+        if (action === 'show' || action === 'info')
+            return definitionHandler(showStorage)(ctx);
+        if (action === 'contained' && mode === undefined)
+            return definitionHandler(containedStatus)(ctx);
+        if (action === 'contained')
+            return fail('Unknown action "' + mode + '" for contained storage.', 'Use: sandbox storage contained on, off or status');
+        return fail('Unknown storage action "' + action + '".', 'Use: sandbox storage, sandbox storage move <folder>, sandbox storage use <folder> or sandbox storage contained on|off|status');
+    },
     engine: engine,
     'host-claude': claudeHost,
     host: hostCommand,
     _watch: watcher,
     vpn: vpn,
+    github: github,
     web: web,
     _web: webServer,
 };

package/dist/cli/commands/repair/checks/data.js

@@ -8,7 +8,7 @@ import { dirExists, isLink, removeLink } from '../../../../core/util/index.js';
 import { writeProblem } from '../../../../host/health/index.js';
 import { assertTestWritable } from '../../../../host/test-guard.js';
 import { OLD_DEFAULT_ROOT, StorageHistory, holdsData, oldDefaultRoot, otherDataFolders, sharedDefaultRoot, } from '../../../../host/storage/index.js';
-import { removeTree } from '../../data/remove.js';
+import { removeTree } from '../../../services/data-remove.js';
 import { findHalfInstalled, findLinks, findStagingLeftovers, resolvedVersionsValid } from '../finders.js';
 import { guard, ok, plural, rel } from './common.js';
 const same = (a, b) => path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();

package/dist/cli/commands/repair/checks/hcs.js

@@ -1,6 +1,6 @@
 // The HCS engine (alpha), only when sandbox.engine is "hcs": can this PC run it. Looks only; the fixes are commands for
 // you to run (they change Windows), never run by repair.
-import { checkHcs, realHcsProbes } from '../../../../host/engines/index.js';
+import { checkHcs, lookForLeftovers, realHcsProbes } from '../../../../host/engines/index.js';
 import { ok } from './common.js';
 const hcsInUse = (env) => env.ctx.loaded.config.sandbox.engine === 'hcs';
 /** Replaceable by tests: the probes the row looks through. */
@@ -25,4 +25,31 @@ export const HCS_CHECKS = [
             };
         },
     },
+    {
+        id: 'hcs-leftovers',
+        group: 'Sandbox',
+        name: 'HCS systems left running',
+        checking: 'HCS systems left running',
+        // Shown for the HCS engine, and on any PC where one of ours is found (never builds HcsHost.exe to look).
+        applies: (env) => hcsInUse(env) || lookQuietly(env).length > 0,
+        timeoutMs: 60000,
+        run: (env) => {
+            const look = lookForLeftovers(env.ctx.loaded.config.storage.root);
+            if (!look.available)
+                return { status: 'skipped', detail: look.reason, means: 'No HCS system can be left running here.' };
+            if (!look.systems.length)
+                return ok('none of ours is running');
+            return {
+                status: 'warn',
+                detail: look.systems.length + ' running: ' + look.systems.map((s) => s.id).join(', '),
+                means: 'They hold memory until stopped (a crashed command can leave one up). If a sandbox is running on purpose, leave them.',
+                fix: 'sandbox engine clean',
+            };
+        },
+    },
 ];
+/** The ids of ours that are running ([] when HCS is not there or has never been used). */
+function lookQuietly(env) {
+    const look = lookForLeftovers(env.ctx.loaded.config.storage.root);
+    return look.available ? look.systems.map((s) => s.id) : [];
+}

package/dist/cli/commands/repair/checks/sandbox.js

@@ -13,7 +13,7 @@ import { assertTestWritable, refuseInSelfTest } from '../../../../host/test-guar
 import { conptyDir, terminalDir, terminalExe } from '../../../../host/tools/index.js';
 import { RunDir } from '../../../../shared/channel/index.js';
 import { safeRemove } from '../../../../shared/io/index.js';
-import { removeTree } from '../../data/remove.js';
+import { removeTree } from '../../../services/data-remove.js';
 import { deadPidFiles } from '../finders.js';
 import { fromFacts } from './pc.js';
 import { ok, plural, rel } from './common.js';

package/dist/cli/commands/repair/health-run.d.ts

@@ -0,0 +1,30 @@
+import { type RunHooks } from './engine.js';
+import type { Check, CheckResult, RepairEnv, Summary } from './types.js';
+/** Where the results of a run go while it runs: the CLI's HealthPrinter, or the shared core's io (ioEvents). */
+export interface HealthEvents {
+    hooks(): RunHooks;
+    plan(fixable: readonly CheckResult[]): void;
+    line(text: string): void;
+}
+/** What happens to the fixes: applied without asking, asked (when allowed), or not at all. */
+export interface HealthPlan {
+    /** Fix without asking. */
+    readonly yes: boolean;
+    /** May ask (a terminal, and not --json). */
+    readonly ask: boolean;
+    /** The question asked after the list of what will change. */
+    readonly question: (n: number) => string;
+}
+/** What both commands find, and what they do about it. */
+export interface HealthReport {
+    readonly found: CheckResult[];
+    readonly final: CheckResult[];
+    readonly summary: Summary;
+    /** Fixes were applied. */
+    readonly changed: boolean;
+}
+/**
+ * Runs the checks, then (when allowed) the fixes. `events` is null for --json. Without a `confirmFix` a question is
+ * answered no, so nothing is fixed unless the plan says yes.
+ */
+export declare function runHealth(env: RepairEnv, events: HealthEvents | null, plan: HealthPlan, checks?: readonly Check[], confirmFix?: (question: string) => Promise<boolean>): Promise<HealthReport>;

package/dist/cli/commands/repair/health-run.js

@@ -0,0 +1,32 @@
+// The look -> ask -> fix decision of doctor and repair, with no surface in it: results go to `events` (the CLI's
+// HealthPrinter, or the shared core's io), and the question is asked through `confirmFix`. Used by run.ts (the CLI) and
+// by the health feature (the menu and the web).
+import { ALL_CHECKS } from './checks/index.js';
+import { HealthRun, summarize } from './engine.js';
+/**
+ * Runs the checks, then (when allowed) the fixes. `events` is null for --json. Without a `confirmFix` a question is
+ * answered no, so nothing is fixed unless the plan says yes.
+ */
+export async function runHealth(env, events, plan, checks = ALL_CHECKS, confirmFix = () => Promise.resolve(false)) {
+    const run = new HealthRun(checks, env, events?.hooks());
+    const found = await run.look();
+    const fixable = found.filter((r) => r.fixable);
+    let final = found;
+    let changed = false;
+    if (fixable.length) {
+        let go = plan.yes;
+        if (!go && plan.ask) {
+            events?.plan(fixable);
+            go = await confirmFix(plan.question(fixable.length));
+        }
+        if (go) {
+            if (plan.yes)
+                events?.plan(fixable);
+            final = await run.fix(found);
+            changed = true;
+        }
+        else
+            events?.line('\nNothing was changed.');
+    }
+    return { found, final, summary: summarize(final), changed };
+}

package/dist/cli/commands/repair/printer.d.ts

@@ -1,11 +1,11 @@
+import { summaryText } from '../../../app/features/health/index.js';
 import type { CheckResult, Summary } from './types.js';
 import type { RunHooks } from './engine.js';
+export { summaryText };
 /** Where text goes (the terminal; a test collects it). */
 export interface Out {
     write(text: string): void;
 }
-/** "12 ok, 2 fixed, 1 needs you": the parts that are zero are left out (except ok). */
-export declare function summaryText(s: Summary): string;
 export declare class HealthPrinter {
     private readonly out;
     /** Redraw lines in place (a terminal); otherwise each result is one finished line. */