windows-development-sandbox 1.4.1 → 1.4.3

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

package/dist/cli/commands/setup/checks.js

@@ -2,7 +2,7 @@
 import { GB } from '../../../core/disk.js';
 import { ENABLE_COMMAND } from './facts.js';
 /** Windows Sandbox needs Pro, Enterprise or Education (build 18305+); Home ("Core*") and Server cannot run it. */
-export const editionSupport = (edition) => {
+export function editionSupport(edition) {
     if (!edition)
         return 'unknown';
     if (/^Core/i.test(edition))
@@ -10,13 +10,24 @@ export const editionSupport = (edition) => {
     if (/^Server/i.test(edition))
         return 'unsupported';
     return /^(Professional|Enterprise|Education|IoTEnterprise)/i.test(edition) ? 'supported' : 'unknown';
-};
-export const nodeMajor = (version) => Number(/^v?(\d+)/.exec(version.trim())?.[1] ?? 0);
+}
+export function nodeMajor(version) {
+    return Number(/^v?(\d+)/.exec(version.trim())?.[1] ?? 0);
+}
 /** Offer to enable the feature only when it is off and this edition can have it. */
-export const canEnableFeature = (f) => f.feature !== 'enabled' && f.feature !== 'pending' && !f.sandboxExe && ['supported', 'unknown'].includes(editionSupport(f.edition));
-const formatGb = (bytes) => (bytes / GB).toFixed(1) + ' GB';
-const check = (name, status, detail) => ({ name, status, detail });
-const editionCheck = (f) => {
+export function canEnableFeature(f) {
+    return (f.feature !== 'enabled' &&
+        f.feature !== 'pending' &&
+        !f.sandboxExe &&
+        ['supported', 'unknown'].includes(editionSupport(f.edition)));
+}
+function formatGb(bytes) {
+    return (bytes / GB).toFixed(1) + ' GB';
+}
+function check(name, status, detail) {
+    return { name, status, detail };
+}
+function editionCheck(f) {
     const support = editionSupport(f.edition);
     const edition = (f.edition ?? 'unknown edition') + (f.build ? ', build ' + f.build : '');
     const name = 'Windows edition';
@@ -29,17 +40,17 @@ const editionCheck = (f) => {
     if (support === 'supported')
         return check(name, 'action', edition + ': too old; Windows Sandbox needs Windows 10 version 1903 or newer.');
     return check(name, 'warn', edition + ': not sure this edition has Windows Sandbox (it needs Pro, Enterprise or Education).');
-};
-const virtualizationCheck = (f) => {
+}
+function virtualizationCheck(f) {
     const name = 'CPU virtualization';
     const virt = f.hypervisorPresent || f.virtualizationFirmware;
     if (virt)
         return check(name, 'ok', f.hypervisorPresent ? 'on (hypervisor running)' : 'on');
     if (virt === false)
-        return check(name, 'action', 'off. Turn on Intel VT-x / AMD-V (SVM) in your PC\'s BIOS/UEFI settings, then run this again.');
+        return check(name, 'action', "off. Turn on Intel VT-x / AMD-V (SVM) in your PC's BIOS/UEFI settings, then run this again.");
     return check(name, 'warn', 'could not tell; if Windows Sandbox will not start, turn on VT-x / AMD-V in the BIOS/UEFI.');
-};
-const featureCheck = (f) => {
+}
+function featureCheck(f) {
     const name = 'Windows Sandbox feature';
     if (f.feature === 'enabled' && f.sandboxExe)
         return check(name, 'ok', 'enabled');
@@ -48,16 +59,16 @@ const featureCheck = (f) => {
     if (f.sandboxExe)
         return check(name, 'ok', 'installed');
     return check(name, 'action', 'not enabled. In an admin PowerShell: ' + ENABLE_COMMAND + ', then restart.');
-};
-const memoryCheck = (f) => {
+}
+function memoryCheck(f) {
     const gb = formatGb(f.totalRamBytes);
     if (f.totalRamBytes < 4 * GB)
         return check('Memory', 'action', gb + ': Windows Sandbox needs at least 4 GB.');
     if (f.totalRamBytes < 8 * GB)
         return check('Memory', 'warn', gb + ': works, but 8 GB or more is recommended.');
     return check('Memory', 'ok', gb);
-};
-const diskCheck = (f) => {
+}
+function diskCheck(f) {
     if (f.freeDiskBytes === null)
         return check('Free disk', 'warn', 'could not check the drive of ' + f.storageRoot);
     const free = formatGb(f.freeDiskBytes) + ' free for ' + f.storageRoot;
@@ -66,6 +77,12 @@ const diskCheck = (f) => {
     if (f.freeDiskBytes < 20 * GB)
         return check('Free disk', 'warn', free + ': getting low; toolchains and caches can use several GB.');
     return check('Free disk', 'ok', free);
-};
-const nodeCheck = (f) => nodeMajor(f.nodeVersion) >= 20 ? check('Node.js', 'ok', f.nodeVersion) : check('Node.js', 'action', f.nodeVersion + ': needs 20 or newer (winget install OpenJS.NodeJS.LTS).');
-export const buildChecks = (f) => [editionCheck(f), virtualizationCheck(f), featureCheck(f), memoryCheck(f), diskCheck(f), nodeCheck(f)];
+}
+function nodeCheck(f) {
+    return nodeMajor(f.nodeVersion) >= 20
+        ? check('Node.js', 'ok', f.nodeVersion)
+        : check('Node.js', 'action', f.nodeVersion + ': needs 20 or newer (winget install OpenJS.NodeJS.LTS).');
+}
+export function buildChecks(f) {
+    return [editionCheck(f), virtualizationCheck(f), featureCheck(f), memoryCheck(f), diskCheck(f), nodeCheck(f)];
+}

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

@@ -16,16 +16,16 @@ export interface MachineFacts {
 }
 export declare const ENABLE_COMMAND: string;
 /** `reg query <key>` output to { valueName: data }. */
-export declare const parseRegQuery: (text: string) => Record<string, string>;
+export declare function parseRegQuery(text: string): Record<string, string>;
 /** The "State : ..." line of `Dism /Get-FeatureInfo` (English output only; anything else is unknown). */
-export declare const parseDismState: (text: string) => FeatureState;
+export declare function parseDismState(text: string): FeatureState;
 /** Win32_OptionalFeature.InstallState: 1 enabled, 2 disabled, 3 absent. */
-export declare const featureFromInstallState: (state: number | null | undefined) => FeatureState;
-declare const Probe: z.ZodObject<{
+export declare function featureFromInstallState(state: number | null | undefined): FeatureState;
+declare const ProbeSchema: z.ZodObject<{
     virtualizationFirmware: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     hypervisorPresent: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     installState: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
-export declare const parseProbe: (text: string) => z.infer<typeof Probe>;
-export declare const gatherFacts: (storageRoot: string) => MachineFacts;
+export declare function parseProbe(text: string): z.infer<typeof ProbeSchema>;
+export declare function gatherFacts(storageRoot: string): MachineFacts;
 export {};

package/dist/cli/commands/setup/facts.js

@@ -3,23 +3,29 @@ import os from 'node:os';
 import _ from 'lodash';
 import { z } from 'zod';
 import { freeBytesAt } from '../../../core/disk.js';
-import { captureOutput, fileExists } from '../../../core/util.js';
+import { captureOutput, fileExists } from '../../../core/util/index.js';
 import { SYSTEM, system32 } from '../../../shared/system.js';
 const FEATURE = 'Containers-DisposableClientVM';
 export const ENABLE_COMMAND = 'Enable-WindowsOptionalFeature -Online -FeatureName ' + FEATURE + ' -All -NoRestart';
 /** `reg query <key>` output to { valueName: data }. */
-export const parseRegQuery = (text) => Object.fromEntries(_.compact(text.split(/\r?\n/).map((line) => /^\s+(\S+)\s+REG_\w+\s+(.*)$/.exec(line)?.slice(1, 3))));
+export function parseRegQuery(text) {
+    return Object.fromEntries(_.compact(text
+        .split(/\r?\n/)
+        .map((line) => /^\s+(\S+)\s+REG_\w+\s+(.*)$/.exec(line)?.slice(1, 3))));
+}
 /** The "State : ..." line of `Dism /Get-FeatureInfo` (English output only; anything else is unknown). */
-export const parseDismState = (text) => {
+export function parseDismState(text) {
     const state = /^State\s*:\s*(.+?)\s*$/im.exec(text)?.[1].toLowerCase() ?? '';
     if (state === 'enabled')
         return 'enabled';
     if (state.includes('pending'))
         return 'pending';
     return state.startsWith('disabled') ? 'disabled' : 'unknown';
-};
+}
 /** Win32_OptionalFeature.InstallState: 1 enabled, 2 disabled, 3 absent. */
-export const featureFromInstallState = (state) => state === 1 ? 'enabled' : state === 2 || state === 3 ? 'disabled' : 'unknown';
+export function featureFromInstallState(state) {
+    return state === 1 ? 'enabled' : state === 2 || state === 3 ? 'disabled' : 'unknown';
+}
 // Fixed script (no outside data): CPU/hypervisor facts and the feature state, readable without admin rights.
 const PROBE = [
     '$ErrorActionPreference = "SilentlyContinue"',
@@ -31,16 +37,22 @@ const PROBE = [
     '$s = $null; if ($f) { $s = [int]$f.InstallState }',
     '@{ virtualizationFirmware = $v; hypervisorPresent = $h; installState = $s } | ConvertTo-Json -Compress',
 ].join('; ');
-const Probe = z.object({ virtualizationFirmware: z.boolean().nullable(), hypervisorPresent: z.boolean().nullable(), installState: z.number().nullable() }).partial();
-export const parseProbe = (text) => {
+const ProbeSchema = z
+    .object({
+    virtualizationFirmware: z.boolean().nullable(),
+    hypervisorPresent: z.boolean().nullable(),
+    installState: z.number().nullable(),
+})
+    .partial();
+export function parseProbe(text) {
     try {
-        return Probe.parse(JSON.parse(_.last(text.trim().split(/\r?\n/)) ?? ''));
+        return ProbeSchema.parse(JSON.parse(_.last(text.trim().split(/\r?\n/)) ?? ''));
     }
     catch {
         return {};
     }
-};
-export const gatherFacts = (storageRoot) => {
+}
+export function gatherFacts(storageRoot) {
     const reg = parseRegQuery(captureOutput(SYSTEM.reg(), ['query', 'HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion']));
     const probe = parseProbe(captureOutput(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', PROBE]));
     // DISM knows about a pending restart but needs admin rights; the CIM state works for everyone.
@@ -57,4 +69,4 @@ export const gatherFacts = (storageRoot) => {
         storageRoot,
         nodeVersion: process.version,
     };
-};
+}

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

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