windows-development-sandbox 1.4.1 → 1.4.3

package/dist/cli/boot-progress.d.ts

@@ -1,22 +0,0 @@
-import type { SandboxStatus } from '../core/types.js';
-/** One progress line: `line` is shown, `key` changes only when the step or what runs changes, `what` names it. */
-export interface Shown {
-    line: string;
-    key: string;
-    what: string;
-}
-/** "[3/8] Developer tools: downloading rust 40%, setting up go (2 of 6 done)". */
-export declare const bootLine: (status: SandboxStatus | null, fallback?: string) => Shown;
-/** Nothing new for a while: say so, and where the details are. */
-export declare const stillWorking: (what: string, ms: number) => string;
-export declare const readyIn: (ms: number) => string;
-/** The wanted tools that are not downloaded yet (`has` says whether a folder in <data>\tools exists), with their rough size. */
-export declare const pendingDownloads: (wanted: string[], has: (dir: string) => boolean) => {
-    names: string[];
-    mb: number;
-};
-/** The heads-up before the wait, or null when everything is already downloaded. first: nothing was ever installed. */
-export declare const firstStartNotice: (first: boolean, pending: {
-    names: string[];
-    mb: number;
-}) => string | null;

package/dist/cli/boot-progress.js

@@ -1,59 +0,0 @@
-// What the terminal says while a sandbox starts: the first-start heads-up (what is downloaded, roughly how much) and
-// one line of progress from the guest's status. Pure: the status is guest-written, so every bit of it is made safe
-// and short here.
-import { plainText } from '../core/util.js';
-import { elapsed } from './progress.js';
-const clean = (text, max) => plainText(text).replace(/\s+/g, ' ').trim().slice(0, max);
-/** "[3/8] Developer tools: downloading rust 40%, setting up go (2 of 6 done)". */
-export const bootLine = (status, fallback = 'Starting Windows Sandbox') => {
-    if (!status)
-        return { line: fallback, key: fallback, what: fallback.toLowerCase() };
-    const p = status.progress;
-    if (!p) {
-        const line = clean(status.message, 200) || fallback;
-        return { line, key: line, what: line };
-    }
-    const title = clean(p.title, 60);
-    const items = p.active.slice(0, 8).map((a) => ({ name: clean(a.name, 40), percent: a.percent }));
-    const loading = items.filter((a) => a.percent !== undefined && a.percent < 100);
-    const others = items.filter((a) => !loading.includes(a));
-    const parts = [
-        ...(loading.length ? ['downloading ' + loading.map((a) => a.name + ' ' + a.percent + '%').join(', ')] : []),
-        ...(others.length ? ['setting up ' + others.map((a) => a.name).join(', ')] : []),
-    ];
-    const count = p.total > 0 && items.length ? ' (' + Math.min(p.done, p.total) + ' of ' + p.total + ' done)' : '';
-    const head = '[' + p.step + '/' + p.steps + '] ' + title;
-    return {
-        line: (head + (parts.length ? ': ' + parts.join('; ') : '') + count).slice(0, 240),
-        key: head + '|' + items.map((a) => a.name).sort().join(','),
-        what: items.length ? items.map((a) => a.name).join(', ') : title,
-    };
-};
-/** Nothing new for a while: say so, and where the details are. */
-export const stillWorking = (what, ms) => 'Still working on ' + clean(what, 80) + ' (' + Math.max(1, Math.round(ms / 60000)) + ' min). Full log: sandbox logs -f';
-export const readyIn = (ms) => 'Ready in ' + elapsed(ms) + '.';
-// ---- the first-start heads-up ----------------------------------------------------------------------------------------
-/** What a first start downloads, by setting name: its folder in <data>\tools, rough size and a readable name. */
-const DOWNLOADS = {
-    node: { dir: 'nvm', mb: 30 }, python: { dir: 'python', mb: 30 }, rust: { dir: 'rust', mb: 300 }, msvc: { dir: 'msvc', mb: 1500, label: 'MSVC' },
-    cpp: { dir: 'mingw', mb: 270, label: 'C/C++' }, dotnet: { dir: 'dotnet', mb: 250, label: '.NET' }, go: { dir: 'go', mb: 80 }, java: { dir: 'java', mb: 200 },
-    ruby: { dir: 'ruby', mb: 100 }, php: { dir: 'php', mb: 30 }, deno: { dir: 'deno', mb: 40 }, pwsh: { dir: 'pwsh', mb: 100, label: 'PowerShell 7' },
-    vscode: { dir: 'vscode', mb: 150, label: 'VS Code' },
-    postgres: { dir: 'postgres', mb: 330, label: 'PostgreSQL' }, mysql: { dir: 'mariadb', mb: 90, label: 'MariaDB' }, mongodb: { dir: 'mongodb', mb: 450, label: 'MongoDB' },
-    redis: { dir: 'redis', mb: 10 }, dynamodb: { dir: 'dynamodb-local', mb: 80, label: 'DynamoDB Local' },
-};
-/** The wanted tools that are not downloaded yet (`has` says whether a folder in <data>\tools exists), with their rough size. */
-export const pendingDownloads = (wanted, has) => {
-    const missing = [...new Set(wanted)].filter((w) => Object.hasOwn(DOWNLOADS, w) && !has(DOWNLOADS[w].dir));
-    return { names: missing.map((w) => DOWNLOADS[w].label ?? w), mb: missing.reduce((sum, w) => sum + DOWNLOADS[w].mb, 0) };
-};
-const roughSize = (mb) => (mb >= 950 ? (Math.round(mb / 100) / 10) + ' GB' : Math.max(10, Math.round(mb / 10) * 10) + ' MB');
-/** The heads-up before the wait, or null when everything is already downloaded. first: nothing was ever installed. */
-export const firstStartNotice = (first, pending) => {
-    if (!first && !pending.names.length)
-        return null;
-    const what = pending.names.length ? ' (about ' + roughSize(pending.mb) + ': ' + pending.names.slice(0, 8).join(', ') + (pending.names.length > 8 ? ', ...' : '') + ')' : '';
-    return first
-        ? 'First start: the sandbox downloads the tools this project needs once' + what + '. This can take 5-20 minutes depending on your connection; later starts take about a minute.'
-        : 'New tools for this project: the sandbox downloads them once' + what + '. This can take a few minutes; later starts skip it.';
-};

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

@@ -1,32 +0,0 @@
-import { attachTerminal } from '../../host/attach.js';
-import type { SandboxStatus } from '../../core/types.js';
-import { type Context } from './context.js';
-import { type Joined } from './project.js';
-/** Attaches this terminal; with attach.autoHide the sandbox window hides meanwhile (best effort, never fails the attach). */
-export declare const attachHere: (ctx: Context, session: Parameters<typeof attachTerminal>[0]) => Promise<number>;
-/** The sandbox writes sandbox.json a few seconds into its boot; a second launch right after the first waits for it. */
-export declare const runningSandboxStatus: (dataPath: string) => Promise<SandboxStatus>;
-/**
- * Waits for the boot with its current step and what it sets up on one line (plain lines without a terminal).
- * timed: say how long it took (a first start, where that is worth knowing).
- */
-export declare const waitForBoot: (dataPath: string, launchId: string | null, timed?: boolean) => Promise<SandboxStatus>;
-/** The running sandbox, once it is ready. */
-export declare const readySandbox: (dataPath: string) => Promise<SandboxStatus>;
-/**
- * Starts (or picks back up) a session in the folder `joined` describes. attach: show it in this terminal.
- * Exported for restart.ts, which reopens the sessions a restart ended.
- */
-export declare const openSession: (ctx: Context, ready: SandboxStatus, joined: Joined, o: {
-    attach: boolean;
-    harness?: string;
-    args?: string[];
-    reuse?: boolean;
-}) => Promise<number>;
-/** A restart that adds a project: map these too, start no session at boot (restart.ts opens them), wait until ready. */
-export interface LaunchExtras {
-    extraProjects?: string[];
-    autoSession?: boolean;
-    waitUntilReady?: boolean;
-}
-export declare const launch: (ctx: Context, generateOnly?: boolean, extras?: LaunchExtras) => Promise<number>;

package/dist/cli/commands/launch.js

@@ -1,421 +0,0 @@
-// `launch` / `generate`, and what sandbox claude runs: start a sandbox, or another session in the running one. From a
-// folder the running sandbox does not have yet, the folder joins it (no restart) when it can, and otherwise a
-// restart that adds it is offered (restart.ts).
-import path from 'node:path';
-import fs from 'node:fs';
-import { select } from '@inquirer/prompts';
-import { activateAccount, activeAccount, defaultAccount } from '../../host/accounts.js';
-import { attachTerminal, findUnwatchedSession } from '../../host/attach.js';
-import { requestSession, resetRunDir, waitForReady, waitForSession } from '../../host/channel.js';
-import { describePrune, pruneStorage } from '../../host/cleanup.js';
-import { generateSandbox } from '../../host/generate.js';
-import { findSecretFiles } from '../../host/secrets.js';
-import { checkRepo, saveRepoSnapshot } from '../../host/repo-guard.js';
-import { assertCanLaunch, insideSandbox, isSandboxRunning, probeHost, spawnDetached, startSandbox } from '../../host/platform.js';
-import { NeedsRestart, readKnown, rememberProject, startRegistry } from '../../host/projects.js';
-import { ensureConpty, ensureTerminal } from '../../host/terminal.js';
-import { planView, saveActiveViews, viewSkipped, WorkspaceView } from '../../host/workspace-view/index.js';
-import { saveForwards } from '../../host/port-forward.js';
-import { saveAuditSettings } from '../../host/audit/collect.js';
-import { readDataSize, saveMarkedProjects } from '../../host/motw.js';
-import { humanBytes } from '../../core/disk.js';
-import { hideSandboxWindow, showSandboxWindow } from '../../host/window.js';
-import { readSandboxStatus } from '../../shared/rundir.js';
-import { isWithin } from '../../shared/projects.js';
-import { syncBeforeLaunch, watcherRunning } from '../../sync/watcher.js';
-import { BOOT_SETTINGS, protectionsOf } from '../../core/project-policy.js';
-import { LOCAL_CONFIG_NAME } from '../../core/local-config.js';
-import { assertSafeMapping, assertSafeWorkspace } from '../../core/safe-paths.js';
-import { dirExists, errMsg, fail, fileExists, isRootPath, sleep } from '../../core/util.js';
-import { planBootProjects } from '../../host/launch/projects.js';
-import { syncAgentCommands } from './agent-commands.js';
-import { askYesNo } from '../../core/prompt.js';
-import { autoGuestWorkspace, placeInRoot, resolveRun } from '../../core/workspace.js';
-import { planMirrorWorkspace } from '../../shared/guest-paths.js';
-import { c } from '../colors.js';
-import { follow, working } from '../progress.js';
-import { bootLine, firstStartNotice, pendingDownloads, readyIn, stillWorking } from '../boot-progress.js';
-import { requireOnPc, sandboxAlive, table } from './context.js';
-import _ from 'lodash';
-import { hereDir, joinHere, readyHere } from './project.js';
-import { offerRestart } from './restart.js';
-import { addToList, setSetting } from './user-config.js';
-import { lastStopWarning, startLife, UPDATE_RESTART_WARNING, updateRestartPending } from '../../host/stops.js';
-/** Attaches this terminal; with attach.autoHide the sandbox window hides meanwhile (best effort, never fails the attach). */
-export const attachHere = (ctx, session) => {
-    if (ctx.loaded.config.attach.autoHide && !insideSandbox())
-        void hideSandboxWindow(ctx.storageRoot, 120).catch(() => false);
-    return attachTerminal(session);
-};
-/** Nothing has been installed into this data set yet: the first start downloads every toolchain once. */
-const firstBoot = (dataPath) => !fs.existsSync(path.join(dataPath, 'tools', 'resolved-versions.json'));
-/** The first-start heads-up (also when this project needs tools not downloaded yet), or null. */
-const FIRST_BOOT = (dataPath, generated, config) => {
-    const wanted = ['node', ...Object.entries(generated.toolchains).filter(([, d]) => d.on).map(([name]) => name), ...(config.toolchains.vscode.enabled ? ['vscode'] : []), ...generated.databases.map((d) => d.database)];
-    return firstStartNotice(firstBoot(dataPath), pendingDownloads(wanted, (dir) => fs.existsSync(path.join(dataPath, 'tools', dir))));
-};
-/** The sandbox writes sandbox.json a few seconds into its boot; a second launch right after the first waits for it. */
-export const runningSandboxStatus = async (dataPath) => {
-    for (let i = 0; i < 60; i++) {
-        const status = readSandboxStatus(dataPath);
-        if (status)
-            return status;
-        await sleep(1000);
-    }
-    return fail('A Windows Sandbox is running that this tool did not start (or that uses another storage.dataName).', 'Close that sandbox window first, then run sandbox claude again.');
-};
-/**
- * Waits for the boot with its current step and what it sets up on one line (plain lines without a terminal).
- * timed: say how long it took (a first start, where that is worth knowing).
- */
-export const waitForBoot = async (dataPath, launchId, timed = false) => {
-    let status = null;
-    const start = Date.now();
-    const ready = await follow(() => bootLine(status), () => waitForReady(dataPath, launchId, sandboxAlive, () => undefined, (s) => { if (s.phase !== 'failed')
-        status = s; }), { stall: stillWorking });
-    if (timed)
-        console.log(readyIn(Date.now() - start));
-    return ready;
-};
-/** The running sandbox, once it is ready. */
-export const readySandbox = async (dataPath) => {
-    const status = await runningSandboxStatus(dataPath);
-    return status.phase === 'ready' ? status : waitForBoot(dataPath, status.launchId);
-};
-/** Waits for a session to start (its project's setup, the agent's install) with its progress on a spinner. */
-const waitForStart = (ctx, requestId, what) => {
-    let step = 'starting';
-    const shown = () => ({ line: what + ': ' + step, key: step, what: step });
-    return follow(shown, () => waitForSession(ctx.dataPath, requestId, sandboxAlive, 60 * 60 * 1000, (m) => { step = m; }), { stall: stillWorking });
-};
-/**
- * Starts (or picks back up) a session in the folder `joined` describes. attach: show it in this terminal.
- * Exported for restart.ts, which reopens the sessions a restart ended.
- */
-export const openSession = async (ctx, ready, joined, o) => {
-    const { options, loaded, dataPath } = ctx;
-    const cwd = joined.guestDir;
-    const harness = o.harness ?? options.harness ?? joined.harness ?? loaded.config.defaultHarness;
-    const args = o.args ?? options.passthrough;
-    // -t with nothing new for the agent: pick up this folder's session if no terminal on this PC shows it (its tab was
-    // closed, or you detached). Someone already attached, --new, or agent arguments: a new session, as before.
-    const reuse = (o.reuse ?? true) && o.attach && !options.newSession && args.length === 0 && loaded.config.attach.reuseSession;
-    const existing = reuse ? await findUnwatchedSession(dataPath, harness, cwd) : null;
-    if (existing) {
-        console.log('Reattaching to ' + harness + ' session ' + existing.id + ' in ' + cwd + ' (no other terminal is attached; --new starts another).');
-        return attachHere(ctx, existing);
-    }
-    console.log(joined.spec
-        ? 'Starting ' + harness + ' for ' + joined.project?.host + ' in the running sandbox (' + cwd + '; the first time sets up what it needs).'
-        : 'Sandbox already running: starting another ' + harness + ' session in ' + cwd);
-    // The agent's definition goes along: the sandbox may have booted with another agent.
-    const harnessSpec = loaded.config.harnesses[harness];
-    const requestId = requestSession(dataPath, harness, args, cwd, { ...(joined.spec ? { project: joined.spec } : {}), ...(harnessSpec ? { harnessSpec } : {}) });
-    const session = await waitForStart(ctx, requestId, 'Starting ' + harness + ' in ' + cwd);
-    if (o.attach)
-        return attachHere(ctx, session);
-    console.log('Session ' + session.id + ' opened in a new tab inside the sandbox. Attach here with: sandbox attach ' + session.id + (ready.headless ? '   (headless: sbx-show opens the window)' : ''));
-    return 0;
-};
-/** The sessions a launch asks for: each --session, else one (the agent, in this folder). */
-const wantedSessions = (ctx) => ctx.options.sessions.length ? ctx.options.sessions : [{ harness: ctx.options.harness, folder: hereDir(ctx) }];
-/** The same command, for one of its sessions (its folder, agent, and the arguments after -- plus its own). */
-const contextFor = (ctx, want) => ({ ...ctx, options: { ...ctx.options, workspace: want.folder, harness: want.harness, sessions: [], passthrough: [...ctx.options.passthrough, ...(want.args ?? [])] } });
-/** Several sessions at once: all requested together (projects set up in parallel), then listed; -t attaches the first. */
-const openSessions = async (ctx, ready, list) => {
-    const { dataPath, loaded, options } = ctx;
-    const requests = list.map(({ ctx: at, joined }) => {
-        const harness = at.options.harness ?? joined.harness ?? loaded.config.defaultHarness;
-        const harnessSpec = loaded.config.harnesses[harness];
-        const id = requestSession(dataPath, harness, at.options.passthrough, joined.guestDir, { ...(joined.spec ? { project: joined.spec } : {}), ...(harnessSpec ? { harnessSpec } : {}) });
-        return { id, harness, folder: at.options.workspace ?? joined.guestDir, cwd: joined.guestDir };
-    });
-    let started = 0;
-    const results = await working(() => 'Starting ' + requests.length + ' sessions (' + started + ' running)', () => Promise.allSettled(requests.map(async (r) => {
-        const s = await waitForSession(dataPath, r.id, sandboxAlive, 60 * 60 * 1000, () => undefined);
-        started++;
-        return s;
-    })));
-    table([['SESSION', 'AGENT', 'FOLDER', ''], ...requests.map((r, i) => {
-            const result = results[i];
-            return [r.id, r.harness, r.folder, result.status === 'fulfilled' ? 'running   sandbox attach ' + r.id : c.red('FAILED: ' + errMsg(result.reason))];
-        })]);
-    const first = results.find((r) => r.status === 'fulfilled');
-    if (options.terminal && first)
-        return attachHere(ctx, first.value);
-    if (!first)
-        return 1;
-    console.log('Each has its own tab inside the sandbox' + (ready.headless ? ' (headless: sbx-show opens the window)' : '') + '. Attach to any of them, from any terminal: sandbox attach');
-    return results.every((r) => r.status === 'fulfilled') ? 0 : 1;
-};
-/** A sandbox is already running: open the sessions in it (new tabs inside; optionally attach here). */
-const launchIntoRunning = async (ctx) => {
-    const ready = await readySandbox(ctx.dataPath);
-    const wants = wantedSessions(ctx);
-    // Every folder joins first: when one needs a restart, nothing has been started that the restart would end.
-    const joined = [];
-    const needs = [];
-    for (const want of wants) {
-        const at = ctx.options.sessions.length ? contextFor(ctx, want) : ctx;
-        try {
-            joined.push({ ctx: at, joined: await joinHere(at, ready) });
-        }
-        catch (e) {
-            if (!(e instanceof NeedsRestart))
-                throw e;
-            if (!needs.some((n) => n.hostDir.toLowerCase() === e.hostDir.toLowerCase()))
-                needs.push(e);
-        }
-    }
-    if (needs.length)
-        return offerRestart(ctx, needs, () => launchIntoRunning(ctx));
-    for (const note of _.uniq(joined.flatMap((j) => j.joined.notes)))
-        console.log(note);
-    if (joined.length === 1)
-        return openSession(joined[0].ctx, ready, joined[0].joined, { attach: ctx.options.terminal });
-    return openSessions(ctx, ready, joined);
-};
-/** `sandbox start` while one runs: this folder joins it (set up, no agent), or a restart that adds it is offered. */
-const startIntoRunning = async (ctx) => {
-    const ready = await readySandbox(ctx.dataPath);
-    let joined;
-    try {
-        joined = await readyHere(ctx, ready);
-    }
-    catch (e) {
-        if (e instanceof NeedsRestart)
-            return offerRestart(ctx, [e], () => startIntoRunning(ctx));
-        throw e;
-    }
-    const where = joined.spec ? ' This folder is ready in it as ' + joined.guestDir + ' (sbx-shell ' + joined.spec.name + ' opens a terminal there inside).' : '';
-    console.log('A sandbox is already running' + (showSandboxWindow(ctx.storageRoot) ? '; its window is in front now.' : '.') + where + ' Start an agent in it with sandbox claude (or sandbox <agent>); stop it with sandbox stop.');
-    return 0;
-};
-const syncSummary = (config, dataPath, workspaceHost) => {
-    try {
-        const s = syncBeforeLaunch(config, dataPath, workspaceHost);
-        return s.history + ' file(s) of history in, claude-mem ' + s.claudeMem;
-    }
-    catch (e) {
-        return 'FAILED: ' + errMsg(e);
-    }
-};
-/**
- * Asked once per parent folder: map it at every start (a project root), so the projects next to this one open in the
- * running sandbox without a restart. The answer is saved to your config.
- */
-const maybeAddRoot = async (ctx, run) => {
-    const { projects } = run.config;
-    const parent = path.dirname(run.workspaceHost);
-    if (!projects.askToAddRoot || ctx.options.yes || !process.stdin.isTTY || !process.stdout.isTTY)
-        return;
-    if (projects.roots.some((r) => isWithin(r, run.workspaceHost)) || projects.declinedRoots.some((d) => isWithin(d, parent) && isWithin(parent, d)))
-        return;
-    if (isRootPath(parent))
-        return;
-    try {
-        assertSafeWorkspace(parent, ctx.packageRoot, run.storageRoot);
-        assertSafeMapping(parent, ctx.packageRoot, run.storageRoot);
-    }
-    catch {
-        return;
-    }
-    const answer = await select({
-        message: 'Map ' + parent + ' at every start, so other projects there (also new ones) open in the running sandbox without a restart? Agents in the sandbox can then see every project in it.',
-        choices: [
-            { name: 'Yes, from now on', value: 'yes' },
-            { name: 'No (and do not ask again for this folder)', value: 'no' },
-            { name: 'Never ask this again', value: 'never' },
-        ],
-    });
-    if (answer === 'yes') {
-        addToList(ctx, ['projects', 'roots'], parent);
-        run.config.projects.roots.push(parent);
-        console.log('Added ' + parent + ' to projects.roots (sandbox projects roots remove ' + parent + ' undoes it).');
-        // From now on this project is under the root's folder inside the sandbox, from this start on (one move, not two).
-        const before = run.config.guestWorkspace;
-        const derived = [autoGuestWorkspace(run.workspaceHost), planMirrorWorkspace(run.workspaceHost, autoGuestWorkspace(run.workspaceHost)).guest];
-        // In place: the caller holds run.config already.
-        if (derived.some((g) => g.toLowerCase() === before.toLowerCase()))
-            run.config.guestWorkspace = placeInRoot(run.config, run.workspaceHost, Boolean(run.mirror), run.notes).guestWorkspace;
-        if (run.config.guestWorkspace !== before)
-            console.log('Inside the sandbox this project is now at ' + run.config.guestWorkspace + ' (was ' + before + '): git worktrees made at the old place need `git worktree repair` once.');
-    }
-    if (answer === 'no')
-        addToList(ctx, ['projects', 'declinedRoots'], parent);
-    if (answer === 'never')
-        setSetting(ctx, ['projects', 'askToAddRoot'], false);
-};
-/**
- * workspaceFilter: brings the project's filtered view in step before the sandbox maps it, and tells the background
- * watcher to keep it in step while the sandbox runs. Returns the line for the launch table.
- */
-const prepareWorkspaceView = async (ctx, run) => {
-    const plan = planView(run.config, ctx.storageRoot, run.workspaceHost);
-    saveActiveViews(ctx.storageRoot, ctx.dataPath, plan ? [plan.options] : []);
-    saveForwards(ctx.storageRoot, ctx.dataPath, run.config.sandbox.networking ? run.config.network.forwardPorts : []);
-    saveAuditSettings(ctx.storageRoot, ctx.dataPath, { ...run.config.audit, projects: [run.workspaceHost] });
-    saveMarkedProjects(ctx.storageRoot, ctx.dataPath, run.config.storage.markSandboxFiles ? [run.workspaceHost] : []);
-    const size = readDataSize(ctx.storageRoot, ctx.dataPath);
-    const limit = run.config.storage.warnDataGb;
-    if (limit > 0 && size && size.bytes > limit * 1024 ** 3)
-        console.warn(c.yellow('The persisted data takes ' + humanBytes(size.bytes) + ' (more than storage.warnDataGb, ' + limit + ' GB). See what: sandbox data; free space: sandbox data clean <what>.'));
-    if (!plan)
-        return viewSkipped(run.config, run.workspaceHost) ?? 'off (git-ignored files are visible in the sandbox; workspaceFilter.enabled keeps them out)';
-    const stats = await working('Preparing the workspace without its git-ignored files', () => new WorkspaceView(plan.options).prepare());
-    return 'on: git-ignored files stay on this PC' + (stats.toView || stats.toHost ? ' (' + stats.toView + ' copied in, ' + stats.toHost + ' out' + (stats.conflicts ? ', ' + stats.conflicts + ' conflicts kept next to the file' : '') + ')' : '') + '; ' + plan.options.view;
-};
-/** Everything a real launch does before the sandbox starts (skipped by `generate`, which only writes files). */
-const prepare = async (ctx, run) => {
-    const { options, dataPath, storageRoot } = ctx;
-    const { config } = run;
-    const account = options.account ?? defaultAccount(storageRoot);
-    if (account && run.harnessName === 'claude' && account !== activeAccount(dataPath))
-        activateAccount(storageRoot, dataPath, account);
-    const terminal = config.provisioning.terminal.enabled ? await ensureTerminal(dataPath, config.provisioning.refresh, { pwsh: config.toolchains.pwsh.enabled !== false }) : { exe: null, message: 'disabled' };
-    const conpty = config.provisioning.conpty.enabled ? await ensureConpty(dataPath, config.provisioning.refresh) : 'off';
-    const history = syncSummary(config, dataPath, run.workspaceHost);
-    const guarded = checkRepo(dataPath);
-    if (guarded.length)
-        console.warn(c.yellow('SECURITY: neutralised ' + guarded.length + ' change(s) the last sandbox made that could run code on this PC (see sandbox status).'));
-    const stopped = lastStopWarning(storageRoot, dataPath, watcherRunning(dataPath));
-    if (stopped)
-        console.warn(c.yellow(stopped));
-    if (updateRestartPending())
-        console.warn(c.yellow(UPDATE_RESTART_WARNING));
-    resetRunDir(dataPath);
-    const filter = await prepareWorkspaceView(ctx, run);
-    return { account, terminal: terminal.message + '; pseudo console: ' + conpty, history, pruned: describePrune(pruneStorage(storageRoot)), filter };
-};
-/**
- * The other projects mapped at boot (a restart's, --session's, projects.all's, and the known projects in your roots),
- * with their effective configs: only approved .sandbox-config.json files and the looser values you allowed for each
- * (nothing is asked here). The sandbox boots with what they want too (generate.ts).
- */
-const bootWantsFor = async (ctx, run, extraProjects) => {
-    const { roots } = run.config.projects;
-    const planned = planBootProjects({ run, packageRoot: ctx.packageRoot, extraProjects }).projects.map((p) => p.host);
-    const inRoots = readKnown(run.storageRoot).map((k) => k.host).filter((h) => roots.some((r) => isWithin(path.resolve(r), h)));
-    const folders = _.uniqBy([...(extraProjects ?? []).map((p) => path.resolve(p)), ...planned, ...inRoots], (f) => f.toLowerCase())
-        .filter((f) => !isWithin(run.workspaceHost, f) && dirExists(f)).slice(0, 200);
-    const projects = [];
-    const notes = [];
-    for (const folder of folders) {
-        try {
-            const other = await resolveRun({ packageRoot: ctx.packageRoot, loaded: ctx.loaded, cwd: folder, workspace: folder, noAgent: true, noLocalConfig: false, trustConfig: false, scripts: [] });
-            projects.push({ name: path.basename(folder), config: other.config });
-        }
-        catch (e) {
-            if (fileExists(path.join(folder, LOCAL_CONFIG_NAME)))
-                notes.push('What ' + path.basename(folder) + ' asks for at boot is not included: ' + errMsg(e).split('\n')[0]);
-        }
-    }
-    const keepOff = BOOT_SETTINGS.filter((s) => _.get(ctx.loaded.config, s) === true && _.get(run.config, s) === false);
-    return { wants: { projects, keepOff }, notes };
-};
-export const launch = async (ctx, generateOnly = false, extras = {}) => {
-    const { options, loaded, packageRoot, dataPath, storageRoot } = ctx;
-    // attach.auto: an agent started from an interactive terminal attaches it, as with -t.
-    if (loaded.config.attach.auto && !options.noAgent && process.stdin.isTTY && process.stdout.isTTY)
-        options.terminal = true;
-    if (!generateOnly)
-        requireOnPc('launch');
-    // agentCommands (Beta) follows the config: a setting changed in the file takes effect here too. Never blocks a launch.
-    if (!generateOnly) {
-        try {
-            syncAgentCommands(ctx, loaded.config);
-        }
-        catch (e) {
-            console.warn('Agent commands (Beta): ' + errMsg(e));
-        }
-    }
-    if (!generateOnly && isSandboxRunning())
-        return options.noAgent ? startIntoRunning(ctx) : launchIntoRunning(ctx);
-    // Several sessions: the sandbox starts from the first one's folder with the others' folders mapped too, then
-    // they all open in it (each project is set up on demand, in parallel). One --session is an ordinary launch.
-    const wants = options.sessions;
-    if (wants.length === 1)
-        return launch(contextFor(ctx, wants[0]), generateOnly, extras);
-    if (wants.length > 1) {
-        const first = contextFor(ctx, wants[0]);
-        const others = _.uniqBy(wants.slice(1).map((w) => w.folder).filter((f) => !isWithin(wants[0].folder, f)), (f) => f.toLowerCase());
-        const started = await launch({ ...first, options: { ...first.options, terminal: false } }, generateOnly, { ...extras, extraProjects: [...(extras.extraProjects ?? []), ...others], autoSession: false, waitUntilReady: true });
-        return generateOnly || started !== 0 ? started : launchIntoRunning(ctx);
-    }
-    const run = await resolveRun({
-        packageRoot, loaded, cwd: process.cwd(), workspace: options.workspace, harness: options.harness, noAgent: options.noAgent,
-        noLocalConfig: options.noLocalConfig, trustConfig: options.trustConfig, scripts: options.scripts, databases: options.databases, headless: options.headless,
-        nodeVersion: options.node, pythonVersion: options.python, ask: askYesNo,
-    });
-    const { config } = run;
-    if (!generateOnly)
-        assertCanLaunch();
-    if (!generateOnly && !extras.extraProjects)
-        await maybeAddRoot(ctx, run);
-    const prepared = generateOnly ? null : await prepare(ctx, run);
-    const bootWants = await bootWantsFor(ctx, run, extras.extraProjects);
-    const generated = generateSandbox({ packageRoot, run, harnessArgs: options.passthrough, probe: probeHost(config, run.harnessName), extraProjects: extras.extraProjects, autoSession: extras.autoSession, bootWants: bootWants.wants });
-    // What the sandbox boots with (the launch folder's settings plus what the other projects at boot want).
-    const booted = generated.bootConfig;
-    for (const note of [...run.notes, ...bootWants.notes, ...generated.projects.notes, ...generated.mappingNotes])
-        console.log(note);
-    const secretFiles = config.secrets.warnFiles ? findSecretFiles(run.workspaceHost) : [];
-    if (secretFiles.length) {
-        const shown = secretFiles.slice(0, 12).join(', ') + (secretFiles.length > 12 ? ', ...' : '');
-        console.warn(c.yellow('Heads-up: the agent can read these files in your workspace, which often hold secrets: ' + shown + '. Move real credentials out of the folder (or use test ones). Silence with secrets.warnFiles = false.'));
-    }
-    const { roots, projects } = generated.projects;
-    table([
-        ['Workspace', run.workspaceHost + '  ->  ' + config.guestWorkspace + (config.readOnly ? '  (read-only)' : '')],
-        ['Agent', 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' : '')],
-        ['Node', run.versions.node.spec + ' (' + run.versions.node.source + ')   Python: ' + run.versions.python.spec + ' (' + run.versions.python.source + ')'],
-        ...(prepared ? [['Ignored files', prepared.filter], ['Terminal', prepared.terminal], ['History', prepared.history], ['Cleanup', prepared.pruned]] : []),
-        ['Toolchains', Object.entries(generated.toolchains).filter(([, d]) => d.on).map(([name, d]) => name + ' (' + d.reason + ')').join(', ') || 'Node only (nothing else used by this project)'],
-        ...(generated.databases.length
-            ? 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)' : '')])
-            : [['Databases', 'none needed (databases.<name>.enabled = true adds one)']]),
-        ['Desktop', generated.personalization],
-        ['Claude', generated.profile.staged.length ? generated.profile.staged.join(', ') + (generated.profile.credentials ? '  (INCLUDING YOUR LOGIN)' : '') : 'no settings copied'],
-        ['Secrets', !config.secrets.strip ? 'NOT stripped (secrets.strip is off)' : generated.profile.secretsRemoved.length ? 'kept on this PC: ' + generated.profile.secretsRemoved.join(', ') + '  (secrets.allow lets one through)' : 'none found in what is copied'],
-        ...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 !== 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 + ')' : '')]),
-        ['Generated', generated.wsbPath],
-    ]);
-    if (generateOnly)
-        return 0;
-    // Every folder the sandbox can write is snapshotted before it starts (the guard compares against this), and the
-    // projects it starts with are recorded host-side for the commands that run later.
-    saveRepoSnapshot(dataPath, run.workspaceHost, projects.map((p) => p.host), roots.map((r) => r.host));
-    startRegistry(storageRoot, { launchId: generated.launchId, protections: protectionsOf(booted), primary: { host: run.workspaceHost, guest: config.guestWorkspace }, roots, boot: projects,
-        atBoot: { memoryMb: generated.memoryMb, mappings: generated.mappings, widened: generated.widened } });
-    rememberProject(storageRoot, run.workspaceHost);
-    startLife(storageRoot, dataPath, config.sandbox.keepAwake);
-    startSandbox(generated.wsbPath);
-    // Absolute: the watcher runs from another folder, and a relative --config there would make it exit silently.
-    if (!watcherRunning(dataPath))
-        spawnDetached(ctx.entry, ['_watch', ...(options.config ? ['--config', path.resolve(options.config)] : [])]);
-    // Hiding runs alongside; a failure to find the window must never break the launch or an attach.
-    const hidden = config.sandbox.headless ? hideSandboxWindow(storageRoot).catch(() => false) : null;
-    const headsUp = FIRST_BOOT(dataPath, generated, config);
-    if (options.terminal || options.noAgent || extras.waitUntilReady) {
-        if (headsUp)
-            console.log(headsUp);
-        await waitForBoot(dataPath, generated.launchId, Boolean(headsUp));
-        if (extras.waitUntilReady)
-            return 0;
-        // Without an agent there is no session to attach to: the sandbox itself is the result.
-        if (options.noAgent) {
-            console.log('Sandbox ready. Its window has a terminal in ' + config.guestWorkspace + '; from here: sandbox exec -- <command>, sandbox stop.');
-            return 0;
-        }
-        return attachHere(ctx, await waitForStart(ctx, generated.launchId, 'Starting ' + run.harnessName));
-    }
-    if (headsUp)
-        console.log(headsUp + '\nFollow along: sandbox logs -f');
-    if (hidden)
-        console.log(await hidden ? 'Sandbox running headless. Open the window: sbx-show   Attach here: sandbox claude -t' : 'Could not find the sandbox window to hide (it may still be starting); run sandbox hide in a moment.');
-    else
-        console.log('Sandbox starting. ' + run.harnessName + ' opens in Windows Terminal inside it. Attach here any time: sandbox claude -t');
-    return 0;
-};

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

@@ -1,10 +0,0 @@
-import { type Context } from './context.js';
-export declare const sync: (ctx: Context) => number;
-export declare const logs: (ctx: Context) => Promise<number>;
-export declare const clean: (ctx: Context) => number;
-export declare const config: (ctx: Context) => number;
-export declare const doctor: (ctx: Context) => number;
-export declare const claudeHost: (ctx: Context) => number;
-export declare const watcher: (ctx: Context) => Promise<void>;
-/** `sandbox audit`: the audit log of the last days (audit.enabled), newest last. */
-export declare const audit: (ctx: Context) => Promise<number>;