windows-development-sandbox 1.13.0 → 1.14.0

package/dist/runtime/view.js

@@ -5892,12 +5892,175 @@ var CtrlCGuard = class {
   }
 };
 
-// src/shared/pty/terminal.ts
-var MOUSE_OFF = "\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1005l\x1B[?1006l\x1B[?1015l";
+// src/shared/pty/key-gate.ts
 function fixWindowsKeys(chunk) {
   if (!chunk.includes(8) && !chunk.includes(127)) return chunk;
   return Buffer.from(chunk.map((b) => b === 8 ? 127 : b === 127 ? 8 : b));
 }
+var KeyGate = class {
+  pending = [];
+  decided;
+  swap = false;
+  /** windowsConsole: input comes from a Windows console in raw mode (its mode is decided later); else it goes as is. */
+  constructor(windowsConsole) {
+    this.decided = !windowsConsole;
+  }
+  /** The bytes to send now (empty while the mode is not known yet). */
+  push(data) {
+    if (!data.length) return data;
+    if (!this.decided) {
+      this.pending.push(data);
+      return Buffer.alloc(0);
+    }
+    return this.swap ? fixWindowsKeys(data) : data;
+  }
+  /** The console's mode is known: what was held, ready to send. Later calls only change how new input is read. */
+  decide(vtInput) {
+    this.swap = !vtInput;
+    this.decided = true;
+    const held = Buffer.concat(this.pending);
+    this.pending = [];
+    return this.swap ? fixWindowsKeys(held) : held;
+  }
+};
+
+// src/shared/pty/mouse-modes.ts
+var TRACKING = [9, 1e3, 1002, 1003];
+var MAX_PARAMS = 64;
+var MOTION = 32;
+var NO_BUTTON = 3;
+var MouseModes = class {
+  on = /* @__PURE__ */ new Set();
+  /** 0 text, 1 after ESC, 2 after ESC[, 3 in ESC[? parameters, 4 after ESC[! */
+  state = 0;
+  params = "";
+  /** Reads the program's output (after OutputFilter): the mode changes in it. */
+  watch(output2) {
+    for (const b of output2) {
+      if (b === 27) {
+        this.state = 1;
+        continue;
+      }
+      if (this.state === 1) {
+        if (b === 99) this.on.clear();
+        this.state = b === 91 ? 2 : 0;
+      } else if (this.state === 2) {
+        this.state = b === 63 ? 3 : b === 33 ? 4 : 0;
+        this.params = "";
+      } else if (this.state === 4) {
+        if (b === 112) this.on.clear();
+        this.state = 0;
+      } else if (this.state === 3) {
+        if (b >= 48 && b <= 57 || b === 59) {
+          this.params += String.fromCharCode(b);
+          if (this.params.length > MAX_PARAMS) this.state = 0;
+        } else {
+          if (b === 104 || b === 108) this.apply(this.params, b === 104);
+          this.state = 0;
+        }
+      }
+    }
+  }
+  /** The program is gone (exited or restarting): its modes went with it. */
+  reset() {
+    this.on.clear();
+    this.state = 0;
+    this.params = "";
+  }
+  /** True while the program tracks the mouse in any way. */
+  tracking() {
+    return TRACKING.some((m) => this.on.has(m));
+  }
+  /** True while the program has a mode on (2004: bracketed paste). */
+  has(mode) {
+    return this.on.has(mode);
+  }
+  /** The mode numbers on now (for the report and tests). */
+  modes() {
+    return [...this.on].sort((a, b) => a - b);
+  }
+  /** `input` without the mouse reports the program has not asked for. Sequences must be whole (InputJoiner). */
+  filter(input2) {
+    if (!input2.includes(27)) return input2;
+    const parts = [];
+    let from = 0;
+    let i = input2.indexOf(27);
+    while (i !== -1) {
+      const report = mouseReport(input2, i, this.on.has(1005), this.on.has(1015));
+      if (report && !this.allows(report.button)) {
+        parts.push(input2.subarray(from, i));
+        from = i + report.length;
+        i = input2.indexOf(27, from);
+      } else i = input2.indexOf(27, i + 1);
+    }
+    if (from === 0) return input2;
+    parts.push(input2.subarray(from));
+    return Buffer.concat(parts);
+  }
+  allows(button) {
+    if (!this.tracking()) return false;
+    if ((button & MOTION) === 0) return true;
+    if (this.on.has(1003)) return true;
+    return this.on.has(1002) && (button & NO_BUTTON) !== NO_BUTTON;
+  }
+  apply(params, set2) {
+    for (const p of params.split(";")) {
+      const mode = Number(p);
+      if (!p || !Number.isSafeInteger(mode)) continue;
+      if (set2) this.on.add(mode);
+      else this.on.delete(mode);
+    }
+  }
+};
+function mouseReport(data, at, utf8, urxvt) {
+  if (data[at + 1] !== 91) return null;
+  const sgr = data[at + 2] === 60;
+  if (sgr || urxvt && data[at + 2] >= 48 && data[at + 2] <= 57) {
+    let i = at + (sgr ? 3 : 2);
+    let digits = "";
+    let fields = 1;
+    for (; i < data.length && i - at < 32; i++) {
+      const b = data[i];
+      if (b >= 48 && b <= 57) {
+        if (fields === 1) digits += String.fromCharCode(b);
+      } else if (b === 59) fields++;
+      else break;
+    }
+    if (i >= data.length || fields !== 3 || !digits) return null;
+    if (sgr ? data[i] !== 77 && data[i] !== 109 : data[i] !== 77) return null;
+    const button = Number(digits) - (sgr ? 0 : 32);
+    return button >= 0 ? { button, length: i - at + 1 } : null;
+  }
+  if (data[at + 2] === 77 && !utf8 && data.length - at >= 6) {
+    const button = data[at + 3] - 32;
+    return button >= 0 ? { button, length: 6 } : null;
+  }
+  return null;
+}
+
+// src/shared/pty/terminal.ts
+var MOUSE_OFF = "\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1005l\x1B[?1006l\x1B[?1015l";
+var SETTLE_QUIET_MS = 50;
+var SETTLE_MAX_MS = 300;
+function drainInput(stream) {
+  return new Promise((done) => {
+    let quiet;
+    const end = () => {
+      clearTimeout(quiet);
+      clearTimeout(cap);
+      stream.off("data", onData);
+      done();
+    };
+    const onData = () => {
+      clearTimeout(quiet);
+      quiet = setTimeout(end, SETTLE_QUIET_MS);
+    };
+    const cap = setTimeout(end, SETTLE_MAX_MS);
+    stream.on("data", onData);
+    onData();
+  });
+}
+var VT_WAIT_MS = 1e4;
 function runTerminalClient(socket, token, options = {}) {
   const stdin = process.stdin;
   const stdout = process.stdout;
@@ -5905,14 +6068,16 @@ function runTerminalClient(socket, token, options = {}) {
     const [c, r] = stdout.isTTY ? stdout.getWindowSize() : [0, 0];
     return [c || 120, r || 30];
   };
-  let swapKeys = process.platform === "win32" && stdin.isTTY;
+  const keys = new KeyGate(process.platform === "win32" && Boolean(stdin.isTTY));
   return new Promise((resolve) => {
     let done = false;
     const reader = new FrameReader();
     const filter = new OutputFilter({ clipboardWrites: options.clipboardWrites });
     let sent = size();
     let resizeTimer;
-    let vtInput;
+    let vtInput, vtTimer;
+    const mouse = new MouseModes();
+    let passthrough = false;
     const finish = (result) => {
       if (done) return;
       done = true;
@@ -5923,9 +6088,13 @@ function runTerminalClient(socket, token, options = {}) {
       clearInterval(sizeWatch);
       clearTimeout(joinTimer);
       clearTimeout(hintTimer);
+      clearTimeout(vtTimer);
       socket.destroy();
-      stdout.write("\x1B[0m\x1B[?25h" + MOUSE_OFF + "\r\n");
-      void (vtInput?.stop() ?? Promise.resolve()).then(() => {
+      const tracked = mouse.tracking();
+      const reset = "\x1B[0m\x1B[?25h" + MOUSE_OFF + (mouse.has(2004) ? "\x1B[?2004l" : "") + "\r\n";
+      const flushed = new Promise((written) => stdout.write(reset, () => written()));
+      const settled = tracked ? flushed.then(() => drainInput(stdin)) : Promise.resolve();
+      void Promise.all([settled, vtInput?.stop()]).then(() => {
         if (stdin.isTTY) stdin.setRawMode(false);
         stdin.pause();
         resolve(result);
@@ -5933,9 +6102,10 @@ function runTerminalClient(socket, token, options = {}) {
     };
     const joiner = new InputJoiner();
     let joinTimer;
-    const sendInput = (data) => {
-      if (data.length && !done) socket.write(encodeFrame(FrameType.Input, swapKeys ? fixWindowsKeys(data) : data));
+    const write = (data) => {
+      if (data.length && !done) socket.write(encodeFrame(FrameType.Input, data));
     };
+    const sendInput = (data) => write(keys.push(passthrough ? mouse.filter(data) : data));
     const guard = options.confirmCtrlC ? new CtrlCGuard() : null;
     let hintTimer;
     const onInput = (chunk) => {
@@ -5957,7 +6127,6 @@ function runTerminalClient(socket, token, options = {}) {
       sendInput(joiner.push(chunk));
       if (joiner.holding()) joinTimer = setTimeout(() => sendInput(joiner.flush()), JOIN_MS);
     };
-    let passthrough = false;
     const sendSize = () => {
       const [c2, r2] = size();
       if (c2 === sent[0] && r2 === sent[1]) return;
@@ -5987,11 +6156,14 @@ function runTerminalClient(socket, token, options = {}) {
       for (const frame of frames) {
         if (frame.type === FrameType.Output) {
           const out = filter.push(frame.payload);
+          mouse.watch(out);
           guard?.watchOutput(out.toString("latin1"));
           stdout.write(out);
         } else if (frame.type === FrameType.Console) passthrough = frame.payload.toString("latin1") === "conpty.dll";
-        else if (frame.type === FrameType.Restarting) stdout.write(MOUSE_OFF + "\x1B[2J\x1B[3J\x1B[H");
-        else if (frame.type === FrameType.Exit)
+        else if (frame.type === FrameType.Restarting) {
+          mouse.reset();
+          stdout.write(MOUSE_OFF + "\x1B[2J\x1B[3J\x1B[H");
+        } else if (frame.type === FrameType.Exit)
           finish({ reason: "exit", exitCode: frame.payload.length >= 4 ? frame.payload.readInt32LE(0) : 1 });
         else if (frame.type === FrameType.Error)
           finish({
@@ -6007,8 +6179,10 @@ function runTerminalClient(socket, token, options = {}) {
     socket.write(helloFrame(token, c, r));
     if (stdin.isTTY) stdin.setRawMode(true);
     vtInput = enableVtInput();
+    vtTimer = setTimeout(() => write(keys.decide(false)), VT_WAIT_MS);
     void vtInput.ready.then((on) => {
-      if (on) swapKeys = false;
+      clearTimeout(vtTimer);
+      write(keys.decide(on));
     });
     stdin.on("data", onInput);
     stdin.resume();
@@ -27603,6 +27777,11 @@ var RunDir = class {
   projectsDir;
   /** audit.processes: programs the sandbox started, in small .jsonl files the host takes in and deletes. */
   auditDir;
+  /**
+   * Each running session's process tree, recorded by its ptyhost (guest only: the daemon ends what a ptyhost that was
+   * itself ended left running).
+   */
+  treesDir;
   /** One-shot secrets the host hands over (see secrets.ts). Next to run, not in it: shared-use users can change run. */
   secretsDir;
   constructor(dataDir2) {
@@ -27616,6 +27795,7 @@ var RunDir = class {
     this.sessionsDir = path5.join(this.root, "sessions");
     this.projectsDir = path5.join(this.root, "projects");
     this.auditDir = path5.join(this.root, "audit");
+    this.treesDir = path5.join(this.root, "trees");
     this.secretsDir = path5.join(dataDir2, "secrets");
   }
   requestFile(id) {
@@ -27627,6 +27807,9 @@ var RunDir = class {
   sessionFile(id) {
     return path5.join(this.sessionsDir, safeId(id) + ".json");
   }
+  treeFile(id) {
+    return path5.join(this.treesDir, safeId(id) + ".json");
+  }
   projectFile(name) {
     return path5.join(this.projectsDir, safeId(name) + ".json");
   }

package/dist/selftest/channel.test.js

@@ -3,7 +3,7 @@
 import { safeId } from '../shared/channel/index.js';
 import { GuestRequestSchema, SandboxStatusSchema, SessionStatusSchema } from '../shared/channel/index.js';
 import { bootLine, firstStartNotice, pendingDownloads, readyIn, stillWorking } from '../cli/commands/launch/index.js';
-import { CTRL_C_CONFIRM_MS, CTRL_C_HINT, CtrlCGuard, encodeFrame, FrameReader, FrameType, fixWindowsKeys, helloFrame, InputJoiner, MAX_FRAME_BYTES, MOUSE_OFF, OutputFilter, } from '../shared/pty/index.js';
+import { CTRL_C_CONFIRM_MS, CTRL_C_HINT, CtrlCGuard, encodeFrame, FrameReader, FrameType, fixWindowsKeys, helloFrame, InputJoiner, KeyGate, MAX_FRAME_BYTES, MOUSE_OFF, MouseModes, OutputFilter, } from '../shared/pty/index.js';
 import { bootSilent, FIRST_STATUS_MS } from '../host/channel/index.js';
 export const channelSuite = {
     name: 'channel',
@@ -148,6 +148,77 @@ export const channelSuite = {
             hello.payload[4] === 2 &&
             hello.payload.subarray(5).toString() === 'tok', 'a frame of exactly the maximum size is accepted; a hello frame carries size, flags and token');
         t.equal(fixWindowsKeys(Buffer.from([0x61, 0x08, 0x7f, 0x1b])), Buffer.from([0x61, 0x7f, 0x08, 0x1b]), 'Windows console Backspace (^H) reaches the agent as DEL, so it deletes one character, not a word');
+        {
+            // Keys typed while the client is still turning VT input on are the terminal's own bytes once it is on: they wait
+            // and are never swapped (a Backspace sent as DEL used to reach the agent as ^H, deleting a word).
+            const keys = new KeyGate(true);
+            const early = keys.push(Buffer.from([0x7f, 0x08]));
+            const held = keys.decide(true);
+            const later = keys.push(Buffer.from([0x7f]));
+            const fallback = new KeyGate(true);
+            fallback.push(Buffer.from([0x08]));
+            const off = fallback.decide(false);
+            const plain = new KeyGate(false).push(Buffer.from([0x7f, 0x08]));
+            t.check(early.length === 0 &&
+                held.equals(Buffer.from([0x7f, 0x08])) &&
+                later.equals(Buffer.from([0x7f])) &&
+                off.equals(Buffer.from([0x7f])) &&
+                fallback.push(Buffer.from([0x7f])).equals(Buffer.from([0x08])) &&
+                plain.equals(Buffer.from([0x7f, 0x08])), 'keys typed before the console mode is known wait, then go unswapped with VT input (swapped only without it)');
+        }
+        t.section('raw mouse input: motion and drag only while the agent asked for them');
+        {
+            const m = new MouseModes();
+            const b = (text) => Buffer.from(text, 'latin1');
+            const press = '\x1b[<0;10;5M';
+            const release = '\x1b[<0;10;5m';
+            const wheel = '\x1b[<64;10;5M';
+            const drag = '\x1b[<32;11;5M';
+            const ctrlDrag = '\x1b[<48;11;5M';
+            const move = '\x1b[<35;12;6M';
+            const all = 'a' + press + drag + move + release + wheel + 'b';
+            const pass = () => m.filter(b(all)).toString('latin1');
+            const none = pass();
+            m.watch(b('\x1b[?10'));
+            m.watch(b('00h\x1b[?1006h'));
+            const normal = pass();
+            m.watch(b('\x1b[?1002h'));
+            const button = pass();
+            const ctrl = m.filter(b(ctrlDrag)).toString('latin1');
+            m.watch(b('\x1b[?1003;1015h'));
+            const any = pass();
+            const urxvt = m.filter(b('\x1b[67;3;4M\x1b[1;5C')).toString('latin1');
+            t.check(none === 'ab' &&
+                normal === 'a' + press + release + wheel + 'b' &&
+                button === 'a' + press + drag + release + wheel + 'b' &&
+                ctrl === ctrlDrag &&
+                any === all &&
+                urxvt === '\x1b[67;3;4M\x1b[1;5C' &&
+                m.modes().join(',') === '1000,1002,1003,1006,1015', 'no tracking: no reports; 1000: clicks and wheel; 1002: + drags (modifiers kept); 1003: + every move; mode ' +
+                'changes split across chunks and lists (1003;1015) are followed; keys are never touched', JSON.stringify({ none, normal, button, ctrl, any, urxvt, modes: m.modes() }));
+            m.watch(b('\x1b[?1003l'));
+            const afterOff = pass();
+            m.watch(b('\x1b[?1015l\x1b[?1000l\x1b[?1002l'));
+            const x10 = m.filter(b('k\x1b[M #%')).toString('latin1');
+            m.watch(b('\x1b[?1000h'));
+            const x10On = m.filter(b('k\x1b[M #%\x1b[MC#%')).toString('latin1');
+            m.watch(b('\x1bc'));
+            const ris = m.tracking();
+            m.watch(b('\x1b[?1003h\x1b[!p'));
+            const decstr = m.tracking();
+            m.watch(b('\x1b[?1002h\x1b[?2004h'));
+            const paste = m.has(2004);
+            m.reset();
+            t.check(afterOff === 'a' + press + drag + release + wheel + 'b' &&
+                x10 === 'k' &&
+                x10On === 'k\x1b[M #%' &&
+                !ris &&
+                !decstr &&
+                paste &&
+                !m.tracking() &&
+                !m.has(2004), 'turning 1003 off drops moves again; X10 reports follow the same rules; a full or soft reset (ESC c, ' +
+                'ESC[!p) and a restart turn tracking off', JSON.stringify({ afterOff, x10, x10On, ris, decstr, paste }));
+        }
         t.section('Ctrl+C meant as "copy" does not reach the agent');
         const ctrlC = Buffer.from([3]);
         const g = new CtrlCGuard();

package/dist/selftest/contained.test.js

@@ -15,44 +15,8 @@ import { currentUserSid } from '../host/sharing/index.js';
 import { addHolder, CONTAINED_FOLDERS, containedAvailability, ContainedStorage, containedMappings, containedPaths, diagnose, hostDataFolder, markMounted, mountedSets, planTransfer, providerFor, pruneHolders, removeHolder, runTransfer, ScriptDiskPort, setNameOf, setStateOf, staleMountNote, StateFile, } from '../host/storage/index.js';
 import { EMPTY_STATE } from '../host/storage/contained/state.js';
 import { SYSTEM } from '../shared/system.js';
+import { fakeVhdx } from './support/vhdx.js';
 const SCRIPTS = ['contained-common', 'mount-contained', 'dismount-contained', 'check-contained', 'run-elevated'];
-/** Mixed-endian GUID bytes, as VHDX (and .NET's Guid) store them. */
-function guidBytes(text) {
-    const hex = text.replace(/-/g, '');
-    const raw = Buffer.from(hex, 'hex');
-    return Buffer.concat([
-        Buffer.from(raw.subarray(0, 4)).reverse(),
-        Buffer.from(raw.subarray(4, 6)).reverse(),
-        Buffer.from(raw.subarray(6, 8)).reverse(),
-        raw.subarray(8, 16),
-    ]);
-}
-/** A file with the parts of a VHDX header the scripts read (signature, region table, metadata table). */
-function fakeVhdx(file, o) {
-    const buf = Buffer.alloc(2 * 1024 * 1024);
-    buf.write('vhdxfile', 0, 'ascii');
-    const table = 196608;
-    buf.write('regi', table, 'ascii');
-    buf.writeUInt32LE(1, table + 8);
-    guidBytes('8b7ca206-4790-4b9a-b8fe-575f050f886e').copy(buf, table + 16);
-    buf.writeBigUInt64LE(BigInt(1048576), table + 32);
-    buf.writeUInt32LE(65536, table + 40);
-    const md = 1048576;
-    buf.write('metadata', md, 'ascii');
-    const items = [
-        { guid: '2fa54224-cd1b-4876-b211-5dbed83bf4b8', offset: 65536 },
-        ...(o.parent ? [{ guid: 'a8d35f2d-b30b-454d-abf7-d3d84834ab0c', offset: 65600 }] : []),
-    ];
-    buf.writeUInt16LE(items.length, md + 10);
-    items.forEach((item, i) => {
-        const at = md + 32 + 32 * i;
-        guidBytes(item.guid).copy(buf, at);
-        buf.writeUInt32LE(item.offset, at + 16);
-        buf.writeUInt32LE(8, at + 20);
-    });
-    buf.writeBigUInt64LE(BigInt(o.gb) * 1024n ** 3n, md + 65536);
-    fs.writeFileSync(file, buf);
-}
 class FakePort {
     paths;
     calls = [];

package/dist/selftest/hcs.test.js

@@ -537,10 +537,13 @@ export const hcsSuite = {
         }
         t.section('the helpers say the version they ship with (file details)');
         const version = JSON.parse(fs.readFileSync(path.join(t.packageRoot, 'package.json'), 'utf8')).version;
-        for (const helper of ['HostTools', 'HcsHost']) {
+        for (const helper of ['HostTools', 'HcsHost', 'StorageHelper']) {
             const info = fs.readFileSync(path.join(t.packageRoot, 'native', 'csharp', helper, 'AssemblyInfo.cs'), 'utf8');
             t.check(info.includes('AssemblyInformationalVersion("' + version + '")') &&
-                info.includes('AssemblyFileVersion("' + version + '.0")'), helper + '.exe file version is ' + version + ' (update AssemblyInfo.cs with package.json)');
+                info.includes('AssemblyFileVersion("' + version + '.0")'), (helper === 'StorageHelper' ? 'AgentSandboxStorage' : helper) +
+                '.exe file version is ' +
+                version +
+                ' (update AssemblyInfo.cs with package.json)');
         }
         t.section('HcsHost.exe compiles (C# 5, the csc that ships with Windows)');
         if (!isWin || !fs.existsSync(SYSTEM.csc())) {

package/dist/selftest/index.js

@@ -34,6 +34,7 @@ import { detectSuite } from './detect.test.js';
 import { generateSuite } from './generate.test.js';
 import { engineSuite } from './engine.test.js';
 import { containedSuite } from './contained.test.js';
+import { storageHelperSuite } from './storage-helper.test.js';
 import { hcsSuite } from './hcs.test.js';
 import { gitAccessSuite } from './git-access.test.js';
 import { guestBootSuite } from './guest-boot.test.js';
@@ -86,6 +87,7 @@ export const SUITES = [
     generateSuite,
     engineSuite,
     containedSuite,
+    storageHelperSuite,
     hcsSuite,
     guestBootSuite,
     mirrorSuite,

package/dist/selftest/install.test.js

@@ -24,6 +24,17 @@ function installerText(t, script) {
         timeout: 60000,
     });
     t.equal(parse.status, 0, 'it parses under the PowerShell 5.1 parser' + (parse.stderr ? ': ' + parse.stderr : ''));
+    t.section('install.ps1: the storage helper (installs for everyone only)');
+    t.check(/\[switch\]\$ContainedStorageHelper,/.test(source) &&
+        /\[switch\]\$NoContainedStorageHelper,/.test(source) &&
+        source.includes("$env:WDS_STORAGEHELPER -eq '1'"), 'it has -ContainedStorageHelper / -NoContainedStorageHelper (and WDS_STORAGEHELPER)');
+    const helperStep = source.slice(source.indexOf('# 8b.'), source.indexOf('# 9. Automatic updates'));
+    t.check(helperStep.includes('if ($machine) {') &&
+        helperStep.includes('set-storage-helper.ps1') &&
+        helperStep.includes('-Install -GroupSid $groupSid -InstallRoot $toolFolder'), 'the helper is installed by its own script, only for an install for everyone, for the group');
+    t.check(helperStep.includes("Ask 'Install a small Windows service") && helperStep.includes('$record.storageHelper'), 'asked once (default no), then the answer in install.json is kept');
+    t.check(source.includes('storageHelper = [bool]$helperOn') && /'staging', 'helper', 'active-version'/.test(source), 'install.json records it, and uninstall removes the helper folder');
+    t.check(/if \(\$machine\) \{ Remove-StorageHelper/.test(source), 'uninstall stops and deletes the service (and dismounts what it mounted) first');
     t.section('install.ps1: the shims equal shimText()');
     const cases = [
         ['sandbox', undefined],

package/dist/selftest/layout.test.js

@@ -1,6 +1,7 @@
 // The architecture rules, checked on the compiled output (dist/**/*.js): which areas may import which, the guest's
 // portable core, the pure guest files the host and tests may load without the guest runtime's side effects, and no
-// import cycles. The bundled dist/runtime is left out (it has no imports).
+// import cycles. The bundled dist/runtime is left out (it has no imports); the bundled commands (dist/bin) must import
+// only their own chunks.
 import fs from 'node:fs';
 import path from 'node:path';
 const STATIC = /^\s*(?:import|export)\b[^;]*?\bfrom\s*(['"])([^'"\n]+)\1;?\s*$|^\s*import\s*(['"])([^'"\n]+)\3;?\s*$/gm;
@@ -149,5 +150,13 @@ export const layoutSuite = {
             .filter((d) => area(d) === 'app' && !(area(f) === 'host' && d.startsWith('app/kernel/')))
             .map((d) => f + ' -> ' + d));
         t.check(!intoApp.length, 'below the CLI only host code uses the shared core, and only its kernel', list(intoApp));
+        t.section('the commands');
+        // Loading the CLI as hundreds of modules took most of a second before anything was shown (scripts/bundle.mjs).
+        const bins = files.filter((f) => area(f) === 'bin');
+        const unbundled = bins.flatMap((f) => modules
+            .get(f)
+            .statics.filter((d) => area(d) !== 'bin')
+            .map((d) => f + ' -> ' + d));
+        t.check(bins.includes('bin/sandbox.js') && bins.some((f) => f.startsWith('bin/chunk-')) && !unbundled.length, 'the commands (dist/bin) are bundled: they load no compiled module one by one', list(unbundled));
     },
 };

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

@@ -2,11 +2,13 @@
 // with cmd.exe standing in for the agent. One daemon serves all the checks below, in order (compiling ptyhost is slow).
 import fs from 'node:fs';
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { queryViewers } from '../shared/pty/index.js';
+import { SYSTEM } from '../shared/system.js';
 import { copyCmdAsFakeAgent, openViewer, sees, startDaemon, tail, viewersWhen, WAIT } from './support/live.js';
 export const liveDaemonSuite = {
     name: 'live-daemon',
-    title: 'live: session daemon + ptyhost (start, attach, viewers, exec, restart, exit)',
+    title: 'live: session daemon + ptyhost (start, attach, viewers, exec, a killed ptyhost, restart, exit)',
     live: true,
     timeoutMs: 360000,
     run: async (t, f) => {
@@ -107,6 +109,54 @@ export const liveDaemonSuite = {
                 const again = await daemon.response('close2');
                 t.check(again?.ok === false, 'closing a session that has ended says it is not running', JSON.stringify(again));
             }
+            t.section('live: a session host ended from outside (Task Manager)');
+            {
+                // A copy of PING with a name of its own, started hidden in a console of its own (closing the pseudo console
+                // does not end it) by a PowerShell the shell runs; then the session's ptyhost is killed.
+                const probe = t.at('tree-probe.exe');
+                fs.copyFileSync(path.join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'PING.EXE'), probe);
+                const probeRunning = () => spawnSync(SYSTEM.tasklist(), ['/FI', 'IMAGENAME eq tree-probe.exe', '/NH'], { encoding: 'utf8' })
+                    .stdout.toLowerCase()
+                    .includes('tree-probe.exe');
+                daemon.request({ kind: 'session', id: 'shell2', harness: 'shell', args: [], cwd: workspace, shell: 'cmd' });
+                const tree = await daemon.started('shell2');
+                const record = path.join(daemon.run, 'trees', 'shell2.json');
+                const readRecord = () => {
+                    try {
+                        return JSON.parse(fs.readFileSync(record, 'utf8'));
+                    }
+                    catch {
+                        return null;
+                    }
+                };
+                if (tree?.attach) {
+                    const treeView = await openViewer(tree.attach);
+                    viewers.push(treeView);
+                    await sees(t, treeView, '>');
+                    treeView.type('"' +
+                        SYSTEM.powershell() +
+                        '" -NoProfile -Command "Start-Process -WindowStyle Hidden -FilePath \'' +
+                        probe +
+                        "' -ArgumentList '-n','120','127.0.0.1'; Start-Sleep -Seconds 8\"");
+                    // cmd, the PowerShell and the probe, once ptyhost has followed the tree (every 3 s).
+                    const recorded = await t.waitFor(() => {
+                        const r = readRecord();
+                        return probeRunning() && r && r.processes.length >= 3 ? r : null;
+                    }, WAIT.screen);
+                    t.check(recorded !== null, "the session's ptyhost records what its program started in the run folder", JSON.stringify(readRecord()) + ' probe running: ' + probeRunning() + '\n' + daemon.diagnostics());
+                    if (recorded) {
+                        spawnSync(path.join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'taskkill.exe'), ['/F', '/PID', String(recorded.ptyhost.pid)], { stdio: 'ignore' });
+                        const gone = await t.waitFor(() => !probeRunning() && !fs.existsSync(record), 30000);
+                        t.check(Boolean(gone) &&
+                            daemon.status('shell2')?.phase === 'exited' &&
+                            /session host was ended from outside; ended [1-9]\d* process\(es\)/.test(daemon.diagnostics()), 'when its ptyhost is killed, the daemon ends what the session left running (and forgets the record)', 'probe running: ' + probeRunning() + ', record: ' + fs.existsSync(record) + '\n' + daemon.diagnostics());
+                    }
+                }
+                else
+                    t.check(false, 'a second shell session starts', JSON.stringify(tree) + '\n' + daemon.diagnostics());
+                if (probeRunning())
+                    spawnSync(path.join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'taskkill.exe'), ['/F', '/IM', 'tree-probe.exe'], { stdio: 'ignore' });
+            }
             t.section('live: restart and exit');
             daemon.request({ kind: 'restart', id: 'restart1', harness: 'claude' });
             const sawResumed = await sees(t, viewer, 'LIVE-AGENT-RESUMED');