windows-development-sandbox 1.4.1 → 1.4.3

package/dist/cli/commands/maintenance.js

@@ -1,220 +0,0 @@
-// sync, logs, clean, config, doctor, host-claude and the internal sync watcher.
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import _ from 'lodash';
-import { DEFAULTS, userConfigPath, userDir } from '../../core/config.js';
-import { allowedAnswer, allowStorePath, applyOverrides, describeOverrides, isTrusted, LOCAL_CONFIG_NAME, loosenedRequests, normalizeOverrides, OUTSIDE_FOLDER, outsideKey, outsideMappings, readLocalConfig, trustStorePath } from '../../core/local-config.js';
-import { guestWorkspaceOf, previewGuest } from '../../core/workspace.js';
-import { assertNoLinks, dirExists, expandPath, fail, plainText, safeText, sleep, writeJson } from '../../core/util.js';
-import { humanBytes } from '../../core/disk.js';
-import { AuditLog } from '../../host/audit/log.js';
-import { readKnown, readRegistry } from '../../host/projects.js';
-import { detectWsb } from '../../host/wsb.js';
-import { describePrune, pruneStorage } from '../../host/cleanup.js';
-import { doctorRows, hostClaude, insideSandbox, isSandboxRunning } from '../../host/platform.js';
-import { readSandboxStatus } from '../../shared/rundir.js';
-import { syncBack, watch } from '../../sync/watcher.js';
-import { printJson, table } from './context.js';
-import { c } from '../colors.js';
-export const 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;
-};
-const 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 const logs = async (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;
-};
-export const clean = (ctx) => {
-    const running = isSandboxRunning() ? readSandboxStatus(ctx.dataPath)?.launchId : undefined;
-    console.log('Cleanup: ' + describePrune(pruneStorage(ctx.storageRoot, { launchDays: ctx.options.days, keep: _.compact([running]) })));
-    return 0;
-};
-const 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).
- */
-const 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.
- */
-const 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));
-    // What a launch from here would do with each folder and each looser setting, without launching.
-    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 rows = (overrides.mappings ?? []).map((m) => {
-        const where = previewGuest(m, dir, workspaceGuest);
-        const status = !dirExists(m.host) ? (m.optional ? 'not on this PC: skipped' : c.red('the folder does not exist: create it, fix the path, or add "optional": true'))
-            : !outside.includes(m) ? (m.guest ? 'inside the project' : 'inside the project (already in the sandbox there)')
-                : policy === true ? 'outside the project, allowed (projects.allowOutsideMappings is true)'
-                    : policy === false ? c.red('outside the project: refused (projects.allowOutsideMappings is false)')
-                        : allowedAnswer(store, file.path, OUTSIDE_FOLDER, outsideKey(m)) === true ? 'outside the project, allowed (you said yes)'
-                            : c.yellow('outside the project: the next interactive launch asks you');
-        return [(m.readOnly ? 'ro ' : 'rw ') + safeText(m.host), '->  ' + safeText(where.guest), status];
-    });
-    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, file.path, 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'));
-    }
-    return 0;
-};
-export const 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');
-    }
-};
-export const 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() ? readRegistry(ctx.storageRoot) : 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: ' + readKnown(ctx.storageRoot).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;
-};
-export const claudeHost = (ctx) => hostClaude(ctx.storageRoot, ctx.options.personal, ctx.options.passthrough);
-export const watcher = (ctx) => watch(ctx.dataPath);
-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 const audit = async (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/project.d.ts

@@ -1,33 +0,0 @@
-import type { SandboxStatus } from '../../core/types.js';
-import { type Missing } from '../../core/project-policy.js';
-import { type RegistryEntry } from '../../host/projects.js';
-import type { ProjectSpecT } from '../../shared/schema.js';
-import { type Context } from './context.js';
-/** The folder the command is about: --workspace, else the current one. */
-export declare const 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 const locateHere: (ctx: Context, status: SandboxStatus | null) => Located;
-export interface Joined {
-    project: RegistryEntry | null;
-    guestDir: string;
-    spec: ProjectSpecT | null;
-    harness: string | null;
-    notes: string[];
-}
-/** restart.ts: the sandbox was restarted for a project in this command. */
-export declare const markRestarted: () => void;
-export declare const 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 const 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 const 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 const provisionJoined: (ctx: Context, joined: Joined) => Promise<void>;
-/** joinHere, then (for another project) waits until the sandbox has set it up. */
-export declare const readyHere: (ctx: Context, status: SandboxStatus) => Promise<Joined>;

package/dist/cli/commands/project.js

@@ -1,102 +0,0 @@
-// 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/project-policy.js';
-import { askYesNo } from '../../core/prompt.js';
-import { isInsideOrEqual } from '../../core/util.js';
-import { resolveRun } from '../../core/workspace.js';
-import { currentSessions, prepareProject } from '../../host/channel.js';
-import { projectHere, readRegistry } from '../../host/projects.js';
-import { joinRunning } from '../../host/join.js';
-import { c } from '../colors.js';
-import { working } from '../progress.js';
-import { describeSessions } from './restart.js';
-import { guestPathFor, sandboxAlive } from './context.js';
-/** The folder the command is about: --workspace, else the current one. */
-export const hereDir = (ctx) => 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 const locateHere = (ctx, status) => {
-    const dir = hereDir(ctx);
-    const here = projectHere(ctx.storageRoot, dir);
-    if (here)
-        return here;
-    // A sandbox started before projects existed: only its launch folder.
-    if (!readRegistry(ctx.storageRoot) && status && isInsideOrEqual(status.workspaceHost, dir))
-        return { project: null, guestDir: guestPathFor(dir, status.workspaceHost, status.guestWorkspace) };
-    return { project: null, guestDir: null };
-};
-/**
- * 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.ts) when that is impossible without a restart.
- */
-let restartedOnce = false;
-/** restart.ts: the sandbox was restarted for a project in this command. */
-export const markRestarted = () => { restartedOnce = true; };
-export const joinHere = async (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 (!readRegistry(storageRoot))
-        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,
-        }),
-        // 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 = currentSessions(dataPath);
-            return select({
-                message: 'What now?',
-                choices: [
-                    { name: 'Continue anyway (join without them)', value: 'continue' },
-                    { name: 'Restart with them (' + (sessions.length ? describeSessions(sessions) + ' will end' : 'no session is running') + ')', 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 const restartCommand = (ctx, host) => 'sandbox ' + (ctx.options.noAgent ? 'start' : ctx.options.harness ?? ctx.loaded.config.defaultHarness) + ' --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 const missingNotes = (ctx, name, host, missing, shown = false) => [
-    ...(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 const provisionJoined = async (ctx, joined) => {
-    if (!joined.spec)
-        return;
-    const spec = joined.spec;
-    let step = 'starting';
-    await working(() => 'Setting up ' + spec.name + ' in the running sandbox: ' + step, () => prepareProject(ctx.dataPath, spec, sandboxAlive, (m) => { step = m; }));
-};
-/** joinHere, then (for another project) waits until the sandbox has set it up. */
-export const readyHere = async (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.d.ts

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

package/dist/cli/commands/projects.js

@@ -1,146 +0,0 @@
-// `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.js';
-import { isSandboxRunning } from '../../host/platform.js';
-import { forgetProject, projectMapper, readKnown, readRegistry, rememberProject } from '../../host/projects.js';
-import { isWithin } from '../../shared/projects.js';
-import { c, pageSizeFor, shortenMiddle, termWidth } from '../colors.js';
-import { printJson, table } from './context.js';
-import { hereDir } from './project.js';
-import { addToList, removeFromList, setSetting } from './user-config.js';
-const 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 const projectRows = (ctx) => {
-    const s = settings(ctx);
-    const registry = isSandboxRunning() ? readRegistry(ctx.storageRoot) : null;
-    const here = hereDir(ctx);
-    const folders = [...readKnown(ctx.storageRoot).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: readKnown(ctx.storageRoot).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.';
-const runningNote = () => (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. */
-const 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;
-};
-const 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. */
-const choose = async (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;
-};
-export const projects = async (ctx) => {
-    const [action = 'list', value, folder] = ctx.options.positionals;
-    switch (action) {
-        case 'list': return list(ctx);
-        case 'choose': return choose(ctx);
-        case 'add': {
-            const dir = checkFolder(ctx, value, 'a project');
-            rememberProject(ctx.storageRoot, 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;
-        }
-        case 'remove': {
-            const dir = path.resolve(value);
-            const forgot = forgetProject(ctx.storageRoot, dir);
-            // The running sandbox forgets it too (its folder stays visible until the sandbox stops, if it was mapped).
-            const registered = isSandboxRunning() ? readRegistry(ctx.storageRoot)?.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;
-        }
-        case 'include':
-        case 'exclude': {
-            const dir = path.resolve(value);
-            const changed = action === 'exclude' ? addToList(ctx, ['projects', 'exclude'], dir) : removeFromList(ctx, ['projects', 'exclude'], dir);
-            if (action === 'include')
-                rememberProject(ctx.storageRoot, 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;
-        }
-        case 'all': {
-            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;
-        }
-        case 'roots': {
-            if (!value || value === 'list') {
-                const roots = settings(ctx).roots;
-                console.log(roots.length ? roots.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;
-        }
-        default: return fail('Unknown projects action "' + action + '".');
-    }
-};

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

@@ -1,6 +0,0 @@
-import type { SessionStatus } from '../../core/types.js';
-import { type NeedsRestart } from '../../host/projects.js';
-import { type Context } from './context.js';
-/** "2 sessions (claude in api, codex in web)". */
-export declare const describeSessions: (sessions: Pick<SessionStatus, "harness" | "cwd" | "project">[]) => string;
-export declare const offerRestart: (ctx: Context, needs: NeedsRestart[], then: () => Promise<number>) => Promise<number>;

package/dist/cli/commands/restart.js

@@ -1,95 +0,0 @@
-// The last way in for a folder the running sandbox cannot show (not in a project root, no `wsb share`): restart it
-// with that folder mapped as well. Only ever with your consent (a prompt, or --yes): it lists what will end, stops
-// the sandbox cleanly (history and claude-mem sync back as on any close), starts it again from the same launch
-// folder with the projects it had plus the new one, reopens the sessions it ended (continuing their conversations
-// where the agent supports it) and then starts the new project's session.
-import path from 'node:path';
-import _ from 'lodash';
-import { missingTip } from '../../core/project-policy.js';
-import { askYesNo } from '../../core/prompt.js';
-import { fail, safeText, sleep } from '../../core/util.js';
-import { currentSessions, execInSandbox } from '../../host/channel.js';
-import { isSandboxRunning } from '../../host/platform.js';
-import { readRegistry } from '../../host/projects.js';
-import { hostDirFor, projectForGuestDir } from '../../shared/projects.js';
-import { readSandboxStatus } from '../../shared/rundir.js';
-import { watcherRunning } from '../../sync/watcher.js';
-import { c } from '../colors.js';
-import { working } from '../progress.js';
-import { sandboxAlive } from './context.js';
-/** "2 sessions (claude in api, codex in web)". */
-export const describeSessions = (sessions) => 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(', ') + ')';
-/** The command to run again with consent, for a non-interactive terminal. */
-const againWithYes = (ctx) => 'sandbox ' + (ctx.options.noAgent ? 'start' : ctx.options.harness ?? ctx.loaded.config.defaultHarness) + (ctx.options.terminal ? ' -t' : '') + ' --yes';
-/** Where each running session is on this PC, so it can be reopened after the restart. */
-const sessionsToReopen = (registry, sessions) => sessions.flatMap((s) => {
-    const project = projectForGuestDir([...registry.projects, ...registry.roots.map((r) => ({ ...r }))], s.cwd);
-    return project ? [{ harness: s.harness, hostDir: hostDirFor(project, s.cwd) }] : [];
-});
-/** Shuts the sandbox down and waits until it (and the background sync's final pass) is gone. */
-const stopAndWait = async (ctx) => {
-    const status = readSandboxStatus(ctx.dataPath);
-    await working('Stopping the sandbox (history syncs back)', async () => {
-        await execInSandbox(ctx.dataPath, ['C:\\Windows\\System32\\shutdown.exe', '/s', '/t', '0'], status?.guestWorkspace ?? 'C:\\', 30, sandboxAlive).catch(() => null);
-        for (let i = 0; i < 180 && isSandboxRunning(); i++)
-            await sleep(1000);
-        if (isSandboxRunning())
-            fail('The sandbox did not shut down within 3 minutes.', 'Close its window yourself, then run the command again.');
-        // The watcher syncs history back a few seconds after the window closes; the next start needs it gone.
-        for (let i = 0; i < 60 && watcherRunning(ctx.dataPath); i++)
-            await sleep(1000);
-    });
-};
-export const offerRestart = async (ctx, needs, then) => {
-    const folders = needs.map((n) => n.hostDir);
-    const registry = readRegistry(ctx.storageRoot) ?? fail('The running sandbox was started by an older version, so it cannot take another folder.', 'Stop it (sandbox stop) and start it again from ' + folders[0] + '.');
-    const primary = registry.projects.find((p) => p.primary) ?? fail('The running sandbox has no launch folder on record.', 'Stop it (sandbox stop) and start it again.');
-    const sessions = currentSessions(ctx.dataPath);
-    // A project that only wants boot settings or folders: you already chose the restart (or gave --yes) when asked.
-    const hidden = needs.filter((n) => !n.missing);
-    for (const need of hidden)
-        console.log(c.yellow('Windows Sandbox cannot add ' + need.hostDir + ' while it runs: ' + need.reason + '.'));
-    console.log((hidden.length ? 'A restart maps ' + (hidden.length === 1 ? 'it' : 'them') + ' as well' : 'Restarting with what ' + needs.map((n) => path.basename(n.hostDir)).join(', ') + ' wants') +
-        ' (and keeps ' + registry.projects.map((p) => p.host).join(', ') + '). ' +
-        (sessions.length ? describeSessions(sessions) + ' will end' : 'No session is running') + '; your files, tools, databases and logins are kept. It takes about a minute.');
-    for (const parent of _.uniq(hidden.map((n) => path.dirname(n.hostDir))))
-        console.log(c.dim('No restart next time for folders in ' + parent + ': sandbox projects roots add "' + parent + '"'));
-    for (const need of needs)
-        if (need.missing)
-            console.log(c.dim(missingTip(need.missing)));
-    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-    if (!ctx.options.yes && hidden.length) {
-        if (!interactive)
-            fail('Not restarting without your consent.', 'Run it again with --yes to restart: ' + againWithYes(ctx));
-        if (!(await askYesNo('Restart the sandbox now?'))) {
-            console.log('Nothing changed.');
-            return 1;
-        }
-    }
-    const reopen = sessionsToReopen(registry, sessions);
-    const resume = reopen.length > 0 && (ctx.options.yes || (await askYesNo('Reopen the ' + reopen.length + ' session(s) afterwards (continuing their conversations where the agent supports it)?', true)));
-    await stopAndWait(ctx);
-    // Imported here: launch.ts imports this file (and project.ts imports describeSessions).
-    const { launch, openSession, readySandbox } = await import('./launch.js');
-    const { joinHere, markRestarted } = await import('./project.js');
-    markRestarted();
-    const keep = registry.projects.filter((p) => !p.primary && p.mechanism !== 'root').map((p) => p.host);
-    const relaunch = { ...ctx, options: { ...ctx.options, workspace: primary.host, harness: ctx.options.harness ?? ctx.options.sessions[0]?.harness, terminal: false, noAgent: false, newSession: true, passthrough: [], sessions: [] } };
-    await launch(relaunch, false, { extraProjects: [...keep, ...folders], autoSession: false, waitUntilReady: true });
-    const ready = await readySandbox(ctx.dataPath);
-    if (resume) {
-        for (const s of reopen) {
-            const at = { ...ctx, options: { ...ctx.options, workspace: s.hostDir, harness: s.harness, terminal: false, newSession: true, passthrough: [], sessions: [] } };
-            try {
-                const joined = await joinHere(at, ready, { noRestart: true });
-                for (const note of joined.notes)
-                    console.log(note);
-                await openSession(at, ready, joined, { attach: false, harness: s.harness, args: ctx.loaded.config.harnesses[s.harness]?.resumeArguments ?? [], reuse: false });
-            }
-            catch (e) {
-                console.warn(c.yellow('Could not reopen ' + s.harness + ' in ' + s.hostDir + ': ' + (e instanceof Error ? e.message : String(e))));
-            }
-        }
-    }
-    return then();
-};

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

@@ -1,12 +0,0 @@
-import { type Context } from './context.js';
-export declare const attach: (ctx: Context) => Promise<number>;
-export declare const sessions: (ctx: Context) => Promise<number>;
-export declare const status: (ctx: Context) => Promise<number>;
-export declare const exec: (ctx: Context) => Promise<number>;
-/** `sandbox db`: runs the sandbox's own `sbx-db` in this folder's project, which knows its database versions and ports. */
-export declare const db: (ctx: Context) => Promise<number>;
-/** Restarts this folder's project's sessions (--all: every session). */
-export declare const restart: (ctx: Context) => Promise<number>;
-export declare const stop: (ctx: Context) => Promise<number>;
-export declare const show: (ctx: Context) => number;
-export declare const hide: (ctx: Context) => Promise<number>;