windows-development-sandbox 1.4.1 → 1.5.0

package/dist/core/detect-pwsh.js

@@ -1,111 +0,0 @@
-// Does a project need PowerShell 7 (pwsh)? Windows PowerShell 5.1 ships with Windows, so a plain *.ps1 says nothing;
-// a script that asks for 7 (#Requires -Version 7 / -PSEdition Core) or tells you to run it with `pwsh` does.
-// usesPwsh is pure; readPwshScripts reads a bounded sample of the workspace (no links followed, files and bytes capped).
-import fs from 'node:fs';
-import path from 'node:path';
-/** Scripts looked at: the workspace root and one folder down, at most this many, only their start. */
-export const PWSH_MAX_SCRIPTS = 40;
-export const PWSH_MAX_BYTES = 64 * 1024;
-const MAX_LINES = 400;
-const MAX_LINE = 400;
-const SKIP = /^(node_modules|\.git|vendor|target|bin|obj|dist|build|out|\.venv|venv|packages)$/i;
-/** Why one line asks for PowerShell 7, or null. Plain string work per line (no regex that can backtrack). */
-const pwshLine = (raw) => {
-    const line = raw.trimStart().slice(0, MAX_LINE).toLowerCase();
-    if (line.startsWith('#requires')) {
-        const words = line.slice('#requires'.length).split(/\s+/).filter(Boolean);
-        const after = (flag) => words[words.indexOf(flag) + 1];
-        const version = words.includes('-version') ? Number.parseInt(after('-version') ?? '', 10) : NaN;
-        if (version >= 7)
-            return '#Requires -Version ' + version;
-        if (words.includes('-psedition') && after('-psedition') === 'core')
-            return '#Requires -PSEdition Core';
-        return null;
-    }
-    // "Usage: pwsh scripts/build.ps1", "& pwsh -File x.ps1", "pwsh.exe -NoProfile ...": the word pwsh, then an option
-    // or a script (so prose like "works in pwsh too" does not count).
-    // At most a few occurrences per line, each looking at a short window: linear in the (capped) input.
-    for (let at = line.indexOf('pwsh'), n = 0; at !== -1 && n < 4; at = line.indexOf('pwsh', at + 4), n++) {
-        const end = at + (line.startsWith('pwsh.exe', at) ? 8 : 4);
-        if (at > 0 && /[\w.$-]/.test(line[at - 1]))
-            continue;
-        if (line[end] !== ' ' && line[end] !== '\t')
-            continue;
-        const next = line.slice(end, end + 80).trimStart().split(/\s/, 1)[0] ?? '';
-        if (next.startsWith('-') || next.includes('.ps1'))
-            return 'pwsh usage';
-    }
-    return null;
-};
-/** The first script that needs PowerShell 7 and why ("moh.ps1: #Requires -Version 7"), or null. */
-export const usesPwsh = (files) => {
-    for (const file of files.slice(0, PWSH_MAX_SCRIPTS)) {
-        if (!/\.ps[dm]?1$/i.test(file.path))
-            continue;
-        const lines = file.text.slice(0, PWSH_MAX_BYTES).split(/\r?\n/, MAX_LINES);
-        for (const line of lines) {
-            const why = pwshLine(line);
-            if (why)
-                return file.path.replace(/\\/g, '/') + ': ' + why;
-        }
-    }
-    return null;
-};
-/** The start of a file, through one handle, only when that handle is a regular file. */
-const readStart = (file) => {
-    let fd = null;
-    try {
-        fd = fs.openSync(file, 'r');
-        const stat = fs.fstatSync(fd);
-        if (!stat.isFile())
-            return null;
-        const buffer = Buffer.alloc(Math.min(stat.size, PWSH_MAX_BYTES));
-        const read = fs.readSync(fd, buffer, 0, buffer.length, 0);
-        return buffer.subarray(0, read).toString('utf8');
-    }
-    catch {
-        return null;
-    }
-    finally {
-        if (fd !== null)
-            fs.closeSync(fd);
-    }
-};
-/** *.ps1 / *.psm1 / *.psd1 in the workspace root and its direct sub-folders (root first), capped. Links are skipped. */
-export const readPwshScripts = (root) => {
-    const list = (dir) => { try {
-        return fs.readdirSync(dir, { withFileTypes: true }).slice(0, 2000);
-    }
-    catch {
-        return [];
-    } };
-    const isScript = (d) => d.isFile() && /\.ps[dm]?1$/i.test(d.name);
-    const top = list(root);
-    const names = [
-        ...top.filter(isScript).map((d) => d.name),
-        ...top.filter((d) => d.isDirectory() && !d.name.startsWith('.') && !SKIP.test(d.name)).slice(0, 200)
-            .flatMap((d) => list(path.join(root, d.name)).filter(isScript).map((f) => d.name + '/' + f.name)),
-    ].slice(0, PWSH_MAX_SCRIPTS);
-    return names.flatMap((name) => { const text = readStart(path.join(root, name)); return text === null ? [] : [{ path: name, text }]; });
-};
-/** PowerShell 7 installed on this PC (the MSI's folder, or a pwsh.exe on PATH other than a Store alias). */
-export const pcHasPwsh = (env = process.env, exists = fs.existsSync) => {
-    const programFiles = env.ProgramFiles ?? 'C:\\Program Files';
-    if (exists(path.win32.join(programFiles, 'PowerShell', '7', 'pwsh.exe')))
-        return true;
-    return (env.PATH ?? env.Path ?? '').split(';').some((d) => d && !/WindowsApps/i.test(d) && exists(path.win32.join(d, 'pwsh.exe')));
-};
-/**
- * The decision for toolchains.pwsh.enabled: true/false are kept; "auto" is on when a script needs PowerShell 7, or, in
- * a folder that is no project yet (`fresh`), when this PC has it.
- */
-export const decidePwsh = (setting, scripts, fresh, pcHas) => {
-    if (setting !== 'auto')
-        return { on: setting, reason: setting ? 'enabled in config' : 'disabled in config' };
-    const why = usesPwsh(scripts);
-    if (why)
-        return { on: true, reason: why };
-    if (fresh && pcHas)
-        return { on: true, reason: 'installed on this PC (new folder)' };
-    return { on: false, reason: 'no script needs PowerShell 7' };
-};

package/dist/core/detect-toolchains.d.ts

@@ -1,30 +0,0 @@
-import type { Toolchains } from './types.js';
-/** Files that show a project uses a language (looked for in the workspace and one folder down). */
-export declare const MARKERS: {
-    readonly python: readonly ["pyproject.toml", "requirements.txt", "setup.py", "setup.cfg", "Pipfile", "uv.lock", "poetry.lock", ".python-version", "*.py", "*.ipynb"];
-    readonly rust: readonly ["Cargo.toml", "rust-toolchain", "rust-toolchain.toml"];
-    readonly msvc: readonly ["*.vcxproj", "CMakePresets.json", "CMakeUserPresets.json"];
-    readonly cpp: readonly ["CMakeLists.txt", "Makefile", "meson.build", "premake5.lua", "Cargo.toml", "*.vcxproj", "*.c", "*.cpp", "*.cc", "*.h", "*.hpp"];
-    readonly dotnet: readonly ["*.sln", "*.slnx", "*.csproj", "*.fsproj", "*.vbproj", "global.json", "*.cs"];
-    readonly go: readonly ["go.mod", "go.work", "*.go"];
-    readonly java: readonly ["pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts", "mvnw", "gradlew", ".java-version", ".sdkmanrc", "*.java"];
-    readonly ruby: readonly ["Gemfile", "*.gemspec", ".ruby-version", "*.rb"];
-    readonly php: readonly ["composer.json", "artisan", ".php-version", "*.php"];
-    readonly deno: readonly ["deno.json", "deno.jsonc", "deno.lock"];
-    readonly pwsh: readonly [];
-};
-export type AutoToolchain = keyof typeof MARKERS;
-export declare const AUTO_TOOLCHAINS: AutoToolchain[];
-export interface ToolchainDecision {
-    on: boolean;
-    reason: string;
-}
-/**
- * The decision per toolchain. true/false are kept; "auto" is on when the project has one of its marker files, or, in
- * a folder that is no project yet, when this PC has the language installed. Rust needs a linker (MSVC or C/C++).
- * hints: reasons found by reading files (a script that calls vcvars/vswhere) or about this PC ("builds Rust with MSVC"),
- * which turn an "auto" toolchain on like a marker file does.
- */
-export declare const decideToolchains: (settings: Toolchains, entries: string[], pcHas: AutoToolchain[], hints?: Partial<Record<AutoToolchain, string>>) => Record<AutoToolchain, ToolchainDecision>;
-/** The settings with every "auto" replaced by the decision (what the sandbox receives). */
-export declare const resolveToolchains: (settings: Toolchains, decisions: Record<AutoToolchain, ToolchainDecision>) => Toolchains;

package/dist/core/detect-toolchains.js

@@ -1,58 +0,0 @@
-import { projectUses } from '../guest/toolchains/versions.js';
-/** Files that show a project uses a language (looked for in the workspace and one folder down). */
-export const MARKERS = {
-    python: ['pyproject.toml', 'requirements.txt', 'setup.py', 'setup.cfg', 'Pipfile', 'uv.lock', 'poetry.lock', '.python-version', '*.py', '*.ipynb'],
-    rust: ['Cargo.toml', 'rust-toolchain', 'rust-toolchain.toml'],
-    msvc: ['*.vcxproj', 'CMakePresets.json', 'CMakeUserPresets.json'],
-    cpp: ['CMakeLists.txt', 'Makefile', 'meson.build', 'premake5.lua', 'Cargo.toml', '*.vcxproj', '*.c', '*.cpp', '*.cc', '*.h', '*.hpp'],
-    dotnet: ['*.sln', '*.slnx', '*.csproj', '*.fsproj', '*.vbproj', 'global.json', '*.cs'],
-    go: ['go.mod', 'go.work', '*.go'],
-    java: ['pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts', 'mvnw', 'gradlew', '.java-version', '.sdkmanrc', '*.java'],
-    ruby: ['Gemfile', '*.gemspec', '.ruby-version', '*.rb'],
-    php: ['composer.json', 'artisan', '.php-version', '*.php'],
-    deno: ['deno.json', 'deno.jsonc', 'deno.lock'],
-    // Windows PowerShell 5.1 runs any .ps1: PowerShell 7 is decided from script contents (hints.pwsh) or this PC.
-    pwsh: [],
-};
-export const AUTO_TOOLCHAINS = Object.keys(MARKERS);
-/** Files of any ecosystem: a folder with none of them is no project yet. */
-const PROJECT_FILES = [...new Set([...Object.values(MARKERS).flat(), 'package.json', 'deno.json', '*.ts', '*.js'])];
-/**
- * The decision per toolchain. true/false are kept; "auto" is on when the project has one of its marker files, or, in
- * a folder that is no project yet, when this PC has the language installed. Rust needs a linker (MSVC or C/C++).
- * hints: reasons found by reading files (a script that calls vcvars/vswhere) or about this PC ("builds Rust with MSVC"),
- * which turn an "auto" toolchain on like a marker file does.
- */
-export const decideToolchains = (settings, entries, pcHas, hints = {}) => {
-    const fresh = !projectUses(entries, PROJECT_FILES);
-    const decide = (name) => {
-        const setting = settings[name].enabled;
-        if (setting !== 'auto')
-            return { on: setting, reason: setting ? 'enabled in config' : 'disabled in config' };
-        const marker = MARKERS[name].map((m) => entries.find((e) => projectUses([e], [m]))).find(Boolean);
-        if (marker)
-            return { on: true, reason: marker };
-        if (hints[name])
-            return { on: true, reason: hints[name] };
-        if (fresh && pcHas.includes(name))
-            return { on: true, reason: 'installed on this PC (new folder)' };
-        return { on: false, reason: 'not used by this project' };
-    };
-    const result = Object.fromEntries(AUTO_TOOLCHAINS.map((name) => [name, decide(name)]));
-    // Rust links with MSVC when this PC does (its rustup host is *-msvc), otherwise with MinGW's gcc.
-    if (result.rust.on && settings.msvc.enabled === 'auto' && !result.msvc.on && pcHas.includes('msvc'))
-        result.msvc = { on: true, reason: 'Rust on this PC builds with MSVC' };
-    // MSVC is a 1-2 GB licensed download: "auto" only installs it once its licence is accepted.
-    if (settings.msvc.enabled === 'auto' && result.msvc.on && !settings.msvc.acceptLicense)
-        result.msvc = { on: false, reason: 'would be used (' + result.msvc.reason + '); set toolchains.msvc.acceptLicense to install it' };
-    if (result.rust.on && !result.msvc.on && !result.cpp.on && settings.cpp.enabled !== false)
-        result.cpp = { on: true, reason: 'the linker for Rust' };
-    return result;
-};
-/** The settings with every "auto" replaced by the decision (what the sandbox receives). */
-export const resolveToolchains = (settings, decisions) => {
-    const out = structuredClone(settings);
-    for (const name of AUTO_TOOLCHAINS)
-        out[name].enabled = decisions[name].on;
-    return out;
-};

package/dist/core/local-config.d.ts

@@ -1,50 +0,0 @@
-import type { Config, LocalConfigFile, Overrides } from './types.js';
-export declare const LOCAL_CONFIG_NAME = ".sandbox-config.json";
-/** Validates a folder's settings and resolves its relative paths against that folder. */
-export declare const normalizeOverrides: (data: unknown, dir: string, source: string) => Overrides;
-/**
- * The project file's mappings of folders outside the project (%VAR% expanded, links and short names followed). A repo
- * ships this file, so these reach the rest of this PC: projects.allowOutsideMappings in YOUR settings decides.
- */
-export declare const outsideMappings: <M extends {
-    host: string;
-}>(dir: string, mappings?: M[]) => M[];
-/** `folder` (also where it really is, through links) is inside the project folder `dir`. */
-export declare const insideProject: (dir: string, folder: string) => boolean;
-/**
- * Protections a project file may only make stricter, never looser. A repo can ship the file, so it must not be able to
- * switch off what you turned on (or turn on what you turned off). The strictest of the two values always wins.
- */
-export declare const ON_IS_SAFER: string[];
-export declare const OFF_IS_SAFER: string[];
-export declare const GIT_STRICTNESS: Record<string, number>;
-export declare const NEVER_LOOSER: string[];
-/** What a project file asks for that would loosen one of your protections (so it is not used). */
-export declare const loosenedRequests: (config: Config, ov: Overrides) => {
-    key: string;
-    wanted: unknown;
-    yours: unknown;
-}[];
-/** Applies validated overrides. Mappings with the same guest folder replace the configured ones. */
-export declare const applyOverrides: (config: Config, ov: Overrides) => Config;
-/** Human-readable list of what a local config changes, with risky items flagged. */
-export declare const describeOverrides: (ov: Overrides, dir?: string) => string[];
-export declare const readLocalConfig: (dir: string) => LocalConfigFile | null;
-export declare const trustStorePath: (storageRoot: string) => string;
-export declare const isTrusted: (store: string, file: string, hash: string) => boolean;
-export declare const saveTrust: (store: string, file: string, hash: string) => void;
-export declare const allowStorePath: (storageRoot: string) => string;
-/** true = you allowed it, false = you said no (not asked again), null = not asked yet. */
-export declare const allowedAnswer: (store: string, file: string, setting: string, value: unknown) => boolean | null;
-export declare const saveAllowed: (store: string, file: string, setting: string, value: unknown, allow: boolean) => void;
-/** Answers for folders outside the project are kept with the others, one per folder (and read-only or not). */
-export declare const OUTSIDE_FOLDER = "folder outside the project";
-export declare const outsideKey: (m: {
-    host: string;
-    readOnly: boolean;
-}) => string;
-/** Your config with these requests let through, so applyOverrides' "strictest wins" keeps the project's value. */
-export declare const allowRequests: (config: Config, allowed: {
-    key: string;
-    wanted: unknown;
-}[]) => Config;

package/dist/core/local-config.js

@@ -1,142 +0,0 @@
-// A project's .sandbox-config.json: validated against the LocalOverrides schema (a safe subset of settings), applied
-// over the user config, and only used once you have approved this exact version of the file.
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import _ from 'lodash';
-import { z } from 'zod';
-import { mergeConfig } from './config.js';
-import { describeIssues, LocalOverrides } from './schema.js';
-import { expandPath, fail, fileExists, isInsideOrEqual, parseJsonc, tryReadJson, writeJson } from './util.js';
-export const LOCAL_CONFIG_NAME = '.sandbox-config.json';
-/** Validates a folder's settings and resolves its relative paths against that folder. */
-export const normalizeOverrides = (data, dir, source) => {
-    const parsed = LocalOverrides.safeParse(data);
-    if (!parsed.success)
-        fail(source + ' is not valid:\n  - ' + describeIssues(parsed.error).join('\n  - '));
-    const overrides = parsed.data;
-    const scripts = overrides.scripts?.map((s) => expandPath(s, dir));
-    const missing = scripts?.filter((s) => !fileExists(s)) ?? [];
-    if (missing.length)
-        fail(source + ' is not valid:\n  - scripts: file not found: ' + missing.join(', '));
-    const mappings = overrides.mappings?.map((m) => ({ ...m, host: expandPath(m.host, dir) }));
-    return { ...overrides, scripts, mappings };
-};
-/**
- * The project file's mappings of folders outside the project (%VAR% expanded, links and short names followed). A repo
- * ships this file, so these reach the rest of this PC: projects.allowOutsideMappings in YOUR settings decides.
- */
-export const outsideMappings = (dir, mappings = []) => mappings.filter((m) => !insideProject(dir, m.host));
-/** `folder` (also where it really is, through links) is inside the project folder `dir`. */
-export const insideProject = (dir, folder) => {
-    // Where a path really is: the nearest existing folder resolved (links, 8.3 short names), plus the part not created yet.
-    const real = (p) => {
-        const full = path.resolve(p);
-        try {
-            return fs.realpathSync.native(full);
-        }
-        catch {
-            return path.dirname(full) === full ? full : path.join(real(path.dirname(full)), path.basename(full));
-        }
-    };
-    return isInsideOrEqual(dir, folder) && isInsideOrEqual(real(dir), real(folder));
-};
-/**
- * Protections a project file may only make stricter, never looser. A repo can ship the file, so it must not be able to
- * switch off what you turned on (or turn on what you turned off). The strictest of the two values always wins.
- */
-export const ON_IS_SAFER = ['readOnly', 'workspaceFilter.enabled', 'network.blockPrivateRanges', 'sandbox.protectedClient', 'downloads.requireChecksum'];
-export const OFF_IS_SAFER = ['sandbox.networking', 'sandbox.clipboard', 'sandbox.audioInput', 'sandbox.videoInput', 'sandbox.printerRedirection', 'sandbox.vGpu', 'claudeProfile.copyCredentials', 'claudeProfile.enabled', 'claudeProfile.syncHistory', 'claudeProfile.syncClaudeMem'];
-export const GIT_STRICTNESS = { full: 0, readonly: 1, none: 2 };
-export const NEVER_LOOSER = [...ON_IS_SAFER, ...OFF_IS_SAFER, 'provisioning.git.access'];
-const keepStrictest = (yours, merged) => {
-    ON_IS_SAFER.forEach((p) => _.set(merged, p, Boolean(_.get(yours, p)) || Boolean(_.get(merged, p))));
-    OFF_IS_SAFER.forEach((p) => _.set(merged, p, Boolean(_.get(yours, p)) && Boolean(_.get(merged, p))));
-    if (GIT_STRICTNESS[yours.provisioning.git.access] > GIT_STRICTNESS[merged.provisioning.git.access])
-        merged.provisioning.git.access = yours.provisioning.git.access;
-};
-/** What a project file asks for that would loosen one of your protections (so it is not used). */
-export const loosenedRequests = (config, ov) => [
-    ...ON_IS_SAFER.filter((p) => _.has(ov, p) && !_.get(ov, p) && _.get(config, p)),
-    ...OFF_IS_SAFER.filter((p) => _.has(ov, p) && _.get(ov, p) && !_.get(config, p)),
-    ...(_.has(ov, 'provisioning.git.access') && GIT_STRICTNESS[_.get(ov, 'provisioning.git.access')] < GIT_STRICTNESS[config.provisioning.git.access] ? ['provisioning.git.access'] : []),
-].map((key) => ({ key, wanted: _.get(ov, key), yours: _.get(config, key) }));
-/** Applies validated overrides. Mappings with the same guest folder replace the configured ones. */
-export const applyOverrides = (config, ov) => {
-    const { harness, mappings, scripts: _scripts, $schema: _schema, ...rest } = ov;
-    const next = mergeConfig(config, rest);
-    keepStrictest(config, next);
-    if (harness)
-        next.defaultHarness = harness;
-    // A project adds catalogue apps to yours; it never removes the ones you chose.
-    if (rest.apps?.install)
-        next.apps.install = _.union(config.apps.install, rest.apps.install);
-    // Its patterns keep more out on top of yours; yours stay.
-    if (rest.network?.blockHosts)
-        next.network.blockHosts = _.union(config.network.blockHosts, rest.network.blockHosts);
-    if (rest.workspaceFilter?.exclude)
-        next.workspaceFilter.exclude = _.union(config.workspaceFilter.exclude, rest.workspaceFilter.exclude);
-    const sameGuest = (a, b) => Boolean(a && b && a.toLowerCase() === b.toLowerCase());
-    if (mappings)
-        next.mappings = [..._.reject(config.mappings, (m) => mappings.some((o) => sameGuest(o.guest, m.guest))), ...mappings];
-    return next;
-};
-const flatten = (value, prefix = '') => _.isPlainObject(value) ? Object.entries(value).flatMap(([k, v]) => flatten(v, prefix ? prefix + '.' + k : k)) : [prefix + ' = ' + JSON.stringify(value)];
-/** Human-readable list of what a local config changes, with risky items flagged. */
-export const describeOverrides = (ov, dir) => {
-    const { harness, mappings = [], scripts = [], $schema: _schema, ...sections } = ov;
-    const outside = dir ? outsideMappings(dir, mappings) : [];
-    const lines = [
-        ...(harness ? ['agent = ' + harness] : []),
-        ...mappings.map((m) => (m.readOnly ? 'read-only' : 'READ/WRITE') + ' folder ' + m.host + '  ->  ' + (m.guest ?? 'the same path') + (outside.includes(m) ? '  (outside the project)' : '')),
-        ...scripts.map((s) => 'runs inside the sandbox: ' + s),
-        ...flatten(sections),
-    ];
-    const risky = _.compact([
-        mappings.some((m) => !m.readOnly) && 'a READ/WRITE mapping lets the agent change files outside your workspace',
-    ]);
-    // These are only used when they are stricter than your own settings, so a project can never loosen them.
-    const limited = NEVER_LOOSER.filter((p) => _.has(sections, p)).map((p) => p + ' is only used if it is stricter than your own setting');
-    return [...lines, ...risky.map((r) => '!! ' + r), ...limited.map((r) => '   ' + r)];
-};
-export const readLocalConfig = (dir) => {
-    const file = path.join(dir, LOCAL_CONFIG_NAME);
-    if (!fileExists(file))
-        return null;
-    const raw = fs.readFileSync(file);
-    return { path: file, hash: crypto.createHash('sha256').update(raw).digest('hex'), data: parseJsonc(raw.toString('utf8'), file) };
-};
-// ---- approvals (host-only: <storage>\trusted-configs.json) ----------------------------------------------------------
-export const trustStorePath = (storageRoot) => path.join(storageRoot, 'trusted-configs.json');
-const loadTrust = (store) => tryReadJson(store) ?? {};
-const key = (file) => path.resolve(file).toLowerCase();
-export const isTrusted = (store, file, hash) => loadTrust(store)[key(file)] === hash;
-export const saveTrust = (store, file, hash) => writeJson(store, { ...loadTrust(store), [key(file)]: hash });
-// ---- looser settings you allowed for one project (host-only: <storage>\allowed-requests.json) ----------------------
-// A project file can never loosen a protection by itself. When it asks, you are asked once (interactively); a "yes"
-// is kept here, per project file and per "setting = value", so only that value is ever let through for that project.
-export const allowStorePath = (storageRoot) => path.join(storageRoot, 'allowed-requests.json');
-const loadAllowed = (store) => {
-    const parsed = z.record(z.string(), z.array(z.string().max(2000)).max(500)).safeParse(tryReadJson(store) ?? {});
-    return parsed.success ? parsed.data : {};
-};
-const allowKey = (setting, value) => setting + ' = ' + JSON.stringify(value);
-/** true = you allowed it, false = you said no (not asked again), null = not asked yet. */
-export const allowedAnswer = (store, file, setting, value) => {
-    const answers = loadAllowed(store)[key(file)] ?? [];
-    return answers.includes(allowKey(setting, value)) ? true : answers.includes('no: ' + allowKey(setting, value)) ? false : null;
-};
-export const saveAllowed = (store, file, setting, value, allow) => {
-    const all = loadAllowed(store);
-    const entry = allowKey(setting, value);
-    writeJson(store, { ...all, [key(file)]: _.union(_.without(all[key(file)] ?? [], entry, 'no: ' + entry), [(allow ? '' : 'no: ') + entry]) });
-};
-/** Answers for folders outside the project are kept with the others, one per folder (and read-only or not). */
-export const OUTSIDE_FOLDER = 'folder outside the project';
-export const outsideKey = (m) => (m.readOnly ? 'read-only ' : 'read/write ') + path.resolve(m.host).toLowerCase();
-/** Your config with these requests let through, so applyOverrides' "strictest wins" keeps the project's value. */
-export const allowRequests = (config, allowed) => {
-    const next = _.cloneDeep(config);
-    allowed.forEach((a) => _.set(next, a.key, a.wanted));
-    return next;
-};

package/dist/core/project-policy.d.ts

@@ -1,62 +0,0 @@
-import type { Config, ResolvedMapping } from './types.js';
-/** The protections of a running sandbox, by setting path (`sandbox.networking`, `provisioning.git.access`, ...). */
-export type Protections = Record<string, boolean | string>;
-export declare const protectionsOf: (config: Config) => Protections;
-export interface JoinCheck {
-    /** Settings this project needs stricter than the running sandbox: the launch is refused. */
-    stricter: string[];
-    /** Settings it would have looser: it gets the sandbox's (stricter) value; shown as a note. */
-    looser: string[];
-    /** Settings the sandbox turned on at its start for another project you allowed them for: shared, shown as a note. */
-    shared: string[];
-}
-/**
- * Compares a project's effective protections with the running sandbox's. Hub projects are always read/write
- * (Windows Sandbox maps the hub once, read/write), so a read-only project counts as stricter. `widened`: the boot
- * settings the sandbox turned on for another of its projects (with your consent); a project that has them off
- * shares them instead of being refused.
- */
-export declare const checkJoin: (running: Protections, wanted: Protections, widened?: string[]) => JoinCheck;
-/** .wsb devices a project may want on (only when your settings or your answer for that project allow it). */
-export declare const BOOT_SETTINGS: string[];
-/** What the running sandbox booted with (host-only registry). */
-export interface BootRecord {
-    memoryMb: number | null;
-    mappings: ResolvedMapping[];
-}
-/** What a project wants that the running sandbox started without. */
-export interface Missing {
-    settings: string[];
-    memoryMb: number | null;
-    mappings: ResolvedMapping[];
-}
-/**
- * The boot-only things `config` (a project's effective config: your settings, its approved file, your answers) asks
- * for that the running sandbox lacks. `exists`: optional mappings whose folder is missing are no wish.
- */
-export declare const missingAtBoot: (running: Protections, boot: BootRecord, config: Config, exists?: (folder: string) => boolean) => Missing;
-export declare const nothingMissing: (m: Missing) => boolean;
-/** "mw2-agent wants vGPU and 2 folders (C:\Steam\..., F:\SteamLibrary\...), but this sandbox started without them." */
-export declare const describeMissing: (project: string, m: Missing) => string;
-/** "Set sandbox.vGpu (or the mappings) in your own settings to have them in every sandbox." */
-export declare const missingTip: (m: Missing) => string;
-/** A project mapped at boot besides the launch folder, with its effective config. */
-export interface BootWant {
-    name: string;
-    config: Config;
-}
-export interface Widened {
-    config: Config;
-    /** Setting -> the project it was turned on for. */
-    widened: Record<string, string>;
-    notes: string[];
-}
-/**
- * The launch folder's config plus what the other projects mapped at boot want: their allowed .wsb devices, a fixed
- * memory size larger than the launch's, and their mappings (placed with every other mapping at launch).
- * `keepOff`: devices the launch folder's own .sandbox-config.json switched off; they stay off.
- */
-export declare const widenForProjects: (launch: Config, others: BootWant[], opts?: {
-    keepOff?: string[];
-    exists?: (folder: string) => boolean;
-}) => Widened;

package/dist/core/project-policy.js

@@ -1,121 +0,0 @@
-// Joining a running sandbox from another project. Its protections (network, LAN block, git access, clipboard, the
-// .wsb device settings, read-only) are machine-wide: they were fixed when the sandbox booted for the first project.
-// A second project may never loosen them, and a project that needs a STRICTER setting than the running sandbox has
-// cannot get it there without changing it for the sessions already running, so that launch is refused with a clear
-// message. A project asking for less than the sandbox has simply runs with the sandbox's (stricter) setting.
-// The other direction: what a project WANTS at boot (a .wsb device you allowed for it, more memory, its mappings) and
-// the running sandbox started without. Those can only come with a restart, so they are named (missingAtBoot), and a
-// sandbox started with several projects boots with all of their allowed wants (widenForProjects).
-// Pure: the host checks it before registering a project, the tests drive it directly.
-import _ from 'lodash';
-import { GIT_STRICTNESS, NEVER_LOOSER, OFF_IS_SAFER, ON_IS_SAFER } from './local-config.js';
-export const protectionsOf = (config) => Object.fromEntries(NEVER_LOOSER.map((p) => [p, _.get(config, p)]));
-/** 1 = `wanted` is stricter than `running`, -1 = looser, 0 = the same. */
-const compare = (setting, running, wanted) => {
-    if (setting === 'provisioning.git.access')
-        return Math.sign((GIT_STRICTNESS[String(wanted)] ?? 0) - (GIT_STRICTNESS[String(running)] ?? 0));
-    if (ON_IS_SAFER.includes(setting))
-        return Number(Boolean(wanted)) - Number(Boolean(running));
-    if (OFF_IS_SAFER.includes(setting))
-        return Number(Boolean(running)) - Number(Boolean(wanted));
-    return 0;
-};
-/**
- * Compares a project's effective protections with the running sandbox's. Hub projects are always read/write
- * (Windows Sandbox maps the hub once, read/write), so a read-only project counts as stricter. `widened`: the boot
- * settings the sandbox turned on for another of its projects (with your consent); a project that has them off
- * shares them instead of being refused.
- */
-export const checkJoin = (running, wanted, widened = []) => {
-    const stricter = [];
-    const looser = [];
-    const shared = [];
-    for (const setting of NEVER_LOOSER) {
-        const result = compare(setting, setting === 'readOnly' ? false : running[setting], wanted[setting]);
-        if (result > 0 && widened.includes(setting))
-            shared.push(setting);
-        else if (result > 0)
-            stricter.push(setting + ' = ' + JSON.stringify(wanted[setting]) + ' (the running sandbox has ' + JSON.stringify(setting === 'readOnly' ? false : running[setting]) + ')');
-        if (result < 0)
-            looser.push(setting + ' stays ' + JSON.stringify(running[setting]));
-    }
-    return { stricter, looser, shared };
-};
-// ---- what a project wants at boot ---------------------------------------------------------------------------------
-/** .wsb devices a project may want on (only when your settings or your answer for that project allow it). */
-export const BOOT_SETTINGS = ['sandbox.vGpu', 'sandbox.networking', 'sandbox.clipboard', 'sandbox.audioInput', 'sandbox.videoInput', 'sandbox.printerRedirection'];
-const LABELS = {
-    'sandbox.vGpu': 'vGPU', 'sandbox.networking': 'networking', 'sandbox.clipboard': 'the shared clipboard',
-    'sandbox.audioInput': 'the microphone', 'sandbox.videoInput': 'the camera', 'sandbox.printerRedirection': 'printers',
-};
-const sameHost = (a, b) => a.toLowerCase().replace(/\\+$/, '') === b.toLowerCase().replace(/\\+$/, '');
-/** `m`'s folder is mapped, wherever the launch placed it (read-only is enough for a read-only wish). */
-const isMapped = (mapped, m) => mapped.some((x) => sameHost(x.host, m.host) && (m.readOnly || !x.readOnly));
-/**
- * The boot-only things `config` (a project's effective config: your settings, its approved file, your answers) asks
- * for that the running sandbox lacks. `exists`: optional mappings whose folder is missing are no wish.
- */
-export const missingAtBoot = (running, boot, config, exists = () => true) => ({
-    settings: BOOT_SETTINGS.filter((s) => _.get(config, s) === true && running[s] === false),
-    memoryMb: typeof config.sandbox.memoryMb === 'number' && boot.memoryMb !== null && config.sandbox.memoryMb > boot.memoryMb ? config.sandbox.memoryMb : null,
-    mappings: config.mappings.filter((m) => (!m.optional || exists(m.host)) && !isMapped(boot.mappings, m)).map((m) => ({ host: m.host, guest: m.guest ?? m.host, readOnly: m.readOnly })),
-});
-export const nothingMissing = (m) => m.settings.length === 0 && m.memoryMb === null && m.mappings.length === 0;
-const listing = (items) => items.length <= 1 ? items.join('') : items.slice(0, -1).join(', ') + ' and ' + items[items.length - 1];
-/** "mw2-agent wants vGPU and 2 folders (C:\Steam\..., F:\SteamLibrary\...), but this sandbox started without them." */
-export const describeMissing = (project, m) => {
-    const items = [
-        ...m.settings.map((s) => LABELS[s] ?? s),
-        ...(m.memoryMb !== null ? [m.memoryMb + ' MB of memory'] : []),
-        ...(m.mappings.length ? [m.mappings.length + ' folder' + (m.mappings.length === 1 ? '' : 's') + ' (' + m.mappings.map((x) => x.host).join(', ') + ')'] : []),
-    ];
-    return project + ' wants ' + listing(items) + ', but this sandbox started without ' + (items.length === 1 && !m.mappings.length ? 'it' : 'them') + '.';
-};
-/** "Set sandbox.vGpu (or the mappings) in your own settings to have them in every sandbox." */
-export const missingTip = (m) => {
-    const keys = [...m.settings, ...(m.memoryMb !== null ? ['sandbox.memoryMb'] : [])];
-    const what = keys.length ? listing(keys) + (m.mappings.length ? ' (or the mappings)' : '') : 'the mappings';
-    return 'Set ' + what + ' in your own settings to have them in every sandbox.';
-};
-/**
- * The launch folder's config plus what the other projects mapped at boot want: their allowed .wsb devices, a fixed
- * memory size larger than the launch's, and their mappings (placed with every other mapping at launch).
- * `keepOff`: devices the launch folder's own .sandbox-config.json switched off; they stay off.
- */
-export const widenForProjects = (launch, others, opts = {}) => {
-    const keepOff = opts.keepOff ?? [];
-    const exists = opts.exists ?? (() => true);
-    const config = _.cloneDeep(launch);
-    const widened = {};
-    const notes = [];
-    for (const setting of BOOT_SETTINGS) {
-        const by = others.find((o) => _.get(o.config, setting) === true);
-        if (!by || _.get(config, setting) === true)
-            continue;
-        if (keepOff.includes(setting)) {
-            notes.push(by.name + ' wants ' + (LABELS[setting] ?? setting) + ', but the launch folder\'s .sandbox-config.json switches it off, so it stays off.');
-            continue;
-        }
-        _.set(config, setting, true);
-        widened[setting] = by.name;
-        notes.push((LABELS[setting] ?? setting) + ' is on in this sandbox (for every project in it): ' + by.name + ' asks for it and you allowed it.');
-    }
-    for (const o of others) {
-        const mem = o.config.sandbox.memoryMb;
-        if (typeof mem === 'number' && typeof config.sandbox.memoryMb === 'number' && mem > config.sandbox.memoryMb)
-            config.sandbox.memoryMb = mem;
-        for (const m of o.config.mappings) {
-            if (config.mappings.some((x) => sameHost(x.host, m.host)))
-                continue;
-            if (m.optional && !exists(m.host))
-                continue;
-            if (!exists(m.host)) {
-                notes.push(o.name + ': mapped folder not found, skipped: ' + m.host);
-                continue;
-            }
-            // Where it appears (and moving it when that place is taken) is decided with every other mapping at launch.
-            config.mappings.push({ ...m, optional: true });
-        }
-    }
-    return { config, widened, notes };
-};

package/dist/core/schema.d.ts

@@ -1,6 +0,0 @@
-export { GitAccess } from './schema/common.js';
-export { Config, LocalOverrides } from './schema/config.js';
-export { Harness } from './schema/harness.js';
-export { describeIssues, jsonSchemas } from './schema/json-schema.js';
-export { Mapping } from './schema/sandbox.js';
-export { Toolchains } from './schema/toolchains.js';

package/dist/core/schema.js

@@ -1,8 +0,0 @@
-// Every setting, defined once with zod, split by area in schema/. This file is the one place the rest of the code (and
-// scripts/schemas.mjs, which generates the JSON Schema files) imports them from.
-export { GitAccess } from './schema/common.js';
-export { Config, LocalOverrides } from './schema/config.js';
-export { Harness } from './schema/harness.js';
-export { describeIssues, jsonSchemas } from './schema/json-schema.js';
-export { Mapping } from './schema/sandbox.js';
-export { Toolchains } from './schema/toolchains.js';