windows-development-sandbox 1.27.3 → 1.29.0

package/dist/runtime/view.js

@@ -5743,7 +5743,7 @@ var OutputFilter = class {
   }
 };
 
-// src/shared/pty/console-input.ts
+// src/shared/pty/clipboard-watch.ts
 import { spawn } from "node:child_process";
 
 // src/shared/system.ts
@@ -5796,7 +5796,36 @@ function scriptArgs(name, args = []) {
   ];
 }
 
+// src/shared/pty/clipboard-watch.ts
+var MAX_PENDING = 1024;
+function watchClipboard(onChange) {
+  if (process.platform !== "win32") return { stop: () => void 0 };
+  let child = null;
+  try {
+    child = spawn(SYSTEM.powershell(), scriptArgs("watch-clipboard.ps1", ["-ProcessId", String(process.pid)]), {
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+  } catch {
+    return { stop: () => void 0 };
+  }
+  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", () => void 0);
+  return {
+    stop: () => {
+      if (child && child.exitCode === null && child.signalCode === null) child.kill();
+    }
+  };
+}
+
 // src/shared/pty/console-input.ts
+import { spawn as spawn2 } from "node:child_process";
 function enableVtInput() {
   if (process.platform !== "win32" || !process.stdin.isTTY)
     return { ready: Promise.resolve(false), stop: () => Promise.resolve() };
@@ -5804,7 +5833,7 @@ function enableVtInput() {
   let exited = Promise.resolve();
   const ready = new Promise((resolve) => {
     try {
-      child = spawn(SYSTEM.powershell(), scriptArgs("enable-vt-input.ps1", ["-ProcessId", String(process.pid)]), {
+      child = spawn2(SYSTEM.powershell(), scriptArgs("enable-vt-input.ps1", ["-ProcessId", String(process.pid)]), {
         stdio: "ignore",
         windowsHide: true
       });
@@ -5863,30 +5892,94 @@ function unfinishedSequence(data) {
   return data.length;
 }
 
-// src/shared/pty/ctrl-c.ts
+// src/shared/web/protocol.ts
+var MAX_CLIENT_MESSAGE_BYTES = 256 * 1024;
+
+// src/shared/web/ctrl-c.ts
 var CTRL_C_CONFIRM_MS = 1500;
 var CTRL_C_HINT = "Ctrl+C again to send it to the program (Esc stops an agent)";
-var OSC_TITLE = /\x1b\][02];([^\x07\x1b]{0,256})(?:\x07|\x1b\\)/g;
-var CtrlCGuard = class {
+var CTRL_C_COPY_HINT = "Copied: Ctrl+C after selecting text is not sent to the program (Esc stops an agent)";
+var CtrlCDecider = class {
+  constructor(confirm = true) {
+    this.confirm = confirm;
+  }
+  confirm;
   armedAt = Number.NEGATIVE_INFINITY;
-  lastTitle = "";
-  /** What to send for one read from the keyboard: a lone Ctrl+C only when another came just before. */
-  push(chunk, nowMs) {
-    if (chunk.length !== 1 || chunk[0] !== 3) return { send: chunk, held: false };
+  selected = false;
+  /** 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: chunk, held: false };
+      return "send";
     }
     this.armedAt = nowMs;
-    return { send: Buffer.alloc(0), held: true };
+    return "hold";
+  }
+};
+var MOUSE_REPORT = /\x1b\[<(\d{1,4});\d{1,5};\d{1,5}([Mm])|\x1b\[M([\s\S])[\s\S]{2}/g;
+function classifyInput(text) {
+  let drag = false;
+  let click = false;
+  for (const m of text.matchAll(MOUSE_REPORT)) {
+    const sgr = m[1] !== void 0;
+    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 };
+}
+function hasClipboardWrite(text) {
+  return /\x1b\]0{0,2}52;/.test(text) || /\u009d0{0,2}52;/.test(text);
+}
+
+// src/shared/pty/ctrl-c.ts
+var OSC_TITLE = /\x1b\][02];([^\x07\x1b]{0,256})(?:\x07|\x1b\\)/g;
+var CtrlCGuard = class {
+  decider;
+  lastTitle = "";
+  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] === 3) {
+      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" };
+    }
+    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) {
     for (const m of text.matchAll(OSC_TITLE)) 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";
@@ -6090,6 +6183,7 @@ function runTerminalClient(socket, token, options = {}) {
       clearTimeout(joinTimer);
       clearTimeout(hintTimer);
       clearTimeout(vtTimer);
+      clipboard.stop();
       socket.destroy();
       const tracked = mouse.tracking();
       const reset = "\x1B[0m\x1B[?25h" + MOUSE_OFF + (mouse.has(2004) ? "\x1B[?2004l" : "") + "\r\n";
@@ -6107,23 +6201,22 @@ function runTerminalClient(socket, token, options = {}) {
       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;
+    const guard = new CtrlCGuard({ confirm: options.confirmCtrlC !== false });
     let hintTimer;
+    const clipboard = watchClipboard(() => guard.clipboardChanged());
     const onInput = (chunk) => {
       if (options.detachKey !== void 0 && 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] === 3) 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] === 3) stdout.write(guard.restoreTitle());
       clearTimeout(joinTimer);
       sendInput(joiner.push(chunk));
       if (joiner.holding()) joinTimer = setTimeout(() => sendInput(joiner.flush()), JOIN_MS);
@@ -6156,9 +6249,10 @@ function runTerminalClient(socket, token, 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) passthrough = frame.payload.toString("latin1") === "conpty.dll";
         else if (frame.type === FrameType.Restarting) {
@@ -26106,7 +26200,7 @@ var SandboxSchema = external_exports.strictObject({
     'The last resort that keeps the sandbox up, in MB below its commit limit (RAM plus paging file): builds are slowed down long before (sandbox.pressureResponse); only if everything the agents start together would take the sandbox to the very edge of its memory, where Windows inside it would start failing, is a build refused memory instead of Windows. "auto" = the larger of 1536 MB and 3 % of the commit limit; "none" = no backstop. Yours only: a project file cannot change it.'
   ),
   pressureResponse: external_exports.boolean().describe(
-    "When the sandbox (or this PC) runs low on memory, slow builds down in steps, like a PC that gets slower instead of failing: build programs get lower CPU and memory priority, then less CPU, then compilers take turns (the waiting ones briefly suspended and trimmed to the paging file). Nothing is stopped or killed, and the agents themselves are never touched. Yours only: a project file cannot change it."
+    "When the sandbox (or this PC) runs low on memory, slow builds down in steps, like a PC that gets slower instead of failing: build programs get lower CPU and memory priority, then less CPU, then compilers take turns (the waiting ones briefly suspended and trimmed to the paging file). Nothing is stopped or killed, and the agents themselves are never touched. A memory gate also holds new compilers and linkers for a moment when the memory of the build programs grows faster than 4 GB in 3 seconds (3 GB with vGPU), and lets them go one at a time. Yours only: a project file cannot change it."
   ),
   vGpu: external_exports.boolean().describe(
     "Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it). Browsers in the sandbox never use it (they draw in software)."
@@ -26120,7 +26214,7 @@ var SandboxSchema = external_exports.strictObject({
   printerRedirection: external_exports.boolean().describe("Printers from this PC."),
   protectedClient: external_exports.boolean().describe("Run the sandbox window in Protected Client mode (recommended)."),
   headless: external_exports.boolean().describe(
-    "Hide the sandbox window (sbx-show brings it back). A headless sandbox shuts down when its last session ends."
+    'Hide the sandbox window ("Show the window" brings it back). A headless sandbox shuts down when its last session ends.'
   ),
   keepAwake: external_exports.boolean().describe(
     "Keep this PC from sleeping while a sandbox runs, so agents left working overnight keep going (the screen may still turn off; closing a laptop lid still sleeps it)."
@@ -28304,6 +28398,8 @@ var PressureStatusSchema = external_exports.object({
   lowered: external_exports.number().int().min(0).max(1024),
   /** Compilers waiting their turn right now (name, process id, seconds until they may go on). */
   paused: external_exports.array(external_exports.object({ name: Text(64), pid: external_exports.number().int(), seconds: external_exports.number().int().min(0).max(60) })).max(8),
+  /** Build programs the memory gate holds right now (let go one at a time). */
+  held: external_exports.number().int().min(0).max(1024).optional(),
   /** The CPU share the compilers get together (percent; 100 = no cap). */
   cpuPercent: external_exports.number().int().min(0).max(100).optional(),
   /** The PC itself asked for slowing down (its memory or CPU is low). */
@@ -28324,6 +28420,8 @@ var HeartbeatSchema = external_exports.object({
   topProcesses: external_exports.array(external_exports.object({ name: Text(64), privateMb: external_exports.number().int().min(0).max(1e7) })).max(5),
   /** The disk queue this PC last reported while asking the sandbox to slow down. */
   diskQueueReported: external_exports.number().min(0).max(1e5).optional(),
+  /** Build programs the memory gate holds right now (let go one at a time). */
+  held: external_exports.number().int().min(0).max(1024).optional(),
   /** "ending": the sandbox is shutting down in order (idle shutdown, sandbox stop, Windows shutting down). */
   phase: external_exports.enum(["ready", "working", "ending"])
 });
@@ -28652,7 +28750,7 @@ import crypto from "node:crypto";
 
 // src/shared/download/spawn.ts
 import os3 from "node:os";
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 function lowerPriority(pid) {
   if (pid === void 0) return;
   try {
@@ -28663,7 +28761,7 @@ function lowerPriority(pid) {
 function spawnAsync(file2, args, options = {}) {
   const { lowPriority, ...spawnOptions } = options;
   return new Promise((resolve, reject) => {
-    const child = spawn2(file2, args, { stdio: "ignore", windowsHide: true, ...spawnOptions });
+    const child = spawn3(file2, args, { stdio: "ignore", windowsHide: true, ...spawnOptions });
     if (lowPriority) lowerPriority(child.pid);
     child.once("error", reject);
     child.once("close", (code) => resolve(code ?? -1));

package/dist/selftest/agent-paths.test.js

@@ -7,7 +7,7 @@ import { isWin } from '../core/util/index.js';
 import { SYSTEM } from '../shared/system.js';
 import { agentCommand, agentShims, bootResetPaths, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, shimText, } from '../guest/agents/agent-files.js';
 import { appendMissing, expandVars, installedToolPaths, isGitUsrBin, isMsvcToolsDir, isPinnedNodeDir, msvcBeforeGitUsr, parseRegPath, pathKey, planPath, rebuildPath, sessionPath, splitPath, } from '../guest/setup/path-plan.js';
-import { withReloadEnvironment } from '../host/tools/index.js';
+import { withCopyOnSelect, withReloadEnvironment } from '../host/tools/index.js';
 import { HarnessSchema } from '../core/schema/index.js';
 export const agentPathsSuite = {
     name: 'agent-paths',
@@ -136,6 +136,8 @@ export const agentPathsSuite = {
         t.section('Windows Terminal reloads the environment');
         t.equal(withReloadEnvironment({ compatibility: { reloadEnvironmentVariables: true } }), null, 'already set: unchanged');
         t.equal(withReloadEnvironment({ theme: 'dark', compatibility: { other: 1 } })?.compatibility, { other: 1, reloadEnvironmentVariables: true }, 'set without touching the rest of compatibility');
+        t.equal(withCopyOnSelect({ theme: 'dark' })?.copyOnSelect, true, 'copy on select is added when the key is missing');
+        t.equal(withCopyOnSelect({ copyOnSelect: false }), null, 'a copy-on-select value the user set stays');
         if (!isWin)
             return;
         t.section('shell start-up (pathsync.exe and the start-up files)');

package/dist/selftest/channel.test.js

@@ -4,6 +4,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, KeyGate, MAX_FRAME_BYTES, MOUSE_OFF, MouseModes, OutputFilter, } from '../shared/pty/index.js';
+import { classifyInput } from '../shared/web/index.js';
 import { bootSilent, FIRST_STATUS_MS } from '../host/channel/index.js';
 export const channelSuite = {
     name: 'channel',
@@ -251,6 +252,38 @@ export const channelSuite = {
             !g.push(Buffer.from('x'), 6000).held, 'a lone Ctrl+C is held back, a second one soon after is sent, a late second one is held again, other input passes');
         g.watchOutput('\x1b]0;claude: working\x07more \x1b]2;\u0001evil\x07');
         t.check(g.hintTitle().includes(CTRL_C_HINT) && g.restoreTitle() === '\x1b]0;evil\x07', "the hint shows in the title, and the program's last title comes back without control characters");
+        const drag = Buffer.from('\x1b[<32;10;5M');
+        const release = Buffer.from('\x1b[<0;12;5m');
+        const copyG = new CtrlCGuard();
+        copyG.push(drag, 0);
+        copyG.push(release, 10);
+        const copies = [100, 200, 300].map((at) => copyG.push(ctrlC, at));
+        t.check(copies.every((c) => c.send.length === 0 && c.copied && !c.held), 'after a mouse drag in the program every Ctrl+C is copied and never sent, however often it is pressed');
+        copyG.push(Buffer.from('x'), 400);
+        t.check(copyG.push(ctrlC, 500).held, 'after another key a lone Ctrl+C is held back again');
+        const clickG = new CtrlCGuard();
+        clickG.push(drag, 0);
+        clickG.push(Buffer.from('\x1b[<0;3;3M'), 10);
+        t.check(clickG.push(ctrlC, 20).held, 'a mouse click after a drag ends copy mode');
+        const quietG = new CtrlCGuard();
+        quietG.push(Buffer.from('\x1b[<64;3;3M'), 0);
+        quietG.push(Buffer.from('\x1b[<35;3;3M'), 1);
+        t.check(quietG.push(ctrlC, 2).held, 'mouse wheel and hover reports do not start copy mode');
+        const clipG = new CtrlCGuard();
+        clipG.watchClipboard('\x1b]52;c;aGk=');
+        t.check(clipG.push(ctrlC, 0).copied, 'the program writing the clipboard (OSC 52) starts copy mode');
+        const copiedG = new CtrlCGuard();
+        copiedG.clipboardChanged();
+        const afterCopy = copiedG.push(ctrlC, 0);
+        copiedG.push(Buffer.from('x'), 1);
+        t.check(afterCopy.copied && !afterCopy.held && afterCopy.send.length === 0 && copiedG.push(ctrlC, 2).held, 'after the clipboard changed a lone Ctrl+C is copied (not sent, not held) until another key is pressed');
+        const noConfirm = new CtrlCGuard({ confirm: false });
+        const sentAtOnce = noConfirm.push(ctrlC, 0);
+        noConfirm.push(drag, 1);
+        t.check(sentAtOnce.send.equals(ctrlC) && noConfirm.push(ctrlC, 2).copied, 'without confirmation a lone Ctrl+C is sent at once, but after a drag it is still copied');
+        const x10 = classifyInput('\x1b[M' + String.fromCharCode(32 + 32) + '!!');
+        const arrow = classifyInput('\x1b[A');
+        t.check(x10.mouse === 'drag' && !x10.keys && arrow.mouse === null && arrow.keys, 'an X10 drag is a drag without keys, and an arrow key is a key without a mouse report');
         t.section('typed input keeps escape sequences whole');
         const joined = (...chunks) => {
             const j = new InputJoiner();

package/dist/selftest/cli.test.js

@@ -47,17 +47,17 @@ export const cliSuite = {
             ['postgres', 'redis', 'mongodb'],
             ['--continue'],
         ], '`start` is launch without an agent; positionals, repeated lists and arguments after -- parse');
-        t.section('parser: agent wrappers (claude-sbx ...) and agent-sandbox');
+        t.section('parser: agent mode (sandbox claude ...) and plain commands');
         const wrapped = parseCli(['--terminal', '--continue', '--headless', '--node', '20', '--', '--terminal'], true);
-        t.equal([wrapped.command, wrapped.terminal, wrapped.headless, wrapped.node, wrapped.passthrough], ['launch', true, true, '20', ['--continue', '--terminal']], 'claude-sbx: sandbox flags are consumed, everything else goes to the agent');
-        await t.throws(() => parseCli(['status', '--bogus']), 'unknown option', 'agent-sandbox: unknown options are errors');
+        t.equal([wrapped.command, wrapped.terminal, wrapped.headless, wrapped.node, wrapped.passthrough], ['launch', true, true, '20', ['--continue', '--terminal']], 'agent mode: sandbox flags are consumed, everything else goes to the agent');
+        await t.throws(() => parseCli(['status', '--bogus']), 'unknown option', 'plain commands: unknown options are errors');
         const agentFlags = parseCli(['--model', 'opus', '-p', 'fix it', '--json', '-f', 'x', '--timeout', '5', '--resume', 'abc'], true);
         t.check(agentFlags.passthrough.join('|') === '--model|opus|-p|fix it|--json|-f|x|--timeout|5|--resume|abc' &&
             !agentFlags.json &&
             !agentFlags.follow &&
-            agentFlags.timeout === 600, 'claude-sbx: any flag that is not a launch option goes to the agent in order and sets no agent-sandbox option');
+            agentFlags.timeout === 600, 'agent mode: any flag that is not a launch option goes to the agent in order and sets no sandbox option');
         const reserved = parseCli(['--sbx-terminal', '--terminal', '--sbx-node=18'], true);
-        t.equal([reserved.terminal, reserved.node, reserved.passthrough], [true, '18', []], '--sbx-<option> always means agent-sandbox');
+        t.equal([reserved.terminal, reserved.node, reserved.passthrough], [true, '18', []], '--sbx-<option> always means the sandbox option');
         await t.throws(() => parseCli(['--sbx-nope'], true), 'Unknown option: --sbx-nope', 'an unknown --sbx-<option> is an error');
         t.section('menu helpers');
         t.check(splitArgs('--model "big one" -c \'x y\'').join('|') === '--model|big one|-c|x y' &&

package/dist/selftest/config.test.js

@@ -75,7 +75,7 @@ export const configSuite = {
         });
         const sharedFile = t.at('share', 'theirs.json');
         fs.writeFileSync(sharedFile, shared);
-        const bin = (args) => f.runBin('agent-sandbox', [...args, '--config', yours], { cwd: f.workA, env });
+        const bin = (args) => f.runBin('sandbox', [...args, '--config', yours], { cwd: f.workA, env });
         const outFile = t.at('share', 'out.json');
         const exportRun = await bin(['config', 'export', outFile]);
         const written = readJsonc(outFile);

package/dist/selftest/credentials.test.js

@@ -191,7 +191,7 @@ export const credentialsSuite = {
             ['vpn', 'status', '--json'],
             ['status', '--json'],
         ]) {
-            const out = await f.runBin('agent-sandbox', [...args, '--config', cliConfig], { cwd: f.workA, env });
+            const out = await f.runBin('sandbox', [...args, '--config', cliConfig], { cwd: f.workA, env });
             t.check(!out.out.includes(API_KEY) && (args[0] !== 'config' || out.out.includes('***')), 'sandbox ' + args.join(' ') + ' never prints the planted key' + (args[0] === 'config' ? ' (it shows ***)' : ''), out.out.slice(0, 400));
         }
     },

package/dist/selftest/engine.test.js

@@ -117,7 +117,7 @@ export const engineSuite = {
             !LocalOverridesSchema.safeParse({ storage: { containedMaxGb: 8 } }).success, "a project's .sandbox-config.json cannot set sandbox.engine, storage.contained or storage.containedMaxGb");
         t.check(LocalOverridesSchema.safeParse({ sandbox: { vGpu: false } }).success, 'other sandbox settings are still allowed in a project file');
         t.section('sandbox engine');
-        const run = await f.runBin('agent-sandbox', ['engine', '--json', '--config', t.writeJson(t.at('engine-config.json'), {})], {
+        const run = await f.runBin('sandbox', ['engine', '--json', '--config', t.writeJson(t.at('engine-config.json'), {})], {
             cwd: f.workA,
             env: { ...process.env, NO_COLOR: '1', AGENT_SANDBOX_HOME: t.dir('engine-home'), AGENT_SANDBOX_HOST_ONLY: '1' },
         });

package/dist/selftest/generate.test.js

@@ -3,7 +3,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { LocalOverridesSchema } from '../core/schema/index.js';
-import { buildWsb, gitIdentity, logonEnv, resolveMemoryMb } from '../host/launch/index.js';
+import { buildWsb, gitIdentity, isSandboxSourceRepo, launchHasSandboxSource, logonEnv, resolveMemoryMb, stagePcLogs, } from '../host/launch/index.js';
+import { pcLogsGuideLine } from '../guest/boot/guide-lines.js';
 export const generateSuite = {
     name: 'generate',
     title: 'generated .wsb, launch folder and session.json',
@@ -90,5 +91,69 @@ export const generateSuite = {
             resolveMemoryMb({ ...auto, maxMemoryPercent: 50 }, 60000 * MB, pcRam),
         ], [31744, 21504, 32768], "memory 'auto' follows free RAM minus the reserve and never takes more than maxMemoryPercent of the PC's RAM");
         await t.throws(() => resolveMemoryMb(auto, 9000 * MB, pcRam), 'Not enough free RAM', "memory 'auto' refuses when too little RAM is free");
+        t.section('PC logs for developing the sandbox');
+        const root = path.join(t.temp, 'pc-logs');
+        const URL = 'git+https://github.com/JoshDiDuca/windows-development-sandbox.git';
+        const project = (name, pkg) => {
+            t.write(path.join(root, name, 'package.json'), pkg);
+            return path.join(root, name);
+        };
+        const own = project('own', JSON.stringify({ name: 'windows-development-sandbox', repository: { type: 'git', url: URL } }));
+        const pkgOf = (url, name = 'windows-development-sandbox') => JSON.stringify({ name, repository: { url } });
+        const variants = [
+            project('v-https', pkgOf('https://github.com/joshdiduca/windows-development-sandbox')),
+            project('v-dotgit', pkgOf('https://github.com/JoshDiDuca/windows-development-sandbox.git')),
+            project('v-string', JSON.stringify({ name: 'windows-development-sandbox', repository: URL })),
+        ];
+        t.equal([isSandboxSourceRepo(own, own), ...variants.map((v) => isSandboxSourceRepo(v, own))], [true, true, true, true], 'a folder with the sandbox name and repository url is its source (git+, .git and case variants too)');
+        const big = project('big', pkgOf(URL) + ' '.repeat(300 * 1024));
+        const link = path.join(root, 'linked');
+        let linked = false;
+        try {
+            fs.symlinkSync(path.join(root, 'own'), link, 'junction');
+            linked = true;
+        }
+        catch {
+            // No permission for links here: that case is skipped.
+        }
+        t.equal([
+            isSandboxSourceRepo(project('wrong-url', pkgOf('https://github.com/someone/windows-development-sandbox')), own),
+            isSandboxSourceRepo(project('wrong-name', pkgOf(URL, 'other')), own),
+            isSandboxSourceRepo(project('invalid', '{ nope'), own),
+            isSandboxSourceRepo(path.join(root, 'missing'), own),
+            isSandboxSourceRepo(big, own),
+            linked ? isSandboxSourceRepo(link, own) : false,
+        ], [false, false, false, false, false, false], 'a wrong url or name, a missing, oversized or invalid package.json and a link are not the sandbox source');
+        t.check(launchHasSandboxSource([f.workA, own], own) && !launchHasSandboxSource([f.workA, f.workB], own), 'any project of the launch can be the source; a launch without it has none');
+        t.check(!fs.existsSync(path.join(gen.launchPath, 'pc-logs')), 'a launch of another project gets no pc-logs');
+        const storage = path.join(root, 'storage');
+        const dataPath = path.join(root, 'data-x');
+        for (let i = 0; i < 12; i++)
+            t.write(path.join(storage, 'logs', 'crashes', 'crash-2026-01-' + String(10 + i) + '.txt'), 'report ' + i);
+        t.write(path.join(storage, 'logs', 'host-memory-data-x.log'), 'start\n' + 'm'.repeat(600 * 1024) + 'END');
+        t.write(path.join(storage, 'logs', 'host-sync-data-x.log'), 'small');
+        t.write(path.join(storage, 'state', 'live-folders.log'), 'live');
+        t.write(path.join(storage, 'state', 'logins.json'), 'SECRET');
+        t.write(path.join(storage, 'secrets', 'x.json'), 'SECRET');
+        const launch = path.join(root, 'launch');
+        const out = stagePcLogs(storage, dataPath, launch);
+        const listing = (dir) => fs
+            .readdirSync(dir, { recursive: true, withFileTypes: true })
+            .flatMap((e) => e.isFile() ? [path.relative(out, path.join(e.parentPath, e.name)).replaceAll('\\', '/')] : []);
+        const copied = listing(out).sort();
+        const reports = copied.filter((n) => n.startsWith('crashes/'));
+        const memory = fs.readFileSync(path.join(out, 'host-memory.log'), 'utf8');
+        t.check(reports.length === 10 &&
+            reports.includes('crashes/crash-2026-01-21.txt') &&
+            !reports.includes('crashes/crash-2026-01-11.txt') &&
+            fs.statSync(path.join(out, 'host-memory.log')).size <= 256 * 1024 &&
+            memory.endsWith('END') &&
+            fs.readFileSync(path.join(out, 'README.txt'), 'utf8').includes('never commit'), 'the newest 10 crash reports, the last 256 KB of the memory log and a README are copied', copied.join(', '));
+        t.equal(copied.filter((n) => !n.startsWith('crashes/')), ['README.txt', 'host-memory.log', 'host-sync.log', 'live-folders.log'], 'nothing else from the storage folder is copied (no state, logins or secrets)');
+        t.section('the guide line for the PC logs');
+        t.equal([pcLogsGuideLine('C:\\AgentLaunch', () => false), pcLogsGuideLine('C:\\AgentLaunch', () => true)], [
+            [],
+            ['- PC crash reports and logs (this project only, read-only, never commit them): `C:\\AgentLaunch\\pc-logs`'],
+        ], 'the guide mentions the PC logs only when the folder exists');
     },
 };

package/dist/selftest/hcs.test.js

@@ -514,7 +514,7 @@ export const hcsSuite = {
             LEFTOVER_DEPS.current = null;
         }
         t.section('sandbox engine check hcs');
-        const out = await f.runBin('agent-sandbox', ['engine', 'check', 'hcs', '--config', t.writeJson(t.at('hcs-config.json'), {})], {
+        const out = await f.runBin('sandbox', ['engine', 'check', 'hcs', '--config', t.writeJson(t.at('hcs-config.json'), {})], {
             cwd: f.workA,
             env: { ...process.env, NO_COLOR: '1', AGENT_SANDBOX_HOME: t.dir('hcs-home'), AGENT_SANDBOX_HOST_ONLY: '1' },
         });

package/dist/selftest/health.test.js

@@ -14,7 +14,7 @@ import { logText, writeRepairLog } from '../cli/commands/repair/log.js';
 import { HealthPrinter, summaryText } from '../cli/commands/repair/printer.js';
 import { runHealth } from '../cli/commands/repair/run.js';
 import { configBackups, findCommandCopies, fileOnDisk, groupEntries, inspectPointers, lineDiff, orphanWatchers, parseGroupMembers, parseIcacls, parseRegPath, pathHas, privacyProblems, repairPointers, runStateProblems, shimProblems, staleActiveRecords, staleLaunchFolders, watcherRecords, } from '../host/health/index.js';
-import { InstallLayout, writeShims } from '../host/install/index.js';
+import { InstallLayout, REMOVED_COMMANDS, shimText, writeShims } from '../host/install/index.js';
 import { ActiveRecords } from '../host/sharing/index.js';
 const SID = 'S-1-5-21-1-2-3-1001';
 function fakeSystem(over = {}) {
@@ -225,7 +225,7 @@ function installChecks(t, mode) {
         t.writeJson(path.join(layout.packageDir(v), 'package.json'), { name: 'x', version: v, bin });
     };
     pkg('1.4.0', { sandbox: 'dist/bin/sandbox.js' });
-    pkg('1.5.0', { sandbox: 'dist/bin/sandbox.js', 'agent-sandbox': 'dist/bin/agent-sandbox.js' });
+    pkg('1.5.0', { sandbox: 'dist/bin/sandbox.js', 'other-tool': 'dist/bin/other-tool.js' });
     t.dir('health', 'install-' + mode, 'WindowsDevelopmentSandbox', 'versions', '1.6.0', 'staging');
     t.write(layout.nodeExe('v22.1.0'), 'x');
     t.write(layout.nodeExe('v22.11.0'), 'x');
@@ -257,13 +257,13 @@ async function pointers(t, layout, env) {
 async function shims(t, layout, env) {
     t.section('install: shims');
     layout.setActive('1.5.0', 'v22.11.0');
-    const bins = { sandbox: 'dist/bin/sandbox.js', 'agent-sandbox': 'dist/bin/agent-sandbox.js' };
+    const bins = { sandbox: 'dist/bin/sandbox.js', 'other-tool': 'dist/bin/other-tool.js' };
     writeShims(layout, bins);
     t.equal(shimProblems(layout, bins), { missing: [], different: [] }, 'freshly written shims are fine');
     fs.rmSync(path.join(layout.binDir, 'sandbox.cmd'));
-    fs.writeFileSync(path.join(layout.binDir, 'agent-sandbox'), '#!/bin/sh\necho old\n');
+    fs.writeFileSync(path.join(layout.binDir, 'other-tool'), '#!/bin/sh\necho old\n');
     const problems = shimProblems(layout, bins);
-    t.equal([problems.missing, problems.different], [['sandbox.cmd'], ['agent-sandbox']], 'a missing and an out-of-date shim are found');
+    t.equal([problems.missing, problems.different], [['sandbox.cmd'], ['other-tool']], 'a missing and an out-of-date shim are found');
     const { run, result } = await lookAt(env, 'install-shims');
     t.check(result.status === 'needs-you' && result.fixable, 'the shims check offers to rewrite them');
     const fixed = await run.fix([result]);
@@ -271,6 +271,19 @@ async function shims(t, layout, env) {
     t.equal(shimProblems(layout, bins), { missing: [], different: [] }, 'the shims read the active version again');
     fs.writeFileSync(path.join(layout.binDir, 'extra.cmd'), 'echo mine');
     t.check(fs.existsSync(path.join(layout.binDir, 'extra.cmd')), 'a file that is not one of ours is left alone');
+    t.section('install: shims of removed commands');
+    for (const [name, target] of Object.entries(REMOVED_COMMANDS)) {
+        fs.writeFileSync(path.join(layout.binDir, name + '.cmd'), shimText(name, 'cmd', target));
+        fs.writeFileSync(path.join(layout.binDir, name), shimText(name, 'sh', target));
+    }
+    fs.writeFileSync(path.join(layout.binDir, 'claude-sbx.cmd'), '@echo off rem mine');
+    writeShims(layout, bins);
+    const left = Object.keys(REMOVED_COMMANDS).flatMap((name) => [name + '.cmd', name].filter((file) => fs.existsSync(path.join(layout.binDir, file))));
+    t.equal(left, ['claude-sbx.cmd'], 'writing the shims removes the shims of old commands, but not a file that is not ours');
+    const kept = { ...bins, 'claude-sbx': 'dist/bin/claude-sbx.js' };
+    writeShims(layout, kept);
+    t.check(fs.readFileSync(path.join(layout.binDir, 'claude-sbx'), 'utf8') ===
+        shimText('claude-sbx', 'sh', kept['claude-sbx']), 'a package that still declares an old command keeps its shim (a rollback)');
 }
 async function copiesOnPath(t) {
     t.section('install: copies of the commands on the PATH');
@@ -282,9 +295,7 @@ async function copiesOnPath(t) {
     t.write(path.join(npmBin, 'sandbox'), '#!/bin/sh');
     t.write(path.join(npmBin, 'node_modules', 'windows-development-sandbox', 'package.json'), '{}');
     t.write(path.join(managedBin, 'sandbox.cmd'), '@echo off');
-    t.write(path.join(managedBin, 'claude-sbx.cmd'), '@echo off');
-    t.write(path.join(managedBin, 'claude-sbx.exe'), '');
-    t.write(path.join(oldBin, 'claude-sbx.cmd'), '@echo off');
+    t.write(path.join(oldBin, 'sandbox.cmd'), '@echo off');
     const machinePath = [npmBin, managedBin].join(';');
     const userPath = [oldBin, npmBin, t.dir('copies', 'empty')].join(';');
     const pathext = '.COM;.EXE;.BAT;.CMD';
@@ -298,8 +309,8 @@ async function copiesOnPath(t) {
     });
     t.equal(found.map((c) => [c.kind, c.files.join(',')]), [
         ['npm', 'sandbox.cmd'],
-        ['managed-machine', 'sandbox.cmd,claude-sbx.exe'],
-        ['old-scripts', 'claude-sbx.cmd'],
+        ['managed-machine', 'sandbox.cmd'],
+        ['old-scripts', 'sandbox.cmd'],
     ], 'copies come in PATH order (machine first, a folder once), each command as its PATHEXT match, extensionless files ignored');
     const asked = [];
     const saved = process.env.ProgramFiles;