windows-development-sandbox 1.10.0 → 1.11.3

package/dist/app/features/defs.js

@@ -1,9 +1,111 @@
+import { addAgent, agentsView, listAgents, makeDefaultAgent, removeAgent, startAgent } from './agents/agents.def.js';
+import { accountsView, defaultAccount, listAccounts, removeAccount, renameAccount, saveAccount, useAccount, } from './accounts/accounts.def.js';
+import { appsView, listApps, requestApp, setCustomApps, toggleApp } from './apps/apps.def.js';
+import { browseFolder } from './files/files.def.js';
+import { checkEngine, cleanEngine, engineLeftovers, engineStatus, engineView } from './engine/engine.def.js';
+import { checkHealth, enableSandbox, healthView, lastHealth, repairHealth } from './health/health.def.js';
+import { cleanData, dataView, pruneStorage, showData } from './data/data.def.js';
+import { changeDataFolder, containedOff, containedOn, containedStatus, moveStorage, showStorage, storageView, useStorage, } from './storage/storage.def.js';
 import { hideWindow, sandboxStatus, sandboxView, showWindow, stopSandbox } from './sandbox/sandbox.def.js';
+import { addProject, allProjects, chooseProjects, excludeProject, includeProject, listProjects, projectRoots, projectsView, removeProject, } from './projects/projects.def.js';
+import { listLogs, logsView, tailLog } from './logs/logs.def.js';
 import { listSessions, restartSessions, sessionsView } from './sessions/sessions.def.js';
-import { getSetting, listSettings, resetSetting, setSetting, settingsView } from './settings/settings.def.js';
-export const OPERATIONS = [showWindow, hideWindow, stopSandbox, restartSessions, setSetting, resetSetting];
-export const QUERIES = [sandboxStatus, listSessions, listSettings, getSetting];
-export const VIEWS = [sandboxView, sessionsView, settingsView];
+import { vpnLogin, vpnLogout, vpnStatus, vpnView } from './vpn/vpn.def.js';
+import { githubLogin, githubLogout, githubStatus, githubView } from './github/github.def.js';
+import { exportConfig, getSetting, importConfig, listSettings, resetSetting, setSetting, settingsView, } from './settings/settings.def.js';
+import { migrateSettings, runUpdate, updatesStatus, updatesView } from './updates/updates.def.js';
+import { openWeb, startWeb, stopWeb, webStatus, webView } from './web/web.def.js';
+export const OPERATIONS = [
+    cleanEngine,
+    showWindow,
+    hideWindow,
+    stopSandbox,
+    restartSessions,
+    startAgent,
+    addAgent,
+    makeDefaultAgent,
+    removeAgent,
+    setSetting,
+    resetSetting,
+    exportConfig,
+    importConfig,
+    saveAccount,
+    useAccount,
+    defaultAccount,
+    renameAccount,
+    removeAccount,
+    toggleApp,
+    setCustomApps,
+    requestApp,
+    chooseProjects,
+    addProject,
+    removeProject,
+    includeProject,
+    excludeProject,
+    allProjects,
+    projectRoots,
+    checkHealth,
+    repairHealth,
+    enableSandbox,
+    cleanData,
+    pruneStorage,
+    runUpdate,
+    migrateSettings,
+    moveStorage,
+    useStorage,
+    changeDataFolder,
+    containedOn,
+    containedOff,
+    startWeb,
+    openWeb,
+    stopWeb,
+    vpnLogin,
+    vpnLogout,
+    githubLogin,
+    githubLogout,
+];
+export const QUERIES = [
+    sandboxStatus,
+    listSessions,
+    listAgents,
+    listSettings,
+    getSetting,
+    browseFolder,
+    listAccounts,
+    listApps,
+    listProjects,
+    lastHealth,
+    showData,
+    showStorage,
+    containedStatus,
+    listLogs,
+    tailLog,
+    updatesStatus,
+    engineStatus,
+    checkEngine,
+    engineLeftovers,
+    webStatus,
+    vpnStatus,
+    githubStatus,
+];
+export const VIEWS = [
+    sandboxView,
+    sessionsView,
+    agentsView,
+    settingsView,
+    accountsView,
+    appsView,
+    projectsView,
+    healthView,
+    dataView,
+    storageView,
+    logsView,
+    updatesView,
+    engineView,
+    webView,
+    vpnView,
+    githubView,
+];
 export const DEFINITIONS = [...OPERATIONS, ...QUERIES];
 export function definitionById(id) {
     return DEFINITIONS.find((d) => d.id === id);
@@ -17,12 +119,47 @@ export function queryById(id) {
 export function viewById(id) {
     return VIEWS.find((v) => v.id === id);
 }
+/** Every entry of the navigation, children included, in order. */
+export function navSections(nav) {
+    return nav.flatMap((n) => [n, ...navSections(n.children ?? [])]);
+}
+/** Every view the web's navigation opens. */
+export function navViews(nav) {
+    return navSections(nav).flatMap((n) => (n.view ? [n.view] : []));
+}
 export const NAV = [
-    { label: 'Agents', elsewhere: 'Start agents from the menu (sandbox) or with sandbox <agent>.' },
+    { label: 'Agents', view: 'agents' },
     { label: 'Sessions', view: 'sessions' },
-    { label: 'Sandbox', view: 'sandbox' },
-    { label: 'Apps', elsewhere: 'Choose apps in the menu (sandbox > Apps).' },
-    { label: 'Settings', view: 'settings' },
-    { label: 'Accounts', elsewhere: 'Manage logins in the menu (sandbox > Accounts) or with sandbox account.' },
-    { label: 'Maintenance', elsewhere: 'Doctor, repair, data and updates are in the menu (sandbox > Maintenance).' },
+    {
+        label: 'Sandbox',
+        children: [
+            { label: 'Status', view: 'sandbox' },
+            { label: 'Projects', view: 'projects' },
+        ],
+    },
+    { label: 'Apps', view: 'apps' },
+    {
+        label: 'Settings',
+        children: [
+            { label: 'All settings', view: 'settings' },
+            { label: 'VPN', view: 'vpn' },
+            { label: 'GitHub', view: 'github' },
+        ],
+    },
+    { label: 'Accounts', view: 'accounts' },
+    {
+        label: 'Maintenance',
+        children: [
+            { label: 'Updates', view: 'updates' },
+            { label: 'Data', view: 'data' },
+            { label: 'Storage', view: 'storage' },
+            { label: 'Health', view: 'health' },
+            { label: 'Logs', view: 'logs' },
+            { label: 'Engine', view: 'engine' },
+            {
+                label: 'More',
+                elsewhere: 'The less common commands are in the menu (sandbox > Maintenance).',
+            },
+        ],
+    },
 ];

package/dist/app/features/engine/engine.def.d.ts

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+/** The label of each capability, in the order the page and the command line show them. */
+export declare const CAPABILITY_NAMES: {
+    readonly desktop: "desktop window";
+    readonly gpu: "GPU";
+    readonly clipboard: "clipboard";
+    readonly audio: "audio";
+    readonly video: "camera";
+    readonly printers: "printers";
+    readonly liveFolderAdd: "add folders while running";
+    readonly attachedDisks: "attached disks";
+    readonly multipleInstances: "several at once";
+    readonly hvsocket: "Hyper-V sockets";
+};
+export declare const EngineIdSchema: z.ZodEnum<{
+    "windows-sandbox": "windows-sandbox";
+    hcs: "hcs";
+}>;
+export declare const CapabilitiesSchema: z.ZodObject<{
+    desktop: z.ZodBoolean;
+    gpu: z.ZodBoolean;
+    clipboard: z.ZodBoolean;
+    audio: z.ZodBoolean;
+    video: z.ZodBoolean;
+    printers: z.ZodBoolean;
+    liveFolderAdd: z.ZodBoolean;
+    attachedDisks: z.ZodBoolean;
+    multipleInstances: z.ZodBoolean;
+    hvsocket: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const EngineCheckSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    reasons: z.ZodArray<z.ZodString>;
+    fixes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const EngineReportSchema: z.ZodObject<{
+    id: z.ZodEnum<{
+        "windows-sandbox": "windows-sandbox";
+        hcs: "hcs";
+    }>;
+    inUse: z.ZodBoolean;
+    capabilities: z.ZodObject<{
+        desktop: z.ZodBoolean;
+        gpu: z.ZodBoolean;
+        clipboard: z.ZodBoolean;
+        audio: z.ZodBoolean;
+        video: z.ZodBoolean;
+        printers: z.ZodBoolean;
+        liveFolderAdd: z.ZodBoolean;
+        attachedDisks: z.ZodBoolean;
+        multipleInstances: z.ZodBoolean;
+        hvsocket: z.ZodBoolean;
+    }, z.core.$strip>;
+    check: z.ZodObject<{
+        available: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodString>;
+        fixes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EngineReportRow = z.output<typeof EngineReportSchema>;
+export declare const EnginesSchema: z.ZodObject<{
+    engine: z.ZodEnum<{
+        "windows-sandbox": "windows-sandbox";
+        hcs: "hcs";
+    }>;
+    engines: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            "windows-sandbox": "windows-sandbox";
+            hcs: "hcs";
+        }>;
+        inUse: z.ZodBoolean;
+        capabilities: z.ZodObject<{
+            desktop: z.ZodBoolean;
+            gpu: z.ZodBoolean;
+            clipboard: z.ZodBoolean;
+            audio: z.ZodBoolean;
+            video: z.ZodBoolean;
+            printers: z.ZodBoolean;
+            liveFolderAdd: z.ZodBoolean;
+            attachedDisks: z.ZodBoolean;
+            multipleInstances: z.ZodBoolean;
+            hvsocket: z.ZodBoolean;
+        }, z.core.$strip>;
+        check: z.ZodObject<{
+            available: z.ZodBoolean;
+            reasons: z.ZodArray<z.ZodString>;
+            fixes: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Engines = z.output<typeof EnginesSchema>;
+/** The lines `sandbox engine check` prints (plain: the colours are the command line's own). */
+export declare function checkText(r: EngineReportRow): string;
+export declare const engineStatus: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    engine: z.ZodEnum<{
+        "windows-sandbox": "windows-sandbox";
+        hcs: "hcs";
+    }>;
+    engines: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            "windows-sandbox": "windows-sandbox";
+            hcs: "hcs";
+        }>;
+        inUse: z.ZodBoolean;
+        capabilities: z.ZodObject<{
+            desktop: z.ZodBoolean;
+            gpu: z.ZodBoolean;
+            clipboard: z.ZodBoolean;
+            audio: z.ZodBoolean;
+            video: z.ZodBoolean;
+            printers: z.ZodBoolean;
+            liveFolderAdd: z.ZodBoolean;
+            attachedDisks: z.ZodBoolean;
+            multipleInstances: z.ZodBoolean;
+            hvsocket: z.ZodBoolean;
+        }, z.core.$strip>;
+        check: z.ZodObject<{
+            available: z.ZodBoolean;
+            reasons: z.ZodArray<z.ZodString>;
+            fixes: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "engine.status">;
+export declare const checkEngine: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+    engine: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodEnum<{
+        "windows-sandbox": "windows-sandbox";
+        hcs: "hcs";
+    }>;
+    inUse: z.ZodBoolean;
+    capabilities: z.ZodObject<{
+        desktop: z.ZodBoolean;
+        gpu: z.ZodBoolean;
+        clipboard: z.ZodBoolean;
+        audio: z.ZodBoolean;
+        video: z.ZodBoolean;
+        printers: z.ZodBoolean;
+        liveFolderAdd: z.ZodBoolean;
+        attachedDisks: z.ZodBoolean;
+        multipleInstances: z.ZodBoolean;
+        hvsocket: z.ZodBoolean;
+    }, z.core.$strip>;
+    check: z.ZodObject<{
+        available: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodString>;
+        fixes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, "engine.check">;
+export declare const LeftoverSystemSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    state: z.ZodString;
+    since: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type LeftoverRow = z.output<typeof LeftoverSystemSchema>;
+export declare const LeftoversSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    message: z.ZodString;
+    systems: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        state: z.ZodString;
+        since: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Leftovers = z.output<typeof LeftoversSchema>;
+export declare const engineLeftovers: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodBoolean;
+    message: z.ZodString;
+    systems: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        state: z.ZodString;
+        since: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "engine.leftovers">;
+export declare const cleanEngine: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodBoolean;
+    stopped: z.ZodNumber;
+    failed: z.ZodNumber;
+    message: z.ZodString;
+}, z.core.$strip>, "engine.clean">;
+/** The engine page: the engine in use, then a card per engine with its capabilities, reasons and fixes. Pure. */
+export declare function enginePage(o: Engines, leftovers?: Leftovers): Page;
+export declare const engineView: import("../../kernel/define.js").ViewDef<{
+    engines: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        engine: z.ZodEnum<{
+            "windows-sandbox": "windows-sandbox";
+            hcs: "hcs";
+        }>;
+        engines: z.ZodArray<z.ZodObject<{
+            id: z.ZodEnum<{
+                "windows-sandbox": "windows-sandbox";
+                hcs: "hcs";
+            }>;
+            inUse: z.ZodBoolean;
+            capabilities: z.ZodObject<{
+                desktop: z.ZodBoolean;
+                gpu: z.ZodBoolean;
+                clipboard: z.ZodBoolean;
+                audio: z.ZodBoolean;
+                video: z.ZodBoolean;
+                printers: z.ZodBoolean;
+                liveFolderAdd: z.ZodBoolean;
+                attachedDisks: z.ZodBoolean;
+                multipleInstances: z.ZodBoolean;
+                hvsocket: z.ZodBoolean;
+            }, z.core.$strip>;
+            check: z.ZodObject<{
+                available: z.ZodBoolean;
+                reasons: z.ZodArray<z.ZodString>;
+                fixes: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, "engine.status">;
+    leftovers: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        available: z.ZodBoolean;
+        message: z.ZodString;
+        systems: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+            state: z.ZodString;
+            since: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, "engine.leftovers">;
+}, Record<string, never>, "engine">;

package/dist/app/features/engine/engine.def.js

@@ -0,0 +1,194 @@
+// The sandbox engines: the engine in use, and for each engine what it can do and whether this PC can run it. `check`
+// says what this PC lacks, with the commands that would fix it as text to copy: nothing is run or changed. Pure: the
+// schemas, the words the check prints and the page. The checks run in engine.run.ts (Node side).
+import { z } from 'zod';
+import { action, ago, defineOperation, defineQuery, defineView, plural, } from '../../kernel/index.js';
+/** The label of each capability, in the order the page and the command line show them. */
+export const CAPABILITY_NAMES = {
+    desktop: 'desktop window',
+    gpu: 'GPU',
+    clipboard: 'clipboard',
+    audio: 'audio',
+    video: 'camera',
+    printers: 'printers',
+    liveFolderAdd: 'add folders while running',
+    attachedDisks: 'attached disks',
+    multipleInstances: 'several at once',
+    hvsocket: 'Hyper-V sockets',
+};
+const CAPABILITY_KEYS = Object.keys(CAPABILITY_NAMES);
+const FALLBACK_FIX = 'see docs/design/engines.md';
+export const EngineIdSchema = z.enum(['windows-sandbox', 'hcs']).describe('The engine');
+export const CapabilitiesSchema = z.object({
+    desktop: z.boolean().describe(CAPABILITY_NAMES.desktop),
+    gpu: z.boolean().describe(CAPABILITY_NAMES.gpu),
+    clipboard: z.boolean().describe(CAPABILITY_NAMES.clipboard),
+    audio: z.boolean().describe(CAPABILITY_NAMES.audio),
+    video: z.boolean().describe(CAPABILITY_NAMES.video),
+    printers: z.boolean().describe(CAPABILITY_NAMES.printers),
+    liveFolderAdd: z.boolean().describe(CAPABILITY_NAMES.liveFolderAdd),
+    attachedDisks: z.boolean().describe(CAPABILITY_NAMES.attachedDisks),
+    multipleInstances: z.boolean().describe(CAPABILITY_NAMES.multipleInstances),
+    hvsocket: z.boolean().describe(CAPABILITY_NAMES.hvsocket),
+});
+export const EngineCheckSchema = z
+    .object({
+    available: z.boolean().describe('This PC can run it'),
+    reasons: z.array(z.string()).describe('Why not, in plain words'),
+    fixes: z.array(z.string()).describe('The command that fixes each reason (never run for you)'),
+})
+    .describe('Whether this PC can run it');
+export const EngineReportSchema = z.object({
+    id: EngineIdSchema,
+    inUse: z.boolean().describe('The setting sandbox.engine names it'),
+    capabilities: CapabilitiesSchema.describe('What it can do'),
+    check: EngineCheckSchema,
+});
+export const EnginesSchema = z.object({
+    engine: EngineIdSchema.describe('The engine in use (the setting sandbox.engine)'),
+    engines: z.array(EngineReportSchema).describe('Every engine'),
+});
+/** The lines `sandbox engine check` prints (plain: the colours are the command line's own). */
+export function checkText(r) {
+    if (r.check.available) {
+        const lines = [r.id + ' can be used on this PC.'];
+        if (r.id === 'hcs')
+            lines.push('HCS is in alpha: starting it is not enabled yet (docs/design/engines.md).');
+        return lines.join('\n');
+    }
+    const lines = [r.id + ' cannot be used on this PC yet:'];
+    r.check.reasons.forEach((reason, i) => {
+        lines.push('', '  ' + (i + 1) + '. ' + reason, '     To fix: ' + (r.check.fixes[i] ?? FALLBACK_FIX));
+    });
+    lines.push('', 'Nothing was changed. These commands change Windows, so they are yours to run (or not).');
+    return lines.join('\n');
+}
+export const engineStatus = defineQuery({
+    id: 'engine.status',
+    title: 'Engine',
+    summary: 'the engine in use and what each engine can do on this PC',
+    input: z.object({}),
+    output: EnginesSchema,
+    cli: { name: 'engine', action: 'show', json: true },
+});
+export const checkEngine = defineQuery({
+    id: 'engine.check',
+    title: 'Check an engine',
+    summary: 'what this PC lacks for an engine, and the commands that would fix it',
+    input: z.object({ engine: z.string().default('hcs').describe('the engine to check') }),
+    output: EngineReportSchema,
+    surfaces: {
+        except: {
+            menu: 'the Engine category shows every engine and its check with the fixes (engine.status)',
+            web: 'the Engine page shows every engine and its check with the fixes (engine.status)',
+        },
+    },
+    text: checkText,
+    cli: {
+        name: 'engine',
+        action: 'check',
+        positional: ['engine'],
+        json: true,
+        exitCode: (r) => (r.check.available ? 0 : 1),
+    },
+});
+export const LeftoverSystemSchema = z.object({
+    id: z.string().describe('The compute system'),
+    kind: z.string().describe('Container or VirtualMachine (the utility VM)'),
+    state: z.string().describe('What it is doing'),
+    since: z.string().nullable().describe('When it was created (ISO time), when HCS says'),
+});
+export const LeftoversSchema = z.object({
+    available: z.boolean().describe('HCS could be asked'),
+    message: z.string().describe('What was found, or why nothing is listed'),
+    systems: z.array(LeftoverSystemSchema).describe('Ours that are running now'),
+});
+export const engineLeftovers = defineQuery({
+    id: 'engine.leftovers',
+    title: 'HCS systems left running',
+    summary: 'list the HCS compute systems this tool left running (a crashed command can leave one up)',
+    input: z.object({}),
+    output: LeftoversSchema,
+    cli: { name: 'engine', action: 'leftovers', json: true },
+});
+export const cleanEngine = defineOperation({
+    id: 'engine.clean',
+    title: 'Stop the leftover systems…',
+    summary: 'stop the HCS compute systems this tool left running (frees their memory; nothing else is touched)',
+    input: z.object({}),
+    output: z.object({
+        available: z.boolean().describe('HCS could be asked'),
+        stopped: z.number().describe('How many were stopped'),
+        failed: z.number().describe('How many could not be stopped'),
+        message: z.string().describe('What happened'),
+    }),
+    danger: true,
+    text: (o) => o.message,
+    cli: { name: 'engine', action: 'clean' },
+});
+function leftoverItem(s) {
+    return {
+        id: 'leftover:' + s.id,
+        label: s.id,
+        hint: s.state + (s.since ? '  started ' + ago(s.since) : ''),
+        tone: 'warn',
+        details: [
+            'System   ' + s.id,
+            'Kind     ' + s.kind,
+            'State    ' + s.state,
+            ...(s.since ? ['Created  ' + s.since] : []),
+        ],
+    };
+}
+/** The HCS systems left running (a section only when there are some). */
+function leftoversSection(o) {
+    if (!o.systems.length)
+        return [];
+    return [
+        {
+            id: 'leftovers',
+            title: 'HCS systems left running',
+            summary: plural(o.systems.length, 'system') + ' (they hold memory; a sandbox running on purpose is listed too)',
+            items: o.systems.map(leftoverItem),
+            actions: [action(cleanEngine, {}, { key: 'x', verb: 'stop them', importance: 1 })],
+        },
+    ];
+}
+function engineSection(r) {
+    const facts = CAPABILITY_KEYS.map((key) => {
+        const yes = r.capabilities[key];
+        return {
+            id: key,
+            label: CAPABILITY_NAMES[key],
+            value: yes ? 'yes' : 'no',
+            ...(yes ? {} : { tone: 'muted' }),
+        };
+    });
+    const items = [
+        ...r.check.reasons.map((reason, i) => ({ id: 'reason:' + i, label: reason, tone: 'warn' })),
+        ...r.check.fixes.map((fix, i) => ({ id: 'fix:' + i, label: 'Fix: ' + fix })),
+    ];
+    return {
+        id: r.id,
+        title: r.id + (r.id === 'hcs' ? '  (alpha)' : '') + (r.inUse ? '  (in use)' : ''),
+        summary: r.check.available ? 'can be used on this PC' : 'cannot be used yet',
+        facts,
+        items,
+    };
+}
+/** The engine page: the engine in use, then a card per engine with its capabilities, reasons and fixes. Pure. */
+export function enginePage(o, leftovers) {
+    return {
+        title: 'Engine',
+        notice: { text: 'Engine in use: ' + o.engine + '  (setting: sandbox.engine)' },
+        sections: [...o.engines.map(engineSection), ...(leftovers ? leftoversSection(leftovers) : [])],
+    };
+}
+export const engineView = defineView({
+    id: 'engine',
+    title: 'Engine',
+    summary: 'What runs your sandbox, and what each engine can do on this PC.',
+    queries: { engines: engineStatus, leftovers: engineLeftovers },
+    operations: [cleanEngine],
+    build: ({ engines, leftovers }) => enginePage(engines, leftovers),
+});

package/dist/app/features/engine/engine.run.d.ts

@@ -0,0 +1,72 @@
+export declare const engineStatusRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    engine: import("zod").ZodEnum<{
+        "windows-sandbox": "windows-sandbox";
+        hcs: "hcs";
+    }>;
+    engines: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodEnum<{
+            "windows-sandbox": "windows-sandbox";
+            hcs: "hcs";
+        }>;
+        inUse: import("zod").ZodBoolean;
+        capabilities: import("zod").ZodObject<{
+            desktop: import("zod").ZodBoolean;
+            gpu: import("zod").ZodBoolean;
+            clipboard: import("zod").ZodBoolean;
+            audio: import("zod").ZodBoolean;
+            video: import("zod").ZodBoolean;
+            printers: import("zod").ZodBoolean;
+            liveFolderAdd: import("zod").ZodBoolean;
+            attachedDisks: import("zod").ZodBoolean;
+            multipleInstances: import("zod").ZodBoolean;
+            hvsocket: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+        check: import("zod").ZodObject<{
+            available: import("zod").ZodBoolean;
+            reasons: import("zod").ZodArray<import("zod").ZodString>;
+            fixes: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, "engine.status">, import("../../../cli/commands/context.js").Context>;
+export declare const checkEngineRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{
+    engine: import("zod").ZodDefault<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    id: import("zod").ZodEnum<{
+        "windows-sandbox": "windows-sandbox";
+        hcs: "hcs";
+    }>;
+    inUse: import("zod").ZodBoolean;
+    capabilities: import("zod").ZodObject<{
+        desktop: import("zod").ZodBoolean;
+        gpu: import("zod").ZodBoolean;
+        clipboard: import("zod").ZodBoolean;
+        audio: import("zod").ZodBoolean;
+        video: import("zod").ZodBoolean;
+        printers: import("zod").ZodBoolean;
+        liveFolderAdd: import("zod").ZodBoolean;
+        attachedDisks: import("zod").ZodBoolean;
+        multipleInstances: import("zod").ZodBoolean;
+        hvsocket: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>;
+    check: import("zod").ZodObject<{
+        available: import("zod").ZodBoolean;
+        reasons: import("zod").ZodArray<import("zod").ZodString>;
+        fixes: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, "engine.check">, import("../../../cli/commands/context.js").Context>;
+export declare const engineLeftoversRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    available: import("zod").ZodBoolean;
+    message: import("zod").ZodString;
+    systems: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodString;
+        state: import("zod").ZodString;
+        since: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, "engine.leftovers">, import("../../../cli/commands/context.js").Context>;
+export declare const cleanEngineRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    available: import("zod").ZodBoolean;
+    stopped: import("zod").ZodNumber;
+    failed: import("zod").ZodNumber;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "engine.clean">, import("../../../cli/commands/context.js").Context>;