windows-development-sandbox 1.4.0 → 1.4.3

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

@@ -3,24 +3,40 @@
 // sandbox is running.
 import path from 'node:path';
 import _ from 'lodash';
-import { DEFAULTS, loadConfig, userDir } from '../../../core/config.js';
-import { errMsg, expandPath, UserError } from '../../../core/util.js';
-import { isSandboxRunning } from '../../../host/platform.js';
-import { createContext, printJson, table } from '../context.js';
+import { DEFAULTS, loadConfig, userDir } from '../../../core/config/index.js';
+import { errMsg, expandPath, UserError } from '../../../core/util/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { createContext } from '../context.js';
+import { printJson, table } from '../../output/index.js';
 import { CHECKS } from './checks.js';
-const LABEL = { ok: 'OK', fixed: 'FIXED', 'needs-you': 'NEEDS YOU', warn: 'WARNING', skipped: 'SKIPPED' };
+const LABEL = {
+    ok: 'OK',
+    fixed: 'FIXED',
+    'needs-you': 'NEEDS YOU',
+    warn: 'WARNING',
+    skipped: 'SKIPPED',
+};
 /** Runs every check in order; a check that throws is reported, never stops the rest. */
-export const runChecks = (env, checks = CHECKS) => checks.map((check) => {
-    try {
-        return { name: check.name, ...check.run(env) };
-    }
-    catch (e) {
-        const fix = e instanceof UserError && e.fix ? ' ' + e.fix : '';
-        return { name: check.name, status: 'needs-you', detail: 'check failed: ' + errMsg(e) + fix };
-    }
-});
-export const repair = (ctx, configError = null) => {
-    const env = { ctx, running: isSandboxRunning(), dataPath: ctx.dataPath, storageRoot: ctx.storageRoot, toolsDir: path.join(ctx.dataPath, 'tools'), configError };
+export function runChecks(env, checks = CHECKS) {
+    return checks.map((check) => {
+        try {
+            return { name: check.name, ...check.run(env) };
+        }
+        catch (e) {
+            const fix = e instanceof UserError && e.fix ? ' ' + e.fix : '';
+            return { name: check.name, status: 'needs-you', detail: 'check failed: ' + errMsg(e) + fix };
+        }
+    });
+}
+export function repair(ctx, configError = null) {
+    const env = {
+        ctx,
+        running: isSandboxRunning(),
+        dataPath: ctx.dataPath,
+        storageRoot: ctx.storageRoot,
+        toolsDir: path.join(ctx.dataPath, 'tools'),
+        configError,
+    };
     // Re-check the config file even when the context loaded (it may have been edited since, or come from --config).
     if (!env.configError) {
         try {
@@ -38,14 +54,17 @@ export const repair = (ctx, configError = null) => {
         return results.some((r) => r.status === 'needs-you') ? 1 : 0;
     table(results.map((r) => [LABEL[r.status], r.name, r.detail]));
     const counts = _.countBy(results, 'status');
-    console.log('\n' + (counts['needs-you'] ? counts['needs-you'] + ' thing(s) need you (see NEEDS YOU above).' : 'All good' + (counts.fixed ? ': fixed ' + counts.fixed + ' problem(s).' : '.')));
+    console.log('\n' +
+        (counts['needs-you']
+            ? counts['needs-you'] + ' thing(s) need you (see NEEDS YOU above).'
+            : 'All good' + (counts.fixed ? ': fixed ' + counts.fixed + ' problem(s).' : '.')));
     return counts['needs-you'] ? 1 : 0;
-};
+}
 /**
  * Entry point that works even when the config file is broken (createContext would throw): falls back to the built-in
  * defaults so the other checks still run, and reports the config problem as the first check.
  */
-export const repairCommand = (packageRoot, entry, options) => {
+export function repairCommand(packageRoot, entry, options) {
     let ctx;
     try {
         ctx = createContext(packageRoot, entry, options);
@@ -55,7 +74,14 @@ export const repairCommand = (packageRoot, entry, options) => {
             throw e;
         const loaded = { config: structuredClone(DEFAULTS), configPath: null, base: userDir() };
         const storageRoot = expandPath(loaded.config.storage.root, loaded.base);
-        return repair({ packageRoot, entry, options, loaded, storageRoot, dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName) }, e);
+        return repair({
+            packageRoot,
+            entry,
+            options,
+            loaded,
+            storageRoot,
+            dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName),
+        }, e);
     }
     return repair(ctx);
-};
+}

package/dist/cli/commands/repair/types.d.ts

@@ -1,4 +1,4 @@
-import type { UserError } from '../../../core/util.js';
+import type { UserError } from '../../../core/util/index.js';
 import type { Context } from '../context.js';
 export type RepairStatus = 'ok' | 'fixed' | 'needs-you' | 'warn' | 'skipped';
 export interface RepairResult {
@@ -18,7 +18,7 @@ export interface RepairCheck {
     name: string;
     run: (env: RepairEnv) => Omit<RepairResult, 'name'>;
 }
-export declare const ok: (detail: string) => Omit<RepairResult, "name">;
+export declare function ok(detail: string): Omit<RepairResult, 'name'>;
 /** For fixes that must not touch folders a running sandbox may be using. */
 export declare const whileRunning: {
     status: "skipped";

package/dist/cli/commands/repair/types.js

@@ -1,3 +1,8 @@
-export const ok = (detail) => ({ status: 'ok', detail });
+export function ok(detail) {
+    return { status: 'ok', detail };
+}
 /** For fixes that must not touch folders a running sandbox may be using. */
-export const whileRunning = { status: 'skipped', detail: 'a sandbox is running and may be using it; run repair again once it is closed' };
+export const whileRunning = {
+    status: 'skipped',
+    detail: 'a sandbox is running and may be using it; run repair again once it is closed',
+};

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

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

package/dist/cli/commands/sessions/attach.js

@@ -0,0 +1,45 @@
+import { select } from '@inquirer/prompts';
+import { SandboxChannel, sessionsFirstIn } from '../../../host/channel/index.js';
+import { ProjectRegistry } from '../../../host/projects/index.js';
+import { isWithin } from '../../../shared/paths/index.js';
+import { safeText, sleep } from '../../../core/util/index.js';
+import { requireOnPc, requireRunning } from '../context.js';
+import { attachHere, readySandbox } from '../launch/index.js';
+import { locateHere } from '../projects/index.js';
+import { ago } from '../../output/index.js';
+import { projectOf } from './list.js';
+/** Asks which session to attach to, this folder's project first (the newest is the default). */
+function chooseSession(ctx, running, here) {
+    const projects = new ProjectRegistry(ctx.storageRoot).read()?.projects ?? [];
+    return 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,
+        })),
+    });
+}
+export async function attach(ctx) {
+    requireOnPc('attach');
+    requireRunning('Start one with: sandbox claude --terminal');
+    const ready = await readySandbox(ctx.dataPath);
+    const channel = new SandboxChannel(ctx.dataPath);
+    const id = ctx.options.positionals[0];
+    if (!id && channel.runningSessions().length === 0)
+        await sleep(1500);
+    const here = locateHere(ctx, ready);
+    if (id)
+        return attachHere(ctx, channel.pickSession(id));
+    // Several sessions: choose, this folder's project first (the newest is the default).
+    const running = sessionsFirstIn(channel.runningSessions(), here.guestDir);
+    if (running.length > 1 && process.stdin.isTTY && process.stdout.isTTY)
+        return attachHere(ctx, channel.pickSession(await chooseSession(ctx, running, here)));
+    return attachHere(ctx, channel.pickSession(undefined, here.guestDir));
+}

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

@@ -0,0 +1,4 @@
+import { type Context } from '../context.js';
+/** Restarts this folder's project's sessions (--all: every session). */
+export declare function restart(ctx: Context): Promise<number>;
+export declare function stop(ctx: Context): Promise<number>;

package/dist/cli/commands/sessions/control.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import { askYesNo } from '../../../core/prompt.js';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { isWithin } from '../../../shared/paths/index.js';
+import { RunDir } from '../../../shared/channel/index.js';
+import { fail, safeText } from '../../../core/util/index.js';
+import { requireOnPc, requireRunning } from '../context.js';
+import { hereDir, locateHere } from '../projects/index.js';
+import { working, c } from '../../output/index.js';
+/** Restarts this folder's project's sessions (--all: every session). */
+export async function restart(ctx) {
+    requireOnPc('restart');
+    requireRunning();
+    const here = locateHere(ctx, new RunDir(ctx.dataPath).readSandboxStatus());
+    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 : ''), () => new SandboxChannel(ctx.dataPath).restart(ctx.options.harness ?? null, scope))).message));
+    return 0;
+}
+/**
+ * Stopping ends every project's sessions: other projects' sessions need a yes (or --yes). A script must never end them
+ * by accident, so without a terminal to ask in it fails.
+ */
+async function othersMayEnd(ctx, others) {
+    if (!others.length || ctx.options.yes)
+        return true;
+    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');
+    return askYesNo(others.length + ' of them belong to other projects. Stop the whole sandbox?');
+}
+export async function stop(ctx) {
+    requireOnPc('stop');
+    if (!isSandboxRunning()) {
+        console.log('No Windows Sandbox is running.');
+        return 0;
+    }
+    const sandbox = new RunDir(ctx.dataPath).readSandboxStatus() ??
+        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 channel = new SandboxChannel(ctx.dataPath);
+    const running = channel.currentSessions();
+    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 (!(await othersMayEnd(ctx, others))) {
+        console.log('Nothing changed.');
+        return 1;
+    }
+    await working('Asking the sandbox to shut down', () => channel.exec(['C:\\Windows\\System32\\shutdown.exe', '/s', '/t', '2'], sandbox.guestWorkspace, 30));
+    console.log('Sandbox is shutting down; history and claude-mem sync back when it closes.');
+    return 0;
+}

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

@@ -0,0 +1,6 @@
+import { type Context } from '../context.js';
+export declare function 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 function db(ctx: Context): Promise<number>;

package/dist/cli/commands/sessions/exec.js

@@ -0,0 +1,72 @@
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { insideSandbox } from '../../../host/sandbox/index.js';
+import { NeedsRestart } from '../../../host/projects/index.js';
+import { fail, safeText } from '../../../core/util/index.js';
+import { printJson, working } from '../../output/index.js';
+import { requireOnPc, requireRunning } from '../context.js';
+import { readySandbox } from '../launch/index.js';
+import { hereDir, joinHere, provisionJoined } from '../projects/index.js';
+/** What a command run in the sandbox printed (text from the sandbox: through safeText), or why it failed. */
+function 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. */
+async function guestFolderHere(ctx, what) {
+    const ready = await readySandbox(ctx.dataPath);
+    try {
+        // A command needs no restart for what the project wants at boot: it runs without them (and says so).
+        const joined = await joinHere(ctx, ready, { noRestart: true });
+        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 async function exec(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 new SandboxChannel(ctx.dataPath).exec(command, cwd, ctx.options.timeout);
+    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 async function db(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', () => new SandboxChannel(ctx.dataPath).exec(['sbx-db', action, ...(name ? [name] : [])], cwd, 1800));
+    printExecResult(result);
+    return result.exitCode ?? 1;
+}

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

@@ -0,0 +1,6 @@
+export * from './attach.js';
+export * from './list.js';
+export * from './status.js';
+export * from './exec.js';
+export * from './control.js';
+export * from './window.js';

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

@@ -0,0 +1,9 @@
+// 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.
+export * from './attach.js';
+export * from './list.js';
+export * from './status.js';
+export * from './exec.js';
+export * from './control.js';
+export * from './window.js';

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

@@ -0,0 +1,15 @@
+import type { SessionStatus } from '../../../core/types.js';
+import type { Viewers } from '../../../shared/pty/index.js';
+import { type RegistryEntry } from '../../../host/projects/index.js';
+import { type Context } from '../context.js';
+export declare function viewerText(v: Viewers | null | undefined): string;
+export declare function projectOf(projects: RegistryEntry[], s: SessionStatus): string;
+/** A session with who is watching it and whether it is in the project of the current folder. */
+export type ListedSession = SessionStatus & {
+    readonly viewers?: Viewers | null;
+    readonly here?: boolean;
+    readonly projectName?: string;
+};
+/** Sessions with who is watching them; `here` marks the ones in the project of the current folder. */
+export declare function listedSessions(ctx: Context): Promise<ListedSession[]>;
+export declare function sessions(ctx: Context): Promise<number>;

package/dist/cli/commands/sessions/list.js

@@ -0,0 +1,65 @@
+import _ from 'lodash';
+import { SandboxChannel, sessionViewers } from '../../../host/channel/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { ProjectRegistry } from '../../../host/projects/index.js';
+import { isWithin, projectForGuestDir } from '../../../shared/paths/index.js';
+import { RunDir } from '../../../shared/channel/index.js';
+import { safeText } from '../../../core/util/index.js';
+import { printJson, table, ago, c, shortenMiddle, termWidth } from '../../output/index.js';
+import { locateHere } from '../projects/index.js';
+export function viewerText(v) {
+    return v === undefined
+        ? '-'
+        : v === null
+            ? 'unknown (older session)'
+            : v.remote + ' here, ' + (v.viewers - v.remote) + ' in sandbox';
+}
+export function projectOf(projects, s) {
+    return s.project ?? projectForGuestDir(projects, s.cwd)?.name ?? '-';
+}
+/** Sessions with who is watching them; `here` marks the ones in the project of the current folder. */
+export async function listedSessions(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 ? new SandboxChannel(ctx.dataPath).currentSessions().map((s) => s.id) : []);
+    const here = live ? locateHere(ctx, new RunDir(ctx.dataPath).readSandboxStatus()) : { guestDir: null };
+    const projects = new ProjectRegistry(ctx.storageRoot).read()?.projects ?? [];
+    return Promise.all(new RunDir(ctx.dataPath).listSessions().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 async function sessions(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;
+}

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

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

package/dist/cli/commands/sessions/status.js

@@ -0,0 +1,153 @@
+import _ from 'lodash';
+import { AccountStore } from '../../../host/profile/index.js';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { ProjectRegistry } from '../../../host/projects/index.js';
+import { RepoGuardStore } from '../../../host/guard/index.js';
+import { projectForGuestDir } from '../../../shared/paths/index.js';
+import { RunDir } from '../../../shared/channel/index.js';
+import { watcherRunning } from '../../../sync/index.js';
+import { errMsg, safeText } from '../../../core/util/index.js';
+import { printJson, table, ago, c, shortenMiddle, termWidth } from '../../output/index.js';
+import { hereDir, locateHere } from '../projects/index.js';
+import { listedSessions, viewerText } from './list.js';
+/** Running databases by port, from the sandbox's own `sbx-db list` (best effort: unknown when it does not answer). */
+async function runningPorts(channel, cwd) {
+    try {
+        const r = await channel.exec(['sbx-db', 'list'], cwd, 30);
+        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;
+    }
+}
+/** One project: its setup, databases, running sessions and repo guard findings (sandbox text through safeText). */
+function projectInfo(p, all, facts) {
+    const prov = facts.provisioning.find((s) => s.name.toLowerCase() === p.name.toLowerCase());
+    const own = facts.sessions.filter((s) => s.phase === 'running' && projectForGuestDir(all, s.cwd)?.name === p.name);
+    const { ports } = facts;
+    return {
+        name: p.name,
+        host: p.host,
+        guest: p.guest,
+        mechanism: p.mechanism,
+        here: facts.here === 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: facts.findings
+            .filter((f) => f.detail.toLowerCase().startsWith(p.host.toLowerCase() + ':'))
+            .map((f) => f.kind + ': ' + safeText(f.detail)),
+    };
+}
+const MECHANISM_TEXT = {
+    launch: 'started from here',
+    root: 'in a project root',
+    boot: 'mapped at start',
+};
+function mechanismText(mechanism) {
+    return mechanism in MECHANISM_TEXT ? MECHANISM_TEXT[mechanism] : 'wsb share';
+}
+function printProject(p) {
+    console.log((p.here ? '* ' : '  ') +
+        c.bold(p.name) +
+        '  ' +
+        p.host +
+        '  ->  ' +
+        p.guest +
+        c.dim('  (' + mechanismText(p.mechanism) + ')'));
+    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));
+}
+export async function status(ctx) {
+    const running = isSandboxRunning();
+    const run = new RunDir(ctx.dataPath);
+    const channel = new SandboxChannel(ctx.dataPath);
+    const guard = new RepoGuardStore(ctx.dataPath);
+    const sandbox = run.readSandboxStatus();
+    const registry = running ? new ProjectRegistry(ctx.storageRoot).read() : null;
+    const ready = running && sandbox?.phase === 'ready';
+    const daemon = ready
+        ? await channel.ping().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 ? run.listProjectStatus() : [];
+    const ports = ready && sandbox ? await runningPorts(channel, sandbox.guestWorkspace) : null;
+    const findings = guard.findings();
+    const startedAt = Number(/^(\d+)-/.exec(registry?.launchId ?? sandbox?.launchId ?? '')?.[1]) || null;
+    const all = registry?.projects ?? [];
+    const facts = { here: here.project?.name ?? null, provisioning, sessions: sessionList, ports, findings };
+    const projects = all.map((p) => projectInfo(p, all, facts));
+    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: new AccountStore(ctx.storageRoot).activeFor(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: guard.guarded().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)
+        printProject(p);
+    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;
+}

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

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

package/dist/cli/commands/sessions/window.js

@@ -0,0 +1,18 @@
+import { hideSandboxWindow, showSandboxWindow } from '../../../host/sandbox/index.js';
+import { fail } from '../../../core/util/index.js';
+import { requireOnPc, requireRunning } from '../context.js';
+export function 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 async function hide(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;
+}

package/dist/cli/commands/setup/checks.d.ts

@@ -6,8 +6,8 @@ export interface Check {
     detail: string;
 }
 /** Windows Sandbox needs Pro, Enterprise or Education (build 18305+); Home ("Core*") and Server cannot run it. */
-export declare const editionSupport: (edition: string | null) => EditionSupport;
-export declare const nodeMajor: (version: string) => number;
+export declare function editionSupport(edition: string | null): EditionSupport;
+export declare function nodeMajor(version: string): number;
 /** Offer to enable the feature only when it is off and this edition can have it. */
-export declare const canEnableFeature: (f: MachineFacts) => boolean;
-export declare const buildChecks: (f: MachineFacts) => Check[];
+export declare function canEnableFeature(f: MachineFacts): boolean;
+export declare function buildChecks(f: MachineFacts): Check[];