windows-development-sandbox 1.4.1 → 1.4.3

package/dist/core/util.js

@@ -1,156 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawn, spawnSync } from 'node:child_process';
-import { SYSTEM } from '../shared/system.js';
-import { writeJsonAtomic } from '../shared/rundir.js';
-import { assertTestWritable } from '../shared/test-guard.js';
-import { parse as parseJsoncText, printParseErrorCode } from 'jsonc-parser';
-export const isWin = process.platform === 'win32';
-/** An expected problem the user can act on: what went wrong, and (optionally) how to fix it. */
-export class UserError extends Error {
-    fix;
-    constructor(message, fix) {
-        super(message);
-        this.fix = fix;
-        this.name = 'UserError';
-    }
-}
-/** Throws a UserError. Typed explicitly so TypeScript narrows after calls (arrow functions need it to act as never). */
-export const fail = (message, fix) => { throw new UserError(message, fix); };
-/**
- * Parses JSON with comments and trailing commas (JSONC, like VS Code's settings.json). Errors name the file, line
- * and column, and say what to fix.
- */
-export const parseJsonc = (text, source) => {
-    const errors = [];
-    const value = parseJsoncText(text.replace(/^/, ''), errors, { allowTrailingComma: true, disallowComments: false });
-    if (errors.length) {
-        const { offset, error } = errors[0];
-        const before = text.slice(0, offset).split(/\r?\n/);
-        fail(source + ' is not valid JSON (line ' + before.length + ', column ' + (before[before.length - 1].length + 1) + ': ' + printParseErrorCode(error) + ').', 'Fix that spot in the file. Comments (// and /* */) and trailing commas are fine.');
-    }
-    return value;
-};
-export const readJsonc = (file) => parseJsonc(fs.readFileSync(file, 'utf8'), file);
-export const errMsg = (e) => e instanceof Error ? e.message : String(e);
-export const ensureDir = (p) => { fs.mkdirSync(p, { recursive: true }); };
-export const dirExists = (p) => { try {
-    return fs.statSync(p).isDirectory();
-}
-catch {
-    return false;
-} };
-export const fileExists = (p) => { try {
-    return fs.statSync(p).isFile();
-}
-catch {
-    return false;
-} };
-export const readJson = (p) => JSON.parse(fs.readFileSync(p, 'utf8').replace(/^\uFEFF/, ''));
-export const tryReadJson = (p) => { try {
-    return readJson(p);
-}
-catch {
-    return null;
-} };
-/** Atomic (a crash or a second command never leaves half a file); refused outside temp during the self-test. */
-export const writeJson = (p, value) => writeJsonAtomic(p, value);
-export const realPath = (p) => { try {
-    return fs.realpathSync(p);
-}
-catch {
-    return p;
-} };
-export const xmlEscape = (v) => v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
-export const homeDir = () => process.env.USERPROFILE ?? os.homedir();
-export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-/** Expands %VAR% and resolves relative paths against `base`. */
-export const expandPath = (input, base) => {
-    const expanded = input.replace(/%([^%]+)%/g, (_m, name) => process.env[name] ?? '%' + name + '%').replace(/^~(?=$|[\\/])/, homeDir());
-    return path.resolve(path.isAbsolute(expanded) ? expanded : path.join(base, expanded));
-};
-export const isRootPath = (p) => { const n = path.resolve(p); return n.toLowerCase() === path.parse(n).root.toLowerCase(); };
-export const isUserProfile = (p) => { const profile = process.env.USERPROFILE ?? process.env.HOME ?? ''; return profile !== '' && path.resolve(p).toLowerCase() === path.resolve(profile).toLowerCase(); };
-export const isInsideOrEqual = (parent, child) => {
-    const rel = path.relative(path.resolve(parent).toLowerCase(), path.resolve(child).toLowerCase());
-    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
-};
-/**
- * Text that came from the sandbox, made safe to print: control characters and escape sequences are removed except
- * plain colours (SGR), so nothing written by the sandbox can drive your terminal (titles, clipboard, cursor tricks).
- */
-export const safeText = (text) => text.replace(/\x1b\[[0-9;]*m|\x1b(\[[0-9;?]*[ -\/]*[@-~]|\][^\x07\x1b]*(\x07|\x1b\\)|[@-Z\\-_])|[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, (m) => (/^\x1b\[[0-9;]*m$/.test(m) ? m : ''));
-/** safeText without colours either: for text you are asked to approve, which must not be able to hide parts of itself. */
-export const plainText = (text) => safeText(text).replace(/\x1b\[[0-9;]*m/g, '');
-export const findOnPath = (names) => {
-    const dirs = (process.env.PATH ?? process.env.Path ?? '').split(path.delimiter).filter((d) => d !== '');
-    for (const name of names)
-        for (const dir of dirs) {
-            const candidate = path.join(dir, name);
-            if (fileExists(candidate))
-                return candidate;
-        }
-    return null;
-};
-/** True if `p` itself is a symlink or junction (lstat; never follows it). */
-export const isLink = (p) => { try {
-    return fs.lstatSync(p).isSymbolicLink();
-}
-catch {
-    return false;
-} };
-/** Removes a symlink or junction itself (never its target). Junctions need rmdir on Windows. */
-export const removeLink = (p) => { assertTestWritable(p); try {
-    fs.unlinkSync(p);
-}
-catch {
-    fs.rmdirSync(p);
-} };
-/**
- * The sandbox can write anywhere in its data folder, so it could swap a folder for a junction that points at this
- * PC's own disk. Before the host reads, writes or deletes anything under `root`, every existing path component from
- * `root` down to `target` must be a plain folder/file. Throws otherwise.
- */
-export const assertNoLinks = (root, target) => {
-    const rel = path.relative(path.resolve(root), path.resolve(target));
-    if (rel.startsWith('..') || path.isAbsolute(rel))
-        fail('Refusing to touch ' + target + ': it is outside ' + root);
-    let current = path.resolve(root);
-    for (const part of ['', ...rel.split(path.sep).filter(Boolean)]) {
-        current = part ? path.join(current, part) : current;
-        if (isLink(current))
-            fail('Refusing to touch ' + target + ': ' + current + ' is a link (possible escape attempt from the sandbox).');
-    }
-};
-/**
- * PowerShell arguments for a script passed encoded (no quoting issues, no progress-bar noise on stderr). Output is
- * UTF-8: Windows PowerShell 5.1 otherwise writes redirected stdout in the OEM code page, mangling non-ASCII (regional
- * date formats, wallpaper paths). UTF8Encoding($false): no byte-order mark in front of the output.
- */
-const powerShellArgs = (script) => {
-    const prelude = "[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding $false\n$ProgressPreference = 'SilentlyContinue'\n";
-    const encoded = Buffer.from(prelude + script, 'utf16le').toString('base64');
-    // -OutputFormat Text: with redirected output PowerShell would otherwise print its progress stream as "#< CLIXML" XML.
-    return ['-NoLogo', '-NoProfile', '-NonInteractive', '-OutputFormat', 'Text', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded];
-};
-/** Runs a PowerShell script and returns its exit code (and stdout when `capture`). */
-export const runPowerShell = (script, capture = false) => {
-    const result = spawnSync(SYSTEM.powershell(), powerShellArgs(script), { stdio: capture ? ['ignore', 'pipe', 'inherit'] : 'inherit', encoding: 'utf8', windowsHide: true });
-    if (result.error)
-        throw result.error;
-    return { status: result.status ?? 1, stdout: result.stdout ?? '' };
-};
-/** Runs a program (an absolute path: `SYSTEM.*`, never a bare name) and returns its stdout, or '' if it failed or timed out. */
-export const captureOutput = (file, args, options = {}) => {
-    const result = spawnSync(file, args, { encoding: 'utf8', windowsHide: true, timeout: 60000, ...options });
-    return result.status === 0 ? result.stdout ?? '' : '';
-};
-/** Async variant (does not block the event loop), resolving with stdout. */
-export const runPowerShellAsync = (script) => new Promise((resolve, reject) => {
-    const child = spawn(SYSTEM.powershell(), powerShellArgs(script), { stdio: ['ignore', 'pipe', 'inherit'], windowsHide: true });
-    let out = '';
-    child.stdout.on('data', (d) => { out += d.toString('utf8'); });
-    child.on('error', reject);
-    child.on('close', () => resolve(out));
-});

package/dist/core/workspace.d.ts

@@ -1,35 +0,0 @@
-import type { Config, Mapping, Overrides, ResolvedRun, RunRequest, ToolVersions } from './types.js';
-/** 'auto' guest workspace: C:\Workspace\<folder name> (shared/projects.ts, where every project's place is decided). */
-export declare const autoGuestWorkspace: (hostDir: string) => string;
-/**
- * A launch folder inside a project root appears under the root's folder (C:\Projects\<root>\<name>, or its PC path
- * with "mirror"), where it also is when another project started the sandbox, so git worktrees and Claude's project
- * folders keep working whichever project starts it. Only for "auto" / "mirror"; a filtered or read-only workspace
- * keeps its own mapping (the root would show the folder unfiltered and writable at that place).
- */
-export declare const placeInRoot: (config: Config, workspaceHost: string, mirror: boolean, notes: string[]) => Config;
-/** The Node version a Volta project pins ("volta": { "node": "20.11.1" } in package.json), so nvm defaults to it too. */
-export declare const voltaNode: (workspace: string) => string | null;
-/**
- * Picks tool versions. Highest priority first: command line, the folder's .sandbox-config.json,
- * version files in the workspace (.nvmrc, .node-version, .python-version), the tool config, this PC's node version.
- */
-export declare const resolveVersions: (config: Config, workspace: string, local: Overrides, req: {
-    nodeVersion?: string;
-    pythonVersion?: string;
-}, hostNodeVersion: string) => ToolVersions;
-/** Precedence (lowest to highest): built-in defaults, user config, .sandbox-config.json in the workspace, command-line flags. */
-export declare const resolveRun: (req: RunRequest, hostNodeVersion?: string) => Promise<ResolvedRun>;
-/** Where the workspace appears: guestWorkspace "auto", "mirror" (with a note when it falls back) or a path. */
-export declare const guestWorkspaceOf: (config: Pick<Config, "guestWorkspace">, workspaceHost: string) => {
-    guest: string;
-    note: string | null;
-};
-/**
- * Where a mapping will most likely appear, before the launch knows every other folder (the prompt and config check
- * show it; the launch places it for real in host/launch/mappings.ts with the same rules).
- */
-export declare const previewGuest: (m: Pick<Mapping, "host" | "guest">, workspaceHost: string, workspaceGuest: string) => {
-    guest: string;
-    note: string | null;
-};

package/dist/core/workspace.js

@@ -1,206 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { z } from 'zod';
-import { deriveGuest, placeGuest, planMirrorWorkspace } from '../shared/guest-paths.js';
-import { autoGuestFolder, PROJECTS_GUEST, rootGuestDir, usableRoots } from '../shared/projects.js';
-import { DATABASES } from './detect-databases.js';
-import { allowedAnswer, allowRequests, allowStorePath, applyOverrides, describeOverrides, isTrusted, LOCAL_CONFIG_NAME, loosenedRequests, normalizeOverrides, OUTSIDE_FOLDER, outsideKey, outsideMappings, readLocalConfig, saveAllowed, saveTrust, trustStorePath } from './local-config.js';
-import { assertSafeWorkspace } from './safe-paths.js';
-import { dirExists, expandPath, fail, fileExists, isInsideOrEqual, plainText } from './util.js';
-/** 'auto' guest workspace: C:\Workspace\<folder name> (shared/projects.ts, where every project's place is decided). */
-export const autoGuestWorkspace = autoGuestFolder;
-/**
- * A launch folder inside a project root appears under the root's folder (C:\Projects\<root>\<name>, or its PC path
- * with "mirror"), where it also is when another project started the sandbox, so git worktrees and Claude's project
- * folders keep working whichever project starts it. Only for "auto" / "mirror"; a filtered or read-only workspace
- * keeps its own mapping (the root would show the folder unfiltered and writable at that place).
- */
-export const placeInRoot = (config, workspaceHost, mirror, notes) => {
-    const guest = rootGuestDir(usableRoots(config.projects.roots, dirExists), mirror, workspaceHost);
-    if (!guest)
-        return config;
-    if (config.workspaceFilter.enabled || config.readOnly) {
-        notes.push(workspaceHost + ' is inside a project root, but ' + (config.readOnly ? 'readOnly' : 'workspaceFilter') + ' is on, so it is mapped on its own at ' + config.guestWorkspace + ' (when another project starts the sandbox it is at ' + guest + ').');
-        return config;
-    }
-    return { ...config, guestWorkspace: guest };
-};
-const firstLine = (file) => {
-    if (!fileExists(file))
-        return null;
-    const line = fs.readFileSync(file, 'utf8').replace(/^/, '').split(/\r?\n/).map((l) => l.replace(/#.*$/, '').trim()).find((l) => l !== '');
-    return line ?? null;
-};
-const VOLTA_PIN = 'package.json volta.node';
-const PackageJson = z.object({ volta: z.object({ node: z.string().regex(/^\d+(\.\d+){0,2}$/).optional() }).optional() });
-/** The Node version a Volta project pins ("volta": { "node": "20.11.1" } in package.json), so nvm defaults to it too. */
-export const voltaNode = (workspace) => {
-    const file = path.join(workspace, 'package.json');
-    if (!fileExists(file))
-        return null;
-    try {
-        return PackageJson.safeParse(JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, ''))).data?.volta?.node ?? null;
-    }
-    catch {
-        return null;
-    }
-};
-/**
- * Picks tool versions. Highest priority first: command line, the folder's .sandbox-config.json,
- * version files in the workspace (.nvmrc, .node-version, .python-version), the tool config, this PC's node version.
- */
-export const resolveVersions = (config, workspace, local, req, hostNodeVersion) => {
-    const localTools = (local.toolchains ?? {});
-    const pick = (cli, localValue, files, configured) => {
-        if (cli)
-            return { spec: cli, source: 'command line' };
-        if (localValue)
-            return { spec: localValue, source: '.sandbox-config.json' };
-        for (const name of files) {
-            const value = name === VOLTA_PIN ? voltaNode(workspace) : firstLine(path.join(workspace, name));
-            if (value)
-                return { spec: value, source: name };
-        }
-        return { spec: configured, source: 'config' };
-    };
-    let node = pick(req.nodeVersion, localTools.node?.version, ['.nvmrc', '.node-version', VOLTA_PIN], config.toolchains.node.version);
-    if (node.spec === 'host')
-        node = { spec: hostNodeVersion.replace(/^v/, ''), source: 'this PC' };
-    const python = pick(req.pythonVersion, localTools.python?.version, ['.python-version'], config.toolchains.python.version);
-    return { node, nodeExtra: config.toolchains.node.extraVersions, python };
-};
-/** Precedence (lowest to highest): built-in defaults, user config, .sandbox-config.json in the workspace, command-line flags. */
-export const resolveRun = async (req, hostNodeVersion = process.version) => {
-    const notes = [];
-    // Mappings from the user config are relative to that config file; expand them before anything else uses them.
-    const expand = (list) => list.map((p) => expandPath(p, req.loaded.base));
-    const projects = req.loaded.config.projects;
-    let config = {
-        ...req.loaded.config,
-        mappings: req.loaded.config.mappings.map((m) => ({ ...m, host: expandPath(m.host, req.loaded.base) })),
-        projects: { ...projects, roots: expand(projects.roots), exclude: expand(projects.exclude), declinedRoots: expand(projects.declinedRoots) },
-    };
-    const mirror = config.guestWorkspace === 'mirror';
-    const storageRoot = expandPath(config.storage.root, req.loaded.base);
-    const workspaceHost = path.resolve(req.workspace ?? req.cwd);
-    if (!dirExists(workspaceHost))
-        fail('The workspace folder does not exist: ' + workspaceHost, 'Check the --workspace path, or cd into the project first.');
-    assertSafeWorkspace(workspaceHost, req.packageRoot, storageRoot);
-    const scripts = [];
-    let localConfigPath = null;
-    let overrides = {};
-    const local = req.noLocalConfig ? null : readLocalConfig(workspaceHost);
-    let outsideAllowed = [];
-    if (local) {
-        overrides = normalizeOverrides(local.data, workspaceHost, local.path);
-        const store = trustStorePath(storageRoot);
-        if (!isTrusted(store, local.path, local.hash)) {
-            const summary = describeOverrides(overrides, workspaceHost);
-            let trusted = req.trustConfig;
-            if (!trusted && req.ask) {
-                console.log('\nFound ' + local.path + ' which is not trusted yet. It would apply:');
-                for (const line of summary)
-                    console.log('  ' + plainText(line));
-                trusted = await req.ask('Trust and use this file?');
-            }
-            if (!trusted)
-                fail(local.path + ' has not been approved yet (a repo can ship this file, so it needs your OK). It would apply:\n  ' + (summary.map(plainText).join('\n  ') || '(no changes)'), 'Review it, then run again in an interactive terminal and answer y, or add --trust-config. To ignore the file: --no-local-config');
-            saveTrust(store, local.path, local.hash);
-            notes.push('Trusted ' + local.path + ' (you will only be asked again if the file changes).');
-        }
-        // A project may only tighten. What it asks for beyond that (a looser setting, a folder outside the project) is used
-        // only if you allowed it for this project: asked once, in one question, at an interactive launch, never by
-        // --trust-config. Folders outside the project follow projects.allowOutsideMappings (your settings only). A looser
-        // setting you did not allow is named in the notes instead of dropped silently.
-        const allowStore = allowStorePath(storageRoot);
-        const policy = config.projects.allowOutsideMappings;
-        // An optional folder that is not on this PC is skipped at launch, so it needs no answer (yet).
-        const outside = outsideMappings(workspaceHost, overrides.mappings).filter((m) => !m.optional || dirExists(m.host));
-        const name = path.basename(workspaceHost) + '\'s ' + LOCAL_CONFIG_NAME;
-        const preview = guestWorkspaceOf(applyOverrides(config, overrides), workspaceHost).guest;
-        const describe = (m) => (m.readOnly ? 'read-only  ' : 'READ/WRITE ') + m.host + '  ->  ' + previewGuest(m, workspaceHost, preview).guest;
-        if (outside.length && policy === false) {
-            fail(name + ' maps ' + outside.length + ' folder' + (outside.length === 1 ? '' : 's') + ' outside the project, and your settings do not allow that:\n  ' + outside.map(describe).join('\n  '), 'Allow it: set projects.allowOutsideMappings to "ask" or true in your settings (sandbox > Settings, or the file sandbox config path shows). Or remove those mappings from the file.');
-        }
-        const looser = loosenedRequests(config, overrides);
-        const interactive = Boolean(req.ask) && (req.interactive ?? Boolean(process.stdin.isTTY));
-        const openOutside = policy === 'ask' ? outside.filter((m) => allowedAnswer(allowStore, local.path, OUTSIDE_FOLDER, outsideKey(m)) !== true) : [];
-        const openLooser = looser.filter((a) => allowedAnswer(allowStore, local.path, a.key, a.wanted) === null);
-        let declinedOutside = false;
-        if (interactive && req.ask && (openOutside.length || openLooser.length)) {
-            console.log('\n' + name + ' asks for more than your settings allow:');
-            if (openOutside.length)
-                console.log('  Folders outside the project:\n' + openOutside.map((m) => '    ' + plainText(describe(m))).join('\n'));
-            for (const a of openLooser)
-                console.log('  ' + a.key + ' = ' + JSON.stringify(a.wanted) + '  (your settings: ' + JSON.stringify(a.yours) + ')');
-            const ok = await req.ask('Allow ' + (openOutside.length + openLooser.length === 1 ? 'it' : 'these') + ' for this project?');
-            for (const a of openLooser)
-                saveAllowed(allowStore, local.path, a.key, a.wanted, ok);
-            // A "no" to folders is not kept: the next interactive launch asks again.
-            if (ok)
-                for (const m of openOutside)
-                    saveAllowed(allowStore, local.path, OUTSIDE_FOLDER, outsideKey(m), true);
-            declinedOutside = !ok && openOutside.length > 0;
-        }
-        const notAllowed = policy === 'ask' ? outside.filter((m) => allowedAnswer(allowStore, local.path, OUTSIDE_FOLDER, outsideKey(m)) !== true) : [];
-        if (notAllowed.length) {
-            const what = name + ' maps ' + notAllowed.length + ' folder' + (notAllowed.length === 1 ? '' : 's') + ' outside the project:\n  ' + notAllowed.map(describe).join('\n  ');
-            fail(what + (declinedOutside ? '\nYou did not allow ' + (notAllowed.length === 1 ? 'it' : 'them') + ', so the sandbox was not started.' : '\nThat needs your OK once (a repo ships this file), and this launch cannot ask (no interactive terminal).'), 'Allow ' + (notAllowed.length === 1 ? 'it' : 'them') + ': start it from an interactive terminal and answer y, or set projects.allowOutsideMappings to true in your settings (sandbox > Settings, or the file sandbox config path shows).');
-        }
-        outsideAllowed = [...new Set(outside.map((m) => m.host))];
-        if (outside.length)
-            notes.push('Folders outside the project allowed for ' + name + ' (' + (policy === true ? 'projects.allowOutsideMappings is true' : 'your answer is kept in ' + allowStore) + '): ' + outsideAllowed.join(', '));
-        const allowed = [];
-        for (const ask of looser) {
-            const ok = allowedAnswer(allowStore, local.path, ask.key, ask.wanted);
-            if (ok) {
-                allowed.push(ask);
-                notes.push('Allowed for this project: ' + ask.key + ' = ' + JSON.stringify(ask.wanted) + ' (your answer is kept in ' + allowStore + ').');
-            }
-            else
-                notes.push('The project asks for ' + ask.key + ' = ' + JSON.stringify(ask.wanted) + ', but your settings say ' + JSON.stringify(ask.yours) + ', so it is not used. ' + (ok === false ? 'You said no (kept in ' + allowStore + ').' : 'Start it from an interactive terminal to allow it for this project.') + ' Or set ' + ask.key + ' in your own settings (sandbox, then Settings > All projects).');
-        }
-        config = applyOverrides(allowRequests(config, allowed), overrides);
-        scripts.push(...(overrides.scripts ?? []));
-        localConfigPath = local.path;
-        notes.push('Using ' + local.path);
-    }
-    if (req.headless !== undefined)
-        config = { ...config, sandbox: { ...config.sandbox, headless: req.headless } };
-    for (const name of req.databases ?? []) {
-        const db = name.toLowerCase();
-        if (!DATABASES.includes(db))
-            fail('Unknown database "' + name + '".', 'Choose from: ' + DATABASES.join(', '));
-        config = { ...config, databases: { ...config.databases, [db]: { ...config.databases[db], enabled: true } } };
-    }
-    // auto / mirror: a project inside a root is where the root shows it, whichever project starts the sandbox.
-    const guest = guestWorkspaceOf(config, workspaceHost);
-    const placed = config.guestWorkspace === 'auto' || mirror ? placeInRoot({ ...config, guestWorkspace: guest.guest }, workspaceHost, mirror, notes) : { ...config, guestWorkspace: guest.guest };
-    if (guest.note && placed.guestWorkspace === guest.guest)
-        notes.push(guest.note);
-    config = placed;
-    scripts.push(...req.scripts.map((s) => path.resolve(s)));
-    const harnessName = req.noAgent ? 'none' : (req.harness ?? config.defaultHarness);
-    if (harnessName !== 'none' && !config.harnesses[harnessName])
-        fail('Unknown agent "' + harnessName + '".', 'Configured agents: ' + Object.keys(config.harnesses).join(', ') + ' (add more under "harnesses" in your config).');
-    const versions = resolveVersions(config, workspaceHost, overrides, req, hostNodeVersion);
-    const dataPath = path.join(storageRoot, 'data', config.storage.dataName);
-    // A project file may ask for "mirror" too (it decides only its own path); project roots follow the user's choice.
-    return { config, storageRoot, dataPath, workspaceHost, harnessName, scripts, localConfigPath, notes, versions, mirror, outsideMappings: outsideAllowed };
-};
-/** Where the workspace appears: guestWorkspace "auto", "mirror" (with a note when it falls back) or a path. */
-export const guestWorkspaceOf = (config, workspaceHost) => {
-    if (config.guestWorkspace === 'auto')
-        return { guest: autoGuestWorkspace(workspaceHost), note: null };
-    if (config.guestWorkspace === 'mirror')
-        return planMirrorWorkspace(workspaceHost, autoGuestWorkspace(workspaceHost));
-    return { guest: config.guestWorkspace, note: null };
-};
-/**
- * Where a mapping will most likely appear, before the launch knows every other folder (the prompt and config check
- * show it; the launch places it for real in host/launch/mappings.ts with the same rules).
- */
-export const previewGuest = (m, workspaceHost, workspaceGuest) => placeGuest(m.host, m.guest ?? deriveGuest(m.host, workspaceHost, workspaceGuest), [
-    ...(m.guest || !isInsideOrEqual(workspaceHost, m.host) ? [{ guest: workspaceGuest, what: 'the project' }] : []),
-    { guest: PROJECTS_GUEST, what: 'other projects' },
-]);

package/dist/guest/boot-env.d.ts

@@ -1,4 +0,0 @@
-import { type BootEnvT } from './project-env.js';
-export { baseEnvFor, type BootEnvT } from './project-env.js';
-export declare const saveBootEnv: (value: BootEnvT) => void;
-export declare const readBootEnv: () => BootEnvT | null;

package/dist/guest/daemon.js

@@ -1,57 +0,0 @@
-// Session daemon (runs detached inside the sandbox for its whole life). It is the only thing that acts on host
-// requests, and it only knows four request kinds: start a session, run a command, restart sessions, ping.
-// It must never die quietly: every iteration is guarded, and anything unexpected is written to its log.
-// The handlers live in daemon/ (session, exec); this file is the polling loop.
-import fs from 'node:fs';
-import { readSession, scanRequests } from '../shared/rundir.js';
-import { saveClaudeMem } from './setup/claude.js';
-import { execCommand } from './daemon/exec.js';
-import { startRelays } from './daemon/relays.js';
-import { startProcessCollector } from './audit.js';
-import { prepareProject, restartSessions, startSession } from './daemon/session.js';
-import { live, respond, safely } from './daemon/state.js';
-import { dataDir, errMsg, log, run, warn } from './env.js';
-let lastMemSave = Date.now();
-process.on('uncaughtException', (e) => warn('daemon: unexpected error (continuing): ' + (e.stack ?? errMsg(e))));
-process.on('unhandledRejection', (e) => warn('daemon: unexpected error (continuing): ' + errMsg(e)));
-const handle = (req) => {
-    switch (req.kind) {
-        case 'session': return startSession(req);
-        case 'project': return prepareProject(req);
-        case 'exec': return execCommand(req);
-        case 'restart': return restartSessions(req);
-        case 'ping': return respond(req.id, { ok: true, message: 'pong (' + live.size + ' session(s) running)' });
-    }
-};
-const tick = () => {
-    const { valid, invalid } = scanRequests(dataDir);
-    // Anything in requests/ that is not a valid request (wrong kind, bad id, junk) is deleted unread.
-    for (const file of invalid)
-        safely('removing an invalid request', () => fs.rmSync(file, { recursive: true, force: true }));
-    for (const req of valid) {
-        safely('claiming a request', () => fs.rmSync(run.request(req.id), { force: true }));
-        if (readSession(dataDir, req.id))
-            continue;
-        // Not awaited: starting a session or running a command must not hold up other requests.
-        void Promise.resolve(handle(req)).catch((e) => respond(req.id, { ok: false, message: errMsg(e) }));
-    }
-    if (Date.now() - lastMemSave > 120000) {
-        lastMemSave = Date.now();
-        safely('claude-mem save', saveClaudeMem);
-    }
-};
-const loop = () => {
-    try {
-        tick();
-    }
-    catch (e) {
-        warn('daemon loop: ' + errMsg(e));
-    }
-    finally {
-        setTimeout(loop, 400);
-    }
-};
-log('Session daemon started (pid ' + process.pid + ').');
-safely('port forwards', startRelays);
-safely('audit', startProcessCollector);
-loop();

package/dist/guest/env.d.ts

@@ -1,56 +0,0 @@
-import { type SpawnOptions, type SpawnSyncOptions } from 'node:child_process';
-import type { GuestSession, SandboxStatus } from '../core/types.js';
-import type { BootProgressT } from '../shared/schema.js';
-export declare const isWin: boolean;
-export declare const dryRun: boolean;
-/** Real provisioning, but nothing machine-wide (environment variables): for end-to-end tests outside a sandbox. */
-export declare const testMode: boolean;
-export declare const launchDir: string;
-export declare const dataDir: string;
-export declare const hostToolsDir: string;
-/** Folders that must stay on the sandbox's own disk (symlinks, SQLite) rather than in a mapped folder. */
-export declare const localDir: string;
-export declare const toolsDir: string;
-export declare const logsDir: string;
-export declare const run: {
-    run: string;
-    sandbox: string;
-    requests: string;
-    responses: string;
-    sessions: string;
-    projects: string;
-    audit: string;
-    request: (id: string) => string;
-    response: (id: string) => string;
-    session: (id: string) => string;
-    project: (id: string) => string;
-};
-export declare const session: GuestSession;
-export declare const workspace: string;
-export declare const stateDir: string;
-export declare const claudeDir: string;
-export declare const log: (message: string) => void;
-export declare const warn: (message: string) => void;
-export declare const errMsg: (e: unknown) => string;
-export declare const exists: (p: string) => boolean;
-export declare const mkdirp: (p: string) => string;
-export declare const logPath: string;
-/**
- * Best-effort: progress reporting must never be what breaks the boot. `update` changes the structured progress
- * (a new step, what is being set up); it stays as it was otherwise.
- */
-export declare const setSandboxStatus: (phase: SandboxStatus["phase"], message: string, update?: Partial<BootProgressT>) => void;
-/** Runs a program, streaming output, and throws with a readable message when it fails. */
-export declare const exec: (file: string, args: string[], options?: SpawnSyncOptions) => void;
-/** exec without blocking: other toolchains keep downloading while this one runs an installer. */
-export declare const execAsync: (file: string, args: string[], options?: SpawnOptions) => Promise<void>;
-export declare const execOutput: (file: string, args: string[], options?: SpawnSyncOptions) => string;
-export declare const powershell: (script: string) => void;
-/** Copies a folder with robocopy (fast, restartable), or just the named files in it; exit codes below 8 mean success. */
-export declare const robocopy: (from: string, to: string, files?: string[]) => void;
-/**
- * A Node install without its global packages (nvm keeps those per version: often tens of thousands of small files,
- * which is what made copying from this PC slow). Same file list as Copy-NodeFromHost in sandbox/bootstrap.ps1.
- * Copied into a staging folder and renamed into place: node.exe alone (an interrupted copy) must not look like a full install.
- */
-export declare const copyNode: (from: string, to: string) => void;

package/dist/guest/env.js

@@ -1,115 +0,0 @@
-// Shared state for the guest scripts (main, daemon, view): fixed paths, the session description, logging, status.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { moveIntoPlace, setChecksumRequired, spawnAsync, stagingFolder } from '../shared/download.js';
-import { now, runPaths, writeJsonAtomic } from '../shared/rundir.js';
-import { safeRemove } from '../shared/safe-remove.js';
-import { SYSTEM } from '../shared/system.js';
-export const isWin = process.platform === 'win32';
-export const dryRun = process.env.AGENT_DRY_RUN === '1';
-/** Real provisioning, but nothing machine-wide (environment variables): for end-to-end tests outside a sandbox. */
-export const testMode = process.env.AGENT_SANDBOX_TEST === '1';
-export const launchDir = process.env.AGENT_LAUNCH_DIR ?? 'C:\\AgentLaunch';
-export const dataDir = process.env.AGENT_DATA_DIR ?? 'C:\\AgentData';
-export const hostToolsDir = process.env.AGENT_HOST_TOOLS_DIR ?? 'C:\\HostTools';
-/** Folders that must stay on the sandbox's own disk (symlinks, SQLite) rather than in a mapped folder. */
-export const localDir = process.env.AGENT_LOCAL_DIR ?? 'C:\\nvm';
-export const toolsDir = path.join(dataDir, 'tools');
-export const logsDir = path.join(dataDir, 'logs');
-export const run = runPaths(dataDir);
-export const session = JSON.parse(fs.readFileSync(path.join(launchDir, 'session.json'), 'utf8').replace(/^\uFEFF/, ''));
-setChecksumRequired(session.downloads?.requireChecksum === true);
-export const workspace = process.env.AGENT_WORKSPACE ?? session.workspace;
-export const stateDir = path.join(dataDir, session.persistAgentState ? 'state' : 'state-session');
-export const claudeDir = path.join(stateDir, 'claude');
-fs.mkdirSync(logsDir, { recursive: true });
-const logFile = path.join(logsDir, (process.env.AGENT_LOG_PREFIX ?? 'guest') + '-' + new Date().toISOString().replace(/[:.]/g, '-') + '.log');
-const append = (line) => { try {
-    fs.appendFileSync(logFile, line + '\n');
-}
-catch { /* logging must never break the run */ } };
-export const log = (message) => { console.log(message); append(message); };
-export const warn = (message) => { console.warn('\x1b[33mWARNING: ' + message + '\x1b[0m'); append('WARNING: ' + message); };
-export const errMsg = (e) => (e instanceof Error ? e.message : String(e));
-export const exists = (p) => fs.existsSync(p);
-export const mkdirp = (p) => { fs.mkdirSync(p, { recursive: true }); return p; };
-export const logPath = logFile;
-/** The boot's structured progress (the host shows it as one line); kept between status writes. */
-let progress;
-/**
- * Best-effort: progress reporting must never be what breaks the boot. `update` changes the structured progress
- * (a new step, what is being set up); it stays as it was otherwise.
- */
-export const setSandboxStatus = (phase, message, update) => {
-    try {
-        if (update)
-            progress = fitProgress({ step: 1, steps: 1, title: '', active: [], done: 0, total: 0, ...progress, ...update });
-        writeJsonAtomicChecked(phase, message);
-    }
-    catch (e) {
-        warn('Could not update sandbox status: ' + errMsg(e));
-    }
-};
-/** Within the limits the host accepts (it drops a progress that is not). */
-const fitProgress = (p) => ({
-    ...p, title: p.title.slice(0, 120), done: Math.min(p.done, 1000), total: Math.min(p.total, 1000),
-    active: p.active.slice(0, 8).map((a) => ({ name: a.name.slice(0, 64), ...(a.percent === undefined ? {} : { percent: Math.max(0, Math.min(100, Math.round(a.percent))) }) })),
-});
-const ownAddresses = () => Object.values(os.networkInterfaces()).flat().filter((i) => Boolean(i) && i.family === 'IPv4' && !i.internal).map((i) => i.address).slice(0, 8);
-const writeJsonAtomicChecked = (phase, message) => {
-    writeJsonAtomic(run.sandbox, { launchId: session.launchId, phase, message, updatedAt: now(), workspaceHost: session.workspaceHost, guestWorkspace: workspace, headless: session.headless, addresses: ownAddresses(), ...(progress ? { progress } : {}) });
-};
-/** Runs a program, streaming output, and throws with a readable message when it fails. */
-export const exec = (file, args, options = {}) => {
-    const result = spawnSync(file, args, { stdio: 'inherit', windowsHide: true, ...options });
-    if (result.error)
-        throw result.error;
-    if (result.status !== 0)
-        throw new Error(path.basename(file) + ' ' + args.slice(0, 3).join(' ') + ' failed with exit code ' + result.status);
-};
-/** exec without blocking: other toolchains keep downloading while this one runs an installer. */
-export const execAsync = async (file, args, options = {}) => {
-    const code = await spawnAsync(file, args, { stdio: 'inherit', ...options });
-    if (code !== 0)
-        throw new Error(path.basename(file) + ' ' + args.slice(0, 3).join(' ') + ' failed with exit code ' + code);
-};
-export const execOutput = (file, args, options = {}) => {
-    const result = spawnSync(file, args, { encoding: 'utf8', windowsHide: true, ...options });
-    return result.status === 0 ? String(result.stdout ?? '').trim() : '';
-};
-export const powershell = (script) => exec(SYSTEM.powershell(), ['-NoLogo', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script]);
-/** Copies a folder with robocopy (fast, restartable), or just the named files in it; exit codes below 8 mean success. */
-export const robocopy = (from, to, files = []) => {
-    if (!isWin) {
-        if (!files.length) {
-            fs.cpSync(from, to, { recursive: true });
-            return;
-        }
-        fs.mkdirSync(to, { recursive: true });
-        for (const f of files.filter((f) => fs.existsSync(path.join(from, f))))
-            fs.copyFileSync(path.join(from, f), path.join(to, f));
-        return;
-    }
-    const what = files.length ? files : ['/E', '/MT:16'];
-    const result = spawnSync(SYSTEM.robocopy(), [from, to, ...what, '/NFL', '/NDL', '/NJH', '/NJS', '/NP', '/R:1', '/W:1', '/XJ'], { stdio: 'ignore', windowsHide: true });
-    if ((result.status ?? 16) >= 8)
-        throw new Error('robocopy ' + from + ' -> ' + to + ' failed (exit ' + result.status + ')');
-};
-/**
- * A Node install without its global packages (nvm keeps those per version: often tens of thousands of small files,
- * which is what made copying from this PC slow). Same file list as Copy-NodeFromHost in sandbox/bootstrap.ps1.
- * Copied into a staging folder and renamed into place: node.exe alone (an interrupted copy) must not look like a full install.
- */
-export const copyNode = (from, to) => {
-    const work = stagingFolder(to);
-    try {
-        robocopy(from, work, ['node.exe', 'npm', 'npm.cmd', 'npx', 'npx.cmd']);
-        robocopy(path.join(from, 'node_modules', 'npm'), path.join(work, 'node_modules', 'npm'));
-        moveIntoPlace(work, to);
-    }
-    finally {
-        safeRemove(work, path.dirname(work));
-    }
-};