windows-development-sandbox 1.10.0 → 1.11.4

package/dist/host/sandbox/tasklist.d.ts

@@ -7,6 +7,12 @@ export interface TasklistRunners {
 export declare function useTasklistRunners(replacement?: TasklistRunners): void;
 /** While set, a synchronous read returns this copy (undefined: none yet, run tasklist). Null removes it. */
 export declare function useTasklistCache(read: (() => string | undefined) | null): void;
+/**
+ * For a long-running server (the web UI): questions within `freshMs` of the last run share its list; an older one
+ * (up to `staleMs`) is still answered from it while a new list is fetched in the background, so no request waits for
+ * tasklist. Nothing runs while nobody asks. Returns the function that stops it.
+ */
+export declare function keepTasklistFresh(freshMs?: number, staleMs?: number): () => void;
 /** The process list now: the cached copy when the menu keeps one, else a run of tasklist the caller waits for. */
 export declare function readTasklist(): string;
 /** The process list from a run of tasklist that does not block the program (the menu's background refresh). */

package/dist/host/sandbox/tasklist.js

@@ -37,6 +37,43 @@ export function useTasklistRunners(replacement = REAL_RUNNERS) {
 export function useTasklistCache(read) {
     cache = read;
 }
+/**
+ * For a long-running server (the web UI): questions within `freshMs` of the last run share its list; an older one
+ * (up to `staleMs`) is still answered from it while a new list is fetched in the background, so no request waits for
+ * tasklist. Nothing runs while nobody asks. Returns the function that stops it.
+ */
+export function keepTasklistFresh(freshMs = 2000, staleMs = 15000) {
+    let copy;
+    let at = 0;
+    let fetching = false;
+    const refresh = () => {
+        if (fetching)
+            return;
+        fetching = true;
+        void runners
+            .async()
+            .then((list) => {
+            copy = list;
+            at = Date.now();
+        })
+            .finally(() => {
+            fetching = false;
+        });
+    };
+    useTasklistCache(() => {
+        const age = Date.now() - at;
+        if (copy !== undefined && age < freshMs)
+            return copy;
+        if (copy !== undefined && age < staleMs) {
+            refresh();
+            return copy;
+        }
+        copy = runners.sync();
+        at = Date.now();
+        return copy;
+    });
+    return () => useTasklistCache(null);
+}
 /** The process list now: the cached copy when the menu keeps one, else a run of tasklist the caller waits for. */
 export function readTasklist() {
     return cache?.() ?? runners.sync();

package/dist/host/secrets/launch-secrets.d.ts

@@ -4,7 +4,8 @@ import type { GuestRequest } from '../../core/types.js';
 export declare function writeSecrets(dataPath: string, id: string, secrets: SecretsFile): string | null;
 /**
  * Removes whatever one-shot files are left (the sandbox did not start, or did not get to read them) and, from older
- * versions, a login copy in a launch folder. Called before a launch writes new ones and when the sandbox stops.
+ * versions, a login copy in a launch folder. Called before a launch writes new ones, and when a launch fails before
+ * its sandbox starts.
  */
 export declare function clearSecrets(storageRoot: string, dataPath: string): number;
 /**

package/dist/host/secrets/launch-secrets.js

@@ -12,7 +12,8 @@ export function writeSecrets(dataPath, id, secrets) {
         !Object.keys(secrets.projectHarnessEnvironment ?? {}).length &&
         !secrets.claudeCredentials &&
         !secrets.vpn &&
-        !secrets.wireguardConfig;
+        !secrets.wireguardConfig &&
+        !secrets.githubToken;
     if (empty)
         return null;
     const run = new RunDir(dataPath);
@@ -23,7 +24,8 @@ export function writeSecrets(dataPath, id, secrets) {
 }
 /**
  * Removes whatever one-shot files are left (the sandbox did not start, or did not get to read them) and, from older
- * versions, a login copy in a launch folder. Called before a launch writes new ones and when the sandbox stops.
+ * versions, a login copy in a launch folder. Called before a launch writes new ones, and when a launch fails before
+ * its sandbox starts.
  */
 export function clearSecrets(storageRoot, dataPath) {
     let removed = 0;

package/dist/host/vpn/status.js

@@ -17,8 +17,16 @@ export function vpnLine(status, hostIp = null) {
     if (!status)
         return { level: 'warn', text: 'The sandbox has not reported on the VPN.' };
     const message = safeText(status.message).slice(0, 300);
+    const leaky = status.killSwitch && status.killSwitchHeld === false;
     if (status.state === 'up') {
         const same = hostIp !== null && status.publicIp === hostIp;
+        if (!same && leaky)
+            return {
+                level: 'warn',
+                text: 'VPN up' +
+                    (status.publicIp ? ', the sandbox appears as ' + safeText(status.publicIp) : '') +
+                    ', but the kill switch did not hold: if the tunnel drops, traffic goes out through your normal connection.',
+            };
         return same
             ? {
                 level: 'bad',
@@ -40,9 +48,11 @@ export function vpnLine(status, hostIp = null) {
             level: 'bad',
             text: 'VPN failed: ' +
                 message +
-                (status.killSwitch
-                    ? ' The kill switch is on, so the sandbox has no internet.'
-                    : ' The kill switch is off, so the sandbox uses your normal connection.'),
+                (leaky
+                    ? ' The kill switch did not hold, so the sandbox is ONLINE through your normal connection, without the VPN.'
+                    : status.killSwitch
+                        ? ' The kill switch is on, so the sandbox has no internet.'
+                        : ' The kill switch is off, so the sandbox uses your normal connection.'),
         };
     return { level: 'warn', text: 'VPN ' + status.state + (message ? ': ' + message : '') };
 }

package/dist/host/web/backend.d.ts

@@ -1,5 +1,5 @@
 import type { Endpoint } from '../../shared/pty/index.js';
-import type { NewSessionRequest, WebInfo, WebSession } from '../../shared/web/index.js';
+import type { WebInfo, WebSession } from '../../shared/web/index.js';
 export interface WebBackend {
     info(): Promise<WebInfo>;
     /** Sessions as the browser may see them: never an attach token or address. */
@@ -9,6 +9,4 @@ export interface WebBackend {
      * running session, the sandbox is not shared with this user, or it has no address on this PC's sandbox network.
      */
     endpoint(sessionId: string): Endpoint | null;
-    /** Starts an agent in a project of the running sandbox and waits until it runs. */
-    create(request: NewSessionRequest): Promise<WebSession>;
 }

package/dist/host/web/index.d.ts

@@ -4,7 +4,8 @@ export { openBrowser, openIssuePage } from './browser.js';
 export { TerminalBridge } from './bridge.js';
 export { WebControl, type WebStatus } from './control.js';
 export { WebRunner } from './runner.js';
+export { LiveHub, type LiveListener } from './live.js';
 export { RpcSession } from './rpc.js';
-export { WebServer, CONTENT_SECURITY_POLICY, RPC_PATH, type WebServerOptions } from './server.js';
+export { WebServer, CONTENT_SECURITY_POLICY, IDLE_EXIT_MS, RPC_PATH, type WebServerOptions } from './server.js';
 export { StaticFiles } from './static-files.js';
 export { WebStore, WebStateSchema, type WebState } from './state.js';

package/dist/host/web/index.js

@@ -3,7 +3,8 @@ export { openBrowser, openIssuePage } from './browser.js';
 export { TerminalBridge } from './bridge.js';
 export { WebControl } from './control.js';
 export { WebRunner } from './runner.js';
+export { LiveHub } from './live.js';
 export { RpcSession } from './rpc.js';
-export { WebServer, CONTENT_SECURITY_POLICY, RPC_PATH } from './server.js';
+export { WebServer, CONTENT_SECURITY_POLICY, IDLE_EXIT_MS, RPC_PATH } from './server.js';
 export { StaticFiles } from './static-files.js';
 export { WebStore, WebStateSchema } from './state.js';

package/dist/host/web/live.d.ts

@@ -0,0 +1,23 @@
+import type { RpcHost } from '../../app/kernel/index.js';
+export type LiveListener = (event: {
+    readonly output: unknown;
+} | {
+    readonly error: unknown;
+}) => void;
+export declare class LiveHub {
+    private readonly host;
+    private readonly polls;
+    constructor(host: RpcHost);
+    /** How many polls run (for tests and the idle check). */
+    get size(): number;
+    /**
+     * Starts listening; the listener gets the current answer (at once when one is known) and every change. Returns the
+     * function that stops listening.
+     */
+    watch(query: string, input: unknown, listener: LiveListener): () => void;
+    /** Something changed (an operation ran): every query reads again now, at its own pace. */
+    poke(): void;
+    private schedule;
+    private isLive;
+    private read;
+}

package/dist/host/web/live.js

@@ -0,0 +1,107 @@
+import { NO_QUESTIONS } from '../../app/kernel/index.js';
+/** A query unchanged this many reads in a row is read less often... */
+const CALM_READS = 4;
+/** ...down to this many times its own interval. */
+const SLOWEST = 4;
+export class LiveHub {
+    host;
+    polls = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    /** How many polls run (for tests and the idle check). */
+    get size() {
+        return this.polls.size;
+    }
+    /**
+     * Starts listening; the listener gets the current answer (at once when one is known) and every change. Returns the
+     * function that stops listening.
+     */
+    watch(query, input, listener) {
+        const key = query + '\u0000' + JSON.stringify(input ?? null);
+        let poll = this.polls.get(key);
+        if (!poll) {
+            poll = {
+                query,
+                input,
+                everyMs: this.host.liveMs(query) ?? 0,
+                listeners: new Set(),
+                timer: undefined,
+                busy: false,
+                last: undefined,
+                lastOutput: undefined,
+                calm: 0,
+                again: false,
+            };
+            this.polls.set(key, poll);
+            void this.read(poll);
+        }
+        else if (poll.last !== undefined)
+            listener({ output: poll.lastOutput });
+        else if (!poll.busy)
+            void this.read(poll); // the last read failed: try again for the newcomer
+        poll.listeners.add(listener);
+        const p = poll;
+        return () => {
+            p.listeners.delete(listener);
+            if (p.listeners.size)
+                return;
+            clearTimeout(p.timer);
+            this.polls.delete(key);
+        };
+    }
+    /** Something changed (an operation ran): every query reads again now, at its own pace. */
+    poke() {
+        for (const poll of this.polls.values()) {
+            poll.calm = 0;
+            void this.read(poll);
+        }
+    }
+    schedule(poll) {
+        clearTimeout(poll.timer);
+        if (!poll.everyMs || !this.isLive(poll))
+            return;
+        const factor = poll.calm >= CALM_READS ? Math.min(SLOWEST, 1 + Math.floor(poll.calm / CALM_READS)) : 1;
+        poll.timer = setTimeout(() => void this.read(poll), poll.everyMs * factor);
+        poll.timer.unref?.();
+    }
+    isLive(poll) {
+        return [...this.polls.values()].includes(poll);
+    }
+    async read(poll) {
+        if (poll.busy) {
+            poll.again = true;
+            return;
+        }
+        poll.busy = true;
+        clearTimeout(poll.timer);
+        try {
+            const output = await this.host.run(poll.query, poll.input, NO_QUESTIONS);
+            const text = JSON.stringify(output);
+            if (text === poll.last)
+                poll.calm++;
+            else {
+                poll.calm = 0;
+                poll.last = text;
+                poll.lastOutput = output;
+                for (const l of [...poll.listeners])
+                    l({ output });
+            }
+        }
+        catch (error) {
+            poll.calm = 0;
+            poll.last = undefined;
+            for (const l of [...poll.listeners])
+                l({ error });
+        }
+        finally {
+            poll.busy = false;
+        }
+        if (poll.again) {
+            poll.again = false;
+            void this.read(poll);
+            return;
+        }
+        this.schedule(poll);
+    }
+}

package/dist/host/web/rpc.d.ts

@@ -1,12 +1,17 @@
 import type { WebSocket } from 'ws';
 import { type RpcHost } from '../../app/kernel/index.js';
+import { LiveHub } from './live.js';
 export declare class RpcSession {
     private readonly ws;
     private readonly host;
+    /** Shared by every socket of the server (one poll per query); a socket of its own by default. */
+    private readonly live;
     private readonly calls;
     private readonly subscriptions;
     private closed;
-    constructor(ws: WebSocket, host: RpcHost);
+    constructor(ws: WebSocket, host: RpcHost, 
+    /** Shared by every socket of the server (one poll per query); a socket of its own by default. */
+    live?: LiveHub);
     start(): void;
     private send;
     /** A browser that sends something that is not one of our messages is closed. */

package/dist/host/web/rpc.js

@@ -1,4 +1,5 @@
-import { ANSWER_SCHEMAS, ClientMessageSchema, MAX_OPEN_PER_SOCKET, NO_QUESTIONS, ioFromAsker, toWireError, } from '../../app/kernel/index.js';
+import { ANSWER_SCHEMAS, ClientMessageSchema, MAX_OPEN_PER_SOCKET, ioFromAsker, toWireError, } from '../../app/kernel/index.js';
+import { LiveHub } from './live.js';
 /** What a question gets when the browser goes away before answering: no. */
 function declined(q) {
     return q.kind === 'confirm' ? false : undefined;
@@ -6,12 +7,16 @@ function declined(q) {
 export class RpcSession {
     ws;
     host;
+    live;
     calls = new Map();
     subscriptions = new Map();
     closed = false;
-    constructor(ws, host) {
+    constructor(ws, host, 
+    /** Shared by every socket of the server (one poll per query); a socket of its own by default. */
+    live = new LiveHub(host)) {
         this.ws = ws;
         this.host = host;
+        this.live = live;
     }
     start() {
         this.ws.on('message', (data, binary) => this.receive(data, binary));
@@ -86,7 +91,12 @@ export class RpcSession {
         this.host
             .run(op, input, io)
             .then((output) => this.send({ t: 'result', id, output }), (e) => this.send({ t: 'error', id, error: toWireError(e) }))
-            .finally(() => this.calls.delete(id));
+            .finally(() => {
+            this.calls.delete(id);
+            // An operation may have changed what the live queries show: they read again now.
+            if (this.host.kind(op) === 'operation')
+                this.live.poke();
+        });
     }
     answer(id, value) {
         const waiting = this.calls.get(id);
@@ -103,38 +113,20 @@ export class RpcSession {
             this.send({ t: 'error', id, error: { kind: 'invalid', message: 'There is no ' + query + ' here.' } });
             return;
         }
-        const sub = { timer: undefined, last: undefined, busy: false };
-        this.subscriptions.set(id, sub);
-        const read = async () => {
-            if (sub.busy)
+        const stop = this.live.watch(query, input, (event) => {
+            if (this.subscriptions.get(id) !== stop)
                 return;
-            sub.busy = true;
-            try {
-                const output = await this.host.run(query, input, NO_QUESTIONS);
-                const text = JSON.stringify(output);
-                if (text !== sub.last && this.subscriptions.get(id) === sub) {
-                    sub.last = text;
-                    this.send({ t: 'data', id, output });
-                }
-            }
-            catch (e) {
-                sub.last = undefined;
-                this.send({ t: 'error', id, error: toWireError(e) });
-            }
-            finally {
-                sub.busy = false;
-            }
-        };
-        void read();
-        const every = this.host.liveMs(query);
-        if (every)
-            sub.timer = setInterval(() => void read(), every);
+            if ('output' in event)
+                this.send({ t: 'data', id, output: event.output });
+            else
+                this.send({ t: 'error', id, error: toWireError(event.error) });
+        });
+        this.subscriptions.set(id, stop);
     }
     unsubscribe(id) {
-        const sub = this.subscriptions.get(id);
-        if (sub?.timer)
-            clearInterval(sub.timer);
+        const stop = this.subscriptions.get(id);
         this.subscriptions.delete(id);
+        stop?.();
     }
     /** The browser went away: subscriptions stop, and questions still open are answered no. */
     close() {

package/dist/host/web/runner.d.ts

@@ -6,6 +6,10 @@ export interface WebRunOptions {
     readonly backend: WebBackend;
     readonly rpc?: RpcHost;
     readonly staticRoot: string;
+    /** This program's version, kept in the state file. */
+    readonly version: string;
+    /** End after this long unused while no sandbox runs (WebServerOptions.idleExitMs). */
+    readonly idleExitMs?: number;
 }
 export declare class WebRunner {
     private readonly options;

package/dist/host/web/runner.js

@@ -1,4 +1,5 @@
 import { fail } from '../../core/util/index.js';
+import { keepTasklistFresh } from '../sandbox/index.js';
 import { newToken } from './auth.js';
 import { WebServer } from './server.js';
 import { WebStore } from './state.js';
@@ -20,6 +21,7 @@ export class WebRunner {
             backend: this.options.backend,
             rpc: this.options.rpc,
             staticRoot: this.options.staticRoot,
+            idleExitMs: this.options.idleExitMs,
             onStop: stop,
         });
         try {
@@ -30,13 +32,22 @@ export class WebRunner {
                 fail('Port ' + this.options.port + ' is taken by another program.', 'Pick another with the web.port setting, then run sandbox web start again.');
             throw e;
         }
-        this.store.write({ pid: process.pid, port: server.port, token, startedAt: new Date().toISOString() });
+        this.store.write({
+            pid: process.pid,
+            port: server.port,
+            token,
+            startedAt: new Date().toISOString(),
+            version: this.options.version,
+        });
         process.once('SIGINT', stop);
         process.once('SIGTERM', stop);
+        // Every browser's status reads share one process list instead of each running tasklist.
+        const stopTasklist = keepTasklistFresh();
         try {
             await stopped;
         }
         finally {
+            stopTasklist();
             this.store.clear();
             await server.stop();
         }

package/dist/host/web/server.d.ts

@@ -4,6 +4,8 @@ import type { Endpoint } from '../../shared/pty/index.js';
 import type { WebBackend } from './backend.js';
 /** No inline script: the page and its script are files from this server. Inline styles are what xterm.js needs. */
 export declare const CONTENT_SECURITY_POLICY: string;
+/** The server ends after this long with no request, no socket and no sandbox running (it starts again with one). */
+export declare const IDLE_EXIT_MS: number;
 export declare const RPC_PATH = "/api/rpc";
 export interface WebServerOptions {
     /** 0 picks a free port (tests). */
@@ -18,6 +20,16 @@ export interface WebServerOptions {
     readonly dial?: (endpoint: Endpoint) => Promise<net.Socket>;
     /** The shared core's operations and queries the browser may run (none: /api/rpc is not served). */
     readonly rpc?: RpcHost;
+    /** End by itself (onStop) after this long unused while no sandbox runs; 0 or missing: never (tests). */
+    readonly idleExitMs?: number;
+    /** Heartbeat period (tests make it short). */
+    readonly heartbeatMs?: number;
+}
+/** A browser's socket: which kind, whether it answered the last ping, and when it was opened. */
+interface Tracked {
+    readonly kind: 'terminal' | 'rpc';
+    readonly opened: number;
+    alive: boolean;
 }
 export declare class WebServer {
     private readonly options;
@@ -25,12 +37,27 @@ export declare class WebServer {
     private readonly sockets;
     private readonly auth;
     private readonly files;
-    private terminals;
-    private rpcSockets;
+    private readonly tracked;
+    /** One poll per live query for all browsers together. */
+    private readonly live;
     private actualPort;
+    private lastUsed;
+    private heartbeat;
+    private idleCheck;
     constructor(options: WebServerOptions);
     get port(): number;
     start(): Promise<void>;
+    /** How many browser sockets are open, by kind. */
+    openSockets(kind: Tracked['kind']): number;
+    /**
+     * Drops sockets that did not answer the last ping (a tab that went away without closing: sleep, a killed browser),
+     * so they never hold a slot or a session connection.
+     */
+    private beat;
+    /** Nothing has used the server for a while and no sandbox runs: it ends (the next launch starts it again). */
+    private checkIdle;
+    /** Counts a new socket; at the limit, the oldest of its kind makes room (a new tab always works). */
+    private track;
     stop(): Promise<void>;
     private headers;
     private json;
@@ -45,3 +72,4 @@ export declare class WebServer {
     /** The RPC socket (after the same Origin and cookie checks as a terminal). */
     private upgradeRpc;
 }
+export {};