windows-development-sandbox 1.27.1 → 1.28.0

package/dist/shared/accounts/kinds.js

@@ -55,7 +55,7 @@ export const SERVICE_SPECS = {
     },
     steam: {
         kind: 'steam',
-        label: 'Steam (SteamCMD)',
+        label: 'Steam',
         usedBy: ['steam'],
         sources: ['file', 'sandbox'],
         singleHolder: true,
@@ -91,7 +91,7 @@ export const SERVICE_SPECS = {
     },
     cfx: {
         kind: 'cfx',
-        label: 'Cfx.re (FiveM / RedM server key)',
+        label: 'FiveM key',
         usedBy: ['fivem'],
         sources: ['typed', 'file'],
         singleHolder: false,
@@ -120,7 +120,7 @@ export const SERVICE_SPECS = {
     },
     keystore: {
         kind: 'keystore',
-        label: 'Android upload keystore',
+        label: 'Android keystore',
         usedBy: ['android'],
         sources: ['file'],
         singleHolder: false,
@@ -135,7 +135,7 @@ export const SERVICE_SPECS = {
     },
     play: {
         kind: 'play',
-        label: 'Google Play (service account)',
+        label: 'Google Play',
         usedBy: ['android'],
         sources: ['file'],
         singleHolder: false,
@@ -146,7 +146,7 @@ export const SERVICE_SPECS = {
     },
     expo: {
         kind: 'expo',
-        label: 'Expo (EAS)',
+        label: 'Expo',
         usedBy: ['reactNative'],
         sources: ['typed'],
         singleHolder: false,
@@ -157,7 +157,7 @@ export const SERVICE_SPECS = {
     },
     appstore: {
         kind: 'appstore',
-        label: 'App Store Connect API key',
+        label: 'App Store Connect',
         usedBy: ['reactNative', 'flutter'],
         sources: ['file', 'typed'],
         singleHolder: false,
@@ -171,7 +171,7 @@ export const SERVICE_SPECS = {
     },
     perplexity: {
         kind: 'perplexity',
-        label: 'Perplexity API key',
+        label: 'Perplexity API',
         usedBy: ['perplexity'],
         sources: ['pc', 'file', 'typed'],
         singleHolder: false,
@@ -195,7 +195,7 @@ export const SERVICE_SPECS = {
     },
     comet: {
         kind: 'comet',
-        label: 'Comet (Perplexity browser)',
+        label: 'Comet',
         usedBy: ['comet'],
         sources: ['sandbox'],
         singleHolder: false,
@@ -212,7 +212,7 @@ export const SERVICE_SPECS = {
     },
     perplexityapp: {
         kind: 'perplexityapp',
-        label: 'Perplexity desktop app',
+        label: 'Perplexity app',
         usedBy: ['perplexityapp'],
         sources: ['sandbox'],
         singleHolder: false,

package/dist/shared/apps/catalogue-gamedev.js

@@ -49,6 +49,7 @@ export const GAMEDEV_APPS = [
         size: '100 MB',
         source: { github: 'f3d-app/f3d', asset: '^F3D-[\\d.]+-Windows-x86_64\\.zip$' },
         exe: 'f3d.exe',
+        onPath: true,
         needs: ['mesa'],
     },
     {

package/dist/shared/apps/catalogue.d.ts

@@ -73,6 +73,8 @@ export interface AppEntry {
     exe: string;
     /** A command-line tool: its folder goes on PATH (no desktop shortcut). */
     cli?: boolean;
+    /** A desktop program an agent also runs by name (F3D renders previews): its folder goes on PATH, shortcut kept. */
+    onPath?: boolean;
     /** Needs these first: 7-Zip to unpack an installer, Mesa for OpenGL without a GPU. */
     needs?: ('7zip' | 'mesa')[];
     /**

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

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

package/dist/shared/channel/schema.js

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

package/dist/shared/concurrency/pools.js

@@ -2,7 +2,7 @@
 // them to the downloader and extractor (guest/runtime/pools.ts installPools).
 import { Limiter } from './limiter.js';
 /** HTTP bodies. */
-export const net = new Limiter(4, 'net');
+export const net = new Limiter(3, 'net');
 /** extractArchive, 7-Zip/NSIS unpack, npm ci/install, uv/pip, Steam, robocopy of big layouts, rustup/cargo. */
 export const heavy = new Limiter(2, 'heavy');
 /** Every msiexec, vcredist, DXSETUP and the Visual Studio bootstrapper: Windows runs one install at a time. */

package/dist/shared/download/archive.js

@@ -34,12 +34,14 @@ export function extractArchive(archive, destination, members = []) {
 }
 async function extract(archive, destination, members) {
     fs.mkdirSync(destination, { recursive: true });
-    let status = await spawnAsync(SYSTEM.tar(), ['-xf', archive, '-C', destination, ...members]);
+    let status = await spawnAsync(SYSTEM.tar(), ['-xf', archive, '-C', destination, ...members], {
+        lowPriority: true,
+    });
     if (status !== 0 && /\.(zip|nupkg)$/i.test(archive)) {
         const zip = archive.endsWith('.zip') ? archive : archive + '.zip';
         if (zip !== archive)
             fs.copyFileSync(archive, zip);
-        status = await spawnAsync(SYSTEM.powershell(), scriptArgs('expand-archive.ps1', ['-Archive', zip, '-Destination', destination]));
+        status = await spawnAsync(SYSTEM.powershell(), scriptArgs('expand-archive.ps1', ['-Archive', zip, '-Destination', destination]), { lowPriority: true });
     }
     if (status !== 0)
         throw new Error('Could not extract ' + archive);

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

@@ -2,5 +2,5 @@ export { fetchRetry, fetchJson, fetchText } from './http.js';
 export { fetchBounded, fetchBoundedResponse, type BoundedResponse, type Fetcher, type RequestFetcher, } from './bounded-fetch.js';
 export { stagingFolder, moveIntoPlace, extractArchive, findFile, limitExtraction } from './archive.js';
 export { type ArchiveOptions, type Checksums, type DownloadWatcher, Downloader, downloader } from './downloader.js';
-export { spawnAsync } from './spawn.js';
+export { spawnAsync, lowerPriority, type SpawnAsyncOptions } from './spawn.js';
 export { type ReleaseAsset, githubAsset, parseReleasePage, latestGithubTag, parseReleaseTags } from './github.js';

package/dist/shared/download/index.js

@@ -2,5 +2,5 @@ export { fetchRetry, fetchJson, fetchText } from './http.js';
 export { fetchBounded, fetchBoundedResponse, } from './bounded-fetch.js';
 export { stagingFolder, moveIntoPlace, extractArchive, findFile, limitExtraction } from './archive.js';
 export { Downloader, downloader } from './downloader.js';
-export { spawnAsync } from './spawn.js';
+export { spawnAsync, lowerPriority } from './spawn.js';
 export { githubAsset, parseReleasePage, latestGithubTag, parseReleaseTags } from './github.js';

package/dist/shared/download/spawn.d.ts

@@ -1,3 +1,9 @@
 import { type SpawnOptions } from 'node:child_process';
+export interface SpawnAsyncOptions extends SpawnOptions {
+    /** Below-normal priority for the program and what it starts: unpacking must not make the desktop sluggish. */
+    readonly lowPriority?: boolean;
+}
+/** Lowers a process to below-normal priority; best effort (it may have ended already). */
+export declare function lowerPriority(pid: number | undefined): void;
 /** Runs a program without blocking the event loop (parallel downloads keep going); resolves with its exit code. */
-export declare function spawnAsync(file: string, args: string[], options?: SpawnOptions): Promise<number>;
+export declare function spawnAsync(file: string, args: string[], options?: SpawnAsyncOptions): Promise<number>;

package/dist/shared/download/spawn.js

@@ -1,8 +1,23 @@
+import os from 'node:os';
 import { spawn } from 'node:child_process';
+/** Lowers a process to below-normal priority; best effort (it may have ended already). */
+export function lowerPriority(pid) {
+    if (pid === undefined)
+        return;
+    try {
+        os.setPriority(pid, os.constants.priority.PRIORITY_BELOW_NORMAL);
+    }
+    catch {
+        /* a normal priority only makes it a little slower to share the machine */
+    }
+}
 /** Runs a program without blocking the event loop (parallel downloads keep going); resolves with its exit code. */
 export function spawnAsync(file, args, options = {}) {
+    const { lowPriority, ...spawnOptions } = options;
     return new Promise((resolve, reject) => {
-        const child = spawn(file, args, { stdio: 'ignore', windowsHide: true, ...options });
+        const child = spawn(file, args, { stdio: 'ignore', windowsHide: true, ...spawnOptions });
+        if (lowPriority)
+            lowerPriority(child.pid);
         child.once('error', reject);
         child.once('close', (code) => resolve(code ?? -1));
     });

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

@@ -1 +1,2 @@
 export * from './policy.js';
+export * from './unreal-build.js';

package/dist/shared/memory/index.js

@@ -1 +1,2 @@
 export * from './policy.js';
+export * from './unreal-build.js';

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

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

package/dist/shared/memory/policy.js

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

package/dist/shared/memory/unreal-build.d.ts

@@ -0,0 +1,2 @@
+/** BuildConfiguration.xml with at most `jobs` compiles and links at once (pure). */
+export declare function ubtBuildConfiguration(jobs: number): string;

package/dist/shared/memory/unreal-build.js

@@ -0,0 +1,21 @@
+// UnrealBuildTool's parallel compiles in the sandbox. Left alone it starts one compiler per core whenever the sandbox
+// looks free (free RAM / 1.5 GB), and each cl.exe with Unreal's precompiled headers commits about 2.6 GB: a build start
+// asks for 50 GB within seconds, faster than the governor can step in, and Windows closes the sandbox.
+// MaxParallelActions caps it before the build starts; UnrealBuildTool runs one build per engine at a time, so the cap
+// is the whole budget.
+/** The XML namespace UnrealBuildTool reads (XmlConfigFile.SchemaNamespaceURI). */
+const NAMESPACE = 'https://www.unrealengine.com/BuildConfiguration';
+/** BuildConfiguration.xml with at most `jobs` compiles and links at once (pure). */
+export function ubtBuildConfiguration(jobs) {
+    const max = Math.max(1, Math.floor(jobs));
+    return [
+        '<?xml version="1.0" encoding="utf-8"?>',
+        '<!-- Written by the sandbox at boot: compiles at once from the build budget (run\\budget.json, buildJobs). -->',
+        '<Configuration xmlns="' + NAMESPACE + '">',
+        '  <BuildConfiguration>',
+        '    <MaxParallelActions>' + max + '</MaxParallelActions>',
+        '  </BuildConfiguration>',
+        '</Configuration>',
+        '',
+    ].join('\r\n');
+}

package/dist/shared/paths/pc-installs.d.ts

@@ -22,6 +22,14 @@ export interface PcInstall {
         readonly artifactId: string;
         readonly appVersion: string;
     };
+    /**
+     * The launcher's manifest of an engine (its Data\Manifests\<name>.item on this PC): without one the sandbox's
+     * launcher drops the engine from its library. Its paths name the sandbox's folder by the time it is in session.json.
+     */
+    readonly launcherItem?: {
+        readonly name: string;
+        readonly text: string;
+    };
 }
 /** What session.json says about them: no host paths. */
 export interface PcInstallManifest {

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

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

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

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

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

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

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

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

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

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

package/dist/shared/pty/index.js

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

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

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

package/dist/shared/pty/terminal.js

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

package/dist/shared/unreal/launcher-files.d.ts

@@ -71,6 +71,13 @@ export declare function itemInfo(text: string): {
 export declare function incompleteDirs(...manifestDirs: string[]): Set<string>;
 /** The sizes the saved manifests give their engine folders (lower-case folder -> bytes). */
 export declare function itemSizes(saved: string): Map<string, number>;
+/** A launcher manifest's file name (<hex id>.item). */
+export declare const ITEM_NAME: RegExp;
+/**
+ * A launcher manifest moved from folder `from` to `to`: every path in it under `from` (either slash) is under `to`, and
+ * a path elsewhere is dropped (it would only name this PC). Null when the text is not a manifest of `from`.
+ */
+export declare function relocateItem(text: string, from: string, to: string): string | null;
 /** Whether the text is a launcher manifest of an app installed under `root`. */
 export declare function isItemUnder(text: string, root: string): boolean;
 /** Copies the launcher's manifests of apps under `root` into `saved` (changed ones only). Returns the file names. */

package/dist/shared/unreal/launcher-files.js

@@ -191,6 +191,37 @@ export function itemSizes(saved) {
     }
     return sizes;
 }
+/** A launcher manifest's file name (<hex id>.item). */
+export const ITEM_NAME = /^[A-Za-z0-9_-]{1,80}\.item$/;
+/**
+ * A launcher manifest moved from folder `from` to `to`: every path in it under `from` (either slash) is under `to`, and
+ * a path elsewhere is dropped (it would only name this PC). Null when the text is not a manifest of `from`.
+ */
+export function relocateItem(text, from, to) {
+    let item;
+    try {
+        item = JSON.parse(stripBom(text));
+    }
+    catch {
+        return null; // Not JSON: not a manifest.
+    }
+    if (!item || typeof item !== 'object' || Array.isArray(item))
+        return null;
+    const base = win.resolve(from).toLowerCase();
+    const out = {};
+    for (const [key, value] of Object.entries(item)) {
+        if (typeof value !== 'string' || !win.isAbsolute(value)) {
+            out[key] = value;
+            continue;
+        }
+        const full = win.resolve(value);
+        const low = full.toLowerCase();
+        if (low === base || low.startsWith(base + '\\'))
+            out[key] = to + full.slice(base.length);
+    }
+    const at = typeof out.InstallLocation === 'string' ? out.InstallLocation : '';
+    return at.toLowerCase() === to.toLowerCase() ? JSON.stringify(out, null, '\t') : null;
+}
 /** Whether the text is a launcher manifest of an app installed under `root`. */
 export function isItemUnder(text, root) {
     const at = itemInstallLocation(text);
@@ -198,7 +229,7 @@ export function isItemUnder(text, root) {
 }
 function itemFiles(dir) {
     try {
-        return fs.readdirSync(dir).filter((f) => /^[A-Za-z0-9_-]{1,80}\.item$/.test(f));
+        return fs.readdirSync(dir).filter((f) => ITEM_NAME.test(f));
     }
     catch {
         return [];

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

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