windows-development-sandbox 1.27.3 → 1.29.0

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

@@ -853,6 +853,7 @@ export declare const PressureStatusSchema: z.ZodObject<{
         pid: z.ZodNumber;
         seconds: z.ZodNumber;
     }, z.core.$strip>>;
+    held: z.ZodOptional<z.ZodNumber>;
     cpuPercent: z.ZodOptional<z.ZodNumber>;
     pcLow: z.ZodBoolean;
     lastAction: z.ZodString;
@@ -875,6 +876,7 @@ export declare const HeartbeatSchema: z.ZodObject<{
         privateMb: z.ZodNumber;
     }, z.core.$strip>>;
     diskQueueReported: z.ZodOptional<z.ZodNumber>;
+    held: z.ZodOptional<z.ZodNumber>;
     phase: z.ZodEnum<{
         ready: "ready";
         working: "working";

package/dist/shared/channel/schema.js

@@ -133,6 +133,8 @@ export const PressureStatusSchema = z.object({
     lowered: z.number().int().min(0).max(1024),
     /** Compilers waiting their turn right now (name, process id, seconds until they may go on). */
     paused: z.array(z.object({ name: Text(64), pid: z.number().int(), seconds: z.number().int().min(0).max(60) })).max(8),
+    /** Build programs the memory gate holds right now (let go one at a time). */
+    held: z.number().int().min(0).max(1024).optional(),
     /** The CPU share the compilers get together (percent; 100 = no cap). */
     cpuPercent: z.number().int().min(0).max(100).optional(),
     /** The PC itself asked for slowing down (its memory or CPU is low). */
@@ -157,6 +159,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(),
+    /** Build programs the memory gate holds right now (let go one at a time). */
+    held: z.number().int().min(0).max(1024).optional(),
     /** "ending": the sandbox is shutting down in order (idle shutdown, sandbox stop, Windows shutting down). */
     phase: z.enum(['ready', 'working', 'ending']),
 });

package/dist/shared/memory/policy.d.ts

@@ -72,3 +72,15 @@ export declare function maxCompilers(cpus: number, profile: LoadProfile): number
  * `CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER`).
  */
 export declare function cargoLinkerVar(host: string): string;
+/** The memory gate in memgov: new build programs wait when the agents' programs grow faster than this. */
+export interface BurstGate {
+    /** Growth (MB of committed memory) that counts as a burst... */
+    readonly growthMb: number;
+    /** ...within this many ms. */
+    readonly windowMs: number;
+    /** Held programs go on one at a time, this far apart (oldest first). */
+    readonly releaseMs: number;
+    /** No program waits longer than this (memgov's own cap is 30000); never killed. */
+    readonly maxHoldMs: number;
+}
+export declare const BURST_GATE: Readonly<Record<LoadProfile, BurstGate>>;

package/dist/shared/memory/policy.js

@@ -115,3 +115,7 @@ export function maxCompilers(cpus, profile) {
 export function cargoLinkerVar(host) {
     return 'CARGO_TARGET_' + host.toUpperCase().replace(/[^A-Z0-9]/g, '_') + '_LINKER';
 }
+export const BURST_GATE = {
+    normal: { growthMb: 4096, windowMs: 3000, releaseMs: 1500, maxHoldMs: 30000 },
+    gentle: { growthMb: 3072, windowMs: 3000, releaseMs: 2000, maxHoldMs: 30000 },
+};

package/dist/shared/pty/clipboard-watch.d.ts

@@ -0,0 +1,4 @@
+/** Calls `onChange` for each clipboard change from now on. No-op off Windows. */
+export declare function watchClipboard(onChange: () => void): {
+    stop: () => void;
+};

package/dist/shared/pty/clipboard-watch.js

@@ -0,0 +1,40 @@
+// Windows: tells the terminal client when the clipboard changes, e.g. you just copied text in the sandbox window (which
+// copies on select). sandbox\scripts\watch-clipboard.ps1 prints a line per change and ends with this process.
+// Only built-ins here: view.js bundles this.
+import { spawn } from 'node:child_process';
+import { SYSTEM } from '../system.js';
+import { scriptArgs } from '../scripts.js';
+/** The most output kept while waiting for the end of a line. */
+const MAX_PENDING = 1024;
+/** Calls `onChange` for each clipboard change from now on. No-op off Windows. */
+export function watchClipboard(onChange) {
+    if (process.platform !== 'win32')
+        return { stop: () => undefined };
+    let child = null;
+    try {
+        child = spawn(SYSTEM.powershell(), scriptArgs('watch-clipboard.ps1', ['-ProcessId', String(process.pid)]), {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
+    }
+    catch {
+        // Without the watcher a copy is only recognised from the program's own selection: nothing else is lost.
+        return { stop: () => undefined };
+    }
+    let pending = '';
+    child.stdout?.setEncoding('latin1');
+    child.stdout?.on('data', (text) => {
+        const lines = (pending + text).split('\n');
+        pending = (lines.pop() ?? '').slice(-MAX_PENDING);
+        for (const line of lines)
+            if (line.trim() === 'changed')
+                onChange();
+    });
+    child.on('error', () => undefined);
+    return {
+        stop: () => {
+            if (child && child.exitCode === null && child.signalCode === null)
+                child.kill();
+        },
+    };
+}

package/dist/shared/pty/ctrl-c.d.ts

@@ -1,18 +1,24 @@
-/** A second Ctrl+C within this long sends it. */
-export declare const CTRL_C_CONFIRM_MS = 1500;
-/** What the title shows while a Ctrl+C is held back. */
-export declare const CTRL_C_HINT = "Ctrl+C again to send it to the program (Esc stops an agent)";
+import { CTRL_C_CONFIRM_MS, CTRL_C_COPY_HINT, CTRL_C_HINT } from '../web/index.js';
+export { CTRL_C_CONFIRM_MS, CTRL_C_COPY_HINT, CTRL_C_HINT };
 export declare class CtrlCGuard {
-    private armedAt;
+    private readonly decider;
     private lastTitle;
-    /** What to send for one read from the keyboard: a lone Ctrl+C only when another came just before. */
+    constructor(options?: {
+        confirm?: boolean;
+    });
+    /** What to send for one read from the keyboard: a lone Ctrl+C only when it is not held back or taken as "copy". */
     push(chunk: Buffer, nowMs: number): {
         send: Buffer;
         held: boolean;
+        copied: boolean;
     };
+    /** The clipboard changed since the last key: you just copied. */
+    clipboardChanged(): void;
+    /** The program wrote to the clipboard: that is a selection too. */
+    watchClipboard(raw: string): void;
     /** Remembers the title the program last set (from its output), to put it back after the hint. */
     watchOutput(text: string): void;
     /** The escape sequence that shows the hint, and the one that puts the program's title back. */
-    hintTitle(): string;
+    hintTitle(kind?: 'hold' | 'copy'): string;
     restoreTitle(): string;
 }

package/dist/shared/pty/ctrl-c.js

@@ -1,25 +1,41 @@
-// A lone Ctrl+C is easy to send by accident: it is "copy" everywhere else, and a terminal sends it to the program when
-// the selection it was meant for has just been cleared by a redraw (an agent's spinner redraws all the time). With
-// attach.confirmCtrlC the terminal client holds a lone Ctrl+C back until it is pressed again within a moment; Esc still
-// stops an agent at once. Pure, so it is tested without a terminal.
-/** A second Ctrl+C within this long sends it. */
-export const CTRL_C_CONFIRM_MS = 1500;
-/** What the title shows while a Ctrl+C is held back. */
-export const CTRL_C_HINT = 'Ctrl+C again to send it to the program (Esc stops an agent)';
+// A Ctrl+C is easy to send by accident: it is "copy" everywhere else. Two rules keep it from stopping an agent.
+// 1. After you select text in the program (a mouse drag it received, or it wrote the clipboard with OSC 52), or the
+//    clipboard changed (you copied: the sandbox window copies on select), every Ctrl+C is "copy" and is never sent,
+//    until you press another key or click.
+// 2. With attach.confirmCtrlC a lone Ctrl+C is held back until it is pressed again within a moment.
+// Esc still stops an agent at once. The rules live in CtrlCDecider (pure, shared with the web terminal).
+import { CTRL_C_CONFIRM_MS, CTRL_C_COPY_HINT, CTRL_C_HINT, CtrlCDecider, classifyInput, hasClipboardWrite, } from '../web/index.js';
+export { CTRL_C_CONFIRM_MS, CTRL_C_COPY_HINT, CTRL_C_HINT };
 const OSC_TITLE = /\x1b\][02];([^\x07\x1b]{0,256})(?:\x07|\x1b\\)/g;
 export class CtrlCGuard {
-    armedAt = Number.NEGATIVE_INFINITY;
+    decider;
     lastTitle = '';
-    /** What to send for one read from the keyboard: a lone Ctrl+C only when another came just before. */
+    constructor(options = {}) {
+        this.decider = new CtrlCDecider(options.confirm !== false);
+    }
+    /** What to send for one read from the keyboard: a lone Ctrl+C only when it is not held back or taken as "copy". */
     push(chunk, nowMs) {
-        if (chunk.length !== 1 || chunk[0] !== 0x03)
-            return { send: chunk, held: false };
-        if (nowMs - this.armedAt <= CTRL_C_CONFIRM_MS) {
-            this.armedAt = Number.NEGATIVE_INFINITY;
-            return { send: chunk, held: false };
+        if (chunk.length === 1 && chunk[0] === 0x03) {
+            const action = this.decider.ctrlC(nowMs);
+            if (action === 'send')
+                return { send: chunk, held: false, copied: false };
+            return { send: Buffer.alloc(0), held: action === 'hold', copied: action === 'copy' };
         }
-        this.armedAt = nowMs;
-        return { send: Buffer.alloc(0), held: true };
+        const c = classifyInput(chunk.toString('latin1'));
+        if (c.keys || c.mouse === 'click')
+            this.decider.otherInput();
+        else if (c.mouse === 'drag')
+            this.decider.selection();
+        return { send: chunk, held: false, copied: false };
+    }
+    /** The clipboard changed since the last key: you just copied. */
+    clipboardChanged() {
+        this.decider.selection();
+    }
+    /** The program wrote to the clipboard: that is a selection too. */
+    watchClipboard(raw) {
+        if (hasClipboardWrite(raw))
+            this.decider.selection();
     }
     /** Remembers the title the program last set (from its output), to put it back after the hint. */
     watchOutput(text) {
@@ -27,8 +43,8 @@ export class CtrlCGuard {
             this.lastTitle = m[1];
     }
     /** The escape sequence that shows the hint, and the one that puts the program's title back. */
-    hintTitle() {
-        return '\x1b]0;' + CTRL_C_HINT + '\x07';
+    hintTitle(kind = 'hold') {
+        return '\x1b]0;' + (kind === 'copy' ? CTRL_C_COPY_HINT : CTRL_C_HINT) + '\x07';
     }
     restoreTitle() {
         return '\x1b]0;' + this.lastTitle.replace(/[\x00-\x1f\x7f]/g, '') + '\x07';

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

@@ -6,4 +6,5 @@ export { MouseModes } from './mouse-modes.js';
 export { JOIN_MS, InputJoiner } from './input-joiner.js';
 export { CTRL_C_CONFIRM_MS, CTRL_C_HINT, CtrlCGuard } from './ctrl-c.js';
 export { type VtInput, enableVtInput } from './console-input.js';
+export { watchClipboard } from './clipboard-watch.js';
 export { OutputFilter } from './output-filter.js';

package/dist/shared/pty/index.js

@@ -6,4 +6,5 @@ export { MouseModes } from './mouse-modes.js';
 export { JOIN_MS, InputJoiner } from './input-joiner.js';
 export { CTRL_C_CONFIRM_MS, CTRL_C_HINT, CtrlCGuard } from './ctrl-c.js';
 export { enableVtInput } from './console-input.js';
+export { watchClipboard } from './clipboard-watch.js';
 export { OutputFilter } from './output-filter.js';

package/dist/shared/pty/terminal.d.ts

@@ -19,7 +19,7 @@ export declare const MOUSE_OFF = "\u001B[?1000l\u001B[?1002l\u001B[?1003l\u001B[
  */
 export declare function runTerminalClient(socket: net.Socket, token: string, 
 /** clipboardWrites: the agent's "copy" (OSC 52) reaches the clipboard; see OutputFilterOptions. */
-/** confirmCtrlC: a lone Ctrl+C is held back until it is pressed again (CtrlCGuard, attach.confirmCtrlC). */
+/** confirmCtrlC (default true): a lone Ctrl+C is held back until pressed again; after a selection it is "copy". */
 options?: {
     detachKey?: number;
     clipboardWrites?: boolean;

package/dist/shared/pty/terminal.js

@@ -1,5 +1,6 @@
 import { FrameReader, encodeFrame, FrameType, resizeFrame, PING_INTERVAL_MS, helloFrame, } from './protocol.js';
 import { OutputFilter } from './output-filter.js';
+import { watchClipboard } from './clipboard-watch.js';
 import { enableVtInput } from './console-input.js';
 import { InputJoiner, JOIN_MS } from './input-joiner.js';
 import { CTRL_C_CONFIRM_MS, CtrlCGuard } from './ctrl-c.js';
@@ -40,7 +41,7 @@ const VT_WAIT_MS = 10000;
  */
 export function runTerminalClient(socket, token, 
 /** clipboardWrites: the agent's "copy" (OSC 52) reaches the clipboard; see OutputFilterOptions. */
-/** confirmCtrlC: a lone Ctrl+C is held back until it is pressed again (CtrlCGuard, attach.confirmCtrlC). */
+/** confirmCtrlC (default true): a lone Ctrl+C is held back until pressed again; after a selection it is "copy". */
 options = {}) {
     const stdin = process.stdin;
     const stdout = process.stdout;
@@ -75,6 +76,7 @@ options = {}) {
             clearTimeout(joinTimer);
             clearTimeout(hintTimer);
             clearTimeout(vtTimer);
+            clipboard.stop();
             socket.destroy();
             // The agent's mouse tracking ends with it: your terminal's wheel scrolls again (and clicks select text). Reports
             // the terminal sent before it read that are dropped here, or they would reach your shell as text.
@@ -98,24 +100,24 @@ options = {}) {
         };
         // Mouse reports the agent has not asked for (motion without 1002/1003 ...) are dropped: see MouseModes.
         const sendInput = (data) => write(keys.push(passthrough ? mouse.filter(data) : data));
-        const guard = options.confirmCtrlC ? new CtrlCGuard() : null;
+        const guard = new CtrlCGuard({ confirm: options.confirmCtrlC !== false });
         let hintTimer;
+        // Copying in your terminal (select) changes the clipboard: the Ctrl+C that follows is "copy", not an interrupt.
+        const clipboard = watchClipboard(() => guard.clipboardChanged());
         const onInput = (chunk) => {
             if (options.detachKey !== undefined && chunk.includes(options.detachKey)) {
                 finish({ reason: 'detach' });
                 return;
             }
-            if (guard) {
-                const decided = guard.push(chunk, Date.now());
-                clearTimeout(hintTimer);
-                if (decided.held) {
-                    stdout.write(guard.hintTitle());
-                    hintTimer = setTimeout(() => stdout.write(guard.restoreTitle()), CTRL_C_CONFIRM_MS);
-                    return;
-                }
-                if (decided.send.length === 1 && decided.send[0] === 0x03)
-                    stdout.write(guard.restoreTitle());
+            const decided = guard.push(chunk, Date.now());
+            clearTimeout(hintTimer);
+            if (decided.held || decided.copied) {
+                stdout.write(guard.hintTitle(decided.copied ? 'copy' : 'hold'));
+                hintTimer = setTimeout(() => stdout.write(guard.restoreTitle()), CTRL_C_CONFIRM_MS);
+                return;
             }
+            if (decided.send.length === 1 && decided.send[0] === 0x03)
+                stdout.write(guard.restoreTitle());
             clearTimeout(joinTimer);
             sendInput(joiner.push(chunk));
             // A lone Esc key press is a "sequence" that never completes: send it after a moment.
@@ -159,9 +161,10 @@ options = {}) {
             }
             for (const frame of frames) {
                 if (frame.type === FrameType.Output) {
+                    guard.watchClipboard(frame.payload.toString('latin1'));
                     const out = filter.push(frame.payload);
                     mouse.watch(out);
-                    guard?.watchOutput(out.toString('latin1'));
+                    guard.watchOutput(out.toString('latin1'));
                     stdout.write(out);
                 }
                 else if (frame.type === FrameType.Console)

package/dist/shared/web/ctrl-c.d.ts

@@ -0,0 +1,26 @@
+/** A second Ctrl+C within this long sends it. */
+export declare const CTRL_C_CONFIRM_MS = 1500;
+/** What the title shows while a Ctrl+C is held back. */
+export declare const CTRL_C_HINT = "Ctrl+C again to send it to the program (Esc stops an agent)";
+/** What the title shows when a Ctrl+C was taken as "copy". */
+export declare const CTRL_C_COPY_HINT = "Copied: Ctrl+C after selecting text is not sent to the program (Esc stops an agent)";
+export type CtrlCAction = 'send' | 'hold' | 'copy';
+export declare class CtrlCDecider {
+    private readonly confirm;
+    private armedAt;
+    private selected;
+    constructor(confirm?: boolean);
+    /** Text was selected in the program: Ctrl+C is "copy" from now on. */
+    selection(): void;
+    /** Any other key or a click: Ctrl+C is an interrupt again. */
+    otherInput(): void;
+    /** What to do with a lone Ctrl+C pressed at `nowMs`. */
+    ctrlC(nowMs: number): CtrlCAction;
+}
+/** What typed input holds: the strongest mouse report (a drag, else a click), and whether anything else is in it. */
+export declare function classifyInput(text: string): {
+    readonly mouse: 'drag' | 'click' | null;
+    readonly keys: boolean;
+};
+/** True when program output asks the terminal to write the clipboard (OSC 52). */
+export declare function hasClipboardWrite(text: string): boolean;

package/dist/shared/web/ctrl-c.js

@@ -0,0 +1,64 @@
+// When a Ctrl+C is "copy" and when it is an interrupt, shared by the terminal client and the web terminal. Agents turn
+// mouse tracking on, so selecting text happens inside the program (a mouse drag, or an OSC 52 clipboard write) and the
+// terminal never sees a selection. After that every Ctrl+C is "copy" and is not sent, until another key or a click.
+// Outside that, a lone Ctrl+C is held and a second one soon after is sent. Pure: no node imports.
+/** A second Ctrl+C within this long sends it. */
+export const CTRL_C_CONFIRM_MS = 1500;
+/** What the title shows while a Ctrl+C is held back. */
+export const CTRL_C_HINT = 'Ctrl+C again to send it to the program (Esc stops an agent)';
+/** What the title shows when a Ctrl+C was taken as "copy". */
+export const CTRL_C_COPY_HINT = 'Copied: Ctrl+C after selecting text is not sent to the program (Esc stops an agent)';
+export class CtrlCDecider {
+    confirm;
+    armedAt = Number.NEGATIVE_INFINITY;
+    selected = false;
+    constructor(confirm = true) {
+        this.confirm = confirm;
+    }
+    /** Text was selected in the program: Ctrl+C is "copy" from now on. */
+    selection() {
+        this.selected = true;
+        this.armedAt = Number.NEGATIVE_INFINITY;
+    }
+    /** Any other key or a click: Ctrl+C is an interrupt again. */
+    otherInput() {
+        this.selected = false;
+    }
+    /** What to do with a lone Ctrl+C pressed at `nowMs`. */
+    ctrlC(nowMs) {
+        if (this.selected)
+            return 'copy';
+        if (!this.confirm)
+            return 'send';
+        if (nowMs - this.armedAt <= CTRL_C_CONFIRM_MS) {
+            this.armedAt = Number.NEGATIVE_INFINITY;
+            return 'send';
+        }
+        this.armedAt = nowMs;
+        return 'hold';
+    }
+}
+// SGR reports (ESC [ < b ; x ; y M|m) and X10 reports (ESC [ M and three characters); bounded, no backtracking.
+const MOUSE_REPORT = /\x1b\[<(\d{1,4});\d{1,5};\d{1,5}([Mm])|\x1b\[M([\s\S])[\s\S]{2}/g;
+/** What typed input holds: the strongest mouse report (a drag, else a click), and whether anything else is in it. */
+export function classifyInput(text) {
+    let drag = false;
+    let click = false;
+    for (const m of text.matchAll(MOUSE_REPORT)) {
+        const sgr = m[1] !== undefined;
+        const b = sgr ? Number(m[1]) : (m[3] ?? ' ').charCodeAt(0) - 32;
+        if (b & 64)
+            continue;
+        if (b & 32) {
+            if ((b & 3) !== 3)
+                drag = true;
+        }
+        else if (sgr ? m[2] === 'M' : (b & 3) !== 3)
+            click = true;
+    }
+    return { mouse: drag ? 'drag' : click ? 'click' : null, keys: text.replace(MOUSE_REPORT, '').length > 0 };
+}
+/** True when program output asks the terminal to write the clipboard (OSC 52). */
+export function hasClipboardWrite(text) {
+    return /\x1b\]0{0,2}52;/.test(text) || /\u009d0{0,2}52;/.test(text);
+}

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

@@ -1 +1,2 @@
 export * from './protocol.js';
+export * from './ctrl-c.js';

package/dist/shared/web/index.js

@@ -1 +1,2 @@
 export * from './protocol.js';
+export * from './ctrl-c.js';

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-NKM7ECSB.js"></script>
+    <script type="module" src="/main-7NY4X6YU.js"></script>
   </head>
   <body>
     <div id="root"></div>