windows-development-sandbox 1.0.5 → 1.1.0

package/dist/host/repo-guard.js

@@ -11,7 +11,10 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import _ from 'lodash';
-import { dirExists, fileExists, isLink, tryReadJson, writeJson } from '../core/util.js';
+import { z } from 'zod';
+import { readValid, writeFileAtomic, writeJsonAtomic } from '../shared/rundir.js';
+import { assertTestWritable } from './test-guard.js';
+import { dirExists, fileExists, isLink } from '../core/util.js';
 /** Config keys that make git run a program, or load more config. */
 const DANGEROUS_KEY = /^(fsmonitor|hookspath|sshcommand|pager|editor|askpass|program|gpgprogram|textconv|command|cmd|clean|smudge|process|driver|helper|uploadpack|receivepack|path|attributesfile|excludesfile|worktree|worktreeconfig|gitproxy|proxycommand|sendemailvalidate|tool)\s*=/i;
 const SECTION = /^\s*\[([^\]]*)\]\s*/;
@@ -30,7 +33,30 @@ const COMMANDS = new RegExp('^(' + [
     'make', 'cmake', 'ninja', 'gcc', 'g\\+\\+', 'clang', 'psql', 'mysql', 'mariadb', 'mongosh', 'redis-cli', 'docker', 'kubectl', 'terraform', 'az', 'aws',
     'powershell', 'pwsh', 'cmd', 'where', 'tasklist', 'tar', 'curl', 'ssh', 'scp',
 ].join('|') + ')\\.(exe|com|bat|cmd|vbs|vbe|js|jse|wsf|wsh|msc|ps1)$', 'i');
-const hash = (file) => (isLink(file) ? 'link' : crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex'));
+/** SHA-256 in small chunks: a sandbox can plant a multi-gigabyte "node.exe" to exhaust this PC's memory. */
+const hash = (file) => {
+    if (isLink(file))
+        return 'link';
+    const sum = crypto.createHash('sha256');
+    const buffer = Buffer.alloc(1 << 20);
+    let fd;
+    // A file that cannot be read (locked by a program in the sandbox) never matches the snapshot, so it is dealt with.
+    try {
+        fd = fs.openSync(file, 'r');
+    }
+    catch {
+        return 'unreadable-' + crypto.randomBytes(4).toString('hex');
+    }
+    try {
+        for (let n = fs.readSync(fd, buffer, 0, buffer.length, null); n > 0; n = fs.readSync(fd, buffer, 0, buffer.length, null))
+            sum.update(buffer.subarray(0, n));
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return sum.digest('hex');
+};
+const MAX_CONFIG_BYTES = 4 * 1024 * 1024;
 const plainGitDir = (workspace) => {
     const dir = path.join(workspace, '.git');
     return dirExists(dir) && !isLink(dir) ? dir : null;
@@ -40,7 +66,7 @@ const filesIn = (dir, accept) => dirExists(dir) && !isLink(dir)
     : {};
 const configLines = (dir) => {
     const file = path.join(dir, 'config');
-    return fileExists(file) && !isLink(file) ? fs.readFileSync(file, 'utf8').split(/\r?\n/) : [];
+    return fileExists(file) && !isLink(file) && fs.statSync(file).size <= MAX_CONFIG_BYTES ? fs.readFileSync(file, 'utf8').split(/\r?\n/) : [];
 };
 export const snapshotRepo = (workspace) => {
     const dir = plainGitDir(workspace);
@@ -59,7 +85,12 @@ const quarantine = (from, names, into, kind) => {
     const target = path.join(into, 'agent-sandbox-quarantine', String(Date.now()));
     fs.mkdirSync(target, { recursive: true });
     return names.map((name) => {
-        fs.renameSync(path.join(from, name), path.join(target, name));
+        try {
+            fs.renameSync(path.join(from, name), path.join(target, name));
+        }
+        catch (e) {
+            return { kind, detail: name + ' (could not be moved: ' + e.code + '; delete it yourself before running anything here)' };
+        }
         return { kind, detail: name + ' (moved to ' + target + ')' };
     });
 };
@@ -85,7 +116,12 @@ const disableConfig = (dir, before) => {
         return MARK + line.trim();
     });
     if (findings.length)
-        fs.writeFileSync(path.join(dir, 'config'), fixed.join('\n'), 'utf8');
+        writeFileAtomic(path.join(dir, 'config'), fixed.join('\n'));
+    const file = path.join(dir, 'config');
+    // A link or a huge file is not read at all, so say so instead of letting it pass as "nothing found".
+    const unchecked = isLink(file) ? '.git/config is a link' : lines.length === 0 && fileExists(file) && fs.statSync(file).size > MAX_CONFIG_BYTES ? '.git/config is over 4 MB' : null;
+    if (unchecked)
+        findings.push({ kind: 'git', detail: unchecked + ', so it cannot be checked. Do not run git in this folder until you have looked at it.' });
     return findings;
 };
 /**
@@ -93,6 +129,7 @@ const disableConfig = (dir, before) => {
  * Returns what was found (and fixed). Never touches what was already there before the sandbox ran.
  */
 export const guardRepo = (workspace, before) => {
+    assertTestWritable(workspace);
     const findings = [];
     const commandsNow = filesIn(workspace, (n) => COMMANDS.test(n));
     findings.push(...quarantine(workspace, Object.keys(commandsNow).filter((n) => before.commands[n] !== commandsNow[n]), workspace, 'command'));
@@ -114,15 +151,69 @@ export const guardRepo = (workspace, before) => {
 const syncDir = (dataPath) => path.join(path.dirname(path.dirname(dataPath)), 'sync');
 const snapshotFile = (dataPath) => path.join(syncDir(dataPath), path.basename(dataPath) + '-repo.json');
 const findingsFile = (dataPath) => path.join(syncDir(dataPath), path.basename(dataPath) + '-repo-findings.json');
-export const saveRepoSnapshot = (dataPath, workspace) => writeJson(snapshotFile(dataPath), { workspace, snapshot: snapshotRepo(workspace) });
-/** Re-checks the workspace of the current/last launch; findings are kept in a host-only file for `status`. */
+const Finding = z.object({ kind: z.enum(['hook', 'config', 'git', 'command']), detail: z.string().max(4096), at: z.string().max(64).optional() });
+const Saved = z.object({
+    workspace: z.string().max(1024).refine((p) => path.isAbsolute(p)),
+    snapshot: z.object({ gitDir: z.boolean(), config: z.array(z.string()), hooks: z.record(z.string(), z.string()), redirects: z.array(z.string()), commands: z.record(z.string(), z.string()) }),
+});
+const Store = z.strictObject({ projects: z.array(Saved).max(4096), roots: z.array(z.string().max(1024).refine((p) => path.isAbsolute(p))).max(64) });
+const StoreAny = z.union([Store, Saved.transform((s) => ({ projects: [s], roots: [] }))]);
+const readStore = (dataPath) => readValid(StoreAny, snapshotFile(dataPath)) ?? { projects: [], roots: [] };
+const EMPTY = { gitDir: false, config: [], hooks: {}, redirects: [], commands: {} };
+const MAX_ROOT_PROJECTS = 2000;
+/** The folders directly inside a project root (plain folders only; links are never followed). */
+const rootProjects = (root) => {
+    if (!dirExists(root) || isLink(root))
+        return [];
+    return fs.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.isSymbolicLink()).slice(0, MAX_ROOT_PROJECTS).map((e) => path.join(root, e.name));
+};
+const has = (projects, workspace) => projects.some((s) => s.workspace.toLowerCase() === workspace.toLowerCase());
+/**
+ * At launch: every folder the sandbox will be able to write. The launch folder, projects mapped with it and every
+ * project already inside a project root are snapshotted as they are now, before the sandbox can touch them.
+ */
+export const saveRepoSnapshot = (dataPath, workspace, more = [], roots = []) => {
+    const folders = _.uniqBy([workspace, ...more, ...roots.flatMap((r) => [r, ...rootProjects(r)])], (w) => w.toLowerCase());
+    writeJsonAtomic(snapshotFile(dataPath), { projects: folders.map((w) => ({ workspace: w, snapshot: snapshotRepo(w) })), roots });
+};
+/**
+ * A project that joins the running sandbox: snapshotted before its first session, then guarded like the launch
+ * folder. A project already guarded keeps its first snapshot (what was there before the sandbox could touch it).
+ */
+export const addRepoSnapshot = (dataPath, workspace, o = {}) => {
+    const store = readStore(dataPath);
+    // A folder inside one that is guarded already is covered by it only for its root files; it gets its own entry.
+    if (has(store.projects, workspace))
+        return;
+    writeJsonAtomic(snapshotFile(dataPath), { ...store, projects: [...store.projects, { workspace, snapshot: o.empty ? EMPTY : snapshotRepo(workspace) }] });
+};
+/**
+ * Folders that appeared inside a project root after the launch: the sandbox could have written them from the start,
+ * so they get an EMPTY baseline: any git hook, git config that runs programs (core.hooksPath, core.fsmonitor, ...)
+ * or planted command in them counts as added inside the sandbox and is neutralised.
+ */
+const discoverRootProjects = (dataPath) => {
+    const store = readStore(dataPath);
+    const found = store.roots.flatMap(rootProjects).filter((w) => !has(store.projects, w)).map((workspace) => ({ workspace, snapshot: EMPTY }));
+    if (!found.length)
+        return store.projects;
+    const projects = [...store.projects, ...found].slice(0, 4096);
+    writeJsonAtomic(snapshotFile(dataPath), { ...store, projects });
+    return projects;
+};
+/** The folders being guarded (for status). */
+export const guardedProjects = (dataPath) => readStore(dataPath).projects.map((s) => s.workspace);
+/** Re-checks every project of the current/last launch; findings are kept in a host-only file for `status`. Returns the new ones. */
 export const checkRepo = (dataPath) => {
-    const saved = tryReadJson(snapshotFile(dataPath));
-    if (!saved?.snapshot?.commands)
+    const saved = discoverRootProjects(dataPath);
+    if (!saved.length)
         return [];
-    const findings = guardRepo(saved.workspace, saved.snapshot);
+    const old = repoFindings(dataPath);
+    // A finding that cannot be fixed (a file locked in the sandbox) is reported once, not every minute.
+    const findings = saved.flatMap((s) => guardRepo(s.workspace, s.snapshot).map((f) => (saved.length > 1 ? { ...f, detail: s.workspace + ': ' + f.detail } : f)))
+        .filter((f) => !old.some((o) => o.kind === f.kind && o.detail === f.detail));
     if (findings.length)
-        writeJson(findingsFile(dataPath), [...repoFindings(dataPath), ...findings.map((f) => ({ ...f, at: new Date().toISOString() }))]);
+        writeJsonAtomic(findingsFile(dataPath), [...old, ...findings.map((f) => ({ ...f, at: new Date().toISOString() }))]);
     return findings;
 };
-export const repoFindings = (dataPath) => tryReadJson(findingsFile(dataPath)) ?? [];
+export const repoFindings = (dataPath) => readValid(z.array(Finding).max(10000), findingsFile(dataPath)) ?? [];

package/dist/host/terminal.js

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { githubAsset, installArchive } from '../shared/download.js';
 import { safeRemove } from '../shared/safe-remove.js';
+import { assertTestWritable } from './test-guard.js';
 import { z } from 'zod';
 import { assertNoLinks, errMsg, fileExists, parseJsonc, writeJson } from '../core/util.js';
 export const terminalDir = (dataPath) => path.join(dataPath, 'tools', 'terminal');
@@ -55,6 +56,7 @@ export const withPwshProfile = (settings, visible) => {
  */
 export const syncPwshProfile = (dataPath, allowed) => {
     const file = path.join(terminalDir(dataPath), 'settings', 'settings.json');
+    assertTestWritable(file);
     assertNoLinks(dataPath, file);
     if (!fileExists(file) || fs.statSync(file).size > MAX_SETTINGS_BYTES)
         return;
@@ -89,6 +91,7 @@ export const ensureTerminal = async (dataPath, refresh, options = {}) => {
 const installTerminal = async (dataPath, refresh) => {
     const exe = terminalExe(dataPath);
     const dir = terminalDir(dataPath);
+    assertTestWritable(dir);
     const settings = path.join(dir, 'settings');
     // installArchive replaces tools\terminal: the portable settings folder waits here meanwhile (and goes back also when
     // the download fails). One still parked from an interrupted earlier run is the one to keep.

package/dist/host/test-guard.d.ts

@@ -0,0 +1,6 @@
+import { selfTestRunning } from '../shared/test-guard.js';
+export { selfTestRunning };
+/** Refuses an action that reaches outside the test's own temp folder (a no-op outside the self-test). */
+export declare const refuseInSelfTest: (what: string) => void;
+/** A write, copy or delete on the host: during the self-test only the temp folder is allowed. */
+export declare const assertTestWritable: (target: string) => void;

package/dist/host/test-guard.js

@@ -0,0 +1,15 @@
+// Host side of the self-test guard (see shared/test-guard.ts): outward actions refuse, with a message the user can read.
+import { testWriteRefusal, selfTestRunning } from '../shared/test-guard.js';
+import { fail } from '../core/util.js';
+export { selfTestRunning };
+/** Refuses an action that reaches outside the test's own temp folder (a no-op outside the self-test). */
+export const refuseInSelfTest = (what) => {
+    if (selfTestRunning())
+        fail('The self-test does not ' + what + '.', 'It only works in temp folders, so it can never change this PC.');
+};
+/** A write, copy or delete on the host: during the self-test only the temp folder is allowed. */
+export const assertTestWritable = (target) => {
+    const refusal = testWriteRefusal(target);
+    if (refusal)
+        fail(refusal);
+};

package/dist/host/window.js

@@ -1,7 +1,9 @@
 // Headless mode: Windows Sandbox always opens its client window, so we hide it (ShowWindow SW_HIDE) as soon as it
 // appears. The VM and the logged-in session keep running; `sbx-show` brings the window back.
 import path from 'node:path';
-import { isWin, runPowerShell, runPowerShellAsync, tryReadJson, writeJson } from '../core/util.js';
+import { writeJsonAtomic } from '../shared/rundir.js';
+import { refuseInSelfTest } from './test-guard.js';
+import { isWin, runPowerShell, runPowerShellAsync, tryReadJson } from '../core/util.js';
 const PRELUDE = `
 $ErrorActionPreference = 'Stop'
 Add-Type -Namespace AgentSandbox -Name Win -MemberDefinition @'
@@ -34,6 +36,7 @@ function Get-SandboxWindows([bool]$visibleOnly) {
 const stateFile = (storageRoot) => path.join(storageRoot, 'run', 'hidden-windows.json');
 /** Waits for the sandbox window and hides it; keeps watching briefly in case Windows re-shows it while connecting. */
 export const hideSandboxWindow = async (storageRoot, waitSeconds = 180) => {
+    refuseInSelfTest('hide windows');
     if (!isWin)
         return false;
     const script = PRELUDE + `
@@ -48,11 +51,12 @@ while ((Get-Date) -lt $deadline) {
 ConvertTo-Json -Compress @($hidden)`;
     const stdout = await runPowerShellAsync(script);
     const handles = JSON.parse(stdout.trim() || '[]').filter((h) => Number.isSafeInteger(h));
-    writeJson(stateFile(storageRoot), { handles });
+    writeJsonAtomic(stateFile(storageRoot), { handles });
     return handles.length > 0;
 };
 /** Shows the sandbox window again (the ones we hid, or any hidden Windows Sandbox window). */
 export const showSandboxWindow = (storageRoot) => {
+    refuseInSelfTest('show windows');
     if (!isWin)
         return false;
     // Only integers go into the script, whatever the file contains.
@@ -63,6 +67,6 @@ if (-not $handles) { $handles = Get-SandboxWindows $false }
 foreach ($h in $handles) { [void][AgentSandbox.Win]::ShowWindow([IntPtr]$h, 5); [void][AgentSandbox.Win]::ShowWindow([IntPtr]$h, 9); [void][AgentSandbox.Win]::SetForegroundWindow([IntPtr]$h) }
 @($handles).Count`;
     const { stdout } = runPowerShell(script, true);
-    writeJson(stateFile(storageRoot), { handles: [] });
+    writeJsonAtomic(stateFile(storageRoot), { handles: [] });
     return Number(stdout.trim()) > 0;
 };

package/dist/host/wsb.d.ts

@@ -0,0 +1,37 @@
+/** Where wsb.exe can be: the Store app's alias, then System32 (never by bare name; cwd is often the workspace). */
+export declare const wsbCandidates: (env?: NodeJS.ProcessEnv) => string[];
+export declare const findWsb: (env?: NodeJS.ProcessEnv, exists?: (p: string) => boolean) => string | null;
+/** The version from `wsb --version` ("0.1.32.0", "wsb 1.2.3+abc"). */
+export declare const parseVersion: (out: string) => string | null;
+/** Subcommand names from `wsb --help` (the lines under "Commands:"). */
+export declare const parseCommands: (help: string) => string[];
+export interface WsbSandbox {
+    id: string;
+    status: string;
+}
+/** `wsb list --raw` (JSON: an array, or an object holding one) or the plain table: the sandboxes and their status. */
+export declare const parseList: (out: string) => WsbSandbox[];
+/** `wsb ip --id <id>`: the first IPv4 address in the output. */
+export declare const parseIp: (out: string) => string | null;
+export interface WsbResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+    error?: string;
+}
+export interface Wsb {
+    exe: string;
+    version: string | null;
+    commands: string[];
+    has: (command: string) => boolean;
+}
+/** The CLI and what it offers, or null on Windows versions without it. */
+export declare const detectWsb: (env?: NodeJS.ProcessEnv) => Wsb | null;
+/** The running sandbox's id: the only running one (with several, none is guessed). */
+export declare const runningSandboxId: (wsb: Wsb) => {
+    id: string | null;
+    error?: string;
+};
+/** Shares a folder of this PC into the running sandbox at `sandboxPath` (read/write unless readOnly). */
+export declare const shareFolder: (wsb: Wsb, id: string, hostPath: string, sandboxPath: string, readOnly?: boolean) => WsbResult;
+export declare const sandboxIp: (wsb: Wsb, id: string) => string | null;

package/dist/host/wsb.js

@@ -0,0 +1,101 @@
+// The Windows Sandbox command line (wsb.exe), Windows 11 24H2+ with the updated Windows Sandbox. Used only where it
+// adds something the .wsb file cannot: `wsb share` puts a folder into the RUNNING sandbox. Launching always stays on
+// the .wsb path, which works on every Windows version. UNTESTED: the machines this was built on predate the CLI, so
+// every call is checked and any failure falls back (the caller offers a restart instead), with the error shown.
+// Syntax from Microsoft's docs (learn.microsoft.com, "Windows Sandbox command line"):
+//   wsb start [--id <id>] [-c|--config <xml>]   wsb list [--raw]   wsb ip --id <id>   wsb stop --id <id>
+//   wsb share --id <id> -f|--host-path <host> -s|--sandbox-path <sandbox> [-w|--allow-write]
+//   wsb exec --id <id> -c <command> -r System|ExistingLogin [-d <dir>]   wsb connect --id <id>   --raw = JSON output
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { refuseInSelfTest } from './test-guard.js';
+const GUID = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
+const MAX_OUTPUT = 1024 * 1024;
+/** Where wsb.exe can be: the Store app's alias, then System32 (never by bare name; cwd is often the workspace). */
+export const wsbCandidates = (env = process.env) => [
+    env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'Microsoft', 'WindowsApps', 'wsb.exe') : '',
+    path.join(env.SystemRoot ?? env.WINDIR ?? 'C:\\Windows', 'System32', 'wsb.exe'),
+].filter(Boolean);
+export const findWsb = (env = process.env, exists = fs.existsSync) => process.platform === 'win32' || exists !== fs.existsSync ? wsbCandidates(env).find((p) => exists(p)) ?? null : null;
+// ---- parsing (pure; the tests feed it recorded output) ---------------------------------------------------------
+/** The version from `wsb --version` ("0.1.32.0", "wsb 1.2.3+abc"). */
+export const parseVersion = (out) => /\d+\.\d+(?:\.\d+){0,2}/.exec(out)?.[0] ?? null;
+/** Subcommand names from `wsb --help` (the lines under "Commands:"). */
+export const parseCommands = (help) => {
+    const lines = help.split(/\r?\n/);
+    const start = lines.findIndex((l) => /^\s*commands:\s*$/i.test(l));
+    if (start < 0)
+        return [];
+    const names = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^\S/.test(line) && line.trim())
+            break;
+        const m = /^\s{1,8}([a-z][a-z-]*)\b/.exec(line);
+        if (m)
+            names.push(m[1].toLowerCase());
+    }
+    return names;
+};
+/** `wsb list --raw` (JSON: an array, or an object holding one) or the plain table: the sandboxes and their status. */
+export const parseList = (out) => {
+    const fromObject = (o) => {
+        if (!o || typeof o !== 'object')
+            return null;
+        const entries = Object.entries(o);
+        const id = entries.find(([k, v]) => /^id$/i.test(k) && typeof v === 'string' && GUID.test(v))?.[1];
+        const status = entries.find(([k]) => /^(status|state)$/i.test(k))?.[1];
+        return id ? { id: GUID.exec(id)[0], status: typeof status === 'string' ? status : 'unknown' } : null;
+    };
+    try {
+        const parsed = JSON.parse(out);
+        const list = Array.isArray(parsed) ? parsed : Object.values(parsed).find(Array.isArray) ?? [parsed];
+        return list.map(fromObject).filter((s) => s !== null);
+    }
+    catch { /* the table */ }
+    return out.split(/\r?\n/).flatMap((line) => {
+        const id = GUID.exec(line)?.[0];
+        if (!id)
+            return [];
+        return [{ id, status: /\brunning\b/i.test(line) ? 'Running' : /\bstopped\b/i.test(line) ? 'Stopped' : 'unknown' }];
+    });
+};
+/** `wsb ip --id <id>`: the first IPv4 address in the output. */
+export const parseIp = (out) => /\b(?:\d{1,3}\.){3}\d{1,3}\b/.exec(out)?.[0] ?? null;
+const call = (exe, args, timeoutMs = 60000) => {
+    const r = spawnSync(exe, args, { encoding: 'utf8', windowsHide: true, timeout: timeoutMs, maxBuffer: MAX_OUTPUT });
+    const stdout = String(r.stdout ?? '').slice(0, MAX_OUTPUT);
+    const stderr = String(r.stderr ?? '').slice(0, MAX_OUTPUT);
+    if (r.error)
+        return { ok: false, stdout, stderr, error: r.error.message };
+    return { ok: r.status === 0, stdout, stderr, ...(r.status === 0 ? {} : { error: (stderr || stdout).trim().split(/\r?\n/).slice(-3).join(' ') || 'exit code ' + r.status }) };
+};
+/** The CLI and what it offers, or null on Windows versions without it. */
+export const detectWsb = (env = process.env) => {
+    const exe = findWsb(env);
+    if (!exe)
+        return null;
+    const version = parseVersion(call(exe, ['--version'], 15000).stdout);
+    const help = call(exe, ['--help'], 15000);
+    const commands = parseCommands(help.stdout + '\n' + help.stderr);
+    // An unreadable help text is not proof of anything: assume the documented commands.
+    const known = commands.length ? commands : ['start', 'list', 'exec', 'stop', 'share', 'connect', 'ip'];
+    return { exe, version, commands: known, has: (c) => known.includes(c) };
+};
+/** The running sandbox's id: the only running one (with several, none is guessed). */
+export const runningSandboxId = (wsb) => {
+    const listed = call(wsb.exe, ['list', '--raw'], 20000);
+    const all = parseList(listed.ok ? listed.stdout : call(wsb.exe, ['list'], 20000).stdout);
+    const running = all.filter((s) => !/stopped/i.test(s.status));
+    if (running.length === 1)
+        return { id: running[0].id };
+    return { id: null, error: running.length ? running.length + ' sandboxes are running (wsb list); cannot tell which one is ours' : 'wsb list shows no running sandbox (one started from a .wsb file may not be listed)' };
+};
+/** Shares a folder of this PC into the running sandbox at `sandboxPath` (read/write unless readOnly). */
+export const shareFolder = (wsb, id, hostPath, sandboxPath, readOnly = false) => {
+    refuseInSelfTest('share a folder into Windows Sandbox');
+    if (!GUID.test(id))
+        return { ok: false, stdout: '', stderr: '', error: 'not a sandbox id: ' + id };
+    return call(wsb.exe, ['share', '--id', id, '-f', hostPath, '-s', sandboxPath, ...(readOnly ? [] : ['--allow-write'])]);
+};
+export const sandboxIp = (wsb, id) => (GUID.test(id) ? parseIp(call(wsb.exe, ['ip', '--id', id], 15000).stdout) : null);