windows-development-sandbox 1.13.0 → 1.14.0

package/dist/selftest/live-terminal.test.js

@@ -2,8 +2,8 @@
 // Windows Terminal's own pseudo console) and runs the real viewer/attach client (runTerminalClient), which is attached
 // to an inner ptyhost running a stand-in agent. The agent turns SGR mouse tracking on and echoes every byte it reads.
 // Checks: clicks and the wheel reach the agent, Backspace stays Backspace, a split escape sequence arrives whole,
-// 500 printed lines scroll through as lines (no alternate screen, no scrollback clear), and a viewer that joins after
-// a screen clear still gets mouse tracking.
+// 500 printed lines scroll through as lines (no alternate screen, no scrollback clear), a viewer that joins after
+// a screen clear still gets mouse tracking, and drag and motion reports reach the agent only once it asked for them.
 import fs from 'node:fs';
 import net from 'node:net';
 import path from 'node:path';
@@ -14,7 +14,7 @@ import { SYSTEM } from '../shared/system.js';
 import { CSC, openViewer, tail, WAIT } from './support/live.js';
 /**
  * The stand-in agent: VT input and SGR mouse tracking on, echoes what it reads ("got <1b>[<0;10;5M"). L prints 500
- * lines, K clears the screen, q quits.
+ * lines, K clears the screen, D turns drag reports on (1002), A every motion (1003), q quits.
  */
 const AGENT_CS = String.raw `
 using System;
@@ -44,6 +44,8 @@ static class MouseAgent
             Say("got " + got + "\r\n");
             if (got == "L") { var lines = new StringBuilder(); for (int i = 1; i <= 500; i++) lines.Append("line " + i + "\r\n"); Say(lines.ToString() + "LINES-DONE\r\n"); }
             if (got == "K") Say("\x1b[2J\x1b[HCLEARED\r\n");
+            if (got == "D") Say("\x1b[?1002hDRAG-ON\r\n");
+            if (got == "A") Say("\x1b[?1003hMOVE-ON\r\n");
             if (got == "q") break;
         }
         // Exits with mouse tracking still on (like a crash): the client must turn it off.
@@ -120,6 +122,75 @@ export const liveTerminalSuite = {
                     stdio: 'ignore',
                 });
         }
+        t.section('a ptyhost ended from outside: what it recorded is ended, and nothing else');
+        {
+            // ptyhost records its program's process tree (PTYHOST_TREE_FILE); --end-tree ends it once ptyhost is gone,
+            // checking every process by id and start time.
+            const record = t.at('tree.json');
+            const ping = path.join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'PING.EXE');
+            const holder = '"' + SYSTEM.cmd() + '" /c "' + ping + '" -n 120 127.0.0.1 >nul';
+            const host = spawn(ptyhost, [String(await freePort()), 'tok', '80', '24', t.at('tree.log'), holder], {
+                env: { ...process.env, PTYHOST_BIND: 'loopback', PTYHOST_TREE_FILE: record },
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+            const read = (file) => {
+                try {
+                    return JSON.parse(fs.readFileSync(file, 'utf8'));
+                }
+                catch {
+                    return null;
+                }
+            };
+            const alive = (pid) => {
+                try {
+                    process.kill(pid, 0);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            };
+            // The program (cmd) and the PING it started, once ptyhost has followed the tree (every 3 s).
+            const recorded = await t.waitFor(() => {
+                const r = read(record);
+                return r && r.ptyhost.pid === host.pid && r.processes.length >= 2 ? r : null;
+            }, WAIT.screen);
+            t.check(recorded !== null, 'ptyhost records its program and what it started', JSON.stringify(read(record)));
+            if (recorded) {
+                const endTree = (file) => {
+                    const r = spawnSync(ptyhost, ['--end-tree', file], { encoding: 'utf8', windowsHide: true });
+                    return { status: r.status, stdout: (r.stdout ?? '').trim() };
+                };
+                const copy = t.at('tree-copy.json');
+                fs.writeFileSync(copy, JSON.stringify(recorded));
+                const whileRunning = endTree(copy);
+                // The same ids with other start times: what a reused id looks like.
+                const forged = t.at('tree-forged.json');
+                fs.writeFileSync(forged, JSON.stringify({
+                    ptyhost: { pid: recorded.ptyhost.pid, start: '1' },
+                    processes: recorded.processes.map((p) => ({ pid: p.pid, start: String(BigInt(p.start) + 1n) })),
+                }));
+                const reused = endTree(forged);
+                t.check(whileRunning.status === 3 &&
+                    reused.status === 0 &&
+                    reused.stdout === 'ended 0 process(es)' &&
+                    recorded.processes.every((p) => alive(p.pid)), 'nothing is ended while the ptyhost that recorded it runs, nor a process whose id was reused (start time)', JSON.stringify({ whileRunning, reused }));
+                host.kill();
+                await t.waitFor(() => host.exitCode !== null, 10000);
+                const left = fs.existsSync(record);
+                const ended = endTree(record);
+                await t.waitFor(() => recorded.processes.every((p) => !alive(p.pid)), 10000);
+                t.check(left && ended.status === 0 && recorded.processes.every((p) => !alive(p.pid)), 'a ptyhost ended from outside leaves its record, and --end-tree ends the processes in it', JSON.stringify({ left, ended, alive: recorded.processes.filter((p) => alive(p.pid)) }));
+            }
+            try {
+                if (host.exitCode === null)
+                    host.kill();
+            }
+            catch {
+                /* it ended between the check and the kill: nothing left to stop */
+            }
+        }
         t.section("the agents' job: a last-resort backstop, set once");
         {
             // A job of the test's own (PTYHOST_JOB_NAME), never the agents' real one.
@@ -289,9 +360,46 @@ export const liveTerminalSuite = {
                     t.check(head.includes('\x1b[?1000h') && head.includes('\x1b[?1006h'), "a viewer joining after a screen clear gets the agent's mouse tracking before the replay", 'late viewer: ' + JSON.stringify(late.output().slice(0, 300)));
                     late.close();
                 }
+                if (kind) {
+                    // Raw mouse input (passed through, the client sees the agent's modes): a drag and a move are dropped while
+                    // the agent tracks clicks only (1000), the drag passes with 1002, every move with 1003.
+                    const drag = '\x1b[<32;11;5M';
+                    const move = '\x1b[<35;12;6M';
+                    const round = async (setup, ready, marker) => {
+                        if (setup) {
+                            send(setup);
+                            await t.waitFor(() => screen().includes(ready), WAIT.screen);
+                        }
+                        const from = screen().length;
+                        send(drag);
+                        await new Promise((r) => setTimeout(r, 50));
+                        send(move);
+                        await new Promise((r) => setTimeout(r, 50));
+                        send(marker);
+                        await t.waitFor(() => screen()
+                            .slice(from)
+                            .includes('got ' + marker), WAIT.screen);
+                        return screen().slice(from);
+                    };
+                    const clicksOnly = await round('', '', 'y');
+                    const drags = await round('D', 'DRAG-ON', 'z');
+                    const moves = await round('A', 'MOVE-ON', 'w');
+                    // (Two reports read at once are echoed on one line.)
+                    const has = (text, report) => text.includes('<1b>' + report.slice(1));
+                    t.check(clicksOnly.includes('got y') &&
+                        !has(clicksOnly, drag) &&
+                        !has(clicksOnly, move) &&
+                        drags.includes('got z') &&
+                        has(drags, drag) &&
+                        !has(drags, move) &&
+                        has(moves, drag) &&
+                        has(moves, move), 'drag and motion reports reach the agent only once it asked for them (1002 drags, 1003 every move)', JSON.stringify({ clicksOnly: tail(clicksOnly, 200), drags: tail(drags, 200), moves: tail(moves, 200) }));
+                }
                 send('q');
                 const ended = await t.waitFor(() => screen().includes('CLIENT-DONE'), WAIT.exit);
-                t.check(Boolean(ended) && (!kind || screen().slice(screen().lastIndexOf('got q')).includes('\x1b[?1000l')), 'the client ends with the agent' + (kind ? ' and turns mouse tracking off in the terminal again' : ''), 'screen: ' + tail(screen()));
+                const last = screen().slice(screen().lastIndexOf('got q'));
+                t.check(Boolean(ended) && (!kind || (last.includes('\x1b[?1000l') && last.includes('\x1b[?1003l'))), 'the client ends with the agent' +
+                    (kind ? ' and turns mouse tracking (clicks, drags, motion) off in the terminal again' : ''), 'screen: ' + tail(screen()));
             }
             finally {
                 for (const v of viewers)

package/dist/selftest/menu-perf.test.js

@@ -1,16 +1,21 @@
-// The menu stays quick: no key or draw waits for a child process (tasklist is faked and counted), a slow tab load shows
-// "Loading…" instead of holding up the keys, a held key is drawn once, and the terminal writes only the rows that
-// changed (the screen after the diffs is the same as a full draw, also after a resize).
+// The menu stays quick: no key or draw waits for a child process (tasklist is faked and counted), the first screen does
+// not wait for the process list, a slow tab load shows "Loading…" instead of holding up the keys, a section seen before
+// shows at once, a held key is drawn once, Esc is a key at once, an idle menu writes nothing, and the terminal writes
+// only the rows that changed (the screen after the diffs is the same as a full draw, also after a resize). The process
+// list is fetched only when it may have changed, and the settings file is read once for a whole list.
+import fs from 'node:fs';
 import { EventEmitter } from 'node:events';
 import { PassThrough } from 'node:stream';
+import { ConfigFile } from '../app/features/settings/index.js';
 import { DEFAULTS } from '../core/config/index.js';
 import { sleep } from '../core/util/index.js';
 import { Menu } from '../cli/menu/menu.js';
-import { LiveStatus } from '../cli/menu/live.js';
+import { LiveStatus, listGap } from '../cli/menu/live.js';
 import { ListPage } from '../cli/menu/pages/list-page.js';
 import { App, Text, Terminal } from '../cli/tui/index.js';
-import { supportsSyncUpdate } from '../cli/tui/terminal.js';
-import { isSandboxRunning, useTasklistCache, useTasklistRunners } from '../host/sandbox/index.js';
+import { ESCAPE_TIMEOUT_MS, supportsSyncUpdate } from '../cli/tui/terminal.js';
+import { isSandboxRunning, readTasklist, sandboxPids, useTasklistCache, useTasklistRunners, } from '../host/sandbox/index.js';
+import { staleMountNote } from '../host/storage/index.js';
 const TASKLIST = [
     '"System Idle Process","0","Services","0","8 K"',
     '"WindowsSandboxClient.exe","4242","Console","1","9,000 K"',
@@ -124,6 +129,26 @@ export const menuPerfSuite = {
             app.close();
             t.check(result === 'bye' && handled === 31 && renders < 10, 'keys that are already waiting are handled first and drawn once, not once each', 'handled ' + handled + ', drawn ' + renders);
         }
+        t.section('Esc is a key at once');
+        {
+            const tty = new FakeTty();
+            const term = tty.terminal();
+            term.start();
+            const times = [];
+            for (let i = 0; i < 3; i++) {
+                const at = Date.now();
+                tty.type('\x1b');
+                const key = await term.key();
+                times.push(Date.now() - at);
+                if (key.name !== 'escape')
+                    times.push(9999);
+            }
+            tty.type('\x1b[B');
+            const arrow = await term.key();
+            term.stop();
+            t.check(Math.max(...times) < 250 && ESCAPE_TIMEOUT_MS <= 50, 'Esc arrives in ' + times.join(', ') + ' ms (Node waits 500 ms for the rest of a sequence by default)', times.join(', '));
+            t.check(arrow.name === 'down', 'an arrow key is still one key, not Esc and letters');
+        }
         t.section('a slow load does not hold up the keys');
         {
             const tty = new FakeTty();
@@ -131,9 +156,10 @@ export const menuPerfSuite = {
             class Slow extends ListPage {
                 label = 'Slow';
                 rows = [];
+                next = ['alpha', 'beta'];
                 async load() {
                     await sleep(500);
-                    this.rows = ['alpha', 'beta'];
+                    this.rows = this.next;
                 }
                 options() {
                     return { path: [], items: this.rows.map((r) => ({ value: r, label: r })) };
@@ -150,6 +176,14 @@ export const menuPerfSuite = {
             t.check(waited < 400 && page.loading && text().includes('Loading'), 'the tab opens at once and says Loading… while the data comes', 'waited ' + waited + ' ms');
             const arrived = await t.waitFor(() => (text().includes('beta') ? true : null), 5000, 20);
             t.check(arrived === true && !page.loading, 'the list is built when the data arrives');
+            // Back on the section later: what it had shows at once, the fresh data replaces it when it is there.
+            page.next = ['alpha', 'gamma'];
+            const again = Date.now();
+            await page.show();
+            const shownIn = Date.now() - again;
+            t.check(shownIn < 100 && text().includes('beta'), 'a section seen before shows its last data at once (in ' + shownIn + ' ms), not Loading…', text());
+            const fresh = await t.waitFor(() => (text().includes('gamma') ? true : null), 5000, 20);
+            t.check(fresh === true && !text().includes('beta'), 'and its fresh data when it has loaded');
         }
         t.section('no child process on a key or a draw');
         const saved = { hostOnly: process.env.AGENT_SANDBOX_HOST_ONLY };
@@ -177,24 +211,34 @@ export const menuPerfSuite = {
                     return TASKLIST;
                 },
                 refreshMs: 100,
+                // The sandbox's process is gone at every look: the list is fetched again on every tick.
+                processAlive: () => false,
             });
+            const startedAt = Date.now();
             const done = menu.start();
-            const shown = await t.waitFor(() => tty.writes.length > 0, 20000, 20);
+            const shown = await t.waitFor(() => tty.writes.length > 0, 20000, 5);
+            const firstPaint = Date.now() - startedAt;
             t.check(shown === true, 'the menu draws its first screen');
+            t.check(firstPaint < 1000, 'the first screen does not wait for a 1.5 second process list (drawn after ' + firstPaint + ' ms)');
             const slowest = { ms: 0, key: '' };
+            const took = [];
             const press = async (name, bytes) => {
                 const before = tty.writes.length;
                 const at = Date.now();
                 tty.type(bytes);
                 // Not every key changes the screen: give the ones that do a chance, and measure those.
-                await t.waitFor(() => tty.writes.length > before, 400, 5);
-                const took = Date.now() - at;
-                if (tty.writes.length > before && took > slowest.ms) {
-                    slowest.ms = took;
+                await t.waitFor(() => tty.writes.length > before, 400, 2);
+                const ms = Date.now() - at;
+                if (tty.writes.length > before)
+                    took.push(ms);
+                if (tty.writes.length > before && ms > slowest.ms) {
+                    slowest.ms = ms;
                     slowest.key = name;
                 }
                 await sleep(15);
             };
+            // The pages have their data (the first process list came after 1.5 s).
+            await sleep(1700);
             const syncBefore = calls.sync;
             for (const section of ['2', '3', '4', '5', '6', '7', '1'])
                 await press('section ' + section, section);
@@ -209,6 +253,21 @@ export const menuPerfSuite = {
                 ' ' +
                 slowest.ms +
                 ' ms)');
+            const median = [...took].sort((a, b) => a - b)[Math.floor(took.length / 2)] ?? 9999;
+            t.check(median < 100, 'a key is usually drawn at once (median ' + median + ' ms over ' + took.length + ' keys)');
+            // Left alone, the menu writes nothing: the process list keeps coming (every tick here), but nothing on the
+            // screen changes, so nothing is drawn.
+            await sleep(300);
+            const idleFrom = tty.writes.length;
+            const fetchesFrom = calls.async;
+            await sleep(3000);
+            const idleWrites = tty.writes.slice(idleFrom);
+            const idleBytes = idleWrites.join('').length;
+            t.check(idleWrites.length <= 1 && idleBytes < 4000 && calls.async > fetchesFrom, 'an idle menu writes nothing for 3 s (' +
+                idleWrites.length +
+                ' writes, ' +
+                idleBytes +
+                ' bytes) while the process list is looked at in the background', Text.strip(idleWrites.join('')).slice(0, 300));
             tty.type(KEYS.ctrlC);
             const code = await Promise.race([done, sleep(5000).then(() => -1)]);
             t.check(code === 130, 'Ctrl+C leaves the menu');
@@ -244,5 +303,132 @@ export const menuPerfSuite = {
             await sleep(80);
             t.check(live.line() === 'status b' && changes === 2, 'a stopped status looks at nothing');
         }
+        t.section('the process list is fetched only when it may have changed');
+        {
+            t.equal([0, 1, 2, 3, 4, 10, -1].map((n) => listGap(n, 2500, 30000)), [2500, 5000, 10000, 20000, 30000, 30000, 2500], 'while nothing changes, the gap between two lists doubles up to the longest');
+            t.equal(sandboxPids(TASKLIST + '\r\n"WindowsSandbox.exe","77","Console","1","5 K"'), [4242, 77], 'the ids of the sandbox programs are read from the list');
+            // A sandbox runs: its programs are checked by id, and the list is fetched again only when one has ended.
+            let fetches = 0;
+            let derived = 0;
+            let alive = true;
+            const running = new LiveStatus({
+                fetch: () => {
+                    fetches++;
+                    return Promise.resolve(TASKLIST);
+                },
+                derive: () => String(++derived),
+                onChange: () => undefined,
+                intervalMs: 20,
+                alive: () => alive,
+                needsList: () => true,
+            });
+            await running.start();
+            await sleep(400);
+            t.check(fetches === 1 && derived > 5, 'while the sandbox runs, its programs are checked by id: no new list (' +
+                fetches +
+                ' fetched), the line is still derived (' +
+                derived +
+                ' times)');
+            alive = false;
+            const refetched = await t.waitFor(() => fetches > 1, 3000, 10);
+            running.stop();
+            t.check(refetched === true, 'when one of them has ended, the list is fetched again');
+            // None runs: fewer and fewer lists, one at once after a key press or when the data folder changes.
+            fetches = 0;
+            let signal = 'a';
+            const idle = new LiveStatus({
+                fetch: () => {
+                    fetches++;
+                    return Promise.resolve('"System Idle Process","0","Services","0","8 K"');
+                },
+                derive: () => 'none',
+                onChange: () => undefined,
+                intervalMs: 20,
+                idleMaxMs: 100000,
+                needsList: () => true,
+                signal: () => signal,
+            });
+            await idle.start();
+            await sleep(1000);
+            const quiet = fetches;
+            t.check(quiet >= 2 && quiet <= 8, 'with nothing running, a second of 20 ms ticks fetched the list ' + quiet + ' times (not 50)');
+            signal = 'b';
+            const onSignal = await t.waitFor(() => fetches > quiet, 1000, 5);
+            t.check(onSignal === true, 'a change in the data folder fetches the list at once');
+            await sleep(100);
+            const beforeKey = fetches;
+            idle.touch();
+            const onKey = await t.waitFor(() => fetches > beforeKey, 1000, 5);
+            idle.stop();
+            t.check(onKey === true, 'so does a key press (someone is looking)');
+            // Inside a sandbox the list is never needed: nothing runs tasklist, not even a question asked meanwhile.
+            fetches = 0;
+            let syncRuns = 0;
+            useTasklistRunners({
+                sync: () => {
+                    syncRuns++;
+                    return '';
+                },
+                async: () => Promise.resolve(''),
+            });
+            try {
+                const inside = new LiveStatus({
+                    fetch: () => {
+                        fetches++;
+                        return Promise.resolve('');
+                    },
+                    derive: () => 'inside',
+                    onChange: () => undefined,
+                    intervalMs: 20,
+                    needsList: () => false,
+                });
+                await inside.start();
+                await sleep(200);
+                const list = readTasklist();
+                inside.stop();
+                t.check(fetches === 0 && syncRuns === 0 && list === '', 'when the list is not needed, it is never fetched and nothing asks tasklist meanwhile');
+            }
+            finally {
+                useTasklistRunners();
+            }
+        }
+        t.section('nothing before the menu waits for tasklist');
+        {
+            let asked = 0;
+            const note = staleMountNote(t.dir('no-mounts'), 'main', () => {
+                asked++;
+                return false;
+            });
+            t.check(note === null && asked === 0, 'with no image mounted, "is a sandbox running?" is not even asked');
+        }
+        t.section('the settings file is read once for a whole list');
+        {
+            const file = t.write(t.at('settings', 'config.json'), JSON.stringify({ defaultHarness: 'codex', workspaceFilter: { exclude: ['a', 'b'] } }));
+            const config = new ConfigFile('user', file);
+            const reads = { count: 0 };
+            const original = fs.readFileSync;
+            const counting = ((...args) => {
+                if (String(args[0]) === file)
+                    reads.count++;
+                return original(...args);
+            });
+            fs.readFileSync = counting;
+            let first;
+            try {
+                first = Array.from({ length: 200 }, () => config.valueInFile(['defaultHarness']));
+            }
+            finally {
+                fs.readFileSync = original;
+            }
+            t.check(reads.count === 1 && first.every((v) => v === 'codex'), '200 values in one run read the file once (' + reads.count + ' reads)');
+            const exclude = ['workspaceFilter', 'exclude'];
+            config.valueInFile(exclude).push('c');
+            t.equal(config.valueInFile(exclude), ['a', 'b'], 'a value handed out is a copy (changing it changes nothing)');
+            fs.writeFileSync(file, JSON.stringify({ defaultHarness: 'gemini' }));
+            await Promise.resolve();
+            t.equal(config.valueInFile(['defaultHarness']), 'gemini', 'the next run reads the file again (a change outside)');
+            const result = config.set(['defaultHarness'], 'opencode');
+            t.equal([result, config.valueInFile(['defaultHarness'])], ['saved', 'opencode'], 'a save is seen at once');
+        }
     },
 };

package/dist/selftest/menu.test.js

@@ -725,6 +725,10 @@ export const menuSuite = {
             ['main', false, false],
             ['second', true, true],
         ], 'rename keeps the default and active marks');
+        const ensured = [service.ensure('codex', 'main'), service.activeName('codex'), fs.readFileSync(codexAuth, 'utf8')];
+        t.equal(ensured, ['main', 'main', '{"token":"A"}'], 'a launch with --account switches the sandbox to that login');
+        t.equal([service.ensure('codex', null), service.activeName('codex'), fs.readFileSync(codexAuth, 'utf8')], ['second', 'second', '{"token":"B2"}'], 'a launch without --account switches the sandbox back to the default login');
+        t.equal([service.ensure('claude', null), service.ensure('nobody', 'x')], [null, null], 'an agent with no saved login, or one that keeps no login: nothing to switch');
         await t.throws(() => service.save('x', false, 'nobody'), 'Unknown agent', 'an unknown agent: refused');
         await t.throws(() => service.save('bad name', false, 'codex'), 'Invalid account name', 'bad names are refused');
         t.section('every screen');

package/dist/selftest/storage-helper.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const storageHelperSuite: Suite;