windows-development-sandbox 1.10.0 → 1.11.3

package/dist/guest/governor/decide.js

@@ -1,3 +1,9 @@
+// The memory governor's decisions (pure): given a memory sample and what it did before, how far to turn the dial and
+// what that means for the build programs in the agents' job. Like a PC that gets slower instead of failing: lower
+// priority, lower memory priority (their pages are trimmed first), less CPU, fewer compilers at a time (the others wait
+// their turn, suspended and always resumed), waiting compilers trimmed to the paging file. Agents, shells and Windows
+// are never touched. Nothing here touches Windows; governor.ts carries the actions out through a port.
+import { compilersAllowed, DIAL_CALM_SAMPLES, DIAL_CPU_RATE, DIAL_EXIT_MARGIN, DIAL_STEPS, } from '../../shared/memory/index.js';
 /** Programs that compile or link: they may be slowed down and, as the last resort, paused for a few seconds. */
 const COMPILERS = new Set([
     'rustc',
@@ -25,8 +31,8 @@ const COMPILERS = new Set([
     'javac',
 ]);
 /** Build tools and workers: slowed down but never paused (a node process may be a dev server or an agent). */
+// Not node: agents such as Codex and Gemini run as node.exe, and the agents are never slowed down.
 const BUILD_TOOLS = new Set([
-    'node',
     'dotnet',
     'msbuild',
     'vbcscompiler',
@@ -97,112 +103,160 @@ const HEAVY = new Set([
 export const isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
 export const canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
 export const INITIAL_STATE = {
-    pressure: false,
+    step: 0,
     calm: 0,
-    samples: 0,
     lowered: {},
-    pausedUntil: 0,
-    nextPauseAt: 0,
+    memLow: [],
+    throttled: [],
+    trimmed: [],
+    cpuRate: 100,
+    lastCommitMb: 0,
+    lastAt: 0,
+    growth: 0,
     hostUntil: 0,
+    hostStep: 0,
 };
-/** How long a held compiler waits before it gets a turn again (the governor repeats the hold while over the cap). */
+/** How much the newest sample counts in the smoothed commit growth. */
+const GROWTH_WEIGHT = 0.3;
+/** How long a held compiler waits before it may get a turn again (the governor repeats the hold while it waits). */
 export const HOLD_MS = 3000;
-export const PAUSE_MS = 5000;
-const PAUSE_COOLDOWN_MS = 10000;
-/** Samples under pressure before programs go from below-normal to idle, and before one is paused. */
-const IDLE_AFTER = 3;
-const PAUSE_AFTER = 4;
-/** Only a program this big is worth pausing. */
-const PAUSE_MIN_MB = 300;
+/** Which compilers wait their turn changes this often, so none waits for ever. */
+export const ROTATE_MS = 20000;
 /**
- * One step. `gentle` (vGPU on): compilers start below normal even without pressure. Programs go back to their normal
- * priority only when pressure ends (several calm samples in a row).
+ * "Full soon" only counts this close (in commit percent) to a step's own threshold: a build that grabs a few GB in a
+ * burst while most of the memory is free is normal, not a reason to pause compilers.
  */
-export function decide(prev, sample, nowMs, thresholds, profile, maxCompilers = null) {
+const SOON_WITHIN_PERCENT = 12;
+/** The step a sample calls for on its own: the highest step whose threshold it crosses. */
+export function stepFor(ramFree, commit, secondsToLimit, profile) {
+    let step = 0;
+    DIAL_STEPS[profile].forEach((t, i) => {
+        const near = commit > t.commitPercent - SOON_WITHIN_PERCENT;
+        const soon = near && t.secondsToLimit !== undefined && secondsToLimit < t.secondsToLimit;
+        if (ramFree < t.availablePercent || commit > t.commitPercent || soon)
+            step = i + 1;
+    });
+    return step;
+}
+/** Is the sample clear of `step` by the exit margins (so the dial may turn down from it)? */
+function clearOf(step, ramFree, commit, profile) {
+    if (step === 0)
+        return true;
+    const t = DIAL_STEPS[profile][step - 1];
+    return (ramFree > t.availablePercent + DIAL_EXIT_MARGIN.availablePercent &&
+        commit < t.commitPercent - DIAL_EXIT_MARGIN.commitPercent);
+}
+/**
+ * One step of the governor. The dial turns up at once and down one step at a time after calm samples. `gentle` (vGPU
+ * on): compilers rest below normal priority, and `maxCompilers` caps how many heavy compilers run at any step.
+ */
+export function decide(prev, sample, nowMs, profile, maxCompilers = null) {
     const ramFree = (sample.ramAvailMb / Math.max(1, sample.ramTotalMb)) * 100;
-    const commit = ((sample.commitLimitMb - sample.commitAvailMb) / Math.max(1, sample.commitLimitMb)) * 100;
+    const usedMb = sample.commitLimitMb - sample.commitAvailMb;
+    const commit = (usedMb / Math.max(1, sample.commitLimitMb)) * 100;
+    const seconds = (nowMs - prev.lastAt) / 1000;
+    const instant = prev.lastAt > 0 && seconds > 0 ? (usedMb - prev.lastCommitMb) / seconds : 0;
+    // Smoothed over the last samples, so one burst between two samples is not read as a trend.
+    const growth = prev.lastAt > 0 ? prev.growth * (1 - GROWTH_WEIGHT) + instant * GROWTH_WEIGHT : 0;
+    const secondsToLimit = growth > 0 ? sample.commitAvailMb / growth : Number.POSITIVE_INFINITY;
     const pcLow = nowMs < prev.hostUntil;
-    const low = ramFree < thresholds.enterAvailablePercent || commit > thresholds.enterCommitPercent || pcLow;
-    const recovered = ramFree > thresholds.exitAvailablePercent && commit < thresholds.exitCommitPercent && !pcLow;
-    let pressure = prev.pressure;
-    let calm = prev.calm;
-    let samples = prev.samples;
-    if (low) {
-        pressure = true;
-        calm = 0;
-        samples = prev.samples + 1;
-    }
-    else if (prev.pressure) {
-        calm = recovered ? prev.calm + 1 : 0;
-        if (calm >= thresholds.calmSamples) {
-            pressure = false;
+    const wanted = Math.max(stepFor(ramFree, commit, secondsToLimit, profile), pcLow ? prev.hostStep : 0);
+    let step = prev.step;
+    let calm = 0;
+    if (wanted > prev.step)
+        step = wanted;
+    else if (prev.step > 0 && wanted < prev.step && clearOf(prev.step, ramFree, commit, profile)) {
+        calm = prev.calm + 1;
+        if (calm >= DIAL_CALM_SAMPLES) {
+            step = prev.step - 1;
             calm = 0;
-            samples = 0;
         }
     }
     const actions = [];
     const present = new Set(sample.procs.map((p) => p.pid));
+    const keep = (pids) => pids.filter((pid) => present.has(pid));
     const lowered = {};
     for (const [pid, to] of Object.entries(prev.lowered))
         if (present.has(Number(pid)))
             lowered[Number(pid)] = to;
-    if (pressure) {
-        const target = samples > IDLE_AFTER ? 'idle' : 'below';
-        for (const p of sample.procs) {
-            if (!canLower(p.name) || lowered[p.pid] === target)
-                continue;
-            // Already as low as asked (or lower): only remember it.
-            if (p.prio !== target && !(target === 'below' && p.prio === 'idle'))
-                actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: target });
+    const memLow = new Set(keep(prev.memLow));
+    const throttled = new Set(keep(prev.throttled));
+    const trimmed = new Set(keep(prev.trimmed));
+    // CPU priority: where a program rests (normal; compilers below in the gentle profile), below from step 1, idle
+    // from step 2. Only changes are sent.
+    for (const p of sample.procs) {
+        if (!canLower(p.name))
+            continue;
+        const rest = profile === 'gentle' && canPause(p.name) ? 'below' : 'normal';
+        const target = step >= 2 ? 'idle' : step === 1 ? 'below' : rest;
+        const was = lowered[p.pid];
+        const touched = was !== undefined || target !== 'normal';
+        if (touched && was !== target && p.prio !== target)
+            actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: target });
+        if (target === 'normal')
+            delete lowered[p.pid];
+        else
             lowered[p.pid] = target;
-        }
     }
-    else {
-        for (const p of sample.procs) {
-            if (!canLower(p.name))
-                continue;
-            // Where a program rests when nothing is wrong: compilers below normal in the gentle profile.
-            const base = profile === 'gentle' && canPause(p.name) ? 'below' : 'normal';
-            const was = lowered[p.pid];
-            if (prev.pressure && was !== undefined && was !== base) {
-                if (p.prio !== base)
-                    actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: base });
-                if (base === 'normal')
-                    delete lowered[p.pid];
-                else
-                    lowered[p.pid] = base;
+    // Memory priority: low from step 1, so Windows trims the builds' pages before the agents'.
+    const lowMemory = step >= 1;
+    for (const p of sample.procs) {
+        if (!canLower(p.name) || lowMemory === memLow.has(p.pid))
+            continue;
+        actions.push({ kind: 'memory', pid: p.pid, name: p.name, low: lowMemory });
+        if (lowMemory)
+            memLow.add(p.pid);
+        else
+            memLow.delete(p.pid);
+    }
+    // CPU share of the compilers: they join the throttle job once (from step 2); its cap follows the dial.
+    if (step >= 2)
+        for (const p of sample.procs)
+            if (canPause(p.name) && !throttled.has(p.pid)) {
+                actions.push({ kind: 'throttle', pid: p.pid, name: p.name });
+                throttled.add(p.pid);
             }
-            else if (!prev.pressure && base === 'below' && was === undefined) {
-                if (p.prio === 'normal')
-                    actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: 'below' });
-                lowered[p.pid] = 'below';
+    const cpuRate = DIAL_CPU_RATE[step] ?? 100;
+    if (cpuRate !== prev.cpuRate)
+        actions.push({ kind: 'cpu', percent: cpuRate });
+    // Turns: of the heavy compilers only so many go on; the rest wait, and who waits changes every ROTATE_MS.
+    const heavy = sample.procs.filter((p) => isHeavyCompiler(p.name)).sort((a, b) => a.pid - b.pid);
+    let allowed = compilersAllowed(step, heavy.length);
+    // The cap is a memory measure: with memory to spare, Windows shares the CPU (the priorities above) and no compiler
+    // waits. A waiting rustc also holds cargo's job tokens, which stalls the whole build.
+    if (maxCompilers !== null && step >= 2)
+        allowed = Math.min(allowed, Math.max(1, maxCompilers));
+    if (allowed < heavy.length) {
+        const turn = Math.floor(nowMs / ROTATE_MS) % heavy.length;
+        const order = [...heavy.slice(turn), ...heavy.slice(0, turn)];
+        for (const p of order.slice(allowed)) {
+            actions.push({ kind: 'hold', pid: p.pid, name: p.name, ms: HOLD_MS });
+            if (step >= 3 && !trimmed.has(p.pid)) {
+                actions.push({ kind: 'trim', pid: p.pid, name: p.name });
+                trimmed.add(p.pid);
             }
         }
+        for (const p of order.slice(0, allowed))
+            trimmed.delete(p.pid);
     }
-    let pausedUntil = prev.pausedUntil;
-    let nextPauseAt = prev.nextPauseAt;
-    if (pressure && samples >= PAUSE_AFTER && nowMs >= prev.nextPauseAt && nowMs >= prev.pausedUntil) {
-        const victim = [...sample.procs]
-            .filter((p) => canPause(p.name) && p.mb >= PAUSE_MIN_MB)
-            .sort((a, b) => b.mb - a.mb)[0];
-        if (victim) {
-            actions.push({ kind: 'pause', pid: victim.pid, name: victim.name, ms: PAUSE_MS });
-            pausedUntil = nowMs + PAUSE_MS;
-            nextPauseAt = pausedUntil + PAUSE_COOLDOWN_MS;
-        }
-    }
-    // Concurrency cap (vGPU profile): the oldest N heavy compilers run, the newer ones wait a few seconds at a time.
-    if (maxCompilers !== null) {
-        const heavy = sample.procs
-            .filter((p) => isHeavyCompiler(p.name) &&
-            !(nowMs < pausedUntil && actions.some((a) => a.kind === 'pause' && a.pid === p.pid)))
-            .sort((a, b) => a.pid - b.pid);
-        for (const p of heavy.slice(Math.max(1, maxCompilers)))
-            actions.push({ kind: 'hold', pid: p.pid, name: p.name, ms: HOLD_MS });
-    }
-    const level = nowMs < pausedUntil ? 'suspending' : pressure ? 'throttled' : 'ok';
+    else
+        trimmed.clear();
+    const level = step >= 3 ? 'suspending' : step >= 1 ? 'throttled' : 'ok';
     return {
-        state: { pressure, calm, samples, lowered, pausedUntil, nextPauseAt, hostUntil: prev.hostUntil },
+        state: {
+            step,
+            calm,
+            lowered,
+            memLow: [...memLow],
+            throttled: [...throttled],
+            trimmed: [...trimmed],
+            cpuRate,
+            lastCommitMb: usedMb,
+            lastAt: nowMs,
+            growth,
+            hostUntil: prev.hostUntil,
+            hostStep: prev.hostStep,
+        },
         actions,
         level,
         ramFreePercent: Math.round(ramFree),

package/dist/guest/governor/governor.d.ts

@@ -1,45 +1,9 @@
-import type { PressureStatus } from '../../shared/channel/schema.js';
-import { type LoadProfile } from '../../shared/memory/index.js';
-import { type GovernorState, type MemSample } from './decide.js';
-/** What the governor needs from Windows (injectable: the tests use a fake). */
-export interface GovernorPort {
-    setPriority(pid: number, to: 'idle' | 'below' | 'normal'): void;
-    pause(pid: number, ms: number): void;
-}
-/** Everything a step changes outside the decision, behind injectable functions. */
-export interface GovernorDeps {
-    readonly port: GovernorPort;
-    readonly profile: LoadProfile;
-    /** At most this many heavy compilers run at once (null = no cap). */
-    readonly maxCompilers?: number | null;
-    readonly now: () => number;
-    /** A line in the memory log. */
-    readonly logLine: (line: string) => void;
-    /** run\pressure.json. */
-    readonly saveStatus: (status: PressureStatus) => void;
-}
-/** The governor's logic over a port: feed it samples; the host's "slow down" requests go to hostPressure. */
-export declare class GovernorCore {
-    private readonly deps;
-    private state;
-    private lastAction;
-    private lastWrite;
-    private lastWriteAt;
-    private pausedName;
-    private pausedPid;
-    private held;
-    constructor(deps: GovernorDeps);
-    hostPressure(seconds: number, reason: string): void;
-    get current(): GovernorState;
-    onSample(sample: MemSample): void;
-    private apply;
-}
 /** The daemon's governor: on unless sandbox.pressureResponse is off. */
 export declare class Governor {
     private core;
     describe(): string;
     start(): void;
-    /** The host's watchdog: this PC is low for a while. */
-    hostPressure(seconds: number, reason: string): void;
+    /** The host's watchdog: this PC is low (or nearly out of memory) for a while. */
+    hostPressure(seconds: number, reason: string, level?: 'slow' | 'severe'): void;
 }
 export declare const governor: Governor;

package/dist/guest/governor/governor.js

@@ -1,22 +1,21 @@
-// The memory governor: samples the sandbox's memory every 2 seconds (memgov.exe, sandbox/csharp/MemGov.cs) and, when it
-// runs low, slows the heaviest build programs the agents started down and, as a last resort, pauses the biggest
-// compiler for a few seconds (decide.ts). What it does goes to the memory log and run\pressure.json, for the host.
+// The memory governor: samples the sandbox's memory every 2 seconds (memgov.exe, sandbox/csharp/MemGov.cs) and turns
+// a dial as it fills: the build programs the agents started get lower priority, lower memory priority, less CPU, and
+// take turns (decide.ts). Builds slow down; nothing fails. What it does goes to the memory log and run\pressure.json.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { z } from 'zod';
-import { now } from '../../shared/channel/run-dir.js';
 import { writeJsonAtomic } from '../../shared/io/json.js';
-import { GUEST_THRESHOLDS, maxCompilers } from '../../shared/memory/index.js';
+import { DIAL_STEPS, maxCompilers } from '../../shared/memory/index.js';
 import { ensureCompiled } from '../runtime/csc.js';
 import { dataDir } from '../runtime/paths.js';
 import { warn } from '../runtime/log.js';
 import { run } from '../runtime/paths.js';
 import { session } from '../runtime/session.js';
 import { errMsg } from '../../core/util/errors.js';
-import { decide, INITIAL_STATE } from './decide.js';
+import { GovernorCore } from './core.js';
 const SampleSchema = z.object({
     ramTotalMb: z.number(),
     ramAvailMb: z.number(),
@@ -31,101 +30,6 @@ const SampleSchema = z.object({
     }))
         .max(1024),
 });
-/** The governor's logic over a port: feed it samples; the host's "slow down" requests go to hostPressure. */
-export class GovernorCore {
-    deps;
-    state = INITIAL_STATE;
-    lastAction = '';
-    lastWrite = '';
-    lastWriteAt = 0;
-    pausedName = '';
-    pausedPid = 0;
-    held = new Set();
-    constructor(deps) {
-        this.deps = deps;
-    }
-    hostPressure(seconds, reason) {
-        const until = this.deps.now() + seconds * 1000;
-        if (until > this.state.hostUntil) {
-            if (this.state.hostUntil <= this.deps.now())
-                this.deps.logLine('governor: this PC is low (' + reason + '); slowing builds down');
-            this.state = { ...this.state, hostUntil: until };
-        }
-    }
-    get current() {
-        return this.state;
-    }
-    onSample(sample) {
-        const nowMs = this.deps.now();
-        const before = this.state.pressure;
-        const seen = new Set(sample.procs.map((p) => p.pid));
-        for (const pid of this.held)
-            if (!seen.has(pid))
-                this.held.delete(pid);
-        const d = decide(this.state, sample, nowMs, GUEST_THRESHOLDS[this.deps.profile], this.deps.profile, this.deps.maxCompilers ?? null);
-        this.state = d.state;
-        for (const action of d.actions)
-            this.apply(action);
-        if (d.state.pressure !== before)
-            this.deps.logLine(d.state.pressure
-                ? 'governor: memory is low (' +
-                    d.ramFreePercent +
-                    '% RAM free, commit ' +
-                    d.commitPercent +
-                    '% used): slowing builds down'
-                : 'governor: memory is fine again: builds back to normal');
-        const paused = nowMs < d.state.pausedUntil && this.pausedPid
-            ? [{ name: this.pausedName, pid: this.pausedPid, seconds: Math.ceil((d.state.pausedUntil - nowMs) / 1000) }]
-            : [];
-        const status = {
-            level: d.level,
-            profile: this.deps.profile,
-            ramFreePercent: Math.max(0, Math.min(100, d.ramFreePercent)),
-            commitPercent: Math.max(0, Math.min(100, d.commitPercent)),
-            lowered: Object.keys(d.state.lowered).length,
-            paused,
-            pcLow: nowMs < d.state.hostUntil,
-            lastAction: this.lastAction,
-            updatedAt: now(),
-        };
-        // Written when something changed, else once a minute (the host reads it, never polls it hard).
-        const shape = JSON.stringify({ ...status, updatedAt: '', paused: paused.map((p) => p.pid) });
-        if (shape !== this.lastWrite || nowMs - this.lastWriteAt > 60000) {
-            this.lastWrite = shape;
-            this.lastWriteAt = nowMs;
-            this.deps.saveStatus(status);
-        }
-    }
-    apply(action) {
-        try {
-            if (action.kind === 'hold') {
-                this.deps.port.pause(action.pid, action.ms);
-                if (!this.held.has(action.pid)) {
-                    this.held.add(action.pid);
-                    this.lastAction = 'holding ' + action.name + ' (' + action.pid + ') until another compiler ends';
-                    this.deps.logLine('governor: ' + this.lastAction);
-                }
-                return;
-            }
-            if (action.kind === 'priority') {
-                this.deps.port.setPriority(action.pid, action.to);
-                this.lastAction = action.name + ' (' + action.pid + ') priority ' + action.to;
-            }
-            else {
-                this.deps.port.pause(action.pid, action.ms);
-                this.pausedName = action.name;
-                this.pausedPid = action.pid;
-                this.lastAction = 'paused ' + action.name + ' (' + action.pid + ') for ' + action.ms / 1000 + ' s';
-                this.deps.logLine('governor: ' + this.lastAction);
-                return;
-            }
-            this.deps.logLine('governor: ' + this.lastAction);
-        }
-        catch (e) {
-            warn('governor: ' + errMsg(e));
-        }
-    }
-}
 /** memgov.exe as a child process: samples come out of its stdout, commands go into its stdin. */
 class MemGovProcess {
     onSample;
@@ -160,10 +64,25 @@ class MemGovProcess {
         }
     }
     setPriority(pid, to) {
-        this.child?.stdin?.write('priority ' + pid + ' ' + to + '\n');
+        this.send('priority ' + pid + ' ' + to);
+    }
+    hold(pid, ms) {
+        this.send('suspend ' + pid + ' ' + ms);
+    }
+    setMemoryPriority(pid, low) {
+        this.send('memprio ' + pid + ' ' + (low ? 'low' : 'normal'));
+    }
+    throttle(pid) {
+        this.send('throttle ' + pid);
+    }
+    setCpuRate(percent) {
+        this.send('cpurate ' + Math.round(percent));
+    }
+    trim(pid) {
+        this.send('trim ' + pid);
     }
-    pause(pid, ms) {
-        this.child?.stdin?.write('suspend ' + pid + ' ' + ms + '\n');
+    send(line) {
+        this.child?.stdin?.write(line + '\n');
     }
 }
 /** The newest memory log SandboxTools writes, to add the governor's lines to it. */
@@ -190,15 +109,15 @@ export class Governor {
     core = null;
     describe() {
         const profile = session.loadProfile === 'gentle' ? 'gentle' : 'normal';
-        const t = GUEST_THRESHOLDS[profile];
+        const first = DIAL_STEPS[profile][0];
         return session.pressureResponse === false
             ? 'off (sandbox.pressureResponse)'
             : profile +
-                ' profile: slows builds down below ' +
-                t.enterAvailablePercent +
-                '% free RAM or above ' +
-                t.enterCommitPercent +
-                '% commit';
+                ' profile: slows builds down from ' +
+                first.availablePercent +
+                '% free RAM or ' +
+                first.commitPercent +
+                '% commit, in steps';
     }
     start() {
         if (session.pressureResponse === false)
@@ -211,6 +130,7 @@ export class Governor {
             maxCompilers: maxCompilers(os.cpus().length, profile),
             now: () => Date.now(),
             logLine: appendToMemoryLog,
+            warn,
             saveStatus: (status) => {
                 try {
                     writeJsonAtomic(run.pressureFile, status);
@@ -222,9 +142,9 @@ export class Governor {
         });
         proc.start();
     }
-    /** The host's watchdog: this PC is low for a while. */
-    hostPressure(seconds, reason) {
-        this.core?.hostPressure(seconds, reason);
+    /** The host's watchdog: this PC is low (or nearly out of memory) for a while. */
+    hostPressure(seconds, reason, level = 'slow') {
+        this.core?.hostPressure(seconds, reason, level);
     }
 }
 export const governor = new Governor();

package/dist/guest/governor/index.d.ts

@@ -1,2 +1,3 @@
 export * from './decide.js';
+export * from './core.js';
 export * from './governor.js';

package/dist/guest/governor/index.js

@@ -1,2 +1,3 @@
 export * from './decide.js';
+export * from './core.js';
 export * from './governor.js';

package/dist/guest/network/firewall.d.ts

@@ -1,6 +1,8 @@
 /** What the agent's manifest says about the LAN. */
 export type LanState = 'blocked' | 'open' | 'offline';
 export declare function networkProblems(): readonly string[];
+/** netsh needs the long form of a path: the sandbox's TEMP is an 8.3 short path (WDAGUT~1). */
+export declare function longPath(file: string): string;
 export declare function run(commands: string[][]): void;
 /**
  * Applies the LAN block. Internet is checked first; if it works before the rules but not after, the rules (not the

package/dist/guest/network/firewall.js

@@ -56,16 +56,16 @@ export function networkProblems() {
     return problems;
 }
 /** netsh needs the long form of a path: the sandbox's TEMP is an 8.3 short path (WDAGUT~1). */
-const longPath = (file) => {
+export function longPath(file) {
     if (!hasShortName(file))
         return file;
     try {
         return fs.realpathSync.native(file);
     }
     catch {
-        return file;
+        return file; // netsh then says the program cannot be found, which is reported where the rule was wanted
     }
-};
+}
 /**
  * The inbound rule for ptyhost (the attach channel). A rule that cannot be added is a missing protection, so it is
  * tried again a few times and then reported loudly instead of being skipped.

package/dist/guest/sessions/viewer.js

@@ -1,5 +1,6 @@
 import { connect, runTerminalClient } from '../../shared/pty/index.js';
 import { run } from '../runtime/paths.js';
+import { session as sandboxSession } from '../runtime/session.js';
 /**
  * A session that is still being set up (its project provisioning, its agent installing): show the progress until it
  * runs.
@@ -32,7 +33,10 @@ export async function viewSession(id) {
     const socket = await connect({ ...session.attach, addresses: ['127.0.0.1'] });
     // The sandbox's own terminal: a copy in the agent reaches the sandbox's clipboard (and yours only through
     // sandbox.clipboard, which already shares it).
-    const result = await runTerminalClient(socket, session.attach.token, { clipboardWrites: true });
+    const result = await runTerminalClient(socket, session.attach.token, {
+        clipboardWrites: true,
+        confirmCtrlC: sandboxSession.attach.confirmCtrlC !== false,
+    });
     if (result.reason === 'exit')
         console.log(session.harness + ' exited with code ' + result.exitCode + '.');
     else if (result.reason === 'error')

package/dist/guest/setup/github-token.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Before the tools are set up: the folder gh uses for a handed-over token exists only when one arrived (gh's setup
+ * points GH_CONFIG_DIR at it while it exists). Without one, gh keeps the login you made in the sandbox.
+ */
+export declare function prepareGithubFolder(token: string | undefined): boolean;
+/** gh logs in with the token (stdin) in the sandbox-only folder, then https git to github.com asks gh. */
+export declare function loginGithub(token: string, env: NodeJS.ProcessEnv): void;

package/dist/guest/setup/github-token.js

@@ -0,0 +1,65 @@
+// The GitHub token the host handed over (github.shareToken, only with git access "full"): gh logs in with it in a
+// folder on the sandbox's own disk (gone with the sandbox, never in the persistent state), and https git asks gh. The
+// token goes to gh on stdin, never in an argument, a file of ours or a log line.
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { ghLoginCommand, ghOutputText, ghSetupGitCommand } from '../../shared/github/index.js';
+import { deliveredGhConfigDir, ghConfigDir, ghExePath } from '../toolchains/tools/cli.js';
+import { addMachineEnvironment } from './environment.js';
+import { dryRun } from '../runtime/paths.js';
+import { exists, mkdirp } from '../runtime/fs.js';
+import { log } from '../runtime/log.js';
+const GH_TIMEOUT_MS = 60_000;
+/**
+ * Before the tools are set up: the folder gh uses for a handed-over token exists only when one arrived (gh's setup
+ * points GH_CONFIG_DIR at it while it exists). Without one, gh keeps the login you made in the sandbox.
+ */
+export function prepareGithubFolder(token) {
+    const dir = deliveredGhConfigDir();
+    fs.rmSync(dir, { recursive: true, force: true });
+    if (!token)
+        return false;
+    mkdirp(dir);
+    return true;
+}
+function runGh(command, token, what) {
+    const result = spawnSync(command.file, [...command.args], {
+        env: command.env,
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: GH_TIMEOUT_MS,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        ...(command.input !== undefined ? { input: command.input } : {}),
+    });
+    if (result.error)
+        throw new Error(what + ' could not run: ' + ghOutputText(result.error.message, token));
+    if (result.status !== 0)
+        throw new Error(what + ' failed: ' + ghOutputText(String(result.stderr ?? '') || String(result.stdout ?? ''), token));
+}
+/** gh logs in with the token (stdin) in the sandbox-only folder, then https git to github.com asks gh. */
+export function loginGithub(token, env) {
+    if (dryRun) {
+        log('(dry run) would log gh in with the GitHub token from your PC');
+        return;
+    }
+    const gh = ghExePath();
+    const dir = deliveredGhConfigDir();
+    if (!exists(gh) || env.GH_CONFIG_DIR !== dir) {
+        // Gone again, so gh set up later (a project added afterwards) keeps the login you make in the sandbox.
+        fs.rmSync(dir, { recursive: true, force: true });
+        log('A GitHub token arrived, but gh is not set up in this sandbox (toolchains.cli.gh), so it is not used.');
+        return;
+    }
+    try {
+        runGh(ghLoginCommand(gh, dir, token, env), token, 'gh auth login');
+        runGh(ghSetupGitCommand(gh, dir, env), token, 'gh auth setup-git');
+    }
+    catch (e) {
+        // gh goes back to the persistent folder (and a `gh auth login` you make inside is kept), for every session.
+        fs.rmSync(dir, { recursive: true, force: true });
+        env.GH_CONFIG_DIR = mkdirp(ghConfigDir());
+        addMachineEnvironment({ GH_CONFIG_DIR: env.GH_CONFIG_DIR }, []);
+        throw e;
+    }
+    log('gh and https git to github.com use the GitHub token from your PC (github.shareToken); the agent can read it.');
+}