windows-development-sandbox 1.4.0 → 1.4.3

package/dist/shared/projects.js

@@ -1,67 +0,0 @@
-// Several projects in one running sandbox. Windows Sandbox fixes its mapped folders at boot, so a project can only
-// join a running sandbox when it is already visible inside:
-//  - the launch folder (mapped directly, as always);
-//  - a folder inside a project root (projects.roots: whole folders of projects, mapped at every start), including
-//    projects created after boot;
-//  - projects mapped at boot because they were in use when the sandbox was restarted to add them;
-//  - a folder shared into the running sandbox with `wsb share` (Windows 11 24H2+, untested).
-// Roots, boot-mapped projects and shares appear under C:\Projects (roots at their PC path with guestWorkspace "mirror").
-// Pure functions only: used by the host (registration, commands), the guest (daemon checks) and the tests.
-import path from 'node:path';
-import { isValidGuestPath } from './guest-paths.js';
-/** Where roots, boot-mapped projects and shared folders appear inside the sandbox. */
-export const PROJECTS_GUEST = 'C:\\Projects';
-const norm = (p) => path.win32.resolve(p).replace(/[\\/]+$/, '').toLowerCase();
-/** `child` is `parent` or somewhere below it (Windows paths, case-insensitive). */
-export const isWithin = (parent, child) => {
-    const a = norm(parent);
-    const b = norm(child);
-    return a === b || b.startsWith(a.endsWith('\\') ? a : a + '\\');
-};
-/**
- * A project id (also its folder name under C:\Projects) for a folder: its name with only letters, digits, '-' and
- * '_' (ids become file names on both sides), at most 48 characters, made unique against `taken` with -2, -3, ...
- */
-export const hubName = (hostDir, taken) => {
-    const base = path.win32.basename(path.win32.resolve(hostDir)).replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'project';
-    const used = new Set([...taken].map((t) => t.toLowerCase()));
-    if (!used.has(base.toLowerCase()))
-        return base;
-    for (let i = 2;; i++)
-        if (!used.has((base + '-' + i).toLowerCase()))
-            return base + '-' + i;
-};
-/** The project a folder on this PC belongs to: the most specific one that contains it (a project inside another wins). */
-export const projectForHostDir = (projects, hostDir) => projects.filter((p) => isWithin(p.host, hostDir)).sort((a, b) => b.host.length - a.host.length)[0] ?? null;
-/** The same for a folder inside the sandbox. */
-export const projectForGuestDir = (projects, guestDir) => projects.filter((p) => isWithin(p.guest, guestDir)).sort((a, b) => b.guest.length - a.guest.length)[0] ?? null;
-/** Where a folder on this PC appears inside the sandbox, given the mapped folder (project or root) that contains it. */
-export const guestDirFor = (mapped, hostDir) => {
-    const rel = path.win32.relative(path.win32.resolve(mapped.host), path.win32.resolve(hostDir));
-    return rel ? path.win32.join(mapped.guest, rel) : mapped.guest;
-};
-/** The other way: where a folder inside the sandbox is on this PC, given the mapped folder that contains it. */
-export const hostDirFor = (mapped, guestDir) => {
-    const rel = path.win32.relative(path.win32.resolve(mapped.guest), path.win32.resolve(guestDir));
-    return rel ? path.win32.join(mapped.host, rel) : mapped.host;
-};
-/** Strictly below `parent` (never `parent` itself). */
-export const isBelow = (parent, child) => isWithin(parent, child) && norm(parent) !== norm(child);
-/** A guest folder some project can be in: below C:\Projects, or inside one of the roots (their guest paths). */
-export const insideProjects = (guestDir, roots = [], projectsDir = PROJECTS_GUEST) => isBelow(projectsDir, guestDir) || roots.some((r) => isWithin(r, guestDir));
-/**
- * Guest folders for the project roots and the projects mapped at boot: C:\Projects\<name>, unique; with
- * guestWorkspace "mirror" a root appears at its PC path when the sandbox can show it there.
- */
-export const planProjectMappings = (roots, projects, mirror, taken = []) => {
-    const names = [...taken];
-    const place = (host, tryMirror) => {
-        const resolved = path.win32.resolve(host).replace(/[\\/]+$/, '');
-        if (tryMirror && isValidGuestPath(resolved) && !isWithin(PROJECTS_GUEST, resolved))
-            return { host: resolved, guest: resolved };
-        const name = hubName(resolved, names);
-        names.push(name);
-        return { host: resolved, guest: path.win32.join(PROJECTS_GUEST, name) };
-    };
-    return { roots: roots.map((r) => place(r, mirror)), projects: projects.map((p) => place(p, false)) };
-};

package/dist/shared/pty-client.d.ts

@@ -1,91 +0,0 @@
-import net from 'node:net';
-export declare const FrameType: {
-    readonly Hello: 1;
-    readonly Input: 2;
-    readonly Resize: 3;
-    readonly Restart: 4;
-    readonly Ping: 5;
-    readonly Output: 16;
-    readonly Exit: 17;
-    readonly Error: 18;
-    readonly Restarting: 19;
-    readonly Status: 20;
-    readonly Console: 21;
-};
-/** HELLO flags: control-only connections get no output and never size the console; a query only asks for STATUS. */
-export declare const HelloFlag: {
-    readonly ControlOnly: 1;
-    readonly Query: 2;
-};
-/** Viewers ping this often; ptyhost counts a viewer as gone after 15 s of silence (e.g. its terminal tab was closed). */
-export declare const PING_INTERVAL_MS = 5000;
-export interface Frame {
-    type: number;
-    payload: Buffer;
-}
-export interface Endpoint {
-    addresses: string[];
-    port: number;
-    token: string;
-}
-export type ClientResult = {
-    reason: 'exit';
-    exitCode: number;
-} | {
-    reason: 'detach' | 'closed';
-} | {
-    reason: 'error';
-    message: string;
-};
-/** Ctrl+] — the same detach key telnet uses; Claude Code does not bind it. */
-export declare const DETACH_KEY = 29;
-export declare const encodeFrame: (type: number, payload?: Buffer) => Buffer;
-export declare const helloFrame: (token: string, cols: number, rows: number, flags?: number) => Buffer;
-export declare const resizeFrame: (cols: number, rows: number) => Buffer;
-/** Same limit as ptyhost.cs; a peer announcing more is broken or hostile. */
-export declare const MAX_FRAME_BYTES: number;
-/** Splits a TCP byte stream back into frames. */
-export declare class FrameReader {
-    private pending;
-    push(chunk: Buffer): Frame[];
-}
-/**
- * Removes the terminal "strings" an untrusted program could abuse from the sandbox's output before it reaches your
- * terminal: clipboard writes (OSC 52), terminal macros (ConEmu's OSC 9), DCS / APC / PM / SOS, and their C1 forms.
- * Titles, links, progress and colours pass. A byte-level state machine, so no split across chunks, leading zero
- * (ESC]052) or huge payload slips through: a dropped string stays dropped until its terminator, however long it is.
- */
-export declare class OutputFilter {
-    /** text: normal output; esc: after ESC; c2: after a 0xC2 lead byte; string: inside an OSC/DCS/...; stringEsc / stringC2: a possible terminator inside one. */
-    private state;
-    /** The string being read: an OSC worth keeping is collected until its terminator; null = being dropped. */
-    private body;
-    push(chunk: Buffer): Buffer;
-}
-/** Tries every address the sandbox published and returns the first one that answers. */
-export declare const connect: (endpoint: Endpoint, timeoutMs?: number) => Promise<net.Socket>;
-/** Sends one control frame (e.g. RESTART) without taking over the screen. */
-export declare const sendControl: (endpoint: Endpoint, type: number) => Promise<void>;
-/** Who is watching a session right now: `remote` counts viewers on the PC (not the sandbox's own tabs). */
-export interface Viewers {
-    viewers: number;
-    remote: number;
-}
-/**
- * Asks a session's ptyhost who is attached. Only viewers heard from in the last few seconds count, so a terminal that
- * was closed (or a PC that went to sleep) is not reported. null when the session does not answer: an older ptyhost
- * treats the query as a silent control connection, so the caller must not assume anything.
- */
-export declare const queryViewers: (endpoint: Endpoint, timeoutMs?: number) => Promise<Viewers | null>;
-/**
- * Node on Windows reads keys through the console API, where Backspace is ^H and Ctrl+Backspace is DEL: the reverse of
- * what terminals send. ConPTY reads ^H as Ctrl+Backspace (delete a word), so swap them back.
- */
-export declare const fixWindowsKeys: (chunk: Buffer) => Buffer;
-/**
- * Bridges this process's terminal to the remote program until it exits, the connection drops, or the user presses
- * the detach key. Restores the terminal before resolving.
- */
-export declare const runTerminalClient: (socket: net.Socket, token: string, options?: {
-    detachKey?: number;
-}) => Promise<ClientResult>;

package/dist/shared/pty-client.js

@@ -1,349 +0,0 @@
-// Client side of the ptyhost protocol (see sandbox/ptyhost.cs). Used by the window inside the sandbox and by
-// `--terminal` / `attach` on the host, so it only depends on Node built-ins.
-import net from 'node:net';
-export const FrameType = { Hello: 1, Input: 2, Resize: 3, Restart: 4, Ping: 5, Output: 16, Exit: 17, Error: 18, Restarting: 19, Status: 20, Console: 21 };
-/** HELLO flags: control-only connections get no output and never size the console; a query only asks for STATUS. */
-export const HelloFlag = { ControlOnly: 1, Query: 2 };
-/** Viewers ping this often; ptyhost counts a viewer as gone after 15 s of silence (e.g. its terminal tab was closed). */
-export const PING_INTERVAL_MS = 5000;
-/** Ctrl+] — the same detach key telnet uses; Claude Code does not bind it. */
-export const DETACH_KEY = 0x1d;
-export const encodeFrame = (type, payload = Buffer.alloc(0)) => {
-    const header = Buffer.alloc(5);
-    header.writeUInt8(type, 0);
-    header.writeUInt32LE(payload.length, 1);
-    return Buffer.concat([header, payload]);
-};
-export const helloFrame = (token, cols, rows, flags = 0) => {
-    const head = Buffer.alloc(5);
-    head.writeInt16LE(cols, 0);
-    head.writeInt16LE(rows, 2);
-    head.writeUInt8(flags, 4);
-    return encodeFrame(FrameType.Hello, Buffer.concat([head, Buffer.from(token, 'utf8')]));
-};
-export const resizeFrame = (cols, rows) => {
-    const payload = Buffer.alloc(4);
-    payload.writeInt16LE(cols, 0);
-    payload.writeInt16LE(rows, 2);
-    return encodeFrame(FrameType.Resize, payload);
-};
-/** Same limit as ptyhost.cs; a peer announcing more is broken or hostile. */
-export const MAX_FRAME_BYTES = 1 << 20;
-/** Splits a TCP byte stream back into frames. */
-export class FrameReader {
-    pending = Buffer.alloc(0);
-    push(chunk) {
-        this.pending = Buffer.concat([this.pending, chunk]);
-        const frames = [];
-        while (this.pending.length >= 5) {
-            const length = this.pending.readUInt32LE(1);
-            if (length > MAX_FRAME_BYTES)
-                throw new Error('frame too large (' + length + ' bytes)');
-            if (this.pending.length < 5 + length)
-                break;
-            frames.push({ type: this.pending[0], payload: this.pending.subarray(5, 5 + length) });
-            this.pending = this.pending.subarray(5 + length);
-        }
-        return frames;
-    }
-}
-/** OSC commands that may reach your terminal: window title (0, 1, 2), links (8), progress (9;4), shell marks (133). */
-const KEPT_OSC = (body) => {
-    const number = /^(\d{1,4})(;|$)/.exec(body);
-    if (!number)
-        return false;
-    const n = Number(number[1]);
-    return n <= 2 || n === 8 || n === 133 || (n === 9 && body.startsWith(number[1] + ';4;'));
-};
-/** Longest OSC kept (a title or a link); anything longer is dropped whole. */
-const MAX_KEPT_STRING = 4096;
-/**
- * Removes the terminal "strings" an untrusted program could abuse from the sandbox's output before it reaches your
- * terminal: clipboard writes (OSC 52), terminal macros (ConEmu's OSC 9), DCS / APC / PM / SOS, and their C1 forms.
- * Titles, links, progress and colours pass. A byte-level state machine, so no split across chunks, leading zero
- * (ESC]052) or huge payload slips through: a dropped string stays dropped until its terminator, however long it is.
- */
-export class OutputFilter {
-    /** text: normal output; esc: after ESC; c2: after a 0xC2 lead byte; string: inside an OSC/DCS/...; stringEsc / stringC2: a possible terminator inside one. */
-    state = 'text';
-    /** The string being read: an OSC worth keeping is collected until its terminator; null = being dropped. */
-    body = null;
-    push(chunk) {
-        const out = Buffer.allocUnsafe(chunk.length + MAX_KEPT_STRING + 8);
-        let n = 0;
-        const put = (...bytes) => { for (const b of bytes)
-            out[n++] = b; };
-        /** After ESC (or the C1 form): ] opens an OSC (maybe kept), P X ^ _ open DCS / SOS / PM / APC (dropped). */
-        const opens = (b, c1) => {
-            if (b === (c1 ? 0x9d : 0x5d)) {
-                this.body = c1 ? null : [];
-                this.state = 'string';
-                return true;
-            }
-            if ((c1 ? [0x90, 0x98, 0x9e, 0x9f] : [0x50, 0x58, 0x5e, 0x5f]).includes(b)) {
-                this.body = null;
-                this.state = 'string';
-                return true;
-            }
-            return false;
-        };
-        const endString = (terminator) => {
-            const body = this.body && Buffer.from(this.body).toString('latin1');
-            if (body !== null && KEPT_OSC(body)) {
-                put(0x1b, 0x5d);
-                out.write(body, n, 'latin1');
-                n += body.length;
-                put(...terminator);
-            }
-            this.body = null;
-            this.state = 'text';
-        };
-        const collect = (b) => { if (this.body && this.body.push(b) > MAX_KEPT_STRING)
-            this.body = null; };
-        for (const b of chunk) {
-            switch (this.state) {
-                case 'text':
-                    if (b === 0x1b)
-                        this.state = 'esc';
-                    else if (b === 0xc2)
-                        this.state = 'c2';
-                    else
-                        put(b);
-                    break;
-                case 'esc':
-                    if (opens(b, false))
-                        break;
-                    if (b !== 0x1b) {
-                        put(0x1b, b);
-                        this.state = 'text';
-                    }
-                    else
-                        put(0x1b);
-                    break;
-                case 'c2':
-                    if (opens(b, true))
-                        break;
-                    if (b === 0x1b) {
-                        put(0xc2);
-                        this.state = 'esc';
-                    }
-                    else if (b === 0xc2)
-                        put(0xc2);
-                    else {
-                        put(0xc2, b);
-                        this.state = 'text';
-                    }
-                    break;
-                case 'string':
-                    if (b === 0x07)
-                        endString([0x07]);
-                    else if (b === 0x1b)
-                        this.state = 'stringEsc';
-                    else if (b === 0xc2)
-                        this.state = 'stringC2';
-                    else if (b === 0x18 || b === 0x1a) {
-                        this.body = null;
-                        this.state = 'text';
-                    }
-                    else
-                        collect(b);
-                    break;
-                case 'stringC2':
-                    // U+009C is the C1 string terminator; any other character is part of the string.
-                    if (b === 0x9c)
-                        endString([0x1b, 0x5c]);
-                    else {
-                        collect(0xc2);
-                        this.state = 'string';
-                        if (b === 0x07)
-                            endString([0x07]);
-                        else if (b === 0x1b)
-                            this.state = 'stringEsc';
-                        else if (b !== 0xc2)
-                            collect(b);
-                        else
-                            this.state = 'stringC2';
-                    }
-                    break;
-                case 'stringEsc':
-                    if (b === 0x5c) {
-                        endString([0x1b, 0x5c]);
-                        break;
-                    }
-                    // ESC inside a string ends it (dropped) and starts a new sequence.
-                    this.body = null;
-                    this.state = 'esc';
-                    if (!opens(b, false) && b !== 0x1b) {
-                        put(0x1b, b);
-                        this.state = 'text';
-                    }
-                    break;
-            }
-        }
-        return out.subarray(0, n);
-    }
-}
-const connectOnce = (host, port, timeoutMs) => {
-    return new Promise((resolve, reject) => {
-        const socket = net.connect({ host, port });
-        const timer = setTimeout(() => { socket.destroy(); reject(new Error('timed out connecting to ' + host + ':' + port)); }, timeoutMs);
-        socket.once('connect', () => { clearTimeout(timer); socket.setNoDelay(true); resolve(socket); });
-        socket.once('error', (e) => { clearTimeout(timer); reject(e); });
-    });
-};
-/** Tries every address the sandbox published and returns the first one that answers. */
-export const connect = async (endpoint, timeoutMs = 3000) => {
-    const errors = [];
-    for (const address of endpoint.addresses) {
-        try {
-            return await connectOnce(address, endpoint.port, timeoutMs);
-        }
-        catch (e) {
-            errors.push(address + ': ' + (e instanceof Error ? e.message : String(e)));
-        }
-    }
-    throw new Error('Could not reach the sandbox session (' + errors.join('; ') + ')');
-};
-/** Sends one control frame (e.g. RESTART) without taking over the screen. */
-export const sendControl = async (endpoint, type) => {
-    const socket = await connect(endpoint);
-    await new Promise((resolve) => socket.end(Buffer.concat([helloFrame(endpoint.token, 80, 24, HelloFlag.ControlOnly), encodeFrame(type)]), resolve));
-};
-/**
- * Asks a session's ptyhost who is attached. Only viewers heard from in the last few seconds count, so a terminal that
- * was closed (or a PC that went to sleep) is not reported. null when the session does not answer: an older ptyhost
- * treats the query as a silent control connection, so the caller must not assume anything.
- */
-export const queryViewers = async (endpoint, timeoutMs = 2000) => {
-    let socket;
-    try {
-        socket = await connect(endpoint, timeoutMs);
-    }
-    catch {
-        return null;
-    }
-    return new Promise((resolve) => {
-        const reader = new FrameReader();
-        const done = (value) => { clearTimeout(timer); socket.destroy(); resolve(value); };
-        const timer = setTimeout(() => done(null), timeoutMs);
-        socket.on('data', (chunk) => {
-            let frames;
-            try {
-                frames = reader.push(chunk);
-            }
-            catch {
-                done(null);
-                return;
-            }
-            const status = frames.find((f) => f.type === FrameType.Status && f.payload.length >= 4);
-            if (status)
-                done({ viewers: status.payload.readInt16LE(0), remote: status.payload.readInt16LE(2) });
-            else if (frames.some((f) => f.type === FrameType.Error))
-                done(null);
-        });
-        socket.on('error', () => done(null));
-        socket.on('close', () => done(null));
-        socket.write(helloFrame(endpoint.token, 80, 24, HelloFlag.Query));
-    });
-};
-/**
- * Node on Windows reads keys through the console API, where Backspace is ^H and Ctrl+Backspace is DEL: the reverse of
- * what terminals send. ConPTY reads ^H as Ctrl+Backspace (delete a word), so swap them back.
- */
-export const fixWindowsKeys = (chunk) => {
-    if (!chunk.includes(0x08) && !chunk.includes(0x7f))
-        return chunk;
-    return Buffer.from(chunk.map((b) => (b === 0x08 ? 0x7f : b === 0x7f ? 0x08 : b)));
-};
-/**
- * Bridges this process's terminal to the remote program until it exits, the connection drops, or the user presses
- * the detach key. Restores the terminal before resolving.
- */
-export const runTerminalClient = (socket, token, options = {}) => {
-    const stdin = process.stdin;
-    const stdout = process.stdout;
-    // getWindowSize asks the console every time; columns/rows only change when Node noticed a resize.
-    const size = () => { const [c, r] = stdout.isTTY ? stdout.getWindowSize() : [0, 0]; return [c || 120, r || 30]; };
-    const swapKeys = process.platform === 'win32' && stdin.isTTY;
-    return new Promise((resolve) => {
-        let done = false;
-        const reader = new FrameReader();
-        const filter = new OutputFilter();
-        let sent = size();
-        let resizeTimer;
-        const finish = (result) => {
-            if (done)
-                return;
-            done = true;
-            stdin.off('data', onInput);
-            stdout.off('resize', onResize);
-            clearTimeout(resizeTimer);
-            clearInterval(heartbeat);
-            clearInterval(sizeWatch);
-            if (stdin.isTTY)
-                stdin.setRawMode(false);
-            stdin.pause();
-            socket.destroy();
-            stdout.write('\x1b[0m\x1b[?25h\r\n');
-            resolve(result);
-        };
-        const onInput = (chunk) => {
-            if (options.detachKey !== undefined && chunk.includes(options.detachKey)) {
-                finish({ reason: 'detach' });
-                return;
-            }
-            socket.write(encodeFrame(FrameType.Input, swapKeys ? fixWindowsKeys(chunk) : chunk));
-        };
-        // Windows' own ConPTY repaints the whole screen on every resize; dragging a window edge fires dozens of them, and
-        // repaints racing each other left the screen garbled. Wait until the size settles, clear what this terminal
-        // reflowed on its own, then let ptyhost repaint everything once at the new size. With conpty.dll (passthrough)
-        // nothing is repainted: this terminal's own reflow and scrollback stay, and the program redraws what it needs.
-        let passthrough = false;
-        const sendSize = () => {
-            const [c, r] = size();
-            if (c === sent[0] && r === sent[1])
-                return;
-            sent = [c, r];
-            if (!passthrough)
-                stdout.write('\x1b[H\x1b[J');
-            socket.write(resizeFrame(c, r));
-        };
-        const onResize = () => { clearTimeout(resizeTimer); resizeTimer = setTimeout(() => { resizeTimer = undefined; sendSize(); }, 120); };
-        const heartbeat = setInterval(() => socket.write(encodeFrame(FrameType.Ping)), PING_INTERVAL_MS);
-        // Windows does not always report a resize in raw mode, so the size is also checked twice a second.
-        const sizeWatch = setInterval(() => { if (!resizeTimer)
-            sendSize(); }, 500);
-        socket.on('data', (chunk) => {
-            let frames;
-            try {
-                frames = reader.push(chunk);
-            }
-            catch {
-                finish({ reason: 'error', message: 'invalid data from the sandbox' });
-                return;
-            }
-            for (const frame of frames) {
-                if (frame.type === FrameType.Output)
-                    stdout.write(filter.push(frame.payload));
-                else if (frame.type === FrameType.Console)
-                    passthrough = frame.payload.toString('latin1') === 'conpty.dll';
-                else if (frame.type === FrameType.Restarting)
-                    stdout.write('\x1b[2J\x1b[3J\x1b[H');
-                else if (frame.type === FrameType.Exit)
-                    finish({ reason: 'exit', exitCode: frame.payload.length >= 4 ? frame.payload.readInt32LE(0) : 1 });
-                else if (frame.type === FrameType.Error)
-                    finish({ reason: 'error', message: frame.payload.toString('utf8').slice(0, 500).replace(/[\x00-\x1f\x7f]/g, ' ') });
-            }
-        });
-        socket.on('close', () => finish({ reason: 'closed' }));
-        socket.on('error', () => finish({ reason: 'closed' }));
-        const [c, r] = size();
-        stdout.write('\x1b[2J\x1b[3J\x1b[H');
-        socket.write(helloFrame(token, c, r));
-        if (stdin.isTTY)
-            stdin.setRawMode(true);
-        stdin.on('data', onInput);
-        stdin.resume();
-        stdout.on('resize', onResize);
-    });
-};

package/dist/shared/rundir.d.ts

@@ -1,41 +0,0 @@
-import type { z } from 'zod';
-import type { GuestRequestT, GuestResponseT, ProjectStatusT, SandboxStatusT, SessionStatusT } from './schema.js';
-/** Anything bigger than this from the other side is ignored (a compromised sandbox must not exhaust the host). */
-export declare const MAX_MESSAGE_BYTES: number;
-/** Ids become file names, so only a strict alphabet is allowed (no separators, no dots). */
-export declare const safeId: (id: string) => string;
-export declare const runPaths: (dataDir: string) => {
-    run: string;
-    sandbox: string;
-    requests: string;
-    responses: string;
-    sessions: string;
-    projects: string;
-    /** audit.processes: programs the sandbox started, in small .jsonl files the host takes in and deletes. */
-    audit: string;
-    request: (id: string) => string;
-    response: (id: string) => string;
-    session: (id: string) => string;
-    project: (id: string) => string;
-};
-export declare const readJsonFile: <T>(file: string) => T | null;
-/** Reads and validates; a missing, oversized or malformed file is simply absent. */
-export declare const readValid: <S extends z.ZodType>(schema: S, file: string) => z.output<S> | null;
-/**
- * Write to a uniquely named temp file and rename, so a reader on the other side of the mapped folder never sees half a
- * file. The rename is retried briefly: antivirus or the other side's reader can hold the target for a moment.
- */
-export declare const writeJsonAtomic: (file: string, value: unknown) => void;
-/** Same for any text file (two commands at once, or a watcher and a command, never leave a half-written file). */
-export declare const writeFileAtomic: (file: string, text: string) => void;
-export declare const readSandboxStatus: (dataDir: string) => SandboxStatusT | null;
-export declare const readSession: (dataDir: string, id: string) => SessionStatusT | null;
-export declare const readResponse: (dataDir: string, id: string) => GuestResponseT | null;
-export declare const listSessions: (dataDir: string) => SessionStatusT[];
-export declare const readProjectStatus: (dataDir: string, name: string) => ProjectStatusT | null;
-export declare const listProjectStatus: (dataDir: string) => ProjectStatusT[];
-export declare const scanRequests: (dataDir: string) => {
-    valid: GuestRequestT[];
-    invalid: string[];
-};
-export declare const now: () => string;

package/dist/shared/rundir.js

@@ -1,96 +0,0 @@
-// The run folder (<data>\run on the host, C:\AgentData\run in the sandbox) is the host <-> sandbox channel. No
-// network needed: boot status, requests (host -> guest) and responses/status (guest -> host) are small JSON files,
-// written atomically and parsed with the channel schemas on read. Anything that does not parse is ignored.
-import fs from 'node:fs';
-import path from 'node:path';
-import { GuestRequest, GuestResponse, Id, ProjectStatus, SandboxStatus, SessionStatus } from './schema.js';
-import { assertTestWritable } from './test-guard.js';
-/** Anything bigger than this from the other side is ignored (a compromised sandbox must not exhaust the host). */
-export const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
-/** Ids become file names, so only a strict alphabet is allowed (no separators, no dots). */
-export const safeId = (id) => Id.parse(id);
-export const runPaths = (dataDir) => {
-    const run = path.join(dataDir, 'run');
-    const file = (dir) => (id) => path.join(run, dir, safeId(id) + '.json');
-    return {
-        run,
-        sandbox: path.join(run, 'sandbox.json'),
-        requests: path.join(run, 'requests'),
-        responses: path.join(run, 'responses'),
-        sessions: path.join(run, 'sessions'),
-        projects: path.join(run, 'projects'),
-        /** audit.processes: programs the sandbox started, in small .jsonl files the host takes in and deletes. */
-        audit: path.join(run, 'audit'),
-        request: file('requests'),
-        response: file('responses'),
-        session: file('sessions'),
-        project: file('projects'),
-    };
-};
-export const readJsonFile = (file) => {
-    try {
-        if (fs.statSync(file).size > MAX_MESSAGE_BYTES)
-            return null;
-        return JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
-    }
-    catch {
-        return null;
-    }
-};
-/** Reads and validates; a missing, oversized or malformed file is simply absent. */
-export const readValid = (schema, file) => {
-    const parsed = schema.safeParse(readJsonFile(file));
-    return parsed.success ? parsed.data : null;
-};
-const pause = (ms) => { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); };
-/**
- * Write to a uniquely named temp file and rename, so a reader on the other side of the mapped folder never sees half a
- * file. The rename is retried briefly: antivirus or the other side's reader can hold the target for a moment.
- */
-export const writeJsonAtomic = (file, value) => writeFileAtomic(file, JSON.stringify(value, null, 2) + '\n');
-/** Same for any text file (two commands at once, or a watcher and a command, never leave a half-written file). */
-export const writeFileAtomic = (file, text) => {
-    assertTestWritable(file);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const temp = file + '.' + process.pid + '-' + Math.random().toString(36).slice(2) + '.tmp';
-    fs.writeFileSync(temp, text, { encoding: 'utf8', flag: 'wx' });
-    for (let attempt = 1;; attempt++) {
-        try {
-            fs.renameSync(temp, file);
-            return;
-        }
-        catch (e) {
-            const code = e.code;
-            if (attempt >= 8 || (code !== 'EPERM' && code !== 'EBUSY' && code !== 'EACCES')) {
-                fs.rmSync(temp, { force: true });
-                throw e;
-            }
-            pause(50 * attempt);
-        }
-    }
-};
-/** Message files in a folder (strict names only), validated; invalid ones are reported separately for deletion. */
-const scan = (schema, dir) => {
-    if (!fs.existsSync(dir))
-        return { valid: [], invalid: [] };
-    const valid = [];
-    const invalid = [];
-    for (const name of fs.readdirSync(dir)) {
-        if (name.endsWith('.tmp'))
-            continue;
-        const message = /^[A-Za-z0-9_-]{1,64}\.json$/.test(name) ? readValid(schema, path.join(dir, name)) : null;
-        if (message)
-            valid.push(message);
-        else
-            invalid.push(path.join(dir, name));
-    }
-    return { valid, invalid };
-};
-export const readSandboxStatus = (dataDir) => readValid(SandboxStatus, runPaths(dataDir).sandbox);
-export const readSession = (dataDir, id) => readValid(SessionStatus, runPaths(dataDir).session(id));
-export const readResponse = (dataDir, id) => readValid(GuestResponse, runPaths(dataDir).response(id));
-export const listSessions = (dataDir) => scan(SessionStatus, runPaths(dataDir).sessions).valid.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
-export const readProjectStatus = (dataDir, name) => readValid(ProjectStatus, runPaths(dataDir).project(name));
-export const listProjectStatus = (dataDir) => scan(ProjectStatus, runPaths(dataDir).projects).valid.slice(0, 64);
-export const scanRequests = (dataDir) => scan(GuestRequest, runPaths(dataDir).requests);
-export const now = () => new Date().toISOString();