windows-development-sandbox 1.4.1 → 1.4.3

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

@@ -0,0 +1,98 @@
+function agentRow(run, generated, prepared) {
+    const { config } = run;
+    // What the sandbox boots with (the launch folder's settings plus what the other projects at boot want).
+    const booted = generated.bootConfig;
+    return (run.harnessName +
+        (prepared?.account ? '  (account: ' + prepared.account + ')' : '') +
+        '   Memory: ' +
+        generated.memoryMb +
+        ' MB   CPU: ' +
+        (config.sandbox.cpuLimit === 'none' ? 'all' : 'max ' + config.sandbox.cpuLimit + '%') +
+        '   Network: ' +
+        booted.sandbox.networking +
+        (booted.sandbox.vGpu ? '   vGPU' : '') +
+        (config.sandbox.headless ? '   HEADLESS' : ''));
+}
+function versionsRow(run) {
+    const { node, python } = run.versions;
+    return node.spec + ' (' + node.source + ')   Python: ' + python.spec + ' (' + python.source + ')';
+}
+function preparedRows(prepared) {
+    return prepared
+        ? [
+            ['Ignored files', prepared.filter],
+            ['Terminal', prepared.terminal],
+            ['History', prepared.history],
+            ['Cleanup', prepared.pruned],
+        ]
+        : [];
+}
+function toolchainsRow(generated) {
+    return (Object.entries(generated.toolchains)
+        .filter(([, d]) => d.on)
+        .map(([name, d]) => name + ' (' + d.reason + ')')
+        .join(', ') || 'Node only (nothing else used by this project)');
+}
+function databaseRows(generated) {
+    if (!generated.databases.length)
+        return [['Databases', 'none needed (databases.<name>.enabled = true adds one)']];
+    return generated.databases.map((d, i) => [
+        i ? '' : 'Databases',
+        d.database +
+            (d.database === 'sqlserver'
+                ? ' (cannot run in the sandbox; use Postgres or SQLite for local work)'
+                : ' on port ' + d.port) +
+            '  because ' +
+            d.reasons[0] +
+            (d.reasons.length > 1 ? ' (+' + (d.reasons.length - 1) + ' more)' : ''),
+    ]);
+}
+function claudeRow(generated) {
+    const { profile } = generated;
+    return profile.staged.length
+        ? profile.staged.join(', ') + (profile.credentials ? '  (INCLUDING YOUR LOGIN)' : '')
+        : 'no settings copied';
+}
+function secretsRow(run, generated) {
+    if (!run.config.secrets.strip)
+        return 'NOT stripped (secrets.strip is off)';
+    const removed = generated.profile.secretsRemoved;
+    return removed.length
+        ? 'kept on this PC: ' + removed.join(', ') + '  (secrets.allow lets one through)'
+        : 'none found in what is copied';
+}
+/** Project roots, boot-mapped projects, then any other folder mapped (not the tool's own nor the workspace). */
+function mappingRows(run, generated) {
+    const { roots, projects } = generated.projects;
+    return [
+        ...roots.map((r, i) => [
+            i ? '' : 'Project roots',
+            r.host + '  ->  ' + r.guest + '  (every project in it opens without a restart)',
+        ]),
+        ...projects.map((p, i) => [i ? '' : 'Projects', p.host + '  ->  ' + p.guest]),
+        ...generated.mappings
+            .slice(2)
+            .filter((m) => m.guest !== run.config.guestWorkspace && ![...roots, ...projects].some((p) => p.guest === m.guest))
+            .map((m) => [
+            '  map ' + (m.readOnly ? 'ro' : 'rw'),
+            m.host + '  ->  ' + m.guest + (m.label ? '  (' + m.label + ')' : ''),
+        ]),
+    ];
+}
+/** The launch summary rows, in the order they are printed. */
+export function launchSummary(run, generated, prepared) {
+    const { config } = run;
+    return [
+        ['Workspace', run.workspaceHost + '  ->  ' + config.guestWorkspace + (config.readOnly ? '  (read-only)' : '')],
+        ['Agent', agentRow(run, generated, prepared)],
+        ['Node', versionsRow(run)],
+        ...preparedRows(prepared),
+        ['Toolchains', toolchainsRow(generated)],
+        ...databaseRows(generated),
+        ['Desktop', generated.personalization],
+        ['Claude', claudeRow(generated)],
+        ['Secrets', secretsRow(run, generated)],
+        ...mappingRows(run, generated),
+        ['Generated', generated.wsbPath],
+    ];
+}

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

@@ -0,0 +1,3 @@
+import { type Context } from '../context.js';
+/** `sandbox audit`: the audit log of the last days (audit.enabled), newest last. */
+export declare function audit(ctx: Context): Promise<number>;

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

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { fail, plainText } from '../../../core/util/index.js';
+import { humanBytes } from '../../../core/disk.js';
+import { AuditLog } from '../../../host/audit/log.js';
+import { printJson, c } from '../../output/index.js';
+const KINDS = ['proc', 'file', 'session', 'guard', 'note'];
+const KIND_LABEL = {
+    proc: 'program',
+    file: 'file',
+    session: 'session',
+    guard: 'GUARD',
+    note: 'note',
+};
+/** `sandbox audit`: the audit log of the last days (audit.enabled), newest last. */
+export async function audit(ctx) {
+    const settings = ctx.loaded.config.audit;
+    const kind = ctx.options.kind;
+    if (kind && !KINDS.includes(kind))
+        fail('Unknown kind "' + kind + '".', 'Use one of: ' + KINDS.join(', '));
+    const log = new AuditLog(AuditLog.dirFor(ctx.storageRoot, ctx.dataPath), settings);
+    const events = log.read({
+        days: ctx.options.days,
+        kinds: kind ? [kind] : undefined,
+        grep: ctx.options.grep,
+    });
+    if (printJson(ctx, events))
+        return 0;
+    if (!events.length) {
+        console.log(settings.enabled
+            ? 'Nothing in the audit log for the last ' + ctx.options.days + ' day(s).'
+            : 'The audit log is off. Turn it on in the menu (Settings > Security & privacy > Audit log) or with audit.enabled in your config.');
+        return 0;
+    }
+    for (const e of events) {
+        // What the sandbox reported is text from the sandbox: no control codes reach your terminal.
+        const [p, cmd, parent, dir, act] = [e.p, e.c, e.pp, e.w, e.a].map((v) => plainText(v ?? ''));
+        const what = e.k === 'proc'
+            ? (cmd || p) + (parent ? c.dim('  <- ' + path.win32.basename(parent)) : '')
+            : e.k === 'file'
+                ? act + ' ' + p + c.dim('  in ' + dir)
+                : e.k === 'session'
+                    ? act + ' ' + p + c.dim('  ' + dir + ' ' + cmd)
+                    : p;
+        console.log(c.dim(new Date(e.t).toLocaleString()) +
+            '  ' +
+            (e.k === 'guard' ? c.yellow(KIND_LABEL[e.k].padEnd(8)) : KIND_LABEL[e.k].padEnd(8)) +
+            what +
+            (e.n && e.n > 1 ? c.dim('  x' + e.n) : ''));
+    }
+    console.log(c.dim('\n' +
+        events.length +
+        ' event(s); the log takes ' +
+        humanBytes(log.bytes()) +
+        ' (' +
+        AuditLog.dirFor(ctx.storageRoot, ctx.dataPath) +
+        ').'));
+    return 0;
+}

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

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

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

@@ -0,0 +1,10 @@
+import _ from 'lodash';
+import { describePrune, pruneStorage } from '../../../host/storage/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { RunDir } from '../../../shared/channel/index.js';
+export function clean(ctx) {
+    const running = isSandboxRunning() ? new RunDir(ctx.dataPath).readSandboxStatus()?.launchId : undefined;
+    console.log('Cleanup: ' +
+        describePrune(pruneStorage(ctx.storageRoot, { launchDays: ctx.options.days, keep: _.compact([running]) })));
+    return 0;
+}

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

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

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

@@ -0,0 +1,145 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { DEFAULTS, userConfigPath, userDir } from '../../../core/config/index.js';
+import { allowedAnswer, allowStorePath, applyOverrides, describeOverrides, isTrusted, LOCAL_CONFIG_NAME, loosenedRequests, normalizeOverrides, OUTSIDE_FOLDER, outsideKey, outsideMappings, readLocalConfig, trustStorePath, } from '../../../core/local-config/index.js';
+import { guestWorkspaceOf, previewGuest } from '../../../core/run/index.js';
+import { dirExists, fail, safeText, writeJson } from '../../../core/util/index.js';
+import { c, table } from '../../output/index.js';
+function initConfig() {
+    const file = userConfigPath();
+    if (fs.existsSync(file))
+        fail(file + ' already exists.');
+    fs.mkdirSync(path.join(userDir(), 'hooks', 'pre-agent'), { recursive: true });
+    // The schema sits next to the file (a local path), so editors trust it and show docs and autocomplete.
+    writeJson(file, { $schema: './config.schema.json', ...DEFAULTS });
+    console.log('Created ' + file + '. It lists every setting with its default; delete the ones you do not change.');
+    console.log('Your own hook scripts go in ' + path.join(userDir(), 'hooks') + '\\{pre-provision,pre-agent,post-agent}.');
+    console.log("For editor help in every project's .sandbox-config.json, run: sandbox config schema");
+    return 0;
+}
+/**
+ * VS Code setting that maps every .sandbox-config.json (and the user config) to the local schema files, so project
+ * files need no "$schema" line and nothing is fetched from the internet (remote schemas need trusting).
+ */
+function printSchemaSettings() {
+    const url = (name) => pathToFileURL(path.join(userDir(), name)).href;
+    const setting = {
+        'json.schemas': [
+            { fileMatch: ['**/.sandbox-config.json'], url: url('sandbox-config.schema.json') },
+            { fileMatch: ['**/.agent-sandbox/config.json'], url: url('config.schema.json') },
+        ],
+    };
+    console.log('Add this to your VS Code settings.json (Ctrl+Shift+P > "Preferences: Open User Settings (JSON)"):\n');
+    console.log(JSON.stringify(setting, null, 2).slice(2, -2));
+    console.log('\nThe schema files live in ' + userDir() + ' and are refreshed whenever the sandbox command runs.');
+    return 0;
+}
+/**
+ * `sandbox config check`: the folder's .sandbox-config.json validated and described (risky settings flagged, approval
+ * state), without launching. Fails with the same message a launch would give when the file is not valid.
+ */
+function checkLocalConfig(ctx) {
+    const dir = path.resolve(ctx.options.workspace ?? process.cwd());
+    const file = readLocalConfig(dir);
+    if (!file) {
+        console.log('No ' + LOCAL_CONFIG_NAME + ' in ' + dir + '; the sandbox uses your own settings only.');
+        return 0;
+    }
+    const overrides = normalizeOverrides(file.data, dir, file.path);
+    const approved = isTrusted(trustStorePath(ctx.storageRoot), file.path, file.hash);
+    console.log(file.path +
+        ': valid. ' +
+        (approved ? 'Approved (this exact version).' : 'Not approved yet: the next launch asks you.') +
+        '\n');
+    for (const line of describeOverrides(overrides, dir))
+        console.log('  ' + safeText(line));
+    previewFolders(ctx, dir, file.path, overrides);
+    return 0;
+}
+/** What a launch from here would do with each folder and each looser setting, without launching. */
+function previewFolders(ctx, dir, filePath, overrides) {
+    const config = ctx.loaded.config;
+    const store = allowStorePath(ctx.storageRoot);
+    const workspaceGuest = guestWorkspaceOf(applyOverrides(config, overrides), dir).guest;
+    const outside = outsideMappings(dir, overrides.mappings);
+    const policy = config.projects.allowOutsideMappings;
+    const statusOf = (m) => {
+        if (!dirExists(m.host))
+            return m.optional
+                ? 'not on this PC: skipped'
+                : c.red('the folder does not exist: create it, fix the path, or add "optional": true');
+        if (!outside.includes(m))
+            return m.guest ? 'inside the project' : 'inside the project (already in the sandbox there)';
+        if (policy === true)
+            return 'outside the project, allowed (projects.allowOutsideMappings is true)';
+        if (policy === false)
+            return c.red('outside the project: refused (projects.allowOutsideMappings is false)');
+        return allowedAnswer(store, filePath, OUTSIDE_FOLDER, outsideKey(m)) === true
+            ? 'outside the project, allowed (you said yes)'
+            : c.yellow('outside the project: the next interactive launch asks you');
+    };
+    const rows = (overrides.mappings ?? []).map((m) => {
+        const where = previewGuest(m, dir, workspaceGuest);
+        return [(m.readOnly ? 'ro ' : 'rw ') + safeText(m.host), '->  ' + safeText(where.guest), statusOf(m)];
+    });
+    if (rows.length) {
+        console.log('\nFolders (where they appear in the sandbox):');
+        table(rows);
+    }
+    for (const m of overrides.mappings ?? []) {
+        const note = dirExists(m.host) ? previewGuest(m, dir, workspaceGuest).note : null;
+        if (note)
+            console.log('  ' + safeText(note));
+    }
+    const looser = loosenedRequests(config, overrides);
+    if (looser.length)
+        console.log('\nLooser than your settings (used only if you allow it for this project):');
+    for (const a of looser) {
+        const answer = allowedAnswer(store, filePath, a.key, a.wanted);
+        console.log('  ' +
+            a.key +
+            ' = ' +
+            JSON.stringify(a.wanted) +
+            ': ' +
+            (answer === true
+                ? 'allowed (you said yes)'
+                : answer === false
+                    ? 'not used (you said no)'
+                    : 'the next interactive launch asks you'));
+    }
+}
+export function config(ctx) {
+    const [action = 'summary'] = ctx.options.positionals;
+    switch (action) {
+        case 'summary':
+            table([
+                [
+                    'Settings file',
+                    ctx.loaded.configPath ?? userConfigPath() + '  (does not exist yet; sandbox config init creates it)',
+                ],
+                ['Default agent', ctx.loaded.config.defaultHarness],
+                ['Storage', ctx.storageRoot],
+                [
+                    'Memory',
+                    String(ctx.loaded.config.sandbox.memoryMb) + (ctx.loaded.config.sandbox.memoryMb === 'auto' ? '' : ' MB'),
+                ],
+            ]);
+            console.log('\nChange settings in the menu (sandbox > Settings). All of them as JSON: sandbox config show');
+            return 0;
+        case 'path':
+            console.log(ctx.loaded.configPath ?? userConfigPath() + '  (does not exist yet)');
+            return 0;
+        case 'init':
+            return initConfig();
+        case 'show':
+            console.log(JSON.stringify(ctx.loaded.config, null, 2));
+            return 0;
+        case 'schema':
+            return printSchemaSettings();
+        case 'check':
+            return checkLocalConfig(ctx);
+        default:
+            fail('Unknown config action "' + action + '".', 'Use one of: sandbox config show | path | init | schema | check');
+    }
+}

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

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

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

@@ -0,0 +1,52 @@
+import { expandPath } from '../../../core/util/index.js';
+import { KnownProjects, ProjectRegistry } from '../../../host/projects/index.js';
+import { detectWsb, doctorRows, insideSandbox, isSandboxRunning } from '../../../host/sandbox/index.js';
+import { table } from '../../output/index.js';
+export function doctor(ctx) {
+    const rows = doctorRows(ctx.loaded.config, ctx.options.harness ?? ctx.loaded.config.defaultHarness, ctx.storageRoot, ctx.loaded.configPath);
+    // Inside a sandbox the feature and "running" rows describe the sandbox itself, and the host rows describe nothing
+    // useful.
+    if (insideSandbox()) {
+        table([
+            ['Where', 'inside a Windows Sandbox started by this tool (run doctor on your PC to check the PC)'],
+            ...rows.filter(([name]) => name === 'Config file'),
+        ]);
+        return 0;
+    }
+    // Several projects: the roots mapped at every start, what the running sandbox has, and whether wsb share is there.
+    const p = ctx.loaded.config.projects;
+    const registry = isSandboxRunning() ? new ProjectRegistry(ctx.storageRoot).read() : null;
+    const wsb = p.wsbShare ? detectWsb() : null;
+    table([
+        ...rows,
+        [
+            'Project roots',
+            p.roots.length
+                ? p.roots.map((r) => expandPath(r, ctx.loaded.base)).join(', ')
+                : 'none (sandbox projects roots add <folder>)',
+        ],
+        [
+            'All projects',
+            p.all
+                ? 'on: ' +
+                    new KnownProjects(ctx.storageRoot).list().length +
+                    ' known project(s) mapped at every start (' +
+                    p.exclude.length +
+                    ' excluded)'
+                : 'off',
+        ],
+        ['Projects running', registry ? registry.projects.map((x) => x.name + ' (' + x.mechanism + ')').join(', ') : '-'],
+        [
+            'wsb share',
+            !p.wsbShare
+                ? 'off (projects.wsbShare)'
+                : wsb
+                    ? 'available: ' +
+                        wsb.exe +
+                        (wsb.version ? ' ' + wsb.version : '') +
+                        ' (untested; a failure offers a restart instead)'
+                    : 'not on this Windows (needs Windows 11 24H2+ with the updated Windows Sandbox): folders outside your roots need a restart',
+        ],
+    ]);
+    return 0;
+}

package/dist/cli/commands/maintenance/host-claude.d.ts

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

package/dist/cli/commands/maintenance/host-claude.js

@@ -0,0 +1,4 @@
+import { hostClaude } from '../../../host/sandbox/index.js';
+export function claudeHost(ctx) {
+    return hostClaude(ctx.storageRoot, ctx.options.personal, ctx.options.passthrough);
+}

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

@@ -0,0 +1,8 @@
+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';
+export * from './watch.js';
+export * from './audit.js';

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

@@ -0,0 +1,9 @@
+// sync, logs, clean, 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';
+export * from './watch.js';
+export * from './audit.js';

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

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

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>;