windows-development-sandbox 1.4.0 → 1.4.3

package/dist/host/channel.js

@@ -1,162 +0,0 @@
-// Host side of the sandbox channel: follow the boot and send requests (sessions, exec, restart, ping). Attaching a
-// terminal to a session is in attach.ts. Everything read from the run folder is guest-written and treated as untrusted.
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import { assertNoLinks, fail, isLink, removeLink, safeText, sleep } from '../core/util.js';
-import { isWithin } from '../shared/projects.js';
-import { listSessions, now, readProjectStatus, readResponse, readSandboxStatus, readSession, runPaths, writeJsonAtomic } from '../shared/rundir.js';
-import { safeRemove } from '../shared/safe-remove.js';
-import { assertTestWritable, refuseInSelfTest } from './test-guard.js';
-const BOOT_TIMEOUT_MS = 30 * 60 * 1000;
-const id = () => Date.now().toString(36) + crypto.randomBytes(3).toString('hex');
-const until = async (timeoutMs, isAlive, poll, timeoutMessage) => {
-    const deadline = Date.now() + timeoutMs;
-    for (let round = 0; Date.now() < deadline; round++) {
-        const value = poll();
-        if (value !== null && value !== undefined)
-            return value;
-        if (round % 10 === 0 && !isAlive())
-            fail('Windows Sandbox closed (or is not running).', 'Start it again with sandbox claude; sandbox logs shows what happened.');
-        await sleep(500);
-    }
-    fail(timeoutMessage, 'Check what the sandbox is doing with sandbox logs -f (or sbx-show to see its window).');
-};
-const printLine = (line) => console.log(line);
-/** Waits until the sandbox finished provisioning, reporting each boot step. */
-export const waitForReady = (dataPath, launchId, isAlive, progress = (m) => printLine('  [sandbox] ' + m)) => {
-    let last = '';
-    return until(BOOT_TIMEOUT_MS, isAlive, () => {
-        const status = readSandboxStatus(dataPath);
-        if (!status || (launchId !== null && status.launchId !== launchId))
-            return null;
-        if (status.message !== last) {
-            progress(safeText(status.message).slice(0, 300));
-            last = status.message;
-        }
-        if (status.phase === 'failed')
-            fail('The sandbox failed to start: ' + status.message, 'See sandbox logs for details; the sandbox window shows the error too (sbx-show if headless).');
-        return status.phase === 'ready' ? status : null;
-    }, 'Timed out waiting for the sandbox to finish provisioning.');
-};
-export const sendRequest = (dataPath, request) => {
-    assertTestWritable(dataPath);
-    // Asking the sandbox to power off is the one request with an effect outside it, so the self-test never sends it.
-    if (request.kind === 'exec' && /shutdown/i.test(request.command[0] ?? ''))
-        refuseInSelfTest('shut down Windows Sandbox');
-    assertNoLinks(dataPath, runPaths(dataPath).requests);
-    writeJsonAtomic(runPaths(dataPath).request(request.id), request);
-};
-export const waitForResponse = (dataPath, requestId, isAlive, timeoutMs) => until(timeoutMs, isAlive, () => {
-    const response = readResponse(dataPath, requestId);
-    if (response)
-        try {
-            assertNoLinks(dataPath, runPaths(dataPath).responses);
-            fs.rmSync(runPaths(dataPath).response(requestId), { force: true });
-        }
-        catch { /* a planted link: the answer is read, nothing is deleted */ }
-    return response;
-}, 'The sandbox did not answer (its session daemon may have stopped).');
-/** project: a project registered after boot (provisioned first). harnessSpec: the agent's definition, for an agent the sandbox did not boot with. */
-export const requestSession = (dataPath, harness, args, cwd, extra = {}) => {
-    const requestId = id();
-    sendRequest(dataPath, { kind: 'session', id: requestId, harness, args, cwd, ...(extra.project ? { project: extra.project } : {}), ...(extra.harnessSpec ? { harnessSpec: extra.harnessSpec } : {}), createdAt: now() });
-    return requestId;
-};
-/**
- * Provisions a registered project without starting an agent and waits for it, printing its progress (the guest's
- * run\projects\<name>.json) as it goes. Throws when it failed.
- */
-export const prepareProject = async (dataPath, project, isAlive, progress = (m) => printLine('  [' + project.name + '] ' + m)) => {
-    const requestId = id();
-    sendRequest(dataPath, { kind: 'project', id: requestId, project, createdAt: now() });
-    let last = '';
-    const response = await until(60 * 60 * 1000, isAlive, () => {
-        const status = readProjectStatus(dataPath, project.name);
-        if (status && status.message !== last) {
-            progress(safeText(status.message).slice(0, 300));
-            last = status.message;
-        }
-        return readResponse(dataPath, requestId);
-    }, 'Timed out waiting for the project to be set up.');
-    try {
-        assertNoLinks(dataPath, runPaths(dataPath).responses);
-        fs.rmSync(runPaths(dataPath).response(requestId), { force: true });
-    }
-    catch { /* read, nothing deleted */ }
-    if (!response.ok)
-        fail(safeText(response.message), 'See sandbox logs for details.');
-    return response;
-};
-export const waitForSession = (dataPath, sessionId, isAlive, timeoutMs = 15 * 60 * 1000, progress = (m) => printLine('  [session] ' + m)) => {
-    let last = '';
-    return until(timeoutMs, isAlive, () => {
-        const session = readSession(dataPath, sessionId);
-        if (!session)
-            return null;
-        if (session.message !== last) {
-            progress(safeText(session.message).slice(0, 300));
-            last = session.message;
-        }
-        if (session.phase === 'failed')
-            fail('The agent session failed to start: ' + session.message, 'See sandbox logs for details.');
-        if (session.phase === 'exited')
-            fail('The agent exited right away (code ' + session.exitCode + ').', 'Check sandbox logs; a wrong agent argument is the usual cause.');
-        return session.phase === 'running' ? session : null;
-    }, 'Timed out waiting for the session to start.');
-};
-/** Runs a command inside the sandbox (in the workspace or a folder below it) and returns its output. */
-export const execInSandbox = async (dataPath, command, cwd, timeoutSeconds, isAlive) => {
-    const requestId = id();
-    sendRequest(dataPath, { kind: 'exec', id: requestId, command, cwd, timeoutSeconds, createdAt: now() });
-    return waitForResponse(dataPath, requestId, isAlive, (timeoutSeconds + 30) * 1000);
-};
-/** Restarts running sessions in place (they resume via the harness's resumeArguments, e.g. claude --continue). */
-export const restartSessions = async (dataPath, harness, isAlive, cwd) => {
-    const requestId = id();
-    sendRequest(dataPath, { kind: 'restart', id: requestId, harness, ...(cwd ? { cwd } : {}), createdAt: now() });
-    return waitForResponse(dataPath, requestId, isAlive, 30000);
-};
-export const pingSandbox = async (dataPath, isAlive) => {
-    const requestId = id();
-    sendRequest(dataPath, { kind: 'ping', id: requestId, createdAt: now() });
-    return waitForResponse(dataPath, requestId, isAlive, 15000);
-};
-export const runningSessions = (dataPath) => listSessions(dataPath).filter((s) => s.phase === 'running');
-/** Most sessions the host will ever contact for one listing: a sandbox can write as many session files as it likes. */
-export const MAX_QUERIED_SESSIONS = 32;
-/** Running sessions of the sandbox that is running now (its launch id), newest last, capped. */
-export const currentSessions = (dataPath) => {
-    const launchId = readSandboxStatus(dataPath)?.launchId;
-    return runningSessions(dataPath).filter((s) => s.launchId === launchId).slice(-MAX_QUERIED_SESSIONS);
-};
-/** Sessions in this guest folder or below (one project's) first, each group newest first. */
-export const sessionsFirstIn = (sessions, guestDir) => {
-    const newest = [...sessions].reverse();
-    if (!guestDir)
-        return newest;
-    return [...newest.filter((s) => isWithin(guestDir, s.cwd)), ...newest.filter((s) => !isWithin(guestDir, s.cwd))];
-};
-/**
- * The session with this id (or id prefix), else the most recently started running one: in `guestDir` (the project
- * you are in) when it has one, else any.
- */
-export const pickSession = (dataPath, sessionId, guestDir = null) => {
-    const running = runningSessions(dataPath);
-    if (running.length === 0)
-        fail('No agent session is running in the sandbox.', 'Start one with sandbox claude (it opens a new session in the running sandbox).');
-    if (!sessionId)
-        return sessionsFirstIn(running, guestDir)[0];
-    return running.find((s) => s.id === sessionId || s.id.startsWith(sessionId)) ?? fail('No running session "' + sessionId + '".', 'Running sessions: ' + running.map((s) => s.id).join(', ') + ' (sandbox sessions lists them).');
-};
-/** Forgets status from a previous sandbox run so nothing stale is picked up. */
-export const resetRunDir = (dataPath) => {
-    const p = runPaths(dataPath);
-    // A link (planted by a sandbox) is removed itself and never followed, including `run` itself.
-    if (isLink(p.run)) {
-        removeLink(p.run);
-        return;
-    }
-    for (const target of [p.sandbox, p.requests, p.responses, p.sessions, p.projects]) {
-        safeRemove(target, dataPath);
-    }
-};

package/dist/host/generate.d.ts

@@ -1,13 +0,0 @@
-import type { GenerateOptions, Generated } from '../core/types.js';
-import { decideToolchains } from '../core/detect-toolchains.js';
-/** Which toolchains the project needs ("auto" settings follow the project's files and what this PC has). */
-export declare const decideProjectToolchains: (o: Pick<GenerateOptions, "run" | "pcLanguages">) => ReturnType<typeof decideToolchains>;
-/**
- * env.cmd, which logon.cmd calls before it opens Windows Terminal: Terminal expands "%AGENT_WORKSPACE%" (the starting
- * folder of new tabs) from its own environment, and the runtime only sets the variable machine-wide after Terminal
- * started. `%` is doubled for cmd; a Windows path holds no quotes.
- */
-export declare const logonEnv: (workspace: string) => string;
-export declare const generateSandbox: (o: GenerateOptions) => Generated & {
-    personalization: string;
-};

package/dist/host/generate.js

@@ -1,108 +0,0 @@
-// Writes a launch folder for one sandbox: session.json (what the guest needs to know), the bundled runtime, hooks, the
-// staged Claude settings and the .wsb file that starts Windows Sandbox. The pieces live in launch/.
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { decideToolchains, resolveToolchains } from '../core/detect-toolchains.js';
-import { readPwshScripts, usesPwsh } from '../core/detect-pwsh.js';
-import { dirExists, ensureDir, fail, writeJson } from '../core/util.js';
-import { substDrives } from '../shared/guest-paths.js';
-import { PROJECTS_GUEST, hubName } from '../shared/projects.js';
-import { planBootProjects } from './launch/projects.js';
-import { hostClaudeDir, stageClaudeProfile } from './claude-profile.js';
-import { databaseCatalog, planDatabases } from './database-plan.js';
-import { collectMappings } from './launch/mappings.js';
-import { copyRuntime, stageGitIdentity, stageHooks } from './launch/stage.js';
-import { buildWsb, resolveMemoryMb } from './launch/wsb.js';
-import { capturePersonalization } from './personalize.js';
-import { pcLanguages } from './pc-scan.js';
-import { msvcHint, projectEntries } from './project-scan.js';
-import { assertTestWritable } from './test-guard.js';
-const NO_PROFILE = { hostDir: null, staged: [], skipped: [], credentials: false, secretsRemoved: [] };
-/** Which toolchains the project needs ("auto" settings follow the project's files and what this PC has). */
-export const decideProjectToolchains = (o) => {
-    const { config, workspaceHost } = o.run;
-    const msvcScript = config.toolchains.msvc.enabled === 'auto' ? msvcHint(workspaceHost) : undefined;
-    const pwshScript = config.toolchains.pwsh.enabled === 'auto' ? usesPwsh(readPwshScripts(workspaceHost)) : null;
-    const hints = { ...(msvcScript ? { msvc: msvcScript } : {}), ...(pwshScript ? { pwsh: pwshScript } : {}) };
-    return decideToolchains(config.toolchains, projectEntries(workspaceHost), o.pcLanguages ?? pcLanguages(), hints);
-};
-/** What was found on this PC to copy instead of download. */
-const hostToolsOf = (probe) => ({
-    node: Boolean(probe.nodeDir),
-    nodeVersion: probe.nodeDir || probe.nvmNode ? probe.hostNodeVersion.replace(/^v/, '') : null,
-    harnessExecutable: probe.harnessExe?.file ?? null,
-    git: Boolean(probe.gitDir),
-    nvm: Boolean(probe.nvmDir),
-    volta: Boolean(probe.volta),
-    pyenv: Boolean(probe.pyenv),
-});
-/**
- * env.cmd, which logon.cmd calls before it opens Windows Terminal: Terminal expands "%AGENT_WORKSPACE%" (the starting
- * folder of new tabs) from its own environment, and the runtime only sets the variable machine-wide after Terminal
- * started. `%` is doubled for cmd; a Windows path holds no quotes.
- */
-export const logonEnv = (workspace) => '@set "AGENT_WORKSPACE=' + workspace.replace(/[\r\n"]/g, '').replace(/%/g, '%%') + '"\r\n';
-export const generateSandbox = (o) => {
-    const { config, dataPath, workspaceHost, harnessName, storageRoot } = o.run;
-    const harness = harnessName === 'none' ? null : config.harnesses[harnessName] ?? fail('Unknown agent: ' + harnessName, 'Configured agents: ' + Object.keys(config.harnesses).join(', '));
-    if (!dirExists(workspaceHost))
-        fail('The workspace folder does not exist: ' + workspaceHost, 'cd into the project first.');
-    assertTestWritable(storageRoot);
-    assertTestWritable(dataPath);
-    // Checked before anything is written, so a refusal leaves nothing behind.
-    const memoryMb = resolveMemoryMb(config.sandbox, o.freeMemoryBytes);
-    const launchId = Date.now() + '-' + crypto.randomBytes(3).toString('hex');
-    const launchPath = path.join(storageRoot, 'launches', launchId);
-    ensureDir(launchPath);
-    ensureDir(dataPath);
-    const boot = planBootProjects({ run: o.run, packageRoot: o.packageRoot, extraProjects: o.extraProjects, knownProjects: o.knownProjects });
-    const mappings = collectMappings(o, launchPath, boot);
-    const profile = harnessName === 'claude' ? stageClaudeProfile(config.claudeProfile, launchPath, workspaceHost, config.secrets) : NO_PROFILE;
-    stageGitIdentity(launchPath);
-    const personalization = config.personalization.enabled ? capturePersonalization(launchPath) : 'disabled';
-    const databases = o.databases ?? planDatabases(config.databases, workspaceHost);
-    const toolchainDecisions = decideProjectToolchains(o);
-    const session = {
-        launchId,
-        project: path.basename(workspaceHost),
-        projectId: hubName(workspaceHost, []),
-        workspace: config.guestWorkspace,
-        workspaceHost,
-        projectsDir: PROJECTS_GUEST,
-        roots: boot.roots.map((r) => r.guest),
-        ...(o.autoSession === false ? { autoSession: false } : {}),
-        harnessName,
-        harness,
-        harnessArguments: o.harnessArgs,
-        persistAgentState: config.storage.persistAgentState,
-        networking: config.sandbox.networking,
-        headless: config.sandbox.headless,
-        network: config.network,
-        provisioning: config.provisioning,
-        // "auto" is decided here, so the guest and the launch table agree.
-        toolchains: resolveToolchains(config.toolchains, toolchainDecisions),
-        databases,
-        databaseCatalog: databaseCatalog(config.databases),
-        versions: o.run.versions,
-        attach: config.attach,
-        hooks: config.hooks,
-        downloads: config.downloads,
-        hostTools: hostToolsOf(o.probe),
-        claudeProfile: { overwrite: config.claudeProfile.overwrite, items: profile.staged, credentials: profile.credentials, hostConfigDir: profile.hostDir ?? hostClaudeDir(config.claudeProfile), syncClaudeMem: config.claudeProfile.syncClaudeMem },
-        personalization: fs.existsSync(path.join(launchPath, 'personalize', 'personalize.reg')),
-        substDrives: substDrives(mappings.map((m) => m.guest)),
-        cpuLimitPercent: config.sandbox.cpuLimit === 'none' ? null : config.sandbox.cpuLimit,
-        pageFileMb: config.sandbox.pageFileMb,
-        apps: config.apps,
-        auditProcesses: config.audit.enabled && config.audit.processes,
-    };
-    const sessionPath = path.join(launchPath, 'session.json');
-    writeJson(sessionPath, session);
-    fs.writeFileSync(path.join(launchPath, 'env.cmd'), logonEnv(session.workspace), 'utf8');
-    copyRuntime(o.packageRoot, launchPath);
-    stageHooks(o.packageRoot, launchPath, o.run.scripts);
-    const wsbPath = path.join(launchPath, 'agent.wsb');
-    fs.writeFileSync(wsbPath, buildWsb(config, memoryMb, mappings), 'utf8');
-    return { wsbPath, launchPath, launchId, sessionPath, memoryMb, mappings, profile, personalization, databases, toolchains: toolchainDecisions, projects: boot };
-};

package/dist/host/join.d.ts

@@ -1,28 +0,0 @@
-import type { ResolvedRun } from '../core/types.js';
-import { type ProjectSpecT } from '../shared/schema.js';
-import { type ProjectMapper, type RegistryEntry } from './projects.js';
-/** The launch folder of the running sandbox (host-only storage; its id comes from the guest, so it is checked). */
-export declare const runningLaunchPath: (storageRoot: string, dataPath: string) => string | null;
-/** What a session or command from this folder needs: where it is inside, and (for another project) its spec. */
-export interface Joined {
-    project: RegistryEntry;
-    guestDir: string;
-    spec: ProjectSpecT | null;
-    run: ResolvedRun | null;
-    notes: string[];
-}
-/** The project spec the guest provisions from (scans the project folder like a launch does). */
-export declare const projectSpec: (run: ResolvedRun, entry: RegistryEntry, hooks: boolean) => ProjectSpecT;
-/**
- * Makes `hostDir` usable in the running sandbox. The launch folder (or a folder below it) needs nothing; any other
- * folder is resolved with `resolve` (the caller's resolveRun, with the approval prompt), checked, and registered.
- */
-export declare const joinRunning: (o: {
-    storageRoot: string;
-    dataPath: string;
-    packageRoot: string;
-    hostDir: string;
-    wsbShare: boolean;
-    resolve: (projectRoot: string) => Promise<ResolvedRun>;
-    mapper?: ProjectMapper;
-}) => Promise<Joined>;

package/dist/host/join.js

@@ -1,76 +0,0 @@
-// Joining the running sandbox from another folder. The folder's run is resolved exactly as a fresh launch would
-// resolve it (its approved .sandbox-config.json, versions, toolchain detection, database plan), checked against the
-// running sandbox's machine-wide protections, made visible inside (host/projects.ts: a project root, a project
-// mapped at boot, or wsb share) and described to the guest, which provisions what is missing before its session.
-// When none of those can make it visible, NeedsRestart reaches the caller, which offers a restart.
-import fs from 'node:fs';
-import path from 'node:path';
-import { checkJoin, protectionsOf } from '../core/project-policy.js';
-import { resolveToolchains } from '../core/detect-toolchains.js';
-import { assertNoLinks, fail } from '../core/util.js';
-import { Id } from '../shared/schema.js';
-import { readSandboxStatus } from '../shared/rundir.js';
-import { syncProjectIn } from '../sync/watcher.js';
-import { planDatabases } from './database-plan.js';
-import { decideProjectToolchains } from './generate.js';
-import { projectHere, projectMapper, readRegistry, rememberProject, rootHere } from './projects.js';
-import { stageScripts } from './launch/stage.js';
-import { addRepoSnapshot } from './repo-guard.js';
-/** The launch folder of the running sandbox (host-only storage; its id comes from the guest, so it is checked). */
-export const runningLaunchPath = (storageRoot, dataPath) => {
-    const launchId = readSandboxStatus(dataPath)?.launchId;
-    if (!launchId || !/^\d+-[0-9a-f]{6}$/.test(launchId) || readRegistry(storageRoot)?.launchId !== launchId)
-        return null;
-    const launchPath = path.join(storageRoot, 'launches', launchId);
-    assertNoLinks(storageRoot, launchPath);
-    return fs.existsSync(path.join(launchPath, 'session.json')) ? launchPath : null;
-};
-/** The project spec the guest provisions from (scans the project folder like a launch does). */
-export const projectSpec = (run, entry, hooks) => {
-    const { config } = run;
-    const toolchains = resolveToolchains(config.toolchains, decideProjectToolchains({ run }));
-    const harness = run.harnessName === 'none' ? null : config.harnesses[run.harnessName];
-    return {
-        name: Id.parse(entry.name), workspace: entry.guest, workspaceHost: entry.host, toolchains, versions: run.versions,
-        databases: planDatabases(config.databases, run.workspaceHost).slice(0, 8),
-        harnesses: harness ? { [run.harnessName]: harness } : {},
-        hooks,
-    };
-};
-/**
- * Makes `hostDir` usable in the running sandbox. The launch folder (or a folder below it) needs nothing; any other
- * folder is resolved with `resolve` (the caller's resolveRun, with the approval prompt), checked, and registered.
- */
-export const joinRunning = async (o) => {
-    const here = projectHere(o.storageRoot, o.hostDir);
-    if (here?.project.primary)
-        return { ...here, spec: null, run: null, notes: [] };
-    const registry = readRegistry(o.storageRoot) ?? fail('The running sandbox was started by an older version, so it cannot take another folder.', 'Stop it (sandbox stop) and start it again.');
-    // A folder below a project already in the sandbox uses that project; anything else becomes a project of its own.
-    const root = here?.project.host ?? path.resolve(o.hostDir);
-    const run = await o.resolve(root);
-    const check = checkJoin(registry.protections, protectionsOf(run.config));
-    if (check.stricter.length) {
-        fail('This project needs stricter protection than the running sandbox has, and those settings are machine-wide:\n  ' + check.stricter.join('\n  '), 'Its sessions cannot get them without changing them for the sessions already running. Stop the sandbox (sandbox stop) and start it from ' + root + '.');
-    }
-    const mapper = o.mapper ?? projectMapper({ storageRoot: o.storageRoot, packageRoot: o.packageRoot, wsbShare: o.wsbShare });
-    // Guarded from now on. A folder the sandbox could already write (inside a root, or mapped at boot) and that has no
-    // snapshot from the launch gets an empty one: what is there now may have been planted, so it counts as new.
-    // Anything else is snapshotted before it becomes visible.
-    addRepoSnapshot(o.dataPath, root, { empty: Boolean(here) || Boolean(rootHere(o.storageRoot, root)) });
-    const entry = mapper.register(root);
-    rememberProject(o.storageRoot, entry.host);
-    const launchPath = runningLaunchPath(o.storageRoot, o.dataPath);
-    // Your hooks in ~/.agent-sandbox/hooks ran at boot (once per sandbox); the project's own scripts ("scripts" in its
-    // .sandbox-config.json, --script) run before its first agent. The launch folder is read-only for the sandbox, but
-    // this side can still add them to it.
-    const hooks = Boolean(launchPath) && run.scripts.length > 0;
-    if (launchPath && hooks)
-        stageScripts(path.join(launchPath, 'projects', entry.name, 'hooks', 'pre-agent'), run.scripts);
-    try {
-        syncProjectIn(o.dataPath, { hostWorkspace: entry.host, guestWorkspace: entry.guest });
-    }
-    catch { /* history is a convenience; never block the session */ }
-    const notes = [...run.notes, ...check.looser.map((l) => 'The running sandbox is stricter: ' + l + '.')];
-    return { project: entry, guestDir: here ? here.guestDir : entry.guest, spec: projectSpec(run, entry, hooks), run, notes };
-};

package/dist/host/launch/projects.d.ts

@@ -1,15 +0,0 @@
-import type { ResolvedRun } from '../../core/types.js';
-import { type RootMapping } from '../../shared/projects.js';
-/** More folders than this would make the .wsb (and every boot) unwieldy; the rest join with a restart later. */
-export declare const MAX_BOOT_PROJECTS = 48;
-export interface BootProjects {
-    roots: RootMapping[];
-    projects: RootMapping[];
-    notes: string[];
-}
-export declare const planBootProjects: (o: {
-    run: ResolvedRun;
-    packageRoot: string;
-    extraProjects?: string[];
-    knownProjects?: string[];
-}) => BootProjects;

package/dist/host/launch/wsb.js

@@ -1,34 +0,0 @@
-// The .wsb file Windows Sandbox starts from: memory, devices and the folders mapped in.
-import os from 'node:os';
-import { fail, xmlEscape } from '../../core/util.js';
-import { MIRROR_ROOT, sandboxFolder } from '../../shared/guest-paths.js';
-export const GUEST = { launch: 'C:\\AgentLaunch', data: 'C:\\AgentData', hostTools: 'C:\\HostTools', mirror: MIRROR_ROOT };
-const toggle = (value) => (value ? 'Enable' : 'Disable');
-/** "auto": free RAM minus the reserve, but never more than maxMemoryMb or maxMemoryPercent of the PC's total RAM. */
-export const resolveMemoryMb = (sandbox, freeMemoryBytes = os.freemem(), totalMemoryBytes = os.totalmem()) => {
-    if (sandbox.memoryMb !== 'auto')
-        return sandbox.memoryMb;
-    const freeMb = Math.floor(freeMemoryBytes / 1048576);
-    const shareMb = Math.floor((totalMemoryBytes / 1048576) * sandbox.maxMemoryPercent / 100);
-    const rounded = Math.floor(Math.min(sandbox.maxMemoryMb, shareMb, freeMb - sandbox.reserveHostMb) / 1024) * 1024;
-    if (rounded < 4096)
-        fail('Not enough free RAM for the sandbox (' + freeMb + ' MB free, ' + sandbox.reserveHostMb + ' MB kept for this PC).', 'Close some apps, lower sandbox.reserveHostMb, or set sandbox.memoryMb to a fixed value (>= 4096).');
-    return rounded;
-};
-export const buildWsb = (config, memoryMb, mappings) => {
-    const s = config.sandbox;
-    // Guest paths on other drive letters (F:\x) really live under C:\Mirror\F; bootstrap.ps1 substs F: onto it at boot.
-    const folders = mappings.map((m) => '<MappedFolder><HostFolder>' + xmlEscape(m.host) + '</HostFolder><SandboxFolder>' + xmlEscape(sandboxFolder(m.guest)) + '</SandboxFolder><ReadOnly>' + String(m.readOnly) + '</ReadOnly></MappedFolder>').join('');
-    return '<Configuration>'
-        + '<MemoryInMB>' + memoryMb + '</MemoryInMB>'
-        + '<vGPU>' + toggle(s.vGpu) + '</vGPU>'
-        + '<Networking>' + toggle(s.networking) + '</Networking>'
-        + '<ClipboardRedirection>' + toggle(s.clipboard) + '</ClipboardRedirection>'
-        + '<AudioInput>' + toggle(s.audioInput) + '</AudioInput>'
-        + '<VideoInput>' + toggle(s.videoInput) + '</VideoInput>'
-        + '<PrinterRedirection>' + toggle(s.printerRedirection) + '</PrinterRedirection>'
-        + '<ProtectedClient>' + toggle(s.protectedClient) + '</ProtectedClient>'
-        + '<MappedFolders>' + folders + '</MappedFolders>'
-        + '<LogonCommand><Command>' + xmlEscape(GUEST.launch + '\\sandbox\\logon.cmd') + '</Command></LogonCommand>'
-        + '</Configuration>';
-};

package/dist/host/motw.d.ts

@@ -1,17 +0,0 @@
-/** What Windows runs when you open it (not source files such as .js or .py: those need a program you choose). */
-export declare const RISKY: RegExp;
-/** Marks one file if it is a program or script (and a plain file, not a link). Returns true when it marked it. */
-export declare const markFromSandbox: (file: string) => boolean;
-/** Has this file the mark? */
-export declare const isMarked: (file: string) => boolean;
-/** Watches the projects while the sandbox runs and marks what appears or changes; returns a function that stops it. */
-export declare const watchAndMark: (projects: string[], note?: (message: string) => void) => (() => void);
-/** The projects to watch and mark (empty: storage.markSandboxFiles is off). */
-export declare const saveMarkedProjects: (storageRoot: string, dataPath: string, projects: string[]) => void;
-export declare const readMarkedProjects: (storageRoot: string, dataPath: string) => string[];
-/** The data folder's size, measured by the watcher when a sandbox closes (measuring at launch would be slow). */
-export declare const saveDataSize: (storageRoot: string, dataPath: string, bytes: number) => void;
-export declare const readDataSize: (storageRoot: string, dataPath: string) => {
-    bytes: number;
-    at: string;
-} | null;

package/dist/host/motw.js

@@ -1,74 +0,0 @@
-// storage.markSandboxFiles: programs and scripts that appear or change in a project while a sandbox runs get Windows'
-// "downloaded from the internet" mark (the Zone.Identifier stream, zone 3). Running one on this PC then goes through
-// SmartScreen, and PowerShell's RemoteSigned policy refuses an unsigned marked script. So something an agent planted is
-// not run by a double-click or a habit. Runs in the background watcher; only the mark is written, never the file.
-import fs from 'node:fs';
-import path from 'node:path';
-import { z } from 'zod';
-import { readValid, writeJsonAtomic } from '../shared/rundir.js';
-/** What Windows runs when you open it (not source files such as .js or .py: those need a program you choose). */
-export const RISKY = /\.(exe|dll|com|scr|pif|msi|msix|msp|appx|appxbundle|bat|cmd|ps1|psm1|psd1|vbs|vbe|wsf|wsh|hta|lnk|url|jar|reg|cpl|application|gadget|chm)$/i;
-const MARK = '[ZoneTransfer]\r\nZoneId=3\r\nHostUrl=about:windows-development-sandbox\r\n';
-/** Folders not worth watching closely (git's own files; dependency and build folders are still marked). */
-const SKIP = /(^|[\\/])\.git([\\/]|$)/i;
-/** Marks one file if it is a program or script (and a plain file, not a link). Returns true when it marked it. */
-export const markFromSandbox = (file) => {
-    if (!RISKY.test(file) || SKIP.test(file))
-        return false;
-    try {
-        const stat = fs.lstatSync(file);
-        if (!stat.isFile())
-            return false;
-        fs.writeFileSync(file + ':Zone.Identifier', MARK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-/** Has this file the mark? */
-export const isMarked = (file) => {
-    try {
-        return fs.readFileSync(file + ':Zone.Identifier', 'utf8').includes('ZoneId=3');
-    }
-    catch {
-        return false;
-    }
-};
-/** Watches the projects while the sandbox runs and marks what appears or changes; returns a function that stops it. */
-export const watchAndMark = (projects, note = () => undefined) => {
-    const pending = new Set();
-    let timer;
-    const flush = () => {
-        timer = undefined;
-        const marked = [...pending].filter(markFromSandbox);
-        pending.clear();
-        if (marked.length)
-            note('marked as from the sandbox (SmartScreen asks before they run here): ' + marked.slice(0, 10).map((f) => path.basename(f)).join(', ') + (marked.length > 10 ? ' and ' + (marked.length - 10) + ' more' : ''));
-    };
-    const watchers = projects.flatMap((project) => {
-        try {
-            return [fs.watch(project, { recursive: true }, (_event, file) => {
-                    const rel = file ? String(file) : '';
-                    if (!rel || !RISKY.test(rel) || SKIP.test(rel))
-                        return;
-                    pending.add(path.join(project, rel));
-                    timer ??= setTimeout(flush, 1000);
-                })];
-        }
-        catch {
-            return [];
-        }
-    });
-    return () => { watchers.forEach((w) => w.close()); clearTimeout(timer); if (pending.size)
-        flush(); };
-};
-// ---- what the watcher marks, and the size of the persisted data (host-only files next to the sync state) ----------
-const marksFile = (storageRoot, dataPath) => path.join(storageRoot, 'sync', path.basename(dataPath) + '-mark.json');
-const sizeFile = (storageRoot, dataPath) => path.join(storageRoot, 'sync', path.basename(dataPath) + '-size.json');
-/** The projects to watch and mark (empty: storage.markSandboxFiles is off). */
-export const saveMarkedProjects = (storageRoot, dataPath, projects) => writeJsonAtomic(marksFile(storageRoot, dataPath), projects);
-export const readMarkedProjects = (storageRoot, dataPath) => readValid(z.array(z.string().max(1024)).max(64), marksFile(storageRoot, dataPath)) ?? [];
-/** The data folder's size, measured by the watcher when a sandbox closes (measuring at launch would be slow). */
-export const saveDataSize = (storageRoot, dataPath, bytes) => writeJsonAtomic(sizeFile(storageRoot, dataPath), { bytes, at: new Date().toISOString() });
-export const readDataSize = (storageRoot, dataPath) => readValid(z.object({ bytes: z.number().min(0), at: z.string().max(40) }), sizeFile(storageRoot, dataPath));

package/dist/host/pc-scan.d.ts

@@ -1,6 +0,0 @@
-import { type Database } from '../core/detect-databases.js';
-import { type AutoToolchain } from '../core/detect-toolchains.js';
-/** Languages this PC has (their commands on PATH; Windows' Store stubs for python do not count). */
-export declare const pcLanguages: () => AutoToolchain[];
-/** Database services installed on this PC (names from the service control manager; nothing is started or changed). */
-export declare const hostDatabases: () => Database[];

package/dist/host/personalize.d.ts

@@ -1,10 +0,0 @@
-export interface RegValue {
-    key: string;
-    name: string;
-    kind: string;
-    value: string | number | string[];
-}
-/** Formats captured values as a .reg file (UTF-16 friendly text; written as UTF-16LE with BOM). */
-export declare const toRegFile: (values: RegValue[]) => string;
-/** Writes personalize.reg (+ the wallpaper image) into `<launch>\personalize`. Returns a short summary. */
-export declare const capturePersonalization: (launchPath: string) => string;