windows-development-sandbox 0.0.0-stage → 1.0.5

package/dist/core/detect-toolchains.js

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,12 @@
+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;
+/** 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) => 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;

package/dist/core/local-config.js

@@ -0,0 +1,64 @@
+// 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 { mergeConfig } from './config.js';
+import { describeIssues, LocalOverrides } from './schema.js';
+import { expandPath, fail, fileExists, 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(', '));
+    return { ...overrides, scripts, mappings: overrides.mappings?.map((m) => ({ ...m, host: expandPath(m.host, dir) })) };
+};
+/** 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);
+    if (harness)
+        next.defaultHarness = harness;
+    if (mappings)
+        next.mappings = [..._.reject(config.mappings, (m) => mappings.some((o) => o.guest.toLowerCase() === m.guest.toLowerCase())), ...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) => {
+    const { harness, mappings = [], scripts = [], $schema: _schema, ...sections } = ov;
+    const lines = [
+        ...(harness ? ['agent = ' + harness] : []),
+        ...mappings.map((m) => (m.readOnly ? 'read-only' : 'READ/WRITE') + ' folder ' + m.host + '  ->  ' + m.guest),
+        ...scripts.map((s) => 'runs inside the sandbox: ' + s),
+        ...flatten(sections),
+    ];
+    const risky = _.compact([
+        ov.claudeProfile?.copyCredentials === true && 'claudeProfile.copyCredentials = true copies your Claude LOGIN into the sandbox',
+        ov.network?.blockPrivateRanges === false && 'network.blockPrivateRanges = false turns OFF the LAN block',
+        mappings.some((m) => !m.readOnly) && 'a READ/WRITE mapping lets the agent change files outside your workspace',
+        ov.provisioning?.git?.access === 'full' && 'provisioning.git.access = full lets the agent commit and push',
+        ov.sandbox?.vGpu === true && 'sandbox.vGpu = true widens the sandbox attack surface',
+    ]);
+    return [...lines, ...risky.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 });