windows-development-sandbox 1.5.0 → 1.7.0

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

@@ -0,0 +1,133 @@
+// `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';
+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 { 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 { 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 };
+}
+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());
+        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();
+    if (printJson(ctx, { checks: report.final, summary: report.summary, details }))
+        return 0;
+    printer?.summary(report.final, report.summary);
+    const left = report.final.filter((r) => r.fixable).length;
+    if (left && !report.changed)
+        printer?.line('\n' + quote(left, 'problem') + ' can be fixed: run sandbox repair (or sandbox doctor --fix).');
+    printer?.line('\n' + 'Details');
+    table(details);
+    return 0;
+}
+/** `sandbox repair` for a loaded context. */
+export async function runRepair(ctx, configError = null) {
+    requireOnPc('repair');
+    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 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;
+    }
+    printer?.summary(report.final, report.summary);
+    if (stillFixable && !ask && !yes)
+        printer?.line('\n' + quote(stillFixable, 'problem') + ' can be fixed: run sandbox repair --yes.');
+    printer?.line(log
+        ? '\nLog of what was found and changed: ' + log
+        : '\nNo log was written (the storage folder does not exist yet).');
+    return report.summary.needsYou ? 1 : 0;
+}
+/**
+ * Entry point that works even when the config file is broken (createContext would throw): falls back to the built-in
+ * defaults so the other checks still run, and reports the settings problem as a check of its own.
+ */
+export function repairCommand(packageRoot, entry, options) {
+    let ctx;
+    try {
+        ctx = createContext(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(ctx);
+}

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

@@ -1,11 +1,89 @@
 import type { UserError } from '../../../core/util/index.js';
+import type { InstallLayout, InstallRecord } from '../../../host/install/index.js';
+import type { SystemProbe } from '../../../host/health/index.js';
+import type { MachineFacts } from '../setup/facts.js';
+import type { Migration } from '../../../host/migrate/index.js';
 import type { Context } from '../context.js';
 export type RepairStatus = 'ok' | 'fixed' | 'needs-you' | 'warn' | 'skipped';
+/** The headings the output is grouped under, in the order they are shown. */
+export declare const CHECK_GROUPS: readonly ["This PC", "Install", "Data folder", "Settings", "Sandbox", "Agents & tools", "Network"];
+export type CheckGroup = (typeof CHECK_GROUPS)[number];
+/** The short form of a result (the menu shows these). */
 export interface RepairResult {
     name: string;
     status: RepairStatus;
     detail: string;
 }
+/** What a check's run() finds. */
+export interface Finding {
+    /** ok, a warning (nothing to do now), something you need to do, or not checked. */
+    status: 'ok' | 'warn' | 'needs-you' | 'skipped';
+    /** One line: what was found. */
+    detail: string;
+    /** What it means for you (shown when not ok). */
+    means?: string;
+    /** What to do about it yourself, when repair cannot (a command or a step). */
+    fix?: string;
+    /** What repair would change, in a few words ("remove 2 stale records"). Set only when fix() can mend this. */
+    plan?: string;
+    /** More lines shown under the plan when repair lists what it will change (a diff, the folders). */
+    lines?: string[];
+    /** Handed to fix() unchanged: what run() decided (the folders to remove ...). */
+    data?: unknown;
+}
+/** What a fix reports: what it changed. The before/after lines come from running the check again. */
+export interface FixOutcome {
+    done: string;
+}
+export interface Check {
+    /** Stable id (kebab-case): used in --json and the repair log. */
+    id: string;
+    group: CheckGroup;
+    /** Short label for the result line ("Data folder"). */
+    name: string;
+    /** "the data folder" in "Checking the data folder..."; the lower-cased name when left out. */
+    checking?: string;
+    /** Not shown at all when it returns false (an all-users check on another install). */
+    applies?: (env: RepairEnv) => boolean;
+    /** Slower checks (the network, Windows tools) say how long they may take; the default is 20 seconds. */
+    timeoutMs?: number;
+    /** look: do not even look while a sandbox runs (the folders are in use). fix: look, but fix only when none runs. */
+    needsIdle?: 'look' | 'fix';
+    run: (env: RepairEnv) => Finding | Promise<Finding>;
+    fix?: (env: RepairEnv, finding: Finding) => FixOutcome | Promise<FixOutcome>;
+}
+export interface CheckResult extends RepairResult {
+    id: string;
+    group: CheckGroup;
+    means?: string;
+    fix?: string;
+    plan?: string;
+    lines?: string[];
+    /** Repair can mend this one (a plan exists and the check has a fix). */
+    fixable: boolean;
+    timedOut?: boolean;
+    /** Milliseconds the look took. */
+    ms: number;
+    /** After a fix: what was changed, and what the check said before. */
+    applied?: {
+        done: string;
+        before: string;
+        after: string;
+    };
+    /** After a fix that failed: why. */
+    error?: string;
+}
+export interface Summary {
+    total: number;
+    ok: number;
+    fixed: number;
+    warn: number;
+    needsYou: number;
+    skipped: number;
+    /** Results repair could still mend. */
+    fixable: number;
+}
+/** Everything the checks read, in one place: injectable, so tests point it at temp folders. */
 export interface RepairEnv {
     ctx: Context;
     running: boolean;
@@ -13,14 +91,24 @@ export interface RepairEnv {
     storageRoot: string;
     toolsDir: string;
     configError: UserError | null;
+    /** The managed install this program runs from, or null (npm). */
+    layout: InstallLayout | null;
+    /** install.json of that install. */
+    record: InstallRecord | null;
+    /** %ProgramData%\AgentSandbox (the PC-wide folder of an all-users install). */
+    machineHome: string;
+    /** ~/.agent-sandbox: the settings file and what belongs to it. */
+    userDir: string;
+    /** The settings file in use (--config, AGENT_SANDBOX_CONFIG, else <userDir>\config.json). */
+    configFile: string;
+    /** The settings updates that exist (a test gives its own). */
+    migrations: readonly Migration[];
+    /** The user-scope install folder next to an all-users one (checked for leftovers). */
+    userInstallRoot: string | null;
+    system: SystemProbe;
+    now: () => number;
+    /** What `sandbox setup` learns about this PC (looked up once, the first time a check asks). */
+    facts: () => MachineFacts;
 }
-export interface RepairCheck {
-    name: string;
-    run: (env: RepairEnv) => Omit<RepairResult, 'name'>;
-}
-export declare function ok(detail: string): Omit<RepairResult, 'name'>;
 /** For fixes that must not touch folders a running sandbox may be using. */
-export declare const whileRunning: {
-    status: "skipped";
-    detail: string;
-};
+export declare const WHILE_RUNNING = "a sandbox is running and may be using it; run repair again once it is closed";

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

@@ -1,8 +1,12 @@
-export function ok(detail) {
-    return { status: 'ok', detail };
-}
+/** The headings the output is grouped under, in the order they are shown. */
+export const CHECK_GROUPS = [
+    'This PC',
+    'Install',
+    'Data folder',
+    'Settings',
+    'Sandbox',
+    'Agents & tools',
+    'Network',
+];
 /** For fixes that must not touch folders a running sandbox may be using. */
-export const whileRunning = {
-    status: 'skipped',
-    detail: 'a sandbox is running and may be using it; run repair again once it is closed',
-};
+export const WHILE_RUNNING = 'a sandbox is running and may be using it; run repair again once it is closed';

package/dist/cli/commands/resume.js

@@ -24,7 +24,7 @@ export async function resume(ctx) {
     const { storageRoot, dataPath, options } = ctx;
     const saved = new SessionLedger(storageRoot, dataPath).read();
     if (!saved) {
-        console.log('Nothing to reopen: no sandbox of this tool has been recorded yet.');
+        console.log('Nothing to resume. Start one: sandbox claude.');
         return 0;
     }
     // By hand, you asked for it. From the watcher, the setting decides.
@@ -32,7 +32,7 @@ export async function resume(ctx) {
     const life = new LifeRecord(storageRoot, dataPath).read();
     const reopening = !options.auto || shouldReopen(setting === 'ask' ? 'always' : setting, life, saved) === 'reopen';
     if (!options.auto && !saved.sessions.length) {
-        console.log('Nothing to reopen: no agent sessions were running in the last sandbox.');
+        console.log('Nothing to resume. Start one: sandbox claude.');
         return 0;
     }
     if (reopening && saved.sessions.length)

package/dist/cli/commands/sessions/list.js

@@ -23,9 +23,10 @@ export async function sessions(asked) {
         return 0;
     }
     // Harness, cwd and times are written by the sandbox.
+    const wide = ctx.options.wide;
     const folderWidth = Math.max(16, termWidth() - 80);
     table([
-        ['', 'ID', 'AGENT', 'PROJECT', 'STATE', 'ATTACHED', 'FOLDER', 'STARTED'],
+        ['', 'ID', 'AGENT', 'PROJECT', 'STATE', 'ATTACHED', ...(wide ? ['FOLDER'] : []), 'STARTED'],
         ...service
             .ordered(list)
             .map((s) => [
@@ -35,11 +36,13 @@ export async function sessions(asked) {
             safeText(s.projectName ?? '-'),
             s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : ''),
             viewerText(s.viewers),
-            shortenMiddle(safeText(s.cwd), folderWidth),
+            ...(wide ? [shortenMiddle(safeText(s.cwd), folderWidth)] : []),
             ago(s.startedAt),
         ]),
     ]);
     if (list.some((s) => s.here))
         console.log(c.dim('* = the project of this folder'));
+    if (!wide)
+        console.log(c.dim('Folders: sandbox sessions --wide'));
     return 0;
 }

package/dist/cli/commands/sessions/status.d.ts

@@ -1,2 +1,4 @@
 import type { Context } from '../context.js';
+/** "pong (2 session(s) running)" from the helper in the sandbox, in plain words. */
+export declare function helperText(answer: string): string;
 export declare function status(asked: Context): Promise<number>;

package/dist/cli/commands/sessions/status.js

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import { safeText } from '../../../core/util/index.js';
 import { printJson, table, ago, c, shortenMiddle, termWidth } from '../../output/index.js';
 import { SandboxService } from '../../services/index.js';
@@ -29,6 +28,13 @@ function printProject(p) {
     for (const f of p.repoGuard)
         console.log('      ' + c.yellow('guard: ' + f));
 }
+/** "pong (2 session(s) running)" from the helper in the sandbox, in plain words. */
+export function helperText(answer) {
+    const sessions = /^pong \((\d+) session/.exec(answer);
+    if (!sessions)
+        return answer === '-' ? '-' : safeText(answer);
+    return 'responding, ' + sessions[1] + (sessions[1] === '1' ? ' session' : ' sessions') + ' running';
+}
 export async function status(asked) {
     // Another user's sandbox: shared, it is shown from their folders; not shared, only whose it is.
     const view = lookAtSandbox(asked);
@@ -63,19 +69,34 @@ export async function status(asked) {
     };
     if (printJson(ctx, info))
         return 0;
-    const yesNo = (v) => (typeof v === 'boolean' ? (v ? 'yes' : 'no') : String(v ?? '-'));
+    const sb = info.sandbox;
     if (view.line)
         console.log(c.bold(view.line) + c.dim('. Its window is on their desktop; use its agents here.'));
-    table(Object.entries(info.sandbox).map(([k, v]) => [_.startCase(k), safeText(yesNo(v))]));
+    table([
+        ...(ctx.borrowed ? [['Started by', safeText(ctx.borrowed.user)]] : []),
+        ['Running', sb.running ? 'yes' : 'no'],
+        ...(sb.running
+            ? [
+                ['Phase', safeText(sb.phase ?? '-')],
+                ['Message', safeText(sb.message ?? '-')],
+                ['Window', sb.headless ? 'hidden (sandbox show opens it)' : 'shown'],
+                ['Uptime', sb.uptime ?? '-'],
+                ['Helper', helperText(sb.daemon)],
+            ]
+            : []),
+        ['Account', sb.account ? safeText(sb.account) : 'none selected (sandbox account use)'],
+        ['Background sync', sb.syncWatcher ? 'on' : 'off'],
+    ]);
     if (!state.running)
         return 0;
-    console.log('\n' +
-        c.bold('Projects') +
-        c.dim('  (* = this folder: ' + info.here.folder + (info.here.project ? '' : ', not in this sandbox') + ')'));
+    console.log('\n' + c.bold('Projects'));
     for (const p of info.projects)
         printProject(p);
     for (const r of info.roots)
         console.log('  root  ' + r.host + '  ->  ' + r.guest + c.dim('  (every project in it opens without a restart)'));
+    console.log(c.dim(info.projects.some((p) => p.here)
+        ? '* = the project of this folder'
+        : info.here.folder + ' is not in this sandbox (start it here: sandbox claude)'));
     for (const s of info.otherSessions)
         console.log('  session ' + s.id + '  ' + s.harness + '  ' + s.cwd);
     const findings = info.repoGuard.findings;

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

@@ -1,2 +1,7 @@
 import { type Context } from '../context.js';
+/**
+ * First start on a PC without Windows Sandbox: offers to turn it on (the setup steps) instead of a bare error.
+ * Returns the setup's exit code, or undefined when there is nothing to offer (it is on, no terminal, or declined).
+ */
+export declare function offerSetupWhenOff(ctx: Context): Promise<number | undefined>;
 export declare function setup(ctx: Context): Promise<number>;

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

@@ -1,6 +1,10 @@
 // `sandbox setup`: checks this PC can run Windows Sandbox and offers to turn the feature on.
+import { spawnSync } from 'node:child_process';
 import { askYesNo } from '../../../core/prompt.js';
-import { fail } from '../../../core/util/index.js';
+import { fail, isWin } from '../../../core/util/index.js';
+import { insideSandbox, sandboxFeatureInstalled } from '../../../host/sandbox/index.js';
+import { refuseInSelfTest } from '../../../host/test-guard.js';
+import { SYSTEM } from '../../../shared/system.js';
 import { c, table } from '../../output/index.js';
 import { HealthService } from '../../services/index.js';
 import { ENABLE_COMMAND } from './facts.js';
@@ -12,6 +16,25 @@ const LABEL = {
 function print(checks) {
     table(checks.map((check) => [LABEL[check.status], check.name, check.detail]));
 }
+/** Seconds Windows waits before it restarts (shutdown /a cancels in that time). */
+const RESTART_DELAY_SECONDS = 30;
+/** After turning the feature on Windows must restart: offered, never done without a yes. */
+async function offerRestart() {
+    if (!(await askYesNo('Restart Windows now?')))
+        return;
+    refuseInSelfTest('restart Windows');
+    spawnSync(SYSTEM.shutdown(), ['/r', '/t', String(RESTART_DELAY_SECONDS)], { windowsHide: true });
+    console.log('Windows restarts in ' + RESTART_DELAY_SECONDS + ' seconds. To cancel: shutdown /a');
+}
+/**
+ * First start on a PC without Windows Sandbox: offers to turn it on (the setup steps) instead of a bare error.
+ * Returns the setup's exit code, or undefined when there is nothing to offer (it is on, no terminal, or declined).
+ */
+export async function offerSetupWhenOff(ctx) {
+    if (!isWin || insideSandbox() || sandboxFeatureInstalled() || !process.stdin.isTTY)
+        return undefined;
+    return (await askYesNo('Windows Sandbox is not turned on. Turn it on now?', true)) ? setup(ctx) : undefined;
+}
 export async function setup(ctx) {
     const health = new HealthService(ctx);
     health.assertWindows();
@@ -28,6 +51,7 @@ export async function setup(ctx) {
             console.log('Done. Restart Windows to finish, then run sandbox setup again.\n');
             checks = health.setupReport().checks;
             print(checks);
+            await offerRestart();
         }
         else
             console.log('To do it yourself, in an admin PowerShell run:\n  ' + ENABLE_COMMAND + '\nthen restart Windows.');

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { type Context } from '../context.js';
+/** Before a command (after the saved settings are up to date). A failed move never stops the command. */
+export declare function storageBeforeCommand(ctx: Context, command: string): Promise<void>;

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

@@ -0,0 +1,85 @@
+// At the start of an interactive command: makes sure the storage folder exists (private when it should be) and, once,
+// offers to move saved data from another folder to where it belongs. Never asks without a terminal.
+import { select } from '@inquirer/prompts';
+import { userDir } from '../../../core/config/index.js';
+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, StorageHistory, } from '../../../host/storage/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. */
+const OFFERS = ['menu', 'launch'];
+async function ask(text) {
+    console.error('\n' + text + '\n');
+    return select({
+        message: 'Move it now?',
+        choices: [
+            { name: 'Move now', value: 'now' },
+            { name: 'Not now', value: 'later' },
+            { name: "Don't ask again", value: 'never' },
+        ],
+        default: 'now',
+    });
+}
+function offerText(offer, size, time, warning) {
+    const where = offer.toIsDefault
+        ? 'The default folder is now ' + offer.to + ', which works for both kinds of install.'
+        : 'Your folder is ' + offer.to + '.';
+    return ('Your saved data (' +
+        size +
+        ') is in ' +
+        offer.from +
+        '. ' +
+        where +
+        ' Move it there now? ' +
+        time +
+        '.' +
+        (warning ? '\n' + warning : ''));
+}
+async function offerMove(ctx, history) {
+    const offer = planOffer(ctx.storageRoot, history);
+    if (!offer || isSandboxRunning())
+        return;
+    const measured = await working('Looking at your saved data', () => measureFolder(offer.from));
+    const est = estimate(offer.from, offer.to, measured);
+    const spoken = est.sameVolume ? 'a few seconds' : describeDuration(est.seconds);
+    const time = spoken.charAt(0).toUpperCase() + spoken.slice(1);
+    if (!est.fits) {
+        console.error(c.dim(moveWarning(measured, est) ?? ''));
+        return;
+    }
+    const answer = await ask(offerText(offer, describeSize(measured), time, moveWarning(measured, est)));
+    if (answer === 'never')
+        history.setDontAsk();
+    else if (answer === 'later')
+        history.setNotNow();
+    if (answer !== 'now')
+        return;
+    const result = await performMove({ ...ctx, storageRoot: offer.from }, offer.to, false);
+    console.error('Moved. Your data is now in ' + result.to + '.');
+    for (const note of result.notes)
+        console.error(c.dim(note));
+    refreshStorage(ctx);
+}
+/** Before a command (after the saved settings are up to date). A failed move never stops the command. */
+export async function storageBeforeCommand(ctx, command) {
+    if (insideSandbox() || NO_STORAGE.includes(command))
+        return;
+    if (OFFERS.includes(command) &&
+        process.stdin.isTTY &&
+        process.stdout.isTTY &&
+        !ctx.options.json &&
+        !ctx.options.unattended) {
+        try {
+            await offerMove(ctx, new StorageHistory(userDir()));
+        }
+        catch (e) {
+            console.error(c.red('Could not move your data: ') + errMsg(e));
+        }
+    }
+    ensureStorageRoot(ctx.storageRoot, protectPrivateFolder);
+}

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

@@ -0,0 +1,8 @@
+import { type MoveResult } from '../../../host/storage/index.js';
+import { type Context } from '../context.js';
+/** Why a move cannot start (a background sync is still on a data folder in the old storage), or null. */
+export declare function storageBusy(root: string): string | null;
+/** Moves the data with progress on the terminal; remembers both folders. Used by the command and the start offer. */
+export declare function performMove(ctx: Context, to: string, keepOld: boolean): Promise<MoveResult>;
+/** `sandbox storage [show|move <folder>|use <folder>]`. */
+export declare function storage(ctx: Context): number | Promise<number>;