windows-development-sandbox 1.18.2 → 1.18.4

package/config.example.json

@@ -140,7 +140,7 @@
       "components": [],
       "targets": [],
       "crates": [],
-      "targetDir": "separate",
+      "targetDir": "auto",
       "linker": "lld",
       "linkSlots": "auto"
     },

package/dist/app/features/defs.d.ts

@@ -26,6 +26,18 @@ export declare const OPERATIONS: readonly [OperationDef<import("zod").ZodObject<
     stopped: import("zod").ZodBoolean;
     message: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, "sandbox.stop">, OperationDef<import("zod").ZodObject<{
+    service: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    outcome: import("zod").ZodEnum<{
+        failed: "failed";
+        nothing: "nothing";
+        alive: "alive";
+        declined: "declined";
+        cleaned: "cleaned";
+        "service-restarted": "service-restarted";
+    }>;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "sandbox.cleanUp">, OperationDef<import("zod").ZodObject<{
     harness: import("zod").ZodOptional<import("zod").ZodString>;
     all: import("zod").ZodDefault<import("zod").ZodBoolean>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -374,6 +386,13 @@ export declare const QUERIES: readonly [QueryDef<import("zod").ZodObject<{}, imp
         guarded: import("zod").ZodNumber;
         findings: import("zod").ZodArray<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
+    lastEnd: import("zod").ZodOptional<import("zod").ZodObject<{
+        text: import("zod").ZodString;
+        at: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    leftover: import("zod").ZodOptional<import("zod").ZodObject<{
+        text: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "sandbox.status">, QueryDef<import("zod").ZodObject<{
     wide: import("zod").ZodDefault<import("zod").ZodBoolean>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -1064,6 +1083,13 @@ export declare const VIEWS: readonly [import("../kernel/define.js").ViewDef<{
             guarded: import("zod").ZodNumber;
             findings: import("zod").ZodArray<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>;
+        lastEnd: import("zod").ZodOptional<import("zod").ZodObject<{
+            text: import("zod").ZodString;
+            at: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        leftover: import("zod").ZodOptional<import("zod").ZodObject<{
+            text: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
     }, import("zod/v4/core").$strip>, "sandbox.status">;
 }, Record<string, never>, "sandbox">, import("../kernel/define.js").ViewDef<{
     sessions: QueryDef<import("zod").ZodObject<{

package/dist/app/features/defs.js

@@ -7,7 +7,7 @@ import { checkEngine, cleanEngine, engineLeftovers, engineStatus, engineView } f
 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 { cleanUpSandbox, 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 { auditView, listAudit } from './audit/audit.def.js';
@@ -23,6 +23,7 @@ export const OPERATIONS = [
     showWindow,
     hideWindow,
     stopSandbox,
+    cleanUpSandbox,
     restartSessions,
     startShell,
     closeSession,

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

@@ -57,6 +57,13 @@ export declare const SandboxStatusSchema: z.ZodObject<{
         guarded: z.ZodNumber;
         findings: z.ZodArray<z.ZodString>;
     }, z.core.$strip>;
+    lastEnd: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>;
+    leftover: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SandboxStatus = z.output<typeof SandboxStatusSchema>;
 /** "pong (2 session(s) running)" from the helper in the sandbox, in plain words. */
@@ -118,6 +125,13 @@ export declare const sandboxStatus: import("../../kernel/define.js").QueryDef<z.
         guarded: z.ZodNumber;
         findings: z.ZodArray<z.ZodString>;
     }, z.core.$strip>;
+    lastEnd: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>;
+    leftover: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>, "sandbox.status">;
 export declare const showWindow: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     message: z.ZodString;
@@ -125,6 +139,19 @@ export declare const showWindow: import("../../kernel/define.js").OperationDef<z
 export declare const hideWindow: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     message: z.ZodString;
 }, z.core.$strip>, "sandbox.hideWindow">;
+export declare const cleanUpSandbox: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    service: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    outcome: z.ZodEnum<{
+        failed: "failed";
+        nothing: "nothing";
+        alive: "alive";
+        declined: "declined";
+        cleaned: "cleaned";
+        "service-restarted": "service-restarted";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>, "sandbox.cleanUp">;
 export declare const stopSandbox: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     stopped: z.ZodBoolean;
     message: z.ZodString;
@@ -189,5 +216,12 @@ export declare const sandboxView: import("../../kernel/define.js").ViewDef<{
             guarded: z.ZodNumber;
             findings: z.ZodArray<z.ZodString>;
         }, z.core.$strip>;
+        lastEnd: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strip>>;
+        leftover: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>, "sandbox.status">;
 }, Record<string, never>, "sandbox">;

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

@@ -1,7 +1,8 @@
 // The running sandbox as a whole: what it is doing (a live query), its window, and stopping it. Pure: schemas, labels
 // and the view; sandbox.run.ts does the work.
 import { z } from 'zod';
-import { action, ago, defineOperation, defineQuery, defineView, plural, } from '../../kernel/index.js';
+import { action, ago, defineOperation, defineQuery, defineView, link, plural, } from '../../kernel/index.js';
+import { CRASH } from '../logs/logs.def.js';
 const ProjectSchema = z.object({
     name: z.string().describe('The project'),
     host: z.string().describe('Its folder on this PC'),
@@ -38,6 +39,16 @@ export const SandboxStatusSchema = z.object({
     projects: z.array(ProjectSchema),
     otherSessions: z.array(z.object({ id: z.string(), harness: z.string(), cwd: z.string() })),
     repoGuard: z.object({ guarded: z.number(), findings: z.array(z.string()) }),
+    /** How the last sandbox ended when nobody closed it (it is not running now). */
+    lastEnd: z
+        .object({ text: z.string().describe('What happened'), at: z.string().describe('When (ISO time)') })
+        .optional()
+        .describe('The last sandbox ended unexpectedly'),
+    /** Windows Sandbox programs left behind by a sandbox that is gone (Windows then refuses to start a new one). */
+    leftover: z
+        .object({ text: z.string().describe('What was found') })
+        .optional()
+        .describe('Windows Sandbox programs are left over from a sandbox that is gone'),
 });
 const MessageSchema = z.object({ message: z.string().describe('What happened') });
 /** "pong (2 session(s) running)" from the helper in the sandbox, in plain words. */
@@ -85,6 +96,8 @@ export const sandboxStatus = defineQuery({
                 projects: o.projects,
                 otherSessions: o.otherSessions,
                 repoGuard: o.repoGuard,
+                ...(o.lastEnd ? { lastEnd: o.lastEnd } : {}),
+                ...(o.leftover ? { leftover: o.leftover } : {}),
             };
         },
     },
@@ -109,6 +122,23 @@ export const hideWindow = defineOperation({
     text: (o) => o.message,
     cli: { name: 'hide', group: 'Sessions' },
 });
+export const cleanUpSandbox = defineOperation({
+    id: 'sandbox.cleanUp',
+    title: 'Clean up Windows Sandbox…',
+    summary: 'close the Windows Sandbox programs a dead sandbox left behind, so a new one can start',
+    input: z.object({
+        service: z
+            .boolean()
+            .optional()
+            .describe('Also restart the Windows Sandbox service (Windows asks for administrator permission)'),
+    }),
+    output: z.object({
+        outcome: z.enum(['nothing', 'alive', 'declined', 'cleaned', 'service-restarted', 'failed']),
+        message: z.string(),
+    }),
+    text: (o) => o.message,
+    cli: { name: 'cleanup', group: 'Sessions' },
+});
 export const stopSandbox = defineOperation({
     id: 'sandbox.stop',
     access: 'control',
@@ -168,6 +198,8 @@ function facts(o) {
                 fact('sessions', 'Sessions', String(sessions)),
             ]
             : []),
+        ...(o.leftover ? [fact('leftover', 'Windows Sandbox', o.leftover.text, { tone: 'warn' })] : []),
+        ...(o.lastEnd ? [fact('lastEnd', 'Last sandbox', o.lastEnd.text, { tone: 'warn' })] : []),
         fact('account', 'Account', s.account ?? 'none selected (sandbox account use)'),
         fact('sync', 'Background sync', s.syncWatcher ? 'on' : 'off'),
     ];
@@ -221,14 +253,24 @@ export function sandboxPage(o) {
         title: 'Status',
         facts: facts(o),
         // Only the window action that changes something: show a hidden window, hide a shown one.
-        actions: running
-            ? [
-                o.sandbox.headless
-                    ? action(showWindow, {}, { key: 'w', verb: 'show', importance: 3 })
-                    : action(hideWindow, {}, { key: 'h', verb: 'hide', importance: 3 }),
-                action(stopSandbox, {}, { key: 'x', verb: 'stop', importance: 1 }),
-            ]
-            : [],
+        actions: [
+            ...(o.leftover ? [action(cleanUpSandbox, {}, { key: 'c', verb: 'clean up', importance: 1 })] : []),
+            ...(running
+                ? [
+                    o.sandbox.headless
+                        ? action(showWindow, {}, { key: 'w', verb: 'show', importance: 3 })
+                        : action(hideWindow, {}, { key: 'h', verb: 'hide', importance: 3 }),
+                    action(stopSandbox, {}, { key: 'x', verb: 'stop', importance: 1 }),
+                ]
+                : o.lastEnd
+                    ? [
+                        link({ kind: 'view', view: 'logs', params: { name: CRASH } }, 'Show crash report', {
+                            verb: 'show',
+                            importance: 2,
+                        }),
+                    ]
+                    : []),
+        ],
     };
     const others = {
         id: 'other-sessions',
@@ -255,6 +297,6 @@ export const sandboxView = defineView({
     title: 'Sandbox',
     summary: 'Status, projects and controls of the running sandbox.',
     queries: { status: sandboxStatus },
-    operations: [showWindow, hideWindow, stopSandbox],
+    operations: [showWindow, hideWindow, stopSandbox, cleanUpSandbox],
     build: ({ status }) => sandboxPage(status),
 });

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

@@ -55,6 +55,13 @@ export declare const sandboxStatusRun: import("../../kernel/define.js").Implemen
         guarded: import("zod").ZodNumber;
         findings: import("zod").ZodArray<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
+    lastEnd: import("zod").ZodOptional<import("zod").ZodObject<{
+        text: import("zod").ZodString;
+        at: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    leftover: import("zod").ZodOptional<import("zod").ZodObject<{
+        text: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "sandbox.status">, import("../../../cli/commands/context.js").Context>;
 export declare const showWindowRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     message: import("zod").ZodString;
@@ -62,6 +69,23 @@ export declare const showWindowRun: import("../../kernel/define.js").Implementat
 export declare const hideWindowRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     message: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, "sandbox.hideWindow">, import("../../../cli/commands/context.js").Context>;
+/**
+ * A dead sandbox leaves Windows Sandbox programs behind and Windows then refuses to start a new one ("signed out"):
+ * ends them after asking, and restarts the Windows Sandbox service when asked to (or when they will not go).
+ */
+export declare const cleanUpSandboxRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    service: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    outcome: import("zod").ZodEnum<{
+        failed: "failed";
+        nothing: "nothing";
+        alive: "alive";
+        declined: "declined";
+        cleaned: "cleaned";
+        "service-restarted": "service-restarted";
+    }>;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "sandbox.cleanUp">, import("../../../cli/commands/context.js").Context>;
 /**
  * Stopping ends every project's sessions: it says which, and the sessions of other projects need a yes (also on the
  * command line, where --yes gives it; a script without it fails rather than end them by accident).

package/dist/app/features/sandbox/sandbox.run.js

@@ -3,6 +3,10 @@
 import path from 'node:path';
 import { safeText } from '../../../core/util/index.js';
 import { SandboxChannel } from '../../../host/channel/index.js';
+import { readSandboxFacts } from '../../../host/health/index.js';
+import { LifeRecord, readLastEnd } from '../../../host/life/index.js';
+import { cleanUpLeftovers, endSandboxPrograms, restartSandboxService } from '../../../host/sandbox/index.js';
+import { judgeSandbox } from '../../../host/health/index.js';
 import { runningOwner } from '../../../host/sharing/index.js';
 import { requireOnPc, requireRunning } from '../../../cli/commands/context.js';
 import { hereDir } from '../../../cli/commands/projects/here.js';
@@ -10,7 +14,7 @@ import { lookAtSandbox, useSharedSandbox } from '../../../cli/commands/shared-us
 import { SandboxService } from '../../../cli/services/index.js';
 import { implement, typedConfirm } from '../../context.js';
 import { cancelled } from '../../kernel/index.js';
-import { hideWindow, sandboxStatus, showWindow, stopSandbox } from './sandbox.def.js';
+import { cleanUpSandbox, hideWindow, sandboxStatus, showWindow, stopSandbox, } from './sandbox.def.js';
 /** Another user's sandbox that is not shared: whose it is, and nothing else. */
 function limitedStatus(view, folder) {
     const owner = view.owner;
@@ -36,7 +40,12 @@ export const sandboxStatusRun = implement(sandboxStatus, async (asked) => {
     if (view.limited)
         return limitedStatus(view, hereDir(asked));
     const report = await new SandboxService(view.ctx).status();
+    const { storageRoot, dataPath } = view.ctx;
+    const lastEnd = readLastEnd(() => new LifeRecord(storageRoot, dataPath).read(), dataPath, report.sandbox.running);
+    const leftover = report.sandbox.running ? judgeSandbox(await readSandboxFacts(storageRoot, dataPath, false)) : null;
     return {
+        ...(lastEnd ? { lastEnd } : {}),
+        ...(leftover?.state === 'leftover' ? { leftover: { text: leftover.why } } : {}),
         ...(view.line ? { shared: { line: view.line, limited: false, startedBy: view.ctx.borrowed?.user ?? null } } : {}),
         ...report,
         sandbox: { ...report.sandbox, daemon: safeText(report.sandbox.daemon) },
@@ -57,6 +66,41 @@ export const hideWindowRun = implement(hideWindow, async (ctx, _input, io) => {
     await new SandboxService(ctx).hideWindow();
     return { message: 'Sandbox window hidden. Bring it back with: sbx-show' };
 });
+/**
+ * A dead sandbox leaves Windows Sandbox programs behind and Windows then refuses to start a new one ("signed out"):
+ * ends them after asking, and restarts the Windows Sandbox service when asked to (or when they will not go).
+ */
+export const cleanUpSandboxRun = implement(cleanUpSandbox, async (ctx, input, io) => {
+    requireOnPc('cleanup');
+    const { storageRoot, dataPath } = ctx;
+    const lines = [];
+    const outcome = await cleanUpLeftovers({
+        facts: () => readSandboxFacts(storageRoot, dataPath, true),
+        end: endSandboxPrograms,
+        restartService: restartSandboxService,
+        confirm: (q) => io.confirm({
+            ...q,
+            danger: true,
+            noTerminal: { message: 'Nothing was closed.', fix: 'Add --yes to answer yes.' },
+        }),
+        say: (line) => {
+            lines.push(line);
+            io.log(line);
+        },
+        alsoService: input.service === true,
+    });
+    if (outcome === 'cleaned' || outcome === 'service-restarted')
+        new SandboxChannel(dataPath, () => false).reset();
+    const message = {
+        nothing: 'No Windows Sandbox program is left over.',
+        alive: lines[lines.length - 1] ?? 'A sandbox is working; nothing was closed.',
+        declined: 'Nothing was closed.',
+        cleaned: 'The leftover Windows Sandbox programs are closed. A new sandbox can start now.',
+        'service-restarted': 'The Windows Sandbox service was restarted. A new sandbox can start now.',
+        failed: 'The Windows Sandbox service could not be restarted.',
+    }[outcome];
+    return { outcome, message };
+});
 /**
  * Stopping ends every project's sessions: it says which, and the sessions of other projects need a yes (also on the
  * command line, where --yes gives it; a script without it fails rather than end them by accident).

package/dist/app/registry.js

@@ -8,7 +8,7 @@ import { cleanDataRun, pruneStorageRun, showDataRun } from './features/data/inde
 import { changeDataFolderRun, containedOffRun, containedOnRun, containedStatusRun, moveStorageRun, showStorageRun, useStorageRun, } from './features/storage/index.js';
 import { addProjectRun, allProjectsRun, chooseProjectsRun, excludeProjectRun, includeProjectRun, listProjectsRun, projectRootsRun, removeProjectRun, } from './features/projects/index.js';
 import { checkHealthRun, enableSandboxRun, lastHealthRun, repairHealthRun } from './features/health/index.js';
-import { hideWindowRun, sandboxStatusRun, showWindowRun, stopSandboxRun } from './features/sandbox/index.js';
+import { cleanUpSandboxRun, hideWindowRun, sandboxStatusRun, showWindowRun, stopSandboxRun, } from './features/sandbox/index.js';
 import { listLogsRun, tailLogRun } from './features/logs/index.js';
 import { listAuditRun } from './features/audit/index.js';
 import { closeSessionRun, listSessionsRun, restartSessionsRun, startShellRun } from './features/sessions/index.js';
@@ -24,6 +24,7 @@ export const IMPLEMENTATIONS = [
     showWindowRun,
     hideWindowRun,
     stopSandboxRun,
+    cleanUpSandboxRun,
     listSessionsRun,
     restartSessionsRun,
     startShellRun,

package/dist/bin/agent-sandbox.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-IIHL7W6B.js";
-import "./chunk-MQIA7GNB.js";
+} from "./chunk-N4GXYTLV.js";
+import "./chunk-FRPLQLSY.js";
 
 // src/bin/agent-sandbox.ts
 run(process.argv.slice(2));