windows-development-sandbox 1.4.0 → 1.4.3

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

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import _ from 'lodash';
+import { assertNoLinks, fail, safeText, sleep } from '../../../core/util/index.js';
+function newestLog(dir) {
+    if (!fs.existsSync(dir))
+        return null;
+    const logs = fs
+        .readdirSync(dir)
+        .filter((f) => /^(guest|daemon|bootstrap)-.*\.log$/.test(f) && fs.lstatSync(path.join(dir, f)).isFile());
+    const newest = _.maxBy(logs, (f) => fs.statSync(path.join(dir, f)).mtimeMs);
+    return newest ? path.join(dir, newest) : null;
+}
+export async function logs(ctx) {
+    const dir = path.join(ctx.dataPath, 'logs');
+    // The sandbox writes this folder: never read through a link it planted there.
+    assertNoLinks(ctx.dataPath, dir);
+    const file = newestLog(dir) ??
+        fail('No sandbox logs yet in ' + dir + '.', 'Logs appear after the first start (sandbox claude).');
+    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 size = fs.statSync(file).size;
+        const from = printed === 0 ? Math.max(0, size - 64 * 1024) : printed;
+        if (size <= from)
+            return;
+        const fd = fs.openSync(file, 'r');
+        const buffer = Buffer.alloc(Math.min(size - from, 4 * 1024 * 1024));
+        fs.readSync(fd, buffer, 0, buffer.length, from);
+        fs.closeSync(fd);
+        const text = safeText(buffer.toString('utf8'));
+        process.stdout.write(printed === 0 ? text.split('\n').slice(-120).join('\n') : text);
+        printed = from + buffer.length;
+    };
+    print();
+    if (ctx.options.follow)
+        console.error('(following; Ctrl+C to stop)');
+    while (ctx.options.follow) {
+        await sleep(1000);
+        print();
+    }
+    return 0;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { syncBack } from '../../../sync/index.js';
+export function sync(ctx) {
+    const running = isSandboxRunning();
+    const result = syncBack(ctx.dataPath, !running);
+    console.log('History: ' +
+        result.history +
+        ' item(s) synced back. claude-mem: ' +
+        result.claudeMem +
+        (running ? ' (claude-mem syncs when the sandbox closes)' : ''));
+    return 0;
+}

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

@@ -0,0 +1,3 @@
+import { type Context } from '../context.js';
+/** The watcher process exits as soon as its work is done: nothing it opened may keep it running after the sandbox. */
+export declare function watcher(ctx: Context): Promise<void>;

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

@@ -0,0 +1,6 @@
+import { watch } from '../../../sync/index.js';
+/** The watcher process exits as soon as its work is done: nothing it opened may keep it running after the sandbox. */
+export async function watcher(ctx) {
+    await watch(ctx.dataPath);
+    process.exit(0);
+}

package/dist/cli/commands/projects/describe-sessions.d.ts

@@ -0,0 +1,3 @@
+import type { SessionStatus } from '../../../core/types.js';
+/** "2 sessions (claude in api, codex in web)". */
+export declare function describeSessions(sessions: Pick<SessionStatus, 'harness' | 'cwd' | 'project'>[]): string;

package/dist/cli/commands/projects/describe-sessions.js

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import { safeText } from '../../../core/util/index.js';
+/** "2 sessions (claude in api, codex in web)". */
+export function describeSessions(sessions) {
+    return sessions.length === 0
+        ? 'no sessions'
+        : sessions.length +
+            ' session' +
+            (sessions.length === 1 ? '' : 's') +
+            ' (' +
+            sessions
+                .map((s) => safeText(s.harness) + ' in ' + safeText(s.project ?? path.win32.basename(s.cwd)))
+                .join(', ') +
+            ')';
+}

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

@@ -0,0 +1,38 @@
+import type { SandboxStatus } from '../../../core/types.js';
+import { type Missing } from '../../../core/local-config/index.js';
+import { type RegistryEntry } from '../../../host/projects/index.js';
+import type { ProjectSpec } from '../../../shared/channel/index.js';
+import { type Context } from '../context.js';
+/** The folder the command is about: --workspace, else the current one. */
+export declare function hereDir(ctx: Context): string;
+export interface Located {
+    project: RegistryEntry | null;
+    guestDir: string | null;
+}
+/** Where this folder is in the running sandbox, if it is in it at all (nothing is registered). */
+export declare function locateHere(ctx: Context, status: SandboxStatus | null): Located;
+export interface Joined {
+    project: RegistryEntry | null;
+    guestDir: string;
+    spec: ProjectSpec | null;
+    harness: string | null;
+    notes: string[];
+}
+/** restart.ts: the sandbox was restarted for a project in this command. */
+export declare function markRestarted(): void;
+/**
+ * Makes this folder a project of the running sandbox (nothing to do for the launch folder and projects already in
+ * it): its .sandbox-config.json is approved like at a launch, its protections are checked, and it is made visible.
+ * Throws NeedsRestart (host/projects) when that is impossible without a restart.
+ */
+export declare function joinHere(ctx: Context, status: SandboxStatus, o?: {
+    noRestart?: boolean;
+}): Promise<Joined>;
+/** The command that restarts the running sandbox with this folder's boot wishes (consent given by --yes). */
+export declare function restartCommand(ctx: Context, host: string): string;
+/** Joined without what it wants at boot: what is missing, how to restart with it, and how to always have it. */
+export declare function missingNotes(ctx: Context, name: string, host: string, missing: Missing, shown?: boolean): string[];
+/** Waits until the sandbox has set a project up, with its progress on a spinner (plain lines without a terminal). */
+export declare function provisionJoined(ctx: Context, joined: Joined): Promise<void>;
+/** joinHere, then (for another project) waits until the sandbox has set it up. */
+export declare function readyHere(ctx: Context, status: SandboxStatus): Promise<Joined>;

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

@@ -0,0 +1,145 @@
+// Which project of the running sandbox a command is run from. Every command that works on a running sandbox uses
+// these, so they all agree: `locateHere` only looks (attach, sessions, status, restart), `joinHere` also makes the
+// 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 { askYesNo } from '../../../core/prompt.js';
+import { isInsideOrEqual } from '../../../core/util/index.js';
+import { resolveRun } from '../../../core/run/index.js';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { ProjectRegistry, joinRunning } from '../../../host/projects/index.js';
+import { c, working } from '../../output/index.js';
+import { describeSessions } from './describe-sessions.js';
+import { guestPathFor } from '../context.js';
+/** The folder the command is about: --workspace, else the current one. */
+export function hereDir(ctx) {
+    return path.resolve(ctx.options.workspace ?? process.cwd());
+}
+/** 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 here = new ProjectRegistry(ctx.storageRoot).here(dir);
+    if (here)
+        return here;
+    // A sandbox started before projects existed: only its launch folder.
+    if (!new ProjectRegistry(ctx.storageRoot).read() && status && isInsideOrEqual(status.workspaceHost, dir))
+        return { project: null, guestDir: guestPathFor(dir, status.workspaceHost, status.guestWorkspace) };
+    return { project: null, guestDir: null };
+}
+let restartedOnce = false;
+/** restart.ts: the sandbox was restarted for a project in this command. */
+export function markRestarted() {
+    restartedOnce = true;
+}
+/**
+ * Makes this folder a project of the running sandbox (nothing to do for the launch folder and projects already in
+ * it): its .sandbox-config.json is approved like at a launch, its protections are checked, and it is made visible.
+ * Throws NeedsRestart (host/projects) when that is impossible without a restart.
+ */
+export async function joinHere(ctx, status, o = {}) {
+    const { options, loaded, packageRoot, storageRoot, dataPath } = ctx;
+    const dir = hereDir(ctx);
+    // A sandbox started before projects existed: only its launch folder (guestPathFor explains why otherwise).
+    if (!new ProjectRegistry(storageRoot).read())
+        return {
+            project: null,
+            guestDir: guestPathFor(dir, status.workspaceHost, status.guestWorkspace),
+            spec: null,
+            harness: null,
+            notes: [],
+        };
+    let shown = false;
+    const joined = await joinRunning({
+        storageRoot,
+        dataPath,
+        packageRoot,
+        hostDir: dir,
+        wsbShare: loaded.config.projects.wsbShare,
+        resolve: (root) => resolveRun({
+            packageRoot,
+            loaded,
+            cwd: root,
+            workspace: root,
+            harness: options.harness,
+            noAgent: options.noAgent,
+            noLocalConfig: options.noLocalConfig,
+            trustConfig: options.trustConfig,
+            scripts: options.scripts,
+            databases: options.databases,
+            nodeVersion: options.node,
+            pythonVersion: options.python,
+            ask: askYesNo,
+        }),
+        // Its own settings are stricter than the sandbox's: --yes or a "yes" in a terminal joins with the sandbox's.
+        acceptStricter: async (name, stricter) => {
+            if (options.yes)
+                return true;
+            if (!process.stdin.isTTY || !process.stdout.isTTY)
+                return false;
+            console.log(c.yellow(name +
+                "'s settings are stricter than this sandbox's (they apply to every session in it):\n  " +
+                stricter.join('\n  ')));
+            return askYesNo("Join with the sandbox's settings?");
+        },
+        // Something it wants only comes with a restart: --yes restarts, a terminal asks, anything else continues.
+        decide: async (name, missing) => {
+            // Once per command: what a restart could not give (see the launch notes) never restarts it again.
+            if (o.noRestart || restartedOnce)
+                return 'continue';
+            if (options.yes)
+                return 'restart';
+            if (!process.stdin.isTTY || !process.stdout.isTTY)
+                return 'continue';
+            console.log(c.yellow(describeMissing(name, missing)));
+            shown = true;
+            const sessions = new SandboxChannel(dataPath).currentSessions();
+            const ending = sessions.length ? describeSessions(sessions) + ' will end' : 'no session is running';
+            return select({
+                message: 'What now?',
+                choices: [
+                    { name: 'Continue anyway (join without them)', value: 'continue' },
+                    { name: 'Restart with them (' + ending + ')', value: 'restart' },
+                    { name: 'Cancel', value: 'cancel' },
+                ],
+                default: 'continue',
+            });
+        },
+    });
+    const harness = joined.run && joined.run.harnessName !== 'none' ? joined.run.harnessName : null;
+    const notes = joined.missing
+        ? [...joined.notes, ...missingNotes(ctx, joined.project.name, joined.project.host, joined.missing, shown)]
+        : joined.notes;
+    return { project: joined.project, guestDir: joined.guestDir, spec: joined.spec, harness, notes };
+}
+/** The command that restarts the running sandbox with this folder's boot wishes (consent given by --yes). */
+export function restartCommand(ctx, host) {
+    const agent = ctx.options.noAgent ? 'start' : (ctx.options.harness ?? ctx.loaded.config.defaultHarness);
+    return 'sandbox ' + agent + ' --workspace "' + host + '" --yes';
+}
+/** Joined without what it wants at boot: what is missing, how to restart with it, and how to always have it. */
+export function missingNotes(ctx, name, host, missing, shown = false) {
+    return [
+        ...(shown ? [] : [c.yellow(describeMissing(name, missing))]),
+        'Joined without them. To restart the sandbox with them (its sessions end): ' + restartCommand(ctx, host),
+        c.dim(missingTip(missing)),
+    ];
+}
+/** Waits until the sandbox has set a project up, with its progress on a spinner (plain lines without a terminal). */
+export async function provisionJoined(ctx, joined) {
+    if (!joined.spec)
+        return;
+    const spec = joined.spec;
+    let step = 'starting';
+    await working(() => 'Setting up ' + spec.name + ' in the running sandbox: ' + step, () => new SandboxChannel(ctx.dataPath).prepareProject(spec, (m) => {
+        step = m;
+    }));
+}
+/** joinHere, then (for another project) waits until the sandbox has set it up. */
+export async function readyHere(ctx, status) {
+    const joined = await joinHere(ctx, status);
+    for (const note of joined.notes)
+        console.log(note);
+    await provisionJoined(ctx, joined);
+    return joined;
+}

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { type Context } from '../context.js';
+interface Row {
+    readonly folder: string;
+    readonly here: boolean;
+    readonly known: boolean;
+    readonly root: string | null;
+    readonly excluded: boolean;
+    readonly mappedAtStart: boolean;
+    readonly running: string | null;
+}
+/** Every project worth listing: known ones, the running sandbox's, and this folder. */
+export declare function projectRows(ctx: Context): Row[];
+export declare function projects(ctx: Context): Promise<number>;
+export {};

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

@@ -0,0 +1,213 @@
+// `sandbox projects`: which projects a sandbox can open without a restart. Project roots (whole folders of projects),
+// the projects this tool has started before, and projects.all / projects.exclude. Changes to what is mapped take
+// effect at the next start; a project you start while a sandbox runs joins it when it can (projects.ts in host/).
+import path from 'node:path';
+import { checkbox } from '@inquirer/prompts';
+import { assertSafeMapping, assertSafeWorkspace } from '../../../core/safe-paths.js';
+import { dirExists, expandPath, fail, isRootPath } from '../../../core/util/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { KnownProjects, projectMapper, ProjectRegistry } from '../../../host/projects/index.js';
+import { isWithin } from '../../../shared/paths/index.js';
+import { c, pageSizeFor, shortenMiddle, termWidth, printJson, table } from '../../output/index.js';
+import { hereDir } from './here.js';
+import { addToList, removeFromList, setSetting } from '../user-config.js';
+function settings(ctx) {
+    const p = ctx.loaded.config.projects;
+    const expand = (list) => list.map((x) => expandPath(x, ctx.loaded.base));
+    return { all: p.all, roots: expand(p.roots), exclude: expand(p.exclude) };
+}
+/** Every project worth listing: known ones, the running sandbox's, and this folder. */
+export function projectRows(ctx) {
+    const s = settings(ctx);
+    const registry = isSandboxRunning() ? new ProjectRegistry(ctx.storageRoot).read() : null;
+    const here = hereDir(ctx);
+    const known = new KnownProjects(ctx.storageRoot).list();
+    const folders = [...known.map((k) => k.host), ...(registry?.projects.map((p) => p.host) ?? [])];
+    const unique = folders.filter((f, i) => folders.findIndex((g) => g.toLowerCase() === f.toLowerCase()) === i);
+    return unique.map((folder) => {
+        const root = s.roots.find((r) => isWithin(r, folder)) ?? null;
+        const excluded = s.exclude.some((e) => isWithin(e, folder));
+        const inSandbox = registry?.projects.find((p) => p.host.toLowerCase() === folder.toLowerCase());
+        return {
+            folder,
+            here: isWithin(folder, here),
+            known: known.some((k) => k.host.toLowerCase() === folder.toLowerCase()),
+            root,
+            excluded,
+            mappedAtStart: root !== null || (s.all && !excluded && dirExists(folder)),
+            running: inSandbox ? inSandbox.name + ' (' + inSandbox.mechanism + ')' : null,
+        };
+    });
+}
+const NEXT_START = 'This changes what is mapped from the next start.';
+function runningNote() {
+    return isSandboxRunning()
+        ? ' The running sandbox keeps what it has; start a project in it (sandbox claude there) and it joins without a restart when it can, or you are offered one.'
+        : '';
+}
+/** A folder for roots: it holds projects, so it must pass the same checks as a workspace and must not be a drive. */
+function checkFolder(ctx, folder, what) {
+    const dir = path.resolve(folder);
+    if (!dirExists(dir))
+        fail('The folder ' + dir + ' does not exist.', 'Check the path.');
+    if (isRootPath(dir))
+        fail('A whole drive cannot be ' + what + ': ' + dir, 'Use the folder that holds your projects, e.g. F:\\Code.');
+    assertSafeWorkspace(dir, ctx.packageRoot, ctx.storageRoot);
+    assertSafeMapping(dir, ctx.packageRoot, ctx.storageRoot);
+    return dir;
+}
+function list(ctx) {
+    const rows = projectRows(ctx);
+    const s = settings(ctx);
+    if (printJson(ctx, { all: s.all, roots: s.roots, exclude: s.exclude, projects: rows }))
+        return 0;
+    console.log(c.bold('projects.all') +
+        ': ' +
+        (s.all ? 'on (every project below is mapped at every start, except excluded ones)' : 'off') +
+        c.dim('   sandbox projects all on|off'));
+    console.log(c.bold('Roots') +
+        ': ' +
+        (s.roots.length ? s.roots.join(', ') : c.dim('none (sandbox projects roots add <folder>)')));
+    if (!rows.length) {
+        console.log('No projects yet: start one with sandbox claude in its folder.');
+        return 0;
+    }
+    const width = Math.max(20, termWidth() - 46);
+    table([
+        ['', 'FOLDER', 'AT START', 'RUNNING SANDBOX'],
+        ...rows.map((r) => [
+            r.here ? '*' : '',
+            shortenMiddle(r.folder, width),
+            r.root ? 'root' : r.excluded ? 'excluded' : r.mappedAtStart ? 'mapped' : '-',
+            r.running ?? '-',
+        ]),
+    ]);
+    console.log(c.dim('* = this folder.  Choose with: sandbox projects choose'));
+    return 0;
+}
+/** Ticks the projects mapped at every start (turns projects.all on when any is ticked); the rest are excluded. */
+async function choose(ctx) {
+    const rows = projectRows(ctx).filter((r) => !r.root);
+    if (!rows.length) {
+        console.log('No projects to choose from yet (projects in a root are always mapped with it). Start one with sandbox claude in its folder.');
+        return 0;
+    }
+    if (!process.stdin.isTTY)
+        fail('sandbox projects choose needs an interactive terminal.', 'Use sandbox projects include|exclude <folder> instead.');
+    const s = settings(ctx);
+    const picked = await checkbox({
+        message: 'Projects mapped at every start, so they open without a restart (every agent in the sandbox can see them):',
+        pageSize: pageSizeFor(rows.length),
+        choices: rows.map((r) => ({
+            value: r.folder,
+            name: shortenMiddle(r.folder, termWidth() - 12) + (r.here ? c.dim('  (this folder)') : ''),
+            checked: s.all && !r.excluded,
+        })),
+    });
+    const exclude = rows.filter((r) => !picked.includes(r.folder)).map((r) => r.folder);
+    setSetting(ctx, ['projects', 'exclude'], [...s.exclude.filter((e) => !rows.some((r) => r.folder.toLowerCase() === e.toLowerCase())), ...exclude]);
+    setSetting(ctx, ['projects', 'all'], picked.length > 0);
+    console.log(picked.length + ' project(s) mapped at every start, ' + exclude.length + ' excluded. ' + NEXT_START + runningNote());
+    return 0;
+}
+function add(ctx, value) {
+    const dir = checkFolder(ctx, value, 'a project');
+    new KnownProjects(ctx.storageRoot).remember(dir);
+    console.log('Added ' +
+        dir +
+        ' to your projects.' +
+        (settings(ctx).all
+            ? ' ' + NEXT_START
+            : ' It is mapped at every start once projects.all is on (sandbox projects all on).'));
+    return 0;
+}
+function remove(ctx, value) {
+    const dir = path.resolve(value);
+    const forgot = new KnownProjects(ctx.storageRoot).forget(dir);
+    // The running sandbox forgets it too (its folder stays visible until the sandbox stops, if it was mapped).
+    const registered = isSandboxRunning()
+        ? new ProjectRegistry(ctx.storageRoot)
+            .read()
+            ?.projects.find((p) => !p.primary && p.host.toLowerCase() === dir.toLowerCase())
+        : undefined;
+    if (registered)
+        projectMapper({ storageRoot: ctx.storageRoot, packageRoot: ctx.packageRoot, wsbShare: false }).unregister(registered.name);
+    console.log(forgot || registered
+        ? 'Removed ' + dir + ' from your projects (nothing in the folder was touched).'
+        : dir + ' was not in your projects.');
+    return 0;
+}
+function includeOrExclude(ctx, action, value) {
+    const dir = path.resolve(value);
+    const changed = action === 'exclude'
+        ? addToList(ctx, ['projects', 'exclude'], dir)
+        : removeFromList(ctx, ['projects', 'exclude'], dir);
+    if (action === 'include')
+        new KnownProjects(ctx.storageRoot).remember(dir);
+    console.log((changed ? (action === 'exclude' ? 'Excluded ' : 'Included ') + dir + '. ' + NEXT_START : 'Nothing changed.') +
+        (action === 'include' && !settings(ctx).all
+            ? ' projects.all is off: sandbox projects all on maps your projects at every start.'
+            : '') +
+        (changed ? runningNote() : ''));
+    return 0;
+}
+function all(ctx, value) {
+    if (value === undefined) {
+        console.log('projects.all is ' + (settings(ctx).all ? 'on' : 'off') + '.');
+        return 0;
+    }
+    setSetting(ctx, ['projects', 'all'], value === 'on');
+    console.log('projects.all is ' +
+        value +
+        '. ' +
+        NEXT_START +
+        (value === 'on' ? ' Every agent in the sandbox can then see all of those projects.' : '') +
+        runningNote());
+    return 0;
+}
+function roots(ctx, value, folder) {
+    if (!value || value === 'list') {
+        const list = settings(ctx).roots;
+        console.log(list.length ? list.join('\n') : 'No project roots. Add one: sandbox projects roots add <folder>');
+        return 0;
+    }
+    if (value === 'add') {
+        const dir = checkFolder(ctx, folder, 'a project root');
+        const added = addToList(ctx, ['projects', 'roots'], dir);
+        console.log(added
+            ? 'Added the project root ' +
+                dir +
+                ': every project in it (also new ones) opens without a restart. Every agent in the sandbox can see all of them. ' +
+                NEXT_START +
+                runningNote()
+            : dir + ' is a root already.');
+        return 0;
+    }
+    const dir = path.resolve(folder);
+    console.log(removeFromList(ctx, ['projects', 'roots'], dir)
+        ? 'Removed the project root ' + dir + '. ' + NEXT_START
+        : dir + ' was not a root.');
+    return 0;
+}
+export async function projects(ctx) {
+    const [action = 'list', value, folder] = ctx.options.positionals;
+    switch (action) {
+        case 'list':
+            return list(ctx);
+        case 'choose':
+            return choose(ctx);
+        case 'add':
+            return add(ctx, value);
+        case 'remove':
+            return remove(ctx, value);
+        case 'include':
+        case 'exclude':
+            return includeOrExclude(ctx, action, value);
+        case 'all':
+            return all(ctx, value);
+        case 'roots':
+            return roots(ctx, value, folder);
+        default:
+            return fail('Unknown projects action "' + action + '".');
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { SandboxStatus } from '../../../core/types.js';
+import { type NeedsRestart } from '../../../host/projects/index.js';
+import type { Context } from '../context.js';
+import type { LaunchExtras, OpenSessionOptions } from '../launch/index.js';
+import { type Joined } from './here.js';
+/** What a restart needs from launch (launch imports this file, so it is handed in rather than imported). */
+export interface Relauncher {
+    launch(ctx: Context, generateOnly: boolean, extras: LaunchExtras): Promise<number>;
+    readySandbox(dataPath: string): Promise<SandboxStatus>;
+    joinHere(ctx: Context, status: SandboxStatus, o?: {
+        noRestart?: boolean;
+    }): Promise<Joined>;
+    openSession(ctx: Context, ready: SandboxStatus, joined: Joined, o: OpenSessionOptions): Promise<number>;
+}
+export declare function offerRestart(ctx: Context, needs: NeedsRestart[], then: () => Promise<number>, relauncher: Relauncher): Promise<number>;