windows-development-sandbox 1.10.0 → 1.11.4

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

@@ -1,26 +1,6 @@
 import { UserError } from '../../../core/util/index.js';
 import type { CliOptions } from '../../args.js';
 import { type Context } from '../context.js';
-import { HealthPrinter } from './printer.js';
-import type { Check, CheckResult, RepairEnv, Summary } from './types.js';
-/** 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;
-}
-interface Plan {
-    /** 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;
-}
-/** Runs the checks, then (when allowed) the fixes. `printer` is null for --json. */
-export declare function runHealth(env: RepairEnv, printer: HealthPrinter | null, plan: Plan, checks?: readonly Check[], confirmFix?: (question: string) => Promise<boolean>): Promise<HealthReport>;
 /** `sandbox doctor` */
 export declare function runDoctor(ctx: Context): Promise<number>;
 /** `sandbox repair` for a loaded context. */
@@ -30,4 +10,4 @@ export declare function runRepair(ctx: Context, configError?: UserError | null):
  * defaults so the other checks still run, and reports the settings problem as a check of its own.
  */
 export declare function repairCommand(packageRoot: string, entry: string, options: CliOptions): Promise<number>;
-export {};
+export { runHealth } from './health-run.js';

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

@@ -1,66 +1,31 @@
-// `sandbox doctor` and `sandbox repair`: both run the same checks through the same engine, a line each as it ends.
-// doctor only looks (and offers to fix, or fixes with --fix); repair looks, lists what it would change, asks once, then
-// fixes and writes a log. --json prints the results instead and never asks.
-import path from 'node:path';
+// `sandbox doctor` and `sandbox repair`: the command line's renderers of the health feature's run (healthWith): lines
+// as each check ends, the summary, the details, the log path. doctor only looks (and offers to fix, or fixes with
+// --fix); repair looks, lists what it would change, asks once, then fixes and writes a log. --json prints the results
+// instead and never asks.
 import { confirm } from '@inquirer/prompts';
-import { DEFAULTS, userDir } from '../../../core/config/index.js';
-import { packageVersion } from '../../../core/package-info.js';
-import { expandPath, UserError } from '../../../core/util/index.js';
+import { UserError } from '../../../core/util/index.js';
 import { insideSandbox } from '../../../host/sandbox/index.js';
 import { printJson, table } from '../../output/index.js';
 import { HealthService } from '../../services/index.js';
-import { createContext, requireOnPc } from '../context.js';
-import { ALL_CHECKS } from './checks/index.js';
-import { buildEnv } from './env.js';
-import { HealthRun, summarize } from './engine.js';
-import { logText, writeRepairLog } from './log.js';
+import { createContext, defaultsContext, requireOnPc } from '../context.js';
+import { healthWith } from '../../../app/features/health/index.js';
 import { HealthPrinter } from './printer.js';
 const interactive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
 const stdout = { write: (text) => void process.stdout.write(text) };
-/** Runs the checks, then (when allowed) the fixes. `printer` is null for --json. */
-export async function runHealth(env, printer, plan, checks = ALL_CHECKS, confirmFix = (q) => confirm({ message: q, default: true })) {
-    const run = new HealthRun(checks, env, printer?.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) {
-            printer?.plan(fixable);
-            go = await confirmFix(plan.question(fixable.length));
-        }
-        if (go) {
-            if (plan.yes)
-                printer?.plan(fixable);
-            final = await run.fix(found);
-            changed = true;
-        }
-        else
-            printer?.line('\nNothing was changed.');
-    }
-    return { found, final, summary: summarize(final), changed };
-}
+const askFix = (question) => confirm({ message: question, default: true });
 function quote(n, what) {
     return n + ' ' + what + (n === 1 ? '' : 's');
 }
 /** `sandbox doctor` */
 export async function runDoctor(ctx) {
-    const health = new HealthService(ctx);
     if (insideSandbox()) {
-        table(health.doctor());
+        table(new HealthService(ctx).doctor());
         return 0;
     }
     const json = ctx.options.json;
     const printer = json ? null : new HealthPrinter(stdout);
     printer?.title('Checking this PC, the install, your settings and the sandbox...');
-    const env = buildEnv(ctx);
-    const report = await runHealth(env, printer, {
-        yes: ctx.options.fix,
-        ask: !json && interactive(),
-        question: (n) => quote(n, 'problem') + ' can be fixed. Fix ' + (n === 1 ? 'it' : 'them') + ' now?',
-    });
-    const details = health.doctor();
+    const { report, details } = await healthWith(ctx, { mode: 'doctor', yes: ctx.options.fix, harness: ctx.options.harness }, { events: printer, mayAsk: !json && interactive(), confirmFix: askFix });
     if (printJson(ctx, { checks: report.final, summary: report.summary, details }))
         return 0;
     printer?.summary(report.final, report.summary);
@@ -77,23 +42,9 @@ export async function runRepair(ctx, configError = null) {
     const json = ctx.options.json;
     const printer = json ? null : new HealthPrinter(stdout);
     printer?.title('Checking this PC, the install, your settings and the sandbox...');
-    const env = buildEnv(ctx, configError);
     const yes = ctx.options.yes;
     const ask = !json && interactive();
-    const report = await runHealth(env, printer, {
-        yes,
-        ask,
-        question: (n) => 'Fix ' + (n === 1 ? 'this problem' : 'these ' + n + ' problems') + '?',
-    });
-    const when = new Date();
-    const log = writeRepairLog(ctx.storageRoot, logText({
-        when,
-        version: packageVersion(),
-        command: 'sandbox repair' + (yes ? ' --yes' : ''),
-        found: report.found,
-        final: report.final,
-        summary: report.summary,
-    }), when);
+    const { report, log } = await healthWith(ctx, { mode: 'repair', yes, configError }, { events: printer, mayAsk: ask, confirmFix: askFix });
     const stillFixable = report.final.filter((r) => r.fixable).length;
     if (printJson(ctx, { checks: report.final, summary: report.summary, changed: report.changed, log })) {
         return report.summary.needsYou ? 1 : 0;
@@ -118,16 +69,8 @@ export function repairCommand(packageRoot, entry, options) {
     catch (e) {
         if (!(e instanceof UserError))
             throw e;
-        const loaded = { config: structuredClone(DEFAULTS), configPath: null, base: userDir() };
-        const storageRoot = expandPath(loaded.config.storage.root, loaded.base);
-        return runRepair({
-            packageRoot,
-            entry,
-            options,
-            loaded,
-            storageRoot,
-            dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName),
-        }, e);
+        return runRepair(defaultsContext(packageRoot, entry, options), e);
     }
     return runRepair(ctx);
 }
+export { runHealth } from './health-run.js';

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

@@ -1,2 +1 @@
-export { storage, storageBusy, performMove } from './storage.js';
 export { storageBeforeCommand } from './offer.js';

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

@@ -1,2 +1 @@
-export { storage, storageBusy, performMove } from './storage.js';
 export { storageBeforeCommand } from './offer.js';

package/dist/cli/commands/storage/offer.js

@@ -6,9 +6,10 @@ import { errMsg } from '../../../core/util/index.js';
 import { isSandboxRunning, insideSandbox } from '../../../host/sandbox/index.js';
 import { protectPrivateFolder } from '../../../host/sharing/index.js';
 import { describeDuration, describeSize, ensureStorageRoot, estimate, measureFolder, moveWarning, planOffer, staleMountNote, StorageHistory, } from '../../../host/storage/index.js';
+import { humanBytes } from '../../../core/disk.js';
+import { StorageService } from '../../services/index.js';
 import { c, working } from '../../output/index.js';
 import { refreshStorage } from '../context.js';
-import { performMove } from './storage.js';
 /** Commands that do not touch the storage folder, or must work whatever state it is in. */
 const NO_STORAGE = ['self-test', '_watch', '_web', 'update', 'storage', 'migrate', 'repair'];
 /** Commands that start something the user is sitting in front of: the offer is shown before them. */
@@ -59,7 +60,10 @@ async function offerMove(ctx, history) {
         history.setNotNow();
     if (answer !== 'now')
         return;
-    const result = await performMove({ ...ctx, storageRoot: offer.from }, offer.to, false);
+    let line = 'Moving your data';
+    const result = await working(() => line, () => new StorageService({ ...ctx, storageRoot: offer.from }).move(offer.to, false, (p) => {
+        line = 'Copying: ' + p.files.toLocaleString('en-US') + ' files, ' + humanBytes(p.bytes);
+    }));
     console.error('Moved. Your data is now in ' + result.to + '.');
     for (const note of result.notes)
         console.error(c.dim(note));

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

@@ -1,4 +1,2 @@
 import { type Context } from './context.js';
-/** The warnings every VPN user must see. */
-export declare const VPN_WARNINGS: readonly string[];
-export declare function vpn(ctx: Context): Promise<number> | number;
+export declare function vpn(ctx: Context): number | Promise<number | void>;

package/dist/cli/commands/vpn.js

@@ -1,92 +1,11 @@
-// `sandbox vpn [status|login|logout]`: the VPN login (kept encrypted on this PC, never printed) and what the VPN is
-// doing.
-import { askSecret } from '../../core/prompt.js';
+// `sandbox vpn [status|login|logout]`: the actions are the VPN feature's operations (src/app/features/vpn); with no
+// action the command shows the status page.
 import { fail } from '../../core/util/index.js';
-import { c, nextStep, printJson, table } from '../output/index.js';
-import { NORD_STEPS, VpnService } from '../services/vpn-service.js';
-import { requireOnPc } from './context.js';
-const LOGIN_TEXT = {
-    none: c.yellow('not saved'),
-    saved: c.green('saved (encrypted)'),
-    unreadable: c.red('cannot be read'),
-};
-/** The warnings every VPN user must see. */
-export const VPN_WARNINGS = [
-    'The VPN is an alpha: not yet tried on a real PC (docs/vpn.md lists what still needs checking).',
-    'The agent in the sandbox can read the VPN login (a service login you can revoke) and can turn the tunnel off, because it is the administrator there.',
-    'Free VPNs see all your traffic: use one you trust.',
-];
-async function status(ctx) {
-    const report = await new VpnService(ctx).report();
-    if (printJson(ctx, report))
-        return 0;
-    table([
-        ['VPN', report.enabled ? c.green('on') : 'off  (turn on: sandbox config set vpn.enabled true)'],
-        [
-            'Provider',
-            report.provider === 'nordvpn'
-                ? 'NordVPN'
-                : report.provider === 'wireguard-file'
-                    ? 'your own WireGuard .conf'
-                    : 'your own .ovpn file',
-        ],
-        ['Protocol', report.protocol],
-        ['Country', report.country || 'best available'],
-        ['Kill switch', report.killSwitch ? 'on (no internet if the tunnel fails)' : c.yellow('off')],
-        [
-            'Login',
-            report.provider === 'wireguard-file'
-                ? c.dim('not needed (the keys are in your config)')
-                : LOGIN_TEXT[report.login] + (report.loginSavedAt ? c.dim('  ' + report.loginSavedAt.slice(0, 10)) : ''),
-        ],
-        ...(report.running ? [['Running now', report.running.text]] : []),
-    ]);
-    if (report.provider !== 'wireguard-file' && report.login === 'none')
-        nextStep('sandbox vpn login');
-    if (report.login === 'unreadable')
-        console.log(c.dim('Only the Windows user that saved it can read it. Save it again: sandbox vpn login'));
-    for (const w of VPN_WARNINGS)
-        console.log(c.dim(w));
-    return 0;
-}
-async function login(ctx) {
-    requireOnPc('vpn login');
-    const service = new VpnService(ctx);
-    if (service.provider === 'wireguard-file') {
-        console.log('A WireGuard config needs no login: the keys are in the file vpn.configFile points to.');
-        return 0;
-    }
-    const nord = service.provider === 'nordvpn';
-    console.log(nord
-        ? 'NordVPN needs its service credentials, not your usual login. To get them:'
-        : 'Type the user name and password your VPN profile asks for.');
-    if (nord)
-        NORD_STEPS.forEach((s, i) => console.log('  ' + (i + 1) + '. ' + s));
-    console.log(c.dim('What you type is not shown. It is kept encrypted for your Windows user and never printed.\n'));
-    const fix = 'Run sandbox vpn login in a terminal.';
-    const username = await askSecret(nord ? 'Service user name' : 'User name', fix);
-    const password = await askSecret(nord ? 'Service password' : 'Password', fix);
-    service.save({ username, password });
-    console.log(c.green('Saved.') + ' Turn the VPN on with: sandbox config set vpn.enabled true');
-    for (const w of VPN_WARNINGS)
-        console.log(c.dim(w));
-    return 0;
-}
-function logout(ctx) {
-    requireOnPc('vpn logout');
-    console.log(new VpnService(ctx).remove() ? 'The saved VPN login is deleted.' : 'No VPN login was saved.');
-    return 0;
-}
+import { vpnStatus } from '../../app/features/vpn/index.js';
+import { definitionHandler } from '../operations/index.js';
 export function vpn(ctx) {
-    const action = ctx.options.positionals[0] ?? 'status';
-    switch (action) {
-        case 'status':
-            return status(ctx);
-        case 'login':
-            return login(ctx);
-        case 'logout':
-            return logout(ctx);
-        default:
-            return fail('Unknown VPN action "' + action + '".', 'Use: sandbox vpn status | login | logout');
-    }
+    const action = ctx.options.positionals[0];
+    if (action === undefined)
+        return definitionHandler(vpnStatus)(ctx);
+    return fail('Unknown VPN action "' + action + '".', 'Use: sandbox vpn status | login | logout');
 }

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

@@ -1,9 +1,10 @@
-import { type Context } from './context.js';
+import type { Context } from './context.js';
 /**
  * At a sandbox start, with web.enabled: the web UI is started in the background when it is not running, and with
  * web.openOnLaunch opened in the browser, signed in. Never stops the launch: a problem is one line.
  */
 export declare function startWebOnLaunch(ctx: Context): Promise<void>;
+/** `sandbox web` with no action is `sandbox web status` (the actions run as definitions). */
 export declare function web(ctx: Context): Promise<number>;
 /** Body of the background process (`sandbox _web`): runs until stopped. */
 export declare function webServer(ctx: Context): Promise<void>;

package/dist/cli/commands/web.js

@@ -1,42 +1,19 @@
-// `sandbox web start | stop | status | open`: the web UI's server runs in the background (as `_web`, like the sync
-// watcher) and keeps running when no sandbox does. The work is in host/web.
+// `sandbox web` (the actions run as definitions in src/app/features/web) and the hidden `sandbox _web`, which is the
+// server process itself. The web UI's server runs in the background (as `_web`, like the sync watcher) and keeps
+// running when no sandbox does. startWebOnLaunch is the sandbox start's hook.
 import fs from 'node:fs';
 import path from 'node:path';
-import { fail, sleep } from '../../core/util/index.js';
-import { spawnDetached } from '../../host/sandbox/index.js';
-import { openBrowser, WebControl, WebRunner, WebStore } from '../../host/web/index.js';
-import { printJson } from '../output/index.js';
+import { currentServer, START_WAIT_MS, webStatus } from '../../app/features/web/index.js';
 import { createRpcHost } from '../../app/registry.js';
+import { packageVersion } from '../../core/package-info.js';
+import { sleep, fail } from '../../core/util/index.js';
+import { IDLE_EXIT_MS, openBrowser, WebControl, WebRunner, WebStore } from '../../host/web/index.js';
+import { spawnDetached } from '../../host/sandbox/index.js';
 import { WebService } from '../services/index.js';
-import { requireOnPc } from './context.js';
-const START_WAIT_MS = 15000;
+import { definitionHandler } from '../operations/index.js';
 function controlOf(ctx) {
     return new WebControl(new WebStore(ctx.storageRoot));
 }
-/** Starts the background server (when it is not running) and waits until it answers. */
-async function startServer(ctx, control) {
-    const before = await control.status();
-    if (before.running && before.state) {
-        console.log('The web UI is already running on port ' + before.state.port + '.');
-        return before.state.port;
-    }
-    if (before.state)
-        control.clear();
-    const { config } = ctx.loaded;
-    if (!config.web.enabled)
-        console.log('web.enabled is off: this starts the web UI for now only. Set it to true in Settings to keep it allowed.');
-    const configFile = ctx.options.config;
-    spawnDetached(ctx.entry, ['_web', ...(configFile ? ['--config', path.resolve(configFile)] : [])]);
-    for (const started = Date.now(); Date.now() - started < START_WAIT_MS; await sleep(300)) {
-        const now = await control.status();
-        if (now.running && now.state) {
-            console.log('The web UI is running at http://127.0.0.1:' + now.state.port + '/ (this PC only).');
-            console.log('Open it already signed in with: sandbox web open');
-            return now.state.port;
-        }
-    }
-    return fail('The web UI did not start.', 'Run sandbox _web to see why (the port ' + config.web.port + ' may be taken: change web.port).');
-}
 /**
  * At a sandbox start, with web.enabled: the web UI is started in the background when it is not running, and with
  * web.openOnLaunch opened in the browser, signed in. Never stops the launch: a problem is one line.
@@ -47,11 +24,8 @@ export async function startWebOnLaunch(ctx) {
         return;
     try {
         const control = controlOf(ctx);
-        const before = await control.status();
-        let state = before.running ? before.state : null;
+        let state = await currentServer(control);
         if (!state) {
-            if (before.state)
-                control.clear();
             const configFile = ctx.options.config;
             spawnDetached(ctx.entry, ['_web', ...(configFile ? ['--config', path.resolve(configFile)] : [])]);
             for (const started = Date.now(); !state && Date.now() - started < START_WAIT_MS; await sleep(300)) {
@@ -75,49 +49,9 @@ export async function startWebOnLaunch(ctx) {
         console.log('The web UI could not be started: ' + (e instanceof Error ? e.message : String(e)));
     }
 }
+/** `sandbox web` with no action is `sandbox web status` (the actions run as definitions). */
 export async function web(ctx) {
-    requireOnPc('web');
-    const action = ctx.options.positionals[0] ?? 'status';
-    const control = controlOf(ctx);
-    switch (action) {
-        case 'start':
-            await startServer(ctx, control);
-            return 0;
-        case 'open': {
-            await startServer(ctx, control);
-            const { state } = await control.status();
-            if (!state)
-                return fail('The web UI stopped right away.', 'Run sandbox web start again.');
-            openBrowser(control.url(state));
-            console.log('Opened in your browser.');
-            return 0;
-        }
-        case 'stop': {
-            const { running, state } = await control.status();
-            if (!state) {
-                console.log('The web UI is not running.');
-                return 0;
-            }
-            if (!running || (await control.stop(state)))
-                control.clear();
-            else
-                return fail('The web UI did not stop.', 'End the process ' + state.pid + ' in Task Manager.');
-            console.log('The web UI stopped.');
-            return 0;
-        }
-        case 'status': {
-            const { running, state } = await control.status();
-            const port = running && state ? state.port : null;
-            if (printJson(ctx, { running, port, address: port ? 'http://127.0.0.1:' + port + '/' : null }))
-                return 0;
-            console.log(running && port
-                ? 'The web UI is running at http://127.0.0.1:' + port + '/ (sandbox web open signs you in).'
-                : 'The web UI is not running (sandbox web start).');
-            return 0;
-        }
-        default:
-            return fail('Unknown action "' + action + '".', 'Use start, stop, status or open.');
-    }
+    return (await definitionHandler(webStatus)(ctx)) ?? 0;
 }
 /** Body of the background process (`sandbox _web`): runs until stopped. */
 export async function webServer(ctx) {
@@ -130,6 +64,8 @@ export async function webServer(ctx) {
         backend: new WebService(ctx),
         rpc: createRpcHost(ctx),
         staticRoot,
+        version: packageVersion(),
+        idleExitMs: IDLE_EXIT_MS,
     }).run();
     process.exit(0);
 }

package/dist/cli/index.js

@@ -15,7 +15,8 @@ import { withConfig, hoistConfig, withoutConfig } from './argv.js';
 import { report } from './report.js';
 import { versionText } from './version.js';
 import { HANDLERS } from './commands/index.js';
-import { operationHandler } from './operations/index.js';
+import { definitionHandler, operationHandler } from './operations/index.js';
+import { runUpdate } from '../app/features/updates/index.js';
 const entry = path.join(PACKAGE_ROOT, 'dist', 'bin', 'agent-sandbox.js');
 /** A first word that is no command and no agent, but close to one: "Did you mean: sandbox status?". */
 function failOnTypo(word, agents) {
@@ -103,7 +104,7 @@ export async function main(rawArgv, preset = {}) {
     }
     // update works on the install, not on a sandbox: it needs no settings (and a broken file must not stop it).
     if (options.command === 'update')
-        return commands.update(options);
+        return (await definitionHandler(runUpdate)(commands.contextOrDefaults(PACKAGE_ROOT, entry, options))) ?? 0;
     const handler = operationHandler(options.command, options.positionals) ?? HANDLERS[options.command];
     if (!handler)
         return fail('Unknown command "' + options.command + '".', 'Run sandbox --help for the list of commands, or sandbox for the menu.');