windows-development-sandbox 1.4.1 → 1.5.0

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

@@ -1,11 +1,12 @@
 // Live: the sandbox's allowOnly proxy (the real bundled runtime\netproxy.js) and the PC-side port forwarder, on
 // loopback only; and that the cargo shim compiles with the compiler that ships with Windows.
+import fs from 'node:fs';
 import net from 'node:net';
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
-import { startPortForwards } from '../host/port-forward.js';
-import { PROXY_PORT, relayPort } from '../shared/netpolicy.js';
-import { CSC } from './live.js';
+import { startPortForwards } from '../host/network/index.js';
+import { PROXY_PORT, relayPort } from '../shared/network/index.js';
+import { CSC } from './support/live.js';
 /** A TCP server that answers every line with "echo:<line>". */
 const echoServer = (port = 0) => new Promise((resolve) => {
     const server = net.createServer((s) => s.on('data', (d) => s.write('echo:' + d.toString())));
@@ -16,11 +17,17 @@ const portOf = (server) => server.address().port;
 const talk = (port, preamble, text) => new Promise((resolve) => {
     const socket = net.connect(port, '127.0.0.1');
     let got = '';
-    socket.on('data', (d) => { got += d.toString(); if (preamble && got.includes('\r\n\r\n') && got.startsWith('HTTP/1.1 200') && !got.includes('echo:'))
-        socket.write(text); });
+    socket.on('data', (d) => {
+        got += d.toString();
+        if (preamble && got.includes('\r\n\r\n') && got.startsWith('HTTP/1.1 200') && !got.includes('echo:'))
+            socket.write(text);
+    });
     socket.on('error', () => resolve(got));
     socket.on('connect', () => socket.write(preamble || text));
-    setTimeout(() => { socket.destroy(); resolve(got); }, 1500);
+    setTimeout(() => {
+        socket.destroy();
+        resolve(got);
+    }, 1500);
 });
 export const liveNetworkSuite = {
     name: 'live-network',
@@ -30,9 +37,18 @@ export const liveNetworkSuite = {
         t.section('allowOnly proxy');
         const gen = await f.launch({}, { config: { ...f.baseConfig, network: { ...f.baseConfig.network, allowOnly: ['localhost'] } } });
         const echo = await echoServer();
-        const proxy = spawn(process.execPath, [path.join(gen.launchPath, 'runtime', 'netproxy.js')], { env: { ...process.env, AGENT_LAUNCH_DIR: gen.launchPath, AGENT_DATA_DIR: t.dir('netproxy-data') }, stdio: 'ignore' });
+        const proxy = spawn(process.execPath, [path.join(gen.launchPath, 'runtime', 'netproxy.js')], {
+            env: { ...process.env, AGENT_LAUNCH_DIR: gen.launchPath, AGENT_DATA_DIR: t.dir('netproxy-data') },
+            stdio: 'ignore',
+        });
         try {
-            const up = await t.waitFor(() => new Promise((resolve) => { const s = net.connect(PROXY_PORT, '127.0.0.1', () => { s.destroy(); resolve(true); }); s.on('error', () => resolve(false)); }), 10000, 200);
+            const up = await t.waitFor(() => new Promise((resolve) => {
+                const s = net.connect(PROXY_PORT, '127.0.0.1', () => {
+                    s.destroy();
+                    resolve(true);
+                });
+                s.on('error', () => resolve(false));
+            }), 10000, 200);
             t.check(Boolean(up), 'the proxy listens on localhost');
             const allowed = await talk(PROXY_PORT, 'CONNECT localhost:' + portOf(echo) + ' HTTP/1.1\r\nHost: localhost\r\n\r\n', 'hi');
             t.check(allowed.startsWith('HTTP/1.1 200') && allowed.includes('echo:hi'), 'an allowed host is tunnelled through', allowed);
@@ -54,10 +70,58 @@ export const liveNetworkSuite = {
         const forwarded = await talk(pcPort, '', 'ping');
         stop();
         relay.close();
-        t.equal(forwarded, 'echo:ping', 'localhost:<pc> on this PC reaches the sandbox\'s relay');
+        t.equal(forwarded, 'echo:ping', "localhost:<pc> on this PC reaches the sandbox's relay");
         t.section('cargo shim');
         const out = path.join(t.dir('cargoshim'), 'cargo.exe');
-        const compiled = spawnSync(CSC, ['/nologo', '/optimize', '/out:' + out, path.join(gen.launchPath, 'sandbox', 'cargoshim.cs')], { encoding: 'utf8' });
-        t.check(compiled.status === 0, 'cargoshim.cs compiles with the .NET Framework compiler (C# 5)', compiled.stdout + compiled.stderr);
+        const compiled = spawnSync(CSC, ['/nologo', '/optimize', '/out:' + out, path.join(gen.launchPath, 'sandbox', 'csharp', 'CargoShim.cs')], { encoding: 'utf8' });
+        t.check(compiled.status === 0, 'CargoShim.cs compiles with the .NET Framework compiler (C# 5)', compiled.stdout + compiled.stderr);
+        t.section('SandboxTools and HostTools');
+        const csharp = (...parts) => {
+            const dir = path.join(...parts);
+            return fs
+                .readdirSync(dir)
+                .filter((n) => n.endsWith('.cs'))
+                .map((n) => path.join(dir, n));
+        };
+        const sandboxTools = path.join(t.dir('sandbox-tools'), 'SandboxTools.exe');
+        const builtTools = spawnSync(CSC, [
+            '/nologo',
+            '/optimize',
+            '/target:winexe',
+            '/out:' + sandboxTools,
+            ...csharp(gen.launchPath, 'sandbox', 'csharp', 'SandboxTools'),
+        ], { encoding: 'utf8' });
+        t.check(builtTools.status === 0, 'SandboxTools compiles (C# 5)', builtTools.stdout + builtTools.stderr);
+        const memoryDir = t.dir('memory-log');
+        spawnSync(sandboxTools, ['memory-log', '--once', '--dir', memoryDir], { timeout: 60000 });
+        const logs = fs.readdirSync(memoryDir).filter((n) => /^memory-\d{8}-\d{6}\.log$/.test(n));
+        const lines = logs.length ? fs.readFileSync(path.join(memoryDir, logs[0]), 'utf8').trim().split(/\r?\n/) : [];
+        t.check(lines.length === 2 &&
+            lines[0].startsWith('time     | RAM used/total MB') &&
+            /^\d\d:\d\d:\d\d \| \d+\/\d+ \| \d+\/\d+ \| \d+ processes; /.test(lines[1]), 'memory-log --once writes the header and one sample', lines.join('\n'));
+        const pressure = fs.existsSync(path.join(memoryDir, 'memory-pressure.txt'))
+            ? fs.readFileSync(path.join(memoryDir, 'memory-pressure.txt'), 'utf8')
+            : '';
+        t.check(/^(ok|high|critical) \d{4}-\d\d-\d\dT\d\d:\d\d:\d\d RAM \d+\/\d+ MB, commit \d+\/\d+ MB/.test(pressure), 'memory-pressure.txt holds the level and the numbers', pressure);
+        const hostTools = path.join(t.dir('host-tools'), 'HostTools.exe');
+        const builtHost = spawnSync(CSC, ['/nologo', '/optimize', '/out:' + hostTools, ...csharp(t.packageRoot, 'native', 'csharp', 'HostTools')], { encoding: 'utf8' });
+        t.check(builtHost.status === 0, 'HostTools compiles (C# 5)', builtHost.stdout + builtHost.stderr);
+        const events = spawnSync(hostTools, ['stop-events', '--since', new Date(Date.now() - 86400000).toISOString()], {
+            encoding: 'utf8',
+            timeout: 60000,
+        });
+        let parsed = null;
+        try {
+            parsed = JSON.parse(events.stdout);
+        }
+        catch {
+            /* checked below */
+        }
+        t.check(Array.isArray(parsed) &&
+            parsed.every((e) => typeof e.at === 'string' &&
+                typeof e.id === 'number' &&
+                typeof e.provider === 'string' &&
+                typeof e.process === 'string'), 'HostTools stop-events prints a JSON list of { at, id, provider, process }', events.stdout.slice(0, 500) + events.stderr);
+        t.equal(spawnSync(hostTools, ['stop-events'], { encoding: 'utf8' }).status, 2, 'HostTools without --since prints its usage');
     },
 };

package/dist/selftest/live-projects.test.d.ts

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

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

@@ -4,10 +4,10 @@
 // Toolchain installers run as a dry run (no downloads); everything else is real. cmd.exe stands in for the agent.
 import fs from 'node:fs';
 import path from 'node:path';
-import { projectSpec } from '../host/join.js';
-import { resizeFrame } from '../shared/pty-client.js';
-import { readJsonFile } from '../shared/rundir.js';
-import { copyCmdAsFakeAgent, openViewer, sees, startDaemon, tail, viewersWhen } from './live.js';
+import { projectSpec } from '../host/projects/index.js';
+import { resizeFrame } from '../shared/pty/index.js';
+import { readJsonFile } from '../shared/io/index.js';
+import { copyCmdAsFakeAgent, openViewer, sees, startDaemon, tail, viewersWhen } from './support/live.js';
 export const liveProjectsSuite = {
     name: 'live-projects',
     title: 'live: two projects, several sessions, several viewers',
@@ -21,11 +21,25 @@ export const liveProjectsSuite = {
         copyCmdAsFakeAgent(data);
         const session = f.readJson(gen.sessionPath);
         // B's root appears at its own path here (like guestWorkspace "mirror"), so host and guest paths are the same.
-        Object.assign(session, { workspace: f.workA, attach: { enabled: true }, projectsDir: t.at('live-projects'), roots: [root], projectId: 'work-a' });
-        Object.assign(session.harness, { arguments: ['/d', '/k', 'echo AGENT-READY'], resumeArguments: ['/d', '/k', 'echo AGENT-RESUMED'] });
+        Object.assign(session, {
+            workspace: f.workA,
+            attach: { enabled: true },
+            projectsDir: t.at('live-projects'),
+            roots: [root],
+            projectId: 'work-a',
+        });
+        Object.assign(session.harness, {
+            arguments: ['/d', '/k', 'echo AGENT-READY'],
+            resumeArguments: ['/d', '/k', 'echo AGENT-RESUMED'],
+        });
         t.writeJson(gen.sessionPath, session);
         const local = t.at('live-multi-local');
-        const daemon = startDaemon(t, f, { launchPath: gen.launchPath, data, workspace: f.workA, env: { AGENT_LOCAL_DIR: local, AGENT_DRY_RUN: '1', AGENT_MANAGED_DIR: t.at('live-managed') } });
+        const daemon = startDaemon(t, f, {
+            launchPath: gen.launchPath,
+            data,
+            workspace: f.workA,
+            env: { AGENT_LOCAL_DIR: local, AGENT_DRY_RUN: '1', AGENT_MANAGED_DIR: t.at('live-managed') },
+        });
         const viewers = [];
         const view = async (attach, cols = 100) => {
             const v = await openViewer(attach, { cols });
@@ -48,10 +62,16 @@ export const liveProjectsSuite = {
             t.check(notRunning.length === 0, 'four sessions requested at once all start (two per project)', notRunning.map((s) => s?.id + ': ' + s?.phase + ' ' + s?.message).join('\n') + '\n' + daemon.diagnostics());
             if (notRunning.length > 0)
                 return;
-            t.equal([a1.project, b1.project, b2.project], ['work-a', 'projB', 'projB'], 'each session knows its project');
-            const log = fs.readdirSync(path.join(data, 'logs')).filter((n) => n.startsWith('daemon')).map((n) => fs.readFileSync(path.join(data, 'logs', n), 'utf8')).join('\n');
-            t.equal((log.match(/Project projB: setting up/g) ?? []).length, 1, 'two sessions for the same new project at once share one setup (no second provisioning run)');
-            t.equal(readJsonFile(path.join(daemon.run, 'projects', 'projB.json'))?.phase, 'ready', 'the project\'s setup status is written for the host (sandbox status)');
+            const log = fs
+                .readdirSync(path.join(data, 'logs'))
+                .filter((n) => n.startsWith('daemon'))
+                .map((n) => fs.readFileSync(path.join(data, 'logs', n), 'utf8'))
+                .join('\n');
+            t.equal({
+                projects: [a1.project, b1.project, b2.project],
+                setups: (log.match(/Project projB: setting up/g) ?? []).length,
+                status: readJsonFile(path.join(daemon.run, 'projects', 'projB.json'))?.phase,
+            }, { projects: ['work-a', 'projB', 'projB'], setups: 1, status: 'ready' }, 'each session knows its project; two sessions for the same new project at once share one setup; the setup status is written for the host');
             t.section('live: each session has its own folder and environment');
             const views = await Promise.all(all.map((s) => view(s.attach)));
             for (const v of views)
@@ -59,41 +79,50 @@ export const liveProjectsSuite = {
             for (const v of views)
                 v.type('echo P=%AGENT_PROJECT% W=%AGENT_WORKSPACE% B=[%LIVE_B%]');
             const bSees = await sees(t, views[2], 'P=projB W=' + projB + ' B=[b-env]');
-            t.check(Boolean(bSees), 'B\'s first session runs with B\'s workspace, project and variables', tail(views[2].output()));
-            t.check(Boolean(await sees(t, views[3], 'B=[b-env]')), 'B\'s second session runs with B\'s variables', tail(views[3].output()));
-            // (The daemon here runs without the boot's environment, so A's own AGENT_* variables are not set at all.)
-            t.check(Boolean(await sees(t, views[0], 'B=[%LIVE_B%]')), 'A\'s first session is untouched by B (B\'s variables never reach it)', tail(views[0].output()));
-            t.check(Boolean(await sees(t, views[1], 'B=[%LIVE_B%]')), 'A\'s second session is untouched by B', tail(views[1].output()));
+            const b2Sees = await sees(t, views[3], 'B=[b-env]');
             views[2].type('echo CWD=%CD%.');
-            t.check(Boolean(await sees(t, views[2], 'CWD=' + projB + '.')), 'B\'s session starts in B\'s folder', tail(views[2].output()));
+            const inB = await sees(t, views[2], 'CWD=' + projB + '.');
+            t.check(Boolean(bSees && b2Sees && inB), "B's sessions run in B's folder with B's workspace, project and variables", tail(views[2].output()) + '\n' + tail(views[3].output()));
+            // (The daemon here runs without the boot's environment, so A's own AGENT_* variables are not set at all.)
+            const a1Clean = await sees(t, views[0], 'B=[%LIVE_B%]');
+            const a2Clean = await sees(t, views[1], 'B=[%LIVE_B%]');
+            t.check(Boolean(a1Clean && a2Clean), "A's sessions are untouched by B (B's variables never reach them)", tail(views[0].output()) + '\n' + tail(views[1].output()));
             t.section('live: several viewers on one session');
             const second = await view(b1.attach, 60);
             const two = await viewersWhen(t, b1.attach, (v) => v.viewers === 2);
-            t.check(two !== null, 'a second viewer attaches to the same session');
             second.socket.write(resizeFrame(90, 25));
             views[2].type('echo TWO-VIEWERS-OK');
-            t.check(Boolean(await sees(t, views[2], 'TWO-VIEWERS-OK')), 'the first viewer sees what it typed (after the second one resized)', tail(views[2].output()));
-            t.check(Boolean(await sees(t, second, 'TWO-VIEWERS-OK')), 'the second viewer sees it too', tail(second.output()));
+            const firstSees = await sees(t, views[2], 'TWO-VIEWERS-OK');
+            const secondSees = await sees(t, second, 'TWO-VIEWERS-OK');
             second.type('echo FROM-SECOND');
-            t.check(Boolean(await sees(t, views[2], 'FROM-SECOND')), 'input from the second viewer reaches the agent and the first viewer', tail(views[2].output()));
+            const fromSecond = await sees(t, views[2], 'FROM-SECOND');
+            t.check(two !== null && Boolean(firstSees && secondSees && fromSecond), 'a second viewer attaches to the same session; both see what the first typed (after the second one resized), and its input reaches the agent', tail(views[2].output()) + '\n' + tail(second.output()));
             views[2].close();
             second.close();
             const none = await viewersWhen(t, b1.attach, (v) => v.viewers === 0);
-            t.check(none !== null, 'closing every viewer is noticed');
-            t.equal(daemon.status('b1')?.phase, 'running', 'closing every viewer never ends the session');
+            t.check(none !== null && daemon.status('b1')?.phase === 'running', 'closing every viewer is noticed and never ends the session');
+            const reattached = [];
             for (let round = 1; round <= 3; round++) {
                 const again = await view(b1.attach);
                 again.type('echo REATTACHED-' + round);
-                t.check(Boolean(await sees(t, again, 'REATTACHED-' + round)), 'reattach ' + round + ': a new viewer works on the same session', tail(again.output()));
+                if (!(await sees(t, again, 'REATTACHED-' + round)))
+                    reattached.push('round ' + round + ': ' + tail(again.output()));
                 again.close();
             }
+            t.check(reattached.length === 0, 'three times in a row a new viewer works on the same session', reattached.join('\n'));
             t.section('live: exec, restart and refusals follow the projects');
             daemon.request({ kind: 'exec', id: 'xb', command: ['echo', '%LIVE_B%'], cwd: projB, timeoutSeconds: 30 });
             daemon.request({ kind: 'exec', id: 'xa', command: ['echo', '[%LIVE_B%]'], cwd: f.workA, timeoutSeconds: 30 });
             const [xb, xa] = await Promise.all([daemon.response('xb'), daemon.response('xa')]);
-            t.check(Boolean(xb?.stdout?.includes('b-env')), 'exec in B\'s folder gets B\'s environment', JSON.stringify(xb));
-            t.check(Boolean(xa?.stdout?.includes('[%LIVE_B%]')), 'exec in A\'s folder gets A\'s', JSON.stringify(xa));
-            daemon.request({ kind: 'session', id: 'bad1', harness: 'claude', args: [], cwd: f.workB, project: { ...spec, name: 'outside', workspace: f.workB } });
+            t.check(Boolean(xb?.stdout?.includes('b-env') && xa?.stdout?.includes('[%LIVE_B%]')), "exec in B's folder gets B's environment, in A's folder A's", JSON.stringify([xb, xa]));
+            daemon.request({
+                kind: 'session',
+                id: 'bad1',
+                harness: 'claude',
+                args: [],
+                cwd: f.workB,
+                project: { ...spec, name: 'outside', workspace: f.workB },
+            });
             const bad = await daemon.started('bad1');
             t.check(bad?.phase === 'failed' && bad.message.includes('not visible inside the sandbox'), 'a project outside the launch folder, the roots and C:\\Projects is refused', JSON.stringify(bad));
             daemon.request({ kind: 'session', id: 'bad2', harness: 'claude', args: [], cwd: f.workA, project: spec });
@@ -101,9 +130,9 @@ export const liveProjectsSuite = {
             t.includes(claimed?.message ?? '', 'not inside project projB', 'a session cannot claim a project its folder is not in');
             daemon.request({ kind: 'restart', id: 'rb', harness: null, cwd: projB });
             t.equal((await daemon.response('rb'))?.message, 'restarted 2 session(s)', 'restart scoped to a project restarts only its sessions');
-            t.check(fs.existsSync(path.join(local, 'projects', 'projB', 'shell.cmd')), 'sbx-shell projB has a shell script');
-            t.includes(fs.readFileSync(path.join(local, 'projects', 'projB', 'env.cmd'), 'utf8'), 'LIVE_B=b-env', 'sbx-shell projB opens with B\'s environment');
-            t.check(fs.existsSync(path.join(local, 'bin', 'sbx-shell.cmd')), 'sbx-shell is on the sandbox\'s PATH');
+            t.check(fs.existsSync(path.join(local, 'projects', 'projB', 'shell.cmd')) &&
+                fs.readFileSync(path.join(local, 'projects', 'projB', 'env.cmd'), 'utf8').includes('LIVE_B=b-env') &&
+                fs.existsSync(path.join(local, 'bin', 'sbx-shell.cmd')), "sbx-shell is on the sandbox's PATH, and projB has a shell script that opens with B's environment");
         }
         finally {
             for (const v of viewers)
@@ -119,7 +148,9 @@ export const liveProjectsSuite = {
                     await t.waitFor(() => v.exitCode() !== null, 10000);
                     v.close();
                 }
-                catch { /* already gone */ }
+                catch {
+                    /* already gone */
+                }
             }
             await daemon.stop();
         }

package/dist/selftest/live-terminal.test.d.ts

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

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

@@ -9,9 +9,12 @@ import net from 'node:net';
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
 import { pathToFileURL } from 'node:url';
-import { encodeFrame, FrameType } from '../shared/pty-client.js';
-import { CSC, openViewer, tail, WAIT } from './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. */
+import { encodeFrame, FrameType } from '../shared/pty/index.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.
+ */
 const AGENT_CS = String.raw `
 using System;
 using System.Runtime.InteropServices;
@@ -50,13 +53,24 @@ static class MouseAgent
 const freePort = () => new Promise((resolve, reject) => {
     const server = net.createServer();
     server.on('error', reject);
-    server.listen(0, '127.0.0.1', () => { const port = server.address().port; server.close(() => resolve(port)); });
+    server.listen(0, '127.0.0.1', () => {
+        const port = server.address().port;
+        server.close(() => resolve(port));
+    });
 });
 const compile = (source, exe) => {
-    const result = spawnSync(CSC, ['/nologo', '/optimize', '/target:exe', '/out:' + exe, source], { encoding: 'utf8', windowsHide: true });
-    return result.status === 0 ? '' : ((result.stdout ?? '') + (result.stderr ?? '')).trim().slice(0, 1500) || 'csc failed';
+    const result = spawnSync(CSC, ['/nologo', '/optimize', '/target:exe', '/out:' + exe, source], {
+        encoding: 'utf8',
+        windowsHide: true,
+    });
+    return result.status === 0
+        ? ''
+        : ((result.stdout ?? '') + (result.stderr ?? '')).trim().slice(0, 1500) || 'csc failed';
 };
-/** conpty.dll as a sandbox has it (C:\AgentData\tools\conpty), when this machine has one; else only Windows' own is tested. */
+/**
+ * conpty.dll as a sandbox has it (C:\AgentData\tools\conpty), when this machine has one; else only Windows' own is
+ * tested.
+ */
 const conptyDll = () => {
     const dll = path.join(process.env.AGENT_DATA_DIR ?? 'C:\\AgentData', 'tools', 'conpty', 'conpty.dll');
     return fs.existsSync(dll) && fs.existsSync(path.join(path.dirname(dll), 'OpenConsole.exe')) ? dll : null;
@@ -70,13 +84,16 @@ export const liveTerminalSuite = {
         const ptyhost = t.at('ptyhost.exe');
         const agent = t.at('mouse-agent.exe');
         fs.writeFileSync(t.at('mouse-agent.cs'), AGENT_CS);
-        const errors = compile(path.join(t.packageRoot, 'sandbox', 'ptyhost.cs'), ptyhost) || compile(t.at('mouse-agent.cs'), agent);
+        const errors = compile(path.join(t.packageRoot, 'sandbox', 'csharp', 'PtyHost.cs'), ptyhost) ||
+            compile(t.at('mouse-agent.cs'), agent);
         t.check(!errors, 'ptyhost and the stand-in agent compile', errors);
         if (errors)
             return;
         const client = t.at('client.mjs');
         fs.writeFileSync(client, [
-            'import { connect, runTerminalClient } from ' + JSON.stringify(pathToFileURL(path.join(t.packageRoot, 'dist', 'shared', 'pty-client.js')).href) + ';',
+            'import { connect, runTerminalClient } from ' +
+                JSON.stringify(pathToFileURL(path.join(t.packageRoot, 'dist', 'shared', 'pty', 'index.js')).href) +
+                ';',
             'const socket = await connect({ addresses: ["127.0.0.1"], port: Number(process.argv[2]), token: "tok" });',
             'const result = await runTerminalClient(socket, "tok");',
             'console.log("CLIENT-DONE " + result.reason);',
@@ -84,9 +101,9 @@ export const liveTerminalSuite = {
         const dll = conptyDll();
         const kinds = dll ? [dll, null] : [null];
         if (!dll)
-            t.skip('conpty.dll not found on this machine: only Windows\' own pseudo console is tested');
+            t.skip("conpty.dll not found on this machine: only Windows' own pseudo console is tested");
         for (const kind of kinds) {
-            const label = kind ? 'conpty.dll' : 'Windows\' pseudo console';
+            const label = kind ? 'conpty.dll' : "Windows' pseudo console";
             t.section('live terminal (' + label + ')');
             const children = [];
             const viewers = [];
@@ -95,7 +112,11 @@ export const liveTerminalSuite = {
                 delete env.PTYHOST_CONPTY;
                 if (kind)
                     env.PTYHOST_CONPTY = kind;
-                children.push(spawn(ptyhost, [String(port), 'tok', '100', '30', t.at(log), command], { env, stdio: 'ignore', windowsHide: true }));
+                children.push(spawn(ptyhost, [String(port), 'tok', '100', '30', t.at(log), command], {
+                    env,
+                    stdio: 'ignore',
+                    windowsHide: true,
+                }));
             };
             try {
                 const innerPort = await freePort();
@@ -106,63 +127,80 @@ export const liveTerminalSuite = {
                 const terminal = await openViewer({ addresses: ['127.0.0.1'], port: outerPort, token: 'tok' });
                 viewers.push(terminal);
                 const screen = () => terminal.output();
-                const send = (text) => { terminal.socket.write(encodeFrame(FrameType.Input, Buffer.from(text, 'latin1'))); };
+                const send = (text) => {
+                    terminal.socket.write(encodeFrame(FrameType.Input, Buffer.from(text, 'latin1')));
+                };
                 const ready = await t.waitFor(() => screen().includes('AGENT-READY'), WAIT.screen);
                 t.check(Boolean(ready), 'the client shows the agent', 'screen: ' + tail(screen()));
                 if (!ready)
                     continue;
                 // The client switches its console to pass the terminal's input through as it is; until then clicks are lost.
                 const click = '\x1b[<0;10;5M\x1b[<0;10;5m';
-                const clicked = await t.waitFor(() => { if (!screen().includes('got <1b>[<0;10;5M'))
-                    send(click); return screen().includes('got <1b>[<0;10;5M'); }, WAIT.screen, 1000);
+                const clicked = await t.waitFor(() => {
+                    if (!screen().includes('got <1b>[<0;10;5M'))
+                        send(click);
+                    return screen().includes('got <1b>[<0;10;5M');
+                }, WAIT.screen, 1000);
                 t.check(Boolean(clicked), 'a mouse click in the terminal reaches the agent (SGR mouse report)', 'screen: ' + tail(screen(), 800));
                 const mark = screen().length;
                 const after = () => screen().slice(mark);
+                const lost = [];
+                const expectKey = async (what, expected) => {
+                    if (!(await t.waitFor(() => after().includes(expected), WAIT.screen)))
+                        lost.push(what);
+                };
                 send('\x1b[<64;10;5M');
-                t.check(Boolean(await t.waitFor(() => after().includes('got <1b>[<64;10;5M'), WAIT.screen)), 'the mouse wheel reaches the agent while it tracks the mouse', 'screen: ' + tail(after(), 800));
+                await expectKey('mouse wheel', 'got <1b>[<64;10;5M');
                 send('\x7f');
-                t.check(Boolean(await t.waitFor(() => after().includes('got <7f>'), WAIT.screen)), 'Backspace reaches the agent as DEL (one character, not a word)', 'screen: ' + tail(after(), 800));
+                await expectKey('Backspace as DEL', 'got <7f>');
                 send('\x08');
-                t.check(Boolean(await t.waitFor(() => after().includes('got <08>'), WAIT.screen)), 'Ctrl+Backspace reaches the agent as ^H', 'screen: ' + tail(after(), 800));
+                await expectKey('Ctrl+Backspace as ^H', 'got <08>');
                 send('\x1b[');
                 await new Promise((r) => setTimeout(r, 5));
                 send('C');
-                t.check(Boolean(await t.waitFor(() => after().includes('got <1b>[C'), WAIT.screen)), 'a Right arrow that reaches the client in two pieces arrives whole (no stray "C")', 'screen: ' + tail(after(), 800));
+                await expectKey('Right arrow sent in two pieces', 'got <1b>[C');
+                t.check(lost.length === 0, 'the mouse wheel, Backspace (DEL), Ctrl+Backspace (^H) and a Right arrow split in two pieces (no stray "C") reach the agent', 'lost: ' + lost.join(', ') + '\nscreen: ' + tail(after(), 800));
                 const before = screen().length;
                 send('L');
                 const done = await t.waitFor(() => screen().includes('LINES-DONE'), WAIT.screen);
                 const printed = screen().slice(before);
                 const seen = new Set([...printed.matchAll(/line (\d+)\b/g)].map((m) => Number(m[1])));
-                const missing = Array.from({ length: 500 }, (_, i) => i + 1).filter((n) => !seen.has(n)).map((n) => 'line ' + n);
+                const missing = Array.from({ length: 500 }, (_, i) => i + 1)
+                    .filter((n) => !seen.has(n))
+                    .map((n) => 'line ' + n);
                 t.check(Boolean(done) && missing.length === 0, 'all 500 printed lines reach the terminal as lines', 'missing: ' + missing.slice(0, 10).join(', ') + '\n' + tail(printed));
                 // (The client clears the tab once when it starts; from then on nothing may take the scrollback away.)
                 const session = screen().slice(screen().indexOf('AGENT-READY'));
-                for (const [sequence, what] of [['\x1b[?1049h', 'alternate screen'], ['\x1b[?47h', 'alternate screen (47)'], ['\x1b[?1047h', 'alternate screen (1047)'], ['\x1b[3J', 'clear scrollback']]) {
-                    t.excludes(session, sequence, 'the terminal is never sent ' + what + ' (' + JSON.stringify(sequence) + ')');
-                }
+                const sent = ['\x1b[?1049h', '\x1b[?47h', '\x1b[?1047h', '\x1b[3J'].filter((s) => session.includes(s));
+                t.check(sent.length === 0, 'the terminal is never sent an alternate screen (1049, 47, 1047) or a clear of its scrollback', 'sent: ' + JSON.stringify(sent));
                 if (kind) {
-                    // A viewer that joins after the agent cleared its screen: the replay starts at the clear, the modes come first.
+                    // A viewer that joins after the agent cleared its screen: the replay starts at the clear, the modes come
+                    // first.
                     send('K');
                     await t.waitFor(() => screen().includes('CLEARED'), WAIT.screen);
                     const late = await openViewer({ addresses: ['127.0.0.1'], port: innerPort, token: 'tok' });
                     viewers.push(late);
                     await t.waitFor(() => late.output().includes('CLEARED'), WAIT.screen);
                     const head = late.output().slice(0, late.output().indexOf('CLEARED'));
-                    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)));
+                    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();
                 }
                 send('q');
                 const ended = await t.waitFor(() => screen().includes('CLIENT-DONE'), WAIT.exit);
-                t.check(Boolean(ended), 'the client ends with the agent', 'screen: ' + tail(screen()));
-                if (kind)
-                    t.includes(screen().slice(screen().lastIndexOf('got q')), '\x1b[?1000l', 'leaving the session turns mouse tracking off in the terminal again');
+                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()));
             }
             finally {
                 for (const v of viewers)
                     v.close();
-                for (const c of children)
-                    if (c.exitCode === null)
-                        c.kill();
+                for (const c of children) {
+                    try {
+                        if (c.exitCode === null)
+                            c.kill();
+                    }
+                    catch {
+                        /* it exited between the check and the kill (Windows says EPERM): nothing left to stop */
+                    }
+                }
             }
         }
     },

package/dist/selftest/local-config.test.d.ts

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