windows-development-sandbox 1.18.3 → 1.20.0

package/dist/selftest/service-accounts.test.js

@@ -306,7 +306,7 @@ export const serviceAccountsSuite = {
         });
         t.check(empty.message.includes('No saved'), 'no launcher sign-in on this PC: it says so');
         await t.throws(() => loginServiceFlow(fakeIO([]).io, 'epic', { store: flowStore, share: true }), 'nothing to type', 'Epic has nothing to type');
-        await t.throws(() => loginServiceFlow(fakeIO([CFX, '']).io, 'cfx', { store: flowStore, share: true }), 'not available yet', 'a kind whose host side is not written yet says so');
+        await t.throws(() => loginServiceFlow(fakeIO([CFX, '']).io, 'cfx', { store: flowStore, share: true }), 'comes in a later version', 'a kind whose host side is not written yet says so');
         t.check(Boolean(HOST_SOURCES.epic.fromPc) && !HOST_SOURCES.epic.fromAnswers, 'Epic comes from this PC (or a sandbox), never typed');
         const gone = await logoutServiceFlow(fakeIO([true]).io, 'epic', t.dir('svc-flow-root'), flowStore, new AccountLeases(t.dir('svc-flow-root')));
         t.check(gone.deleted && flowStore.state('epic') === 'none', 'forgetting deletes it after asking');

package/dist/selftest/support/engine-golden.js

@@ -67,7 +67,7 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/scripts/enable-vt-input.ps1',
     'sandbox/scripts/expand-archive.ps1',
     'sandbox/scripts/get-gpu-names.ps1',
-    'sandbox/scripts/get-signer.ps1',
+    'sandbox/scripts/get-signature.ps1',
     'sandbox/scripts/install-shell-path.ps1',
     'sandbox/scripts/link-profile-dirs.ps1',
     'sandbox/scripts/new-shortcuts.ps1',

package/dist/selftest/support/fixtures.d.ts

@@ -194,6 +194,7 @@ export declare function createFixtures(t: Harness): {
                 acceptLicense: boolean;
                 components: string[];
                 keepInstallFiles: boolean;
+                visualStudio: "full" | "autosdk";
                 persistEngines: boolean;
                 derivedDataCache: "persisted" | "local";
             };
@@ -429,6 +430,14 @@ export declare function createFixtures(t: Harness): {
             resumeArguments?: string[] | undefined;
             resumeOneArguments?: string[] | undefined;
         }>;
+        codex: {
+            sandboxMode: "danger-full-access" | "workspace-write" | "read-only";
+            approvalPolicy: "never" | "on-request" | "on-failure" | "untrusted";
+            model: string;
+            reasoningEffort: "default" | "minimal" | "low" | "medium" | "high" | "xhigh";
+            windowsSandbox: "off" | "unelevated" | "elevated";
+            mcpLoginsInFile: boolean;
+        };
         hooks: {
             failFast: boolean;
         };

package/dist/selftest/vpn.test.js

@@ -14,7 +14,8 @@ import { ConfigSchema, LocalOverridesSchema } from '../core/schema/index.js';
 import { SecretStore } from '../host/secrets/index.js';
 import { clearSecrets } from '../host/secrets/index.js';
 import { generateSandbox } from '../host/launch/index.js';
-import { findCountry, nordProfile, prepareVpn, wireguardFileProblem, recommendedServer, VpnLogin, vpnLine, vpnNotes, } from '../host/vpn/index.js';
+import { classifyFailure, FAILURE_TEXT } from '../shared/vpn/failure.js';
+import { findCountry, loginProblem, loginWarning, nordProfile, prepareVpn, wireguardFileProblem, recommendedServer, VpnLogin, vpnLine, vpnNotes, } from '../host/vpn/index.js';
 import { RunDir } from '../shared/channel/index.js';
 import { OPENVPN_MSI, WIREGUARD_MSI } from '../shared/vpn/download.js';
 import { cleanServers, ipv4Except, killSwitchCommands, removeKillSwitchCommands, tunnelAddressFromLog, tunnelCommands, } from '../shared/vpn/kill-switch.js';
@@ -221,6 +222,52 @@ export const vpnSuite = {
         t.check(login.state('nordvpn') === 'unreadable', 'a login this Windows user cannot open is reported as unreadable');
         login.remove('nordvpn');
         t.check(login.state('nordvpn') === 'none', 'logout deletes it');
+        t.section('NordVPN login checks and why a tunnel failed');
+        const sampleStatus = () => ({
+            enabled: true,
+            provider: 'nordvpn',
+            protocol: 'udp',
+            country: '',
+            killSwitch: true,
+            login: 'saved',
+            loginSavedAt: '2026-11-02T19:00:00.000Z',
+            running: null,
+            lastFailure: null,
+        });
+        t.check((loginProblem({ username: 'me@example.com', password: 'x' }, 'nordvpn') ?? '').includes('service credentials') &&
+            loginProblem({ username: 'me@example.com', password: 'x' }, 'openvpn-file') === null &&
+            (loginProblem({ username: 'abc', password: 'p[200~w' }, 'nordvpn') ?? '').includes('paste'), 'an e-mail is refused for NordVPN only (it needs the service credentials); hidden paste markers are refused');
+        login.save('nordvpn', { username: '  ' + USERNAME + ' ', password: ' ' + PASSWORD + '  ' });
+        t.equal(login.read('nordvpn'), { username: USERNAME, password: PASSWORD }, 'spaces around the user name and the password are not saved (a pasted login often has them)');
+        t.check(loginWarning({ username: 'x', password: 'y' }, 'openvpn-file') === null &&
+            loginWarning({ username: 'a'.repeat(24), password: 'B'.repeat(24) }, 'nordvpn') === null &&
+            loginWarning({ username: 'a b', password: 'c' }, 'nordvpn') !== null, 'a NordVPN login that does not look like service credentials gets a hint, not a refusal');
+        login.remove('nordvpn');
+        const failed = (log) => classifyFailure(log)?.code;
+        t.equal([
+            failed('AUTH: Received control message: AUTH_FAILED'),
+            failed('TLS Error: TLS key negotiation failed to occur within 60 seconds'),
+            failed('Could not create Wintun interface'),
+            failed('Exiting due to fatal error'),
+            failed('all fine'),
+        ], ['auth', 'unreachable', 'driver', 'other', undefined], 'the OpenVPN log is turned into a stable code the host acts on');
+        const refusedPage = vpnPage({
+            ...sampleStatus(),
+            lastFailure: { code: 'auth', text: FAILURE_TEXT.auth, at: '2026-11-02T19:15:21.000Z' },
+        });
+        const refusedText = pageLines(refusedPage).join('\n');
+        const refusedOps = pageActions(refusedPage).flatMap((a) => (a.kind === 'operation' ? [[a.op, a.label]] : []));
+        t.check(refusedText.includes('Last attempt') &&
+            refusedText.includes('login refused') &&
+            refusedText.includes('service credentials') &&
+            refusedOps.some(([op, label]) => op === 'vpn.login' && label === 'Save the login again…') &&
+            !/sandbox (vpn|config|agent)/.test(refusedText), 'after a refused login the VPN page says so and offers to save the login again, without naming a command');
+        const unreachablePage = vpnPage({
+            ...sampleStatus(),
+            lastFailure: { code: 'unreachable', text: FAILURE_TEXT.unreachable, at: '2026-11-02T19:15:21.000Z' },
+        });
+        t.check(pageActions(unreachablePage).some((a) => a.kind === 'operation' && a.input.key === 'vpn.protocol') &&
+            !pageActions(vpnPage({ ...sampleStatus(), protocol: 'tcp', lastFailure: { code: 'unreachable', text: 'x', at: 'y' } })).some((a) => a.kind === 'operation' && a.input.key === 'vpn.protocol'), 'a server that could not be reached offers TCP instead of UDP (once)');
         t.section('settings: what a project may and may not do');
         t.check(DEFAULTS.vpn.enabled === false && DEFAULTS.vpn.provider === 'nordvpn' && DEFAULTS.vpn.killSwitch === true, 'the VPN is off by default, NordVPN, with the kill switch on');
         t.check(ConfigSchema.safeParse(DEFAULTS).success, 'the defaults are valid');
@@ -458,11 +505,12 @@ export const vpnSuite = {
             login: 'none',
             loginSavedAt: null,
             running: null,
+            lastFailure: null,
         };
         const lines = pageLines(vpnPage(sample)).join('\n');
-        t.check(lines.includes('Next: sandbox vpn login') &&
+        t.check(!/sandbox (vpn|config|agent)/.test(lines) &&
             VPN_WARNINGS.every((w) => lines.includes(w)) &&
-            !lines.includes('Running now'), 'vpn status page: the facts, the next step on the command line only, the warnings', lines);
+            !lines.includes('Running now'), 'vpn status page: the facts and the warnings, no command to type', lines);
         t.equal(pageActions(vpnPage({ ...sample, provider: 'wireguard-file' })).map((a) => a.kind === 'operation' ? a.op : a.kind), ['settings.set'], 'vpn: wireguard needs no login and offers only turning the VPN on or off');
         t.equal(pageActions(vpnPage({ ...sample, login: 'saved', loginSavedAt: '2026-10-14T09:30:00.000Z' })).map((a) => a.kind === 'operation' ? a.op : a.kind), ['settings.set', 'vpn.login', 'vpn.logout'], 'a saved login offers turning the VPN on or off, saving the login again and deleting it');
         t.equal(vpnLoginRowOf(sample).hint, 'not saved', 'the Settings row says not saved when no login is saved');

package/dist/shared/accounts/anthropic.d.ts

@@ -0,0 +1,5 @@
+export declare const ANTHROPIC_KEY_PATTERN: RegExp;
+/** The only part of a key ever shown: sk-ant-...abcd. */
+export declare const ANTHROPIC_KEY_HINT: RegExp;
+/** What is wrong with a typed or found API key, or null when it has the right shape. Never quotes the key. */
+export declare function anthropicKeyProblem(key: string): string | null;

package/dist/shared/accounts/anthropic.js

@@ -0,0 +1,15 @@
+// The one shape of an Anthropic API key, for the host and the web (no node imports). A key from the Claude Console
+// starts with sk-ant-api, a key from a user workspace with sk-ant-usr.
+export const ANTHROPIC_KEY_PATTERN = /^sk-ant-(api|usr)\d{2}-[A-Za-z0-9_-]{20,400}$/;
+/** The only part of a key ever shown: sk-ant-...abcd. */
+export const ANTHROPIC_KEY_HINT = /^sk-ant-\.\.\.[A-Za-z0-9_-]{4}$/;
+/** What is wrong with a typed or found API key, or null when it has the right shape. Never quotes the key. */
+export function anthropicKeyProblem(key) {
+    if (ANTHROPIC_KEY_PATTERN.test(key))
+        return null;
+    if (key.startsWith('sk-ant-oat'))
+        return 'That is a Claude subscription token (from claude setup-token), not an API key. Save the subscription login instead.';
+    if (key.startsWith('sk-ant-admin'))
+        return 'That is an Admin key: it cannot run Claude. Make an API key instead.';
+    return 'An Anthropic API key starts with sk-ant-api or sk-ant-usr and has only letters, digits, - and _ (copy it from the Claude Console).';
+}

package/dist/shared/accounts/index.d.ts

@@ -3,3 +3,4 @@ export * from './payloads.js';
 export { fingerprint } from './fingerprint.js';
 export { epicSettingsFile, MAX_EPIC_INI_BYTES, readEpicLogin, withEpicLogin, type EpicPayload } from './kinds/epic.js';
 export * from './kinds/steam.js';
+export * from './anthropic.js';

package/dist/shared/accounts/index.js

@@ -5,3 +5,4 @@ export * from './payloads.js';
 export { fingerprint } from './fingerprint.js';
 export { epicSettingsFile, MAX_EPIC_INI_BYTES, readEpicLogin, withEpicLogin } from './kinds/epic.js';
 export * from './kinds/steam.js';
+export * from './anthropic.js';

package/dist/shared/channel/schema.d.ts

@@ -93,6 +93,10 @@ export declare const ProjectSpecSchema: z.ZodObject<{
             acceptLicense: z.ZodBoolean;
             components: z.ZodArray<z.ZodString>;
             keepInstallFiles: z.ZodBoolean;
+            visualStudio: z.ZodEnum<{
+                full: "full";
+                autosdk: "autosdk";
+            }>;
             persistEngines: z.ZodBoolean;
             derivedDataCache: z.ZodEnum<{
                 persisted: "persisted";
@@ -326,6 +330,10 @@ export declare const GuestRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 acceptLicense: z.ZodBoolean;
                 components: z.ZodArray<z.ZodString>;
                 keepInstallFiles: z.ZodBoolean;
+                visualStudio: z.ZodEnum<{
+                    full: "full";
+                    autosdk: "autosdk";
+                }>;
                 persistEngines: z.ZodBoolean;
                 derivedDataCache: z.ZodEnum<{
                     persisted: "persisted";
@@ -579,6 +587,10 @@ export declare const GuestRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 acceptLicense: z.ZodBoolean;
                 components: z.ZodArray<z.ZodString>;
                 keepInstallFiles: z.ZodBoolean;
+                visualStudio: z.ZodEnum<{
+                    full: "full";
+                    autosdk: "autosdk";
+                }>;
                 persistEngines: z.ZodBoolean;
                 derivedDataCache: z.ZodEnum<{
                     persisted: "persisted";
@@ -828,6 +840,7 @@ export declare const HeartbeatSchema: z.ZodObject<{
     phase: z.ZodEnum<{
         ready: "ready";
         working: "working";
+        ending: "ending";
     }>;
 }, z.core.$strip>;
 export type Heartbeat = z.output<typeof HeartbeatSchema>;
@@ -897,6 +910,13 @@ export declare const VpnStatusSchema: z.ZodObject<{
         up: "up";
     }>;
     message: z.ZodString;
+    code: z.ZodOptional<z.ZodEnum<{
+        auth: "auth";
+        unreachable: "unreachable";
+        driver: "driver";
+        timeout: "timeout";
+        other: "other";
+    }>>;
     killSwitch: z.ZodBoolean;
     killSwitchHeld: z.ZodOptional<z.ZodBoolean>;
     server: z.ZodOptional<z.ZodString>;

package/dist/shared/channel/schema.js

@@ -150,7 +150,8 @@ export const HeartbeatSchema = z.object({
     topProcesses: z.array(z.object({ name: Text(64), privateMb: z.number().int().min(0).max(1e7) })).max(5),
     /** The disk queue this PC last reported while asking the sandbox to slow down. */
     diskQueueReported: z.number().min(0).max(100000).optional(),
-    phase: z.enum(['ready', 'working']),
+    /** "ending": the sandbox is shutting down in order (idle shutdown, sandbox stop, Windows shutting down). */
+    phase: z.enum(['ready', 'working', 'ending']),
 });
 /** C:\AgentData\run\responses\<id>.json: the guest's reply. */
 export const GuestResponseSchema = z.object({
@@ -197,6 +198,8 @@ export const ProjectStatusSchema = z.object({
 export const VpnStatusSchema = z.object({
     state: z.enum(['off', 'starting', 'up', 'failed']),
     message: Text(2000),
+    /** Why it failed, when it did: `auth` (login refused), `unreachable`, `driver`, `timeout` or `other`. */
+    code: z.enum(['auth', 'unreachable', 'driver', 'timeout', 'other']).optional(),
     killSwitch: z.boolean(),
     /** A direct connection was tried after the kill switch was applied: false = it still got out. */
     killSwitchHeld: z.boolean().optional(),

package/dist/shared/io/disk.d.ts

@@ -0,0 +1,9 @@
+export type StatFs = (dir: string) => {
+    bavail: number;
+    bsize: number;
+};
+/**
+ * Free bytes for this user on the drive that holds `dir` (which may not exist yet: the nearest existing parent is
+ * asked); null when it cannot be told. `statfs` is injectable for tests.
+ */
+export declare function freeBytesAt(dir: string, statfs?: StatFs): number | null;

package/dist/shared/io/disk.js

@@ -0,0 +1,19 @@
+// Free room on a disk: one implementation for the PC (core/disk.ts) and the guest (toolchains/persisted.ts).
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Free bytes for this user on the drive that holds `dir` (which may not exist yet: the nearest existing parent is
+ * asked); null when it cannot be told. `statfs` is injectable for tests.
+ */
+export function freeBytesAt(dir, statfs = fs.statfsSync) {
+    let at = path.resolve(dir);
+    while (!fs.existsSync(at) && path.dirname(at) !== at)
+        at = path.dirname(at);
+    try {
+        const s = statfs(at);
+        return s.bavail * s.bsize;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/shared/io/index.d.ts

@@ -5,3 +5,4 @@ export * from './robocopy-result.js';
 export * from './copy-tree.js';
 export * from './bounded.js';
 export * from './text.js';
+export * from './disk.js';

package/dist/shared/io/index.js

@@ -5,3 +5,4 @@ export * from './robocopy-result.js';
 export * from './copy-tree.js';
 export * from './bounded.js';
 export * from './text.js';
+export * from './disk.js';

package/dist/shared/readiness.d.ts

@@ -0,0 +1,9 @@
+export declare const NOT_READY: {
+    /** Toolchains whose step is a stub: their settings rows are hidden and "auto" never turns them on. */
+    readonly toolchains: readonly ["unity", "godot", "android", "flutter", "dart", "reactNative", "fivem"];
+    /** Service sign-ins whose host or guest side is a stub: the menu and the web do not list them. */
+    readonly kinds: readonly ["unity", "keystore", "play", "expo", "appstore", "cfx"];
+    readonly unreal: readonly ["engines"];
+};
+export declare const isToolchainReady: (name: string) => boolean;
+export declare const isKindReady: (kind: string) => boolean;

package/dist/shared/readiness.js

@@ -0,0 +1,11 @@
+// What is not written yet, so no menu, web page or "auto" decision offers it. Each package that lands deletes its own
+// entries here (the end of round 2 leaves it empty). Pure.
+export const NOT_READY = {
+    /** Toolchains whose step is a stub: their settings rows are hidden and "auto" never turns them on. */
+    toolchains: ['unity', 'godot', 'android', 'flutter', 'dart', 'reactNative', 'fivem'],
+    /** Service sign-ins whose host or guest side is a stub: the menu and the web do not list them. */
+    kinds: ['unity', 'keystore', 'play', 'expo', 'appstore', 'cfx'],
+    unreal: ['engines'],
+};
+export const isToolchainReady = (name) => !NOT_READY.toolchains.includes(name);
+export const isKindReady = (kind) => !NOT_READY.kinds.includes(kind);

package/dist/shared/signer.d.ts

@@ -0,0 +1,24 @@
+/** Patterns (regex sources, case-insensitive) the signature's subject and issuer must match; every one of them. */
+export interface AppSigner {
+    readonly subject: readonly string[];
+    readonly issuer?: readonly string[];
+}
+/** A valid Authenticode signature's certificate names (an invalid or missing one is reported as null). */
+export interface Signature {
+    readonly subject: string;
+    readonly issuer: string;
+}
+/** Whether a signature is the expected signer's: every subject and issuer pattern matches. */
+export declare function signerMatches(signature: Signature | null, signer: AppSigner): boolean;
+/** Who signs the installers the toolchains run (the patterns the signature's subject must match). */
+export declare const SIGNERS: {
+    readonly microsoft: {
+        readonly subject: readonly ["^CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US$"];
+    };
+    readonly valve: {
+        readonly subject: readonly ["^CN=\"?Valve(,| Corp)"];
+    };
+    readonly unity: {
+        readonly subject: readonly ["^CN=\"?Unity Technologies"];
+    };
+};

package/dist/shared/signer.js

@@ -0,0 +1,15 @@
+// Who must sign an app's download (AppEntry.signer), for vendors that publish no checksum: the Authenticode subject
+// and issuer as patterns, checked against what sandbox\scripts\get-signature.ps1 reports for a valid signature. Pure.
+/** Whether a signature is the expected signer's: every subject and issuer pattern matches. */
+export function signerMatches(signature, signer) {
+    if (!signature || !signature.subject)
+        return false;
+    const all = (text, patterns) => patterns.every((p) => new RegExp(p, 'i').test(text));
+    return all(signature.subject, signer.subject) && all(signature.issuer, signer.issuer ?? []);
+}
+/** Who signs the installers the toolchains run (the patterns the signature's subject must match). */
+export const SIGNERS = {
+    microsoft: { subject: ['^CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US$'] },
+    valve: { subject: ['^CN="?Valve(,| Corp)'] },
+    unity: { subject: ['^CN="?Unity Technologies'] },
+};

package/dist/shared/system.d.ts

@@ -3,6 +3,7 @@ export declare const SYSTEM: {
     readonly cmd: () => string;
     readonly powershell: () => string;
     readonly tasklist: () => string;
+    readonly taskkill: () => string;
     readonly whoami: () => string;
     readonly icacls: () => string;
     readonly tar: () => string;

package/dist/shared/system.js

@@ -9,6 +9,7 @@ export const SYSTEM = {
     cmd: () => system32('cmd.exe'),
     powershell: () => system32('WindowsPowerShell\\v1.0\\powershell.exe'),
     tasklist: () => system32('tasklist.exe'),
+    taskkill: () => system32('taskkill.exe'),
     whoami: () => system32('whoami.exe'),
     icacls: () => system32('icacls.exe'),
     tar: () => system32('tar.exe'),

package/dist/shared/vpn/failure.d.ts

@@ -0,0 +1,10 @@
+export declare const VPN_FAILURE_CODES: readonly ["auth", "unreachable", "driver", "timeout", "other"];
+export type VpnFailureCode = (typeof VPN_FAILURE_CODES)[number];
+export interface VpnFailure {
+    readonly code: VpnFailureCode;
+    readonly reason: string;
+}
+/** What the log says went wrong, or null when it says nothing (yet). */
+export declare function classifyFailure(text: string): VpnFailure | null;
+/** The plain words for a code, for the page ("login refused by NordVPN"). */
+export declare const FAILURE_TEXT: Readonly<Record<VpnFailureCode, string>>;

package/dist/shared/vpn/failure.js

@@ -0,0 +1,28 @@
+// Why an OpenVPN run failed, from its log: a stable code (what the host acts on) and a plain sentence. Pure.
+export const VPN_FAILURE_CODES = ['auth', 'unreachable', 'driver', 'timeout', 'other'];
+/** What the log says went wrong, or null when it says nothing (yet). */
+export function classifyFailure(text) {
+    if (/AUTH_FAILED/i.test(text))
+        return {
+            code: 'auth',
+            reason: 'the VPN refused the login (for NordVPN use the service credentials, not your account password)',
+        };
+    if (/TLS Error: TLS key negotiation failed|TLS handshake failed/i.test(text))
+        return {
+            code: 'unreachable',
+            reason: 'it could not reach the VPN server (the network blocks it, or the server is down)',
+        };
+    if (/All wintun adapters on this system are in use|Cannot open TUN\/TAP|Could not create Wintun|ovpn-dco.*(error|failed)/i.test(text))
+        return { code: 'driver', reason: 'the network driver for the tunnel could not be used' };
+    if (/Exiting due to fatal error/i.test(text))
+        return { code: 'other', reason: 'OpenVPN stopped with an error' };
+    return null;
+}
+/** The plain words for a code, for the page ("login refused by NordVPN"). */
+export const FAILURE_TEXT = {
+    auth: 'login refused by the VPN',
+    unreachable: 'the VPN server could not be reached',
+    driver: 'the tunnel driver could not be used',
+    timeout: 'the tunnel did not come up in time',
+    other: 'the VPN failed',
+};

package/dist/sync/watcher.js

@@ -13,7 +13,8 @@ import { readForwards, sandboxAddress, startPortForwards } from '../host/network
 import { AuditCollector, AuditLog, readAuditSettings } from '../host/audit/index.js';
 import { readMarkedProjects, saveDataSize, watchAndMark } from '../host/guard/index.js';
 import { sizeWithin } from '../core/disk.js';
-import { autoRestartAllowed, causeSince, appendHostMemory, cpuPercentBetween, KeepAwake, LifeRecord, HostMemoryStream, readHostMemoryAsync, readLoadSettings, REQUEST_SECONDS, WATCHDOG_START, watchdogStep, saveCrashReport, SessionLedger, } from '../host/life/index.js';
+import { autoRestartAllowed, causeSince, readHeartbeat, vanishedCause, appendHostMemory, cpuPercentBetween, KeepAwake, LifeRecord, HostMemoryStream, readHostMemoryAsync, readLoadSettings, REQUEST_SECONDS, WATCHDOG_START, watchdogStep, saveCrashReport, SessionLedger, } from '../host/life/index.js';
+import { recordLastVpn } from '../host/vpn/index.js';
 import { SandboxChannel } from '../host/channel/index.js';
 import { ProjectRegistry } from '../host/projects/registry.js';
 import { ContainedStorage, setNameOf, storageOf } from '../host/storage/index.js';
@@ -67,7 +68,7 @@ export function watcherRunning(dataPath) {
     }
 }
 /** The ways the sandbox itself ends badly (the PC going down takes the watcher with it, so it never gets here). */
-const RESTARTABLE = ['sandboxCrash', 'memory'];
+const RESTARTABLE = ['sandboxCrash', 'memory', 'gpu', 'hyperv', 'vanished'];
 /**
  * The background watcher of one data folder: while the sandbox runs it syncs history back every minute, guards the
  * projects' git folders, keeps filtered workspaces in step, forwards ports, marks downloaded files, records the audit
@@ -276,6 +277,7 @@ export class Watcher {
         catch (e) {
             this.note('repo guard failed: ' + errMsg(e));
         }
+        recordLastVpn(this.storageRoot, this.dataPath);
         try {
             const s = syncBack(this.dataPath, final);
             if (s.history || final)
@@ -318,8 +320,13 @@ export class Watcher {
     recordEnd() {
         try {
             const last = this.life.read();
-            const cause = last ? causeSince(last.lastSeen, this.storageRoot) : null;
-            const report = last && cause ? saveCrashReport(this.storageRoot, this.dataPath, last.lastSeen) : null;
+            // Windows' own log first; when it says nothing, a sandbox that was busy and left no word of leaving "vanished".
+            const logged = last ? causeSince(last.lastSeen, this.storageRoot) : null;
+            const cause = logged ??
+                (last
+                    ? vanishedCause(readHeartbeat(this.dataPath), last.started, this.ledger.read()?.closedOnPurpose === true, Date.now())
+                    : null);
+            const report = last && cause ? saveCrashReport(this.storageRoot, this.dataPath, last.lastSeen, cause) : null;
             this.life.end(cause, new Date(), report);
             this.cause = cause;
             // Ended with nothing wrong (its window closed, or it shut itself down idle): on purpose.

package/dist/web/index.html

@@ -6,7 +6,7 @@
     <title>Sandbox</title>
     <link rel="icon" href="data:," />
     <link rel="stylesheet" href="/main-XT7T6ODM.css" />
-    <script type="module" src="/main-6XYO5FZC.js"></script>
+    <script type="module" src="/main-OUUQYNK4.js"></script>
   </head>
   <body>
     <div id="root"></div>