windows-development-sandbox 1.4.0 → 1.4.3

package/dist/cli/commands/project.js

@@ -1,63 +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 { askYesNo } from '../../core/prompt.js';
-import { isInsideOrEqual } from '../../core/util.js';
-import { resolveRun } from '../../core/workspace.js';
-import { prepareProject } from '../../host/channel.js';
-import { projectHere, readRegistry } from '../../host/projects.js';
-import { joinRunning } from '../../host/join.js';
-import { working } from '../progress.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.
- */
-export const joinHere = async (ctx, status) => {
-    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: [] };
-    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,
-        }),
-    });
-    const harness = joined.run && joined.run.harnessName !== 'none' ? joined.run.harnessName : null;
-    return { project: joined.project, guestDir: joined.guestDir, spec: joined.spec, harness, notes: joined.notes };
-};
-/** 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,85 +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 { 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);
-    for (const need of needs)
-        console.log(c.yellow('Windows Sandbox cannot add ' + need.hostDir + ' while it runs: ' + need.reason + '.'));
-    console.log('A restart maps ' + (needs.length === 1 ? 'it' : 'them') + ' as well (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(folders.map((f) => path.dirname(f))))
-        console.log(c.dim('No restart next time for folders in ' + parent + ': sandbox projects roots add "' + parent + '"'));
-    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-    if (!ctx.options.yes) {
-        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.
-    const { launch, openSession, readySandbox } = await import('./launch.js');
-    const { joinHere } = await import('./project.js');
-    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);
-                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>;

package/dist/cli/commands/sessions.js

@@ -1,257 +0,0 @@
-// Working with a running sandbox: attach, sessions, status, exec, restart, stop, show/hide. Each knows which project
-// you run it from (project.ts): attach and sessions put that project's sessions first, exec and db run in it, restart
-// restarts its sessions, stop warns about the other projects' sessions.
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { select } from '@inquirer/prompts';
-import _ from 'lodash';
-import { askYesNo } from '../../core/prompt.js';
-import { activeAccount } from '../../host/accounts.js';
-import { execInSandbox, pickSession, pingSandbox, restartSessions, currentSessions, runningSessions, sessionsFirstIn } from '../../host/channel.js';
-import { sessionViewers } from '../../host/attach.js';
-import { insideSandbox, isSandboxRunning } from '../../host/platform.js';
-import { NeedsRestart, readRegistry } from '../../host/projects.js';
-import { guardedProjects, repoFindings } from '../../host/repo-guard.js';
-import { hideSandboxWindow, showSandboxWindow } from '../../host/window.js';
-import { isWithin, projectForGuestDir } from '../../shared/projects.js';
-import { listProjectStatus, listSessions, readSandboxStatus } from '../../shared/rundir.js';
-import { watcherRunning } from '../../sync/watcher.js';
-import { errMsg, fail, safeText, sleep } from '../../core/util.js';
-import { printJson, requireOnPc, requireRunning, sandboxAlive, table } from './context.js';
-import { attachHere, readySandbox } from './launch.js';
-import { hereDir, joinHere, locateHere, provisionJoined } from './project.js';
-import { working } from '../progress.js';
-import { ago, c, shortenMiddle, termWidth } from '../colors.js';
-const viewerText = (v) => (v === undefined ? '-' : v === null ? 'unknown (older session)' : v.remote + ' here, ' + (v.viewers - v.remote) + ' in sandbox');
-const projectOf = (projects, s) => s.project ?? projectForGuestDir(projects, s.cwd)?.name ?? '-';
-export const attach = async (ctx) => {
-    requireOnPc('attach');
-    requireRunning('Start one with: sandbox claude --terminal');
-    const ready = await readySandbox(ctx.dataPath);
-    const id = ctx.options.positionals[0];
-    if (!id && runningSessions(ctx.dataPath).length === 0)
-        await sleep(1500);
-    const here = locateHere(ctx, ready);
-    if (id)
-        return attachHere(ctx, pickSession(ctx.dataPath, id));
-    // Several sessions: choose, this folder's project first (the newest is the default).
-    const running = sessionsFirstIn(runningSessions(ctx.dataPath), here.guestDir);
-    if (running.length > 1 && process.stdin.isTTY && process.stdout.isTTY) {
-        const projects = readRegistry(ctx.storageRoot)?.projects ?? [];
-        const chosen = await select({
-            message: 'Which session?' + (here.project ? ' (' + here.project.name + ' first)' : ''),
-            choices: running.map((s) => ({ value: s.id, name: (here.guestDir && isWithin(here.guestDir, s.cwd) ? '* ' : '  ') + safeText(s.harness).padEnd(9) + ' ' + safeText(projectOf(projects, s)).padEnd(16) + ' ' + ago(s.startedAt).padEnd(11) + ' ' + s.id })),
-        });
-        return attachHere(ctx, pickSession(ctx.dataPath, chosen));
-    }
-    return attachHere(ctx, pickSession(ctx.dataPath, undefined, here.guestDir));
-};
-/** Sessions with who is watching them; `here` marks the ones in the project of the current folder. */
-const listedSessions = async (ctx) => {
-    // Who is attached comes from each session itself, so a terminal that was closed is never counted.
-    const live = isSandboxRunning();
-    // Only this sandbox's sessions are asked (and at most MAX_QUERIED_SESSIONS): the sandbox writes these files.
-    const ask = new Set(live ? currentSessions(ctx.dataPath).map((s) => s.id) : []);
-    const here = live ? locateHere(ctx, readSandboxStatus(ctx.dataPath)) : { guestDir: null };
-    const projects = readRegistry(ctx.storageRoot)?.projects ?? [];
-    return Promise.all(listSessions(ctx.dataPath).map(async (s) => ({
-        ...s, projectName: projectOf(projects, s), here: Boolean(here.guestDir && isWithin(here.guestDir, s.cwd)),
-        ...(ask.has(s.id) ? { viewers: await sessionViewers(s) } : {}),
-    })));
-};
-export const sessions = async (ctx) => {
-    const list = await listedSessions(ctx);
-    if (printJson(ctx, list.map((s) => _.omit(s, 'attach'))))
-        return 0;
-    if (list.length === 0) {
-        console.log('No sessions. Start one with: sandbox claude');
-        return 0;
-    }
-    // This folder's project first, newest first within each group; harness, cwd and times are written by the sandbox.
-    const ordered = [..._.sortBy(list.filter((s) => s.here), (s) => s.startedAt).reverse(), ..._.sortBy(list.filter((s) => !s.here), (s) => s.startedAt).reverse()];
-    const folderWidth = Math.max(16, termWidth() - 80);
-    table([['', 'ID', 'AGENT', 'PROJECT', 'STATE', 'ATTACHED', 'FOLDER', 'STARTED'], ...ordered.map((s) => [
-            s.here ? '*' : '', s.id, safeText(s.harness), safeText(s.projectName ?? '-'), s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : ''), viewerText(s.viewers), shortenMiddle(safeText(s.cwd), folderWidth), ago(s.startedAt),
-        ])]);
-    if (list.some((s) => s.here))
-        console.log(c.dim('* = the project of this folder'));
-    return 0;
-};
-/** Running databases by port, from the sandbox's own `sbx-db list` (best effort: unknown when it does not answer). */
-const runningPorts = async (ctx, cwd) => {
-    try {
-        const r = await execInSandbox(ctx.dataPath, ['sbx-db', 'list'], cwd, 30, sandboxAlive);
-        return new Set((r.stdout ?? '').split(/\r?\n/).filter((l) => /\brunning\b/.test(l)).map((l) => Number(/port (\d+)/.exec(l)?.[1])).filter((n) => n > 0));
-    }
-    catch {
-        return null;
-    }
-};
-export const status = async (ctx) => {
-    const running = isSandboxRunning();
-    const sandbox = readSandboxStatus(ctx.dataPath);
-    const registry = running ? readRegistry(ctx.storageRoot) : null;
-    const ready = running && sandbox?.phase === 'ready';
-    const daemon = ready ? await pingSandbox(ctx.dataPath, sandboxAlive).then((r) => r.message, (e) => 'no answer (' + errMsg(e) + ')') : '-';
-    const here = running ? locateHere(ctx, sandbox) : { project: null, guestDir: null };
-    const sessionList = running ? await listedSessions(ctx) : [];
-    const provisioning = running ? listProjectStatus(ctx.dataPath) : [];
-    const ports = ready && sandbox ? await runningPorts(ctx, sandbox.guestWorkspace) : null;
-    const findings = repoFindings(ctx.dataPath);
-    const startedAt = Number(/^(\d+)-/.exec(registry?.launchId ?? sandbox?.launchId ?? '')?.[1]) || null;
-    const projects = (registry?.projects ?? []).map((p) => {
-        const prov = provisioning.find((s) => s.name.toLowerCase() === p.name.toLowerCase());
-        const own = sessionList.filter((s) => s.phase === 'running' && projectForGuestDir(registry?.projects ?? [], s.cwd)?.name === p.name);
-        return {
-            name: p.name, host: p.host, guest: p.guest, mechanism: p.mechanism, here: here.project?.name === p.name,
-            setup: prov ? { phase: prov.phase, message: safeText(prov.message) } : { phase: 'not set up yet', message: 'set up when you first start a session or command there' },
-            databases: (prov?.databases ?? []).map((d) => ({ database: safeText(d.database), port: d.port, state: ports ? (ports.has(d.port) ? 'running' : 'stopped') : 'unknown' })),
-            sessions: own.map((s) => ({ id: s.id, harness: safeText(s.harness), viewers: viewerText(s.viewers), started: s.startedAt })),
-            // With several guarded folders each finding starts with its folder.
-            repoGuard: findings.filter((f) => f.detail.toLowerCase().startsWith(p.host.toLowerCase() + ':')).map((f) => f.kind + ': ' + safeText(f.detail)),
-        };
-    });
-    const info = {
-        sandbox: {
-            running, phase: running ? sandbox?.phase ?? 'unknown' : 'stopped', message: sandbox?.message, headless: sandbox?.headless,
-            uptime: running && startedAt ? ago(startedAt).replace(' ago', '') : null, daemon, account: activeAccount(ctx.dataPath), syncWatcher: watcherRunning(ctx.dataPath),
-        },
-        here: { folder: hereDir(ctx), project: here.project?.name ?? null, guest: here.guestDir },
-        roots: registry?.roots ?? [],
-        projects,
-        otherSessions: sessionList.filter((s) => s.phase === 'running' && !projects.some((p) => p.sessions.some((x) => x.id === s.id))).map((s) => ({ id: s.id, harness: safeText(s.harness), cwd: safeText(s.cwd) })),
-        repoGuard: { guarded: guardedProjects(ctx.dataPath).length, findings: findings.map((f) => f.kind + ': ' + f.detail) },
-    };
-    if (printJson(ctx, info))
-        return 0;
-    const yesNo = (v) => (typeof v === 'boolean' ? (v ? 'yes' : 'no') : String(v ?? '-'));
-    table(Object.entries(info.sandbox).map(([k, v]) => [_.startCase(k), safeText(yesNo(v))]));
-    if (!running)
-        return 0;
-    console.log('\n' + c.bold('Projects') + c.dim('  (* = this folder: ' + info.here.folder + (info.here.project ? '' : ', not in this sandbox') + ')'));
-    for (const p of projects) {
-        console.log((p.here ? '* ' : '  ') + c.bold(p.name) + '  ' + p.host + '  ->  ' + p.guest + c.dim('  (' + (p.mechanism === 'launch' ? 'started from here' : p.mechanism === 'root' ? 'in a project root' : p.mechanism === 'boot' ? 'mapped at start' : 'wsb share') + ')'));
-        console.log('      setup: ' + p.setup.phase + (p.setup.phase === 'ready' ? '' : ' - ' + shortenMiddle(p.setup.message, termWidth() - 20)));
-        if (p.databases.length)
-            console.log('      databases: ' + p.databases.map((d) => d.database + ' :' + d.port + ' ' + d.state).join(', '));
-        for (const s of p.sessions)
-            console.log('      session ' + s.id + '  ' + s.harness + '  ' + s.viewers + '  ' + ago(s.started));
-        for (const f of p.repoGuard)
-            console.log('      ' + c.yellow('guard: ' + f));
-    }
-    for (const r of info.roots)
-        console.log('  root  ' + r.host + '  ->  ' + r.guest + c.dim('  (every project in it opens without a restart)'));
-    for (const s of info.otherSessions)
-        console.log('  session ' + s.id + '  ' + s.harness + '  ' + s.cwd);
-    console.log('\n' + c.bold('Repo guard') + '  ' + info.repoGuard.guarded + ' folder(s) guarded; ' + (findings.length ? c.yellow(findings.length + ' change(s) neutralised:') : 'nothing from the sandbox needed neutralising'));
-    for (const f of info.repoGuard.findings.slice(-10))
-        console.log('  ' + c.yellow(safeText(f)));
-    return 0;
-};
-/** What a command run in the sandbox printed (text from the sandbox: through safeText), or why it failed. */
-const printExecResult = (result) => {
-    if (result.stdout)
-        process.stdout.write(safeText(result.stdout));
-    if (result.stderr)
-        process.stderr.write(safeText(result.stderr));
-    if (!result.ok && !result.stdout && !result.stderr)
-        console.error(safeText(result.message));
-};
-/** The guest folder for this folder, joining the running sandbox (and setting the project up) when needed. */
-const guestFolderHere = async (ctx, what) => {
-    const ready = await readySandbox(ctx.dataPath);
-    try {
-        const joined = await joinHere(ctx, ready);
-        for (const note of joined.notes)
-            console.error(note);
-        await provisionJoined(ctx, joined);
-        return joined.guestDir;
-    }
-    catch (e) {
-        if (!(e instanceof NeedsRestart))
-            throw e;
-        return fail(hereDir(ctx) + ' is not in the running sandbox (' + e.reason + '), so "sandbox ' + what + '" cannot run there.', 'sandbox claude (or sandbox start) from that folder offers a restart that adds it; or add its parent folder as a root: sandbox projects roots add "' + path.dirname(e.hostDir) + '"');
-    }
-};
-export const exec = async (ctx) => {
-    const command = [...ctx.options.positionals, ...ctx.options.passthrough];
-    if (command.length === 0)
-        fail('No command given.', 'Usage: sandbox exec [--timeout <s>] -- <command> [args...]');
-    requireOnPc('exec');
-    requireRunning();
-    const cwd = await guestFolderHere(ctx, 'exec');
-    const result = await execInSandbox(ctx.dataPath, command, cwd, ctx.options.timeout, sandboxAlive);
-    if (!printJson(ctx, result))
-        printExecResult(result);
-    return result.exitCode ?? 1;
-};
-/** `sandbox db`: runs the sandbox's own `sbx-db` in this folder's project, which knows its database versions and ports. */
-export const db = async (ctx) => {
-    const [action = 'list', name] = ctx.options.positionals;
-    if (!['list', 'start', 'stop'].includes(action))
-        fail('Unknown db action "' + action + '".', 'Use: sandbox db  (list)  or  sandbox db start|stop <postgres|mysql|mongodb|redis|dynamodb>');
-    if (action !== 'list' && !name)
-        fail('Which database?', 'Usage: sandbox db ' + action + ' <postgres|mysql|mongodb|redis|dynamodb>');
-    // Already inside the sandbox: run the database tool here instead of asking the sandbox from outside.
-    if (insideSandbox())
-        return spawnSync(process.execPath, [path.join(ctx.packageRoot, 'dist', 'runtime', 'db.js'), action, ...(name ? [name] : [])], { stdio: 'inherit', windowsHide: true }).status ?? 1;
-    requireRunning('Start one with: sandbox start --database <name>');
-    const cwd = await guestFolderHere(ctx, 'db');
-    // Starting can download the database the first time.
-    const result = await working((action === 'list' ? 'Asking' : action === 'start' ? 'Starting' : 'Stopping') + ' the database' + (name ? ' ' + name : 's') + ' in the sandbox', () => execInSandbox(ctx.dataPath, ['sbx-db', action, ...(name ? [name] : [])], cwd, 1800, sandboxAlive));
-    printExecResult(result);
-    return result.exitCode ?? 1;
-};
-/** Restarts this folder's project's sessions (--all: every session). */
-export const restart = async (ctx) => {
-    requireOnPc('restart');
-    requireRunning();
-    const here = locateHere(ctx, readSandboxStatus(ctx.dataPath));
-    const scope = ctx.options.all || !here.project ? undefined : here.project.guest;
-    if (!scope && !ctx.options.all)
-        console.log(c.dim(hereDir(ctx) + ' is not a project of the running sandbox: restarting every session.'));
-    console.log(safeText((await working('Restarting the agents' + (scope ? ' of ' + here.project?.name : ''), () => restartSessions(ctx.dataPath, ctx.options.harness ?? null, sandboxAlive, scope))).message));
-    return 0;
-};
-export const stop = async (ctx) => {
-    requireOnPc('stop');
-    if (!isSandboxRunning()) {
-        console.log('No Windows Sandbox is running.');
-        return 0;
-    }
-    const sandbox = readSandboxStatus(ctx.dataPath) ?? fail('This sandbox was not started by this tool.', 'Close its window instead.');
-    // Stopping ends every project's sessions, not just this folder's: say which, and ask when others would end too.
-    const here = locateHere(ctx, sandbox);
-    const running = currentSessions(ctx.dataPath);
-    const others = running.filter((s) => !(here.guestDir && isWithin(here.project?.guest ?? here.guestDir, s.cwd)));
-    if (running.length)
-        console.log('Stopping ends ' + running.length + ' session(s): ' + running.map((s) => safeText(s.harness) + ' in ' + safeText(s.project ?? path.win32.basename(s.cwd))).join(', ') + '.');
-    if (others.length && !ctx.options.yes) {
-        // A script must never end other projects' sessions by accident: without a terminal to ask in, it needs --yes.
-        const interactive = process.stdin.isTTY && process.stdout.isTTY;
-        if (!interactive)
-            fail(others.length + ' of these sessions belong to other projects, so the sandbox was not stopped.', 'Stop it anyway with: sandbox stop --yes');
-        if (!(await askYesNo(others.length + ' of them belong to other projects. Stop the whole sandbox?'))) {
-            console.log('Nothing changed.');
-            return 1;
-        }
-    }
-    await working('Asking the sandbox to shut down', () => execInSandbox(ctx.dataPath, ['C:\\Windows\\System32\\shutdown.exe', '/s', '/t', '2'], sandbox.guestWorkspace, 30, sandboxAlive));
-    console.log('Sandbox is shutting down; history and claude-mem sync back when it closes.');
-    return 0;
-};
-export const show = (ctx) => {
-    requireOnPc('show');
-    requireRunning();
-    if (!showSandboxWindow(ctx.storageRoot))
-        fail('Could not find the Windows Sandbox window.', 'It may still be starting; try again in a few seconds.');
-    return 0;
-};
-export const hide = async (ctx) => {
-    requireOnPc('hide');
-    requireRunning();
-    if (!(await hideSandboxWindow(ctx.storageRoot, 5)))
-        fail('Could not find a visible Windows Sandbox window.', 'It may already be hidden (sbx-show brings it back).');
-    console.log('Sandbox window hidden. Bring it back with: sbx-show');
-    return 0;
-};