windows-development-sandbox 1.0.5 → 1.4.0

package/dist/selftest/config.test.js

@@ -1,74 +1,38 @@
-// Config loading, argument parsing, workspace resolution and .sandbox-config.json trust.
-import fs from 'node:fs';
+// Loading the settings: built-in defaults, a user config file, and the example config that ships with the tool.
 import path from 'node:path';
-import { parseCli as parseArgs } from '../cli/args.js';
-import { loadConfig } from '../core/config.js';
-import { ensureDir } from '../core/util.js';
-import { autoGuestWorkspace } from '../core/workspace.js';
-export const configTests = async (t, f) => {
-    const { check, rejects, write, temp } = t;
-    t.section('config');
-    const builtIn = loadConfig();
-    check(builtIn.configPath === null && builtIn.config.guestWorkspace === 'auto' && !builtIn.config.sandbox.headless && !builtIn.config.sandbox.vGpu && builtIn.config.provisioning.git.access === 'full', 'no user config: built-in defaults (auto guest folder, headless off, vGPU off, git full)');
-    const custom = loadConfig(write(path.join(temp, 'cfg.json'), JSON.stringify({ sandbox: { headless: true }, toolchains: { rust: { enabled: false } }, mappings: [{ host: 'rel-folder', guest: 'C:\\Rel', readOnly: true }] })));
-    check(custom.config.sandbox.headless && custom.config.toolchains.rust.enabled === false && custom.config.toolchains.python.enabled === 'auto', 'a config file only needs the keys it changes (deep merge over defaults)');
-    check(await rejects(() => loadConfig(path.join(temp, 'missing.json')), 'Config file not found'), 'an explicit --config that does not exist is an error');
-    check(loadConfig(path.join(t.packageRoot, 'config.example.json')).config.defaultHarness === 'claude', 'config.example.json is valid');
-    ensureDir(path.join(temp, 'rel-folder'));
-    const relRun = await f.run({}, { ...custom.config, storage: f.baseConfig.storage });
-    check(relRun.config.mappings.some((m) => m.host === path.join(temp, 'rel-folder')), 'relative mappings in the user config resolve against the config file\'s folder');
-    t.section('arguments');
-    const wrapped = parseArgs(['--terminal', '--continue', '--headless', '--node', '20', '--', '--terminal'], true);
-    check(wrapped.command === 'launch' && wrapped.terminal && wrapped.headless === true && wrapped.node === '20' && wrapped.passthrough.join(' ') === '--continue --terminal', 'claude-sbx: sandbox flags are consumed, everything else goes to the agent');
-    check(await rejects(() => parseArgs(['status', '--bogus']), 'unknown option') && parseArgs(['account', 'use', 'work', '--no-restart']).positionals.join() === 'use,work' && parseArgs(['clean', '--days=3']).days === 3, 'agent-sandbox: unknown options are errors; positionals and --opt=value work');
-    const agentFlags = parseArgs(['--model', 'opus', '-p', 'fix it', '--json', '-f', 'x', '--timeout', '5', '--resume', 'abc'], true);
-    check(agentFlags.passthrough.join(' ') === '--model opus -p fix it --json -f x --timeout 5 --resume abc' && !agentFlags.json && !agentFlags.follow && agentFlags.timeout === 600, 'claude-sbx: only launch options are ours; any other flag (even ones agent-sandbox uses elsewhere) goes to the agent, in order');
-    const reserved = parseArgs(['--sbx-terminal', '--terminal', '--sbx-node=18'], true);
-    check(reserved.terminal && reserved.node === '18' && reserved.passthrough.join(' ') === '' && parseArgs(['launch', '--continue', '--sbx-headless']).passthrough.join() === '--continue' && await rejects(() => parseArgs(['--sbx-nope'], true), 'Unknown option: --sbx-nope'), '--sbx-<option> always means agent-sandbox; agent-sandbox launch passes agent flags too');
-    t.section('workspace');
-    const rA = await f.run();
-    check(rA.workspaceHost === f.workA && rA.config.guestWorkspace === 'C:\\Workspace\\work-a' && rA.harnessName === 'claude' && rA.dataPath.endsWith(path.join('data', 'testdata')), 'any folder is the workspace; guest path is C:\\Workspace\\<folder name>');
-    check(autoGuestWorkspace('C:\\x\\My Proj (2)') === 'C:\\Workspace\\My Proj _2_' && autoGuestWorkspace('D:\\...') === 'C:\\Workspace\\project', 'auto guest folder names are sanitised');
-    check(rA.versions.node.spec === '22.3.0' && rA.versions.node.source === 'this PC' && rA.versions.python.spec === '3', 'default Node version is this PC\'s; Python defaults to latest 3.x');
-    write(path.join(f.workA, '.nvmrc'), 'lts/iron\n');
-    write(path.join(f.workA, '.python-version'), '3.11\n');
-    const rV = await f.run();
-    check(rV.versions.node.spec === 'lts/iron' && rV.versions.node.source === '.nvmrc' && rV.versions.python.spec === '3.11', '.nvmrc and .python-version are respected');
-    check((await f.run({ nodeVersion: '18' })).versions.node.source === 'command line', '--node beats .nvmrc');
-    fs.rmSync(path.join(f.workA, '.nvmrc'));
-    fs.rmSync(path.join(f.workA, '.python-version'));
-    write(path.join(f.workA, '.node-version'), 'v20.11.1');
-    check((await f.run()).versions.node.spec === 'v20.11.1', '.node-version is respected');
-    fs.rmSync(path.join(f.workA, '.node-version'));
-    check(await rejects(() => f.run({ cwd: f.install }), 'install folder') && await rejects(() => f.run({ cwd: temp }), 'must not be able to change') && await rejects(() => f.run({ cwd: path.join(temp, 'storage') }), 'storage folder'), 'refuses the install folder, its parents and the storage folder');
-    const originalWindir = process.env.WINDIR;
-    ensureDir(path.join(temp, 'winroot', 'sys'));
-    process.env.WINDIR = path.join(temp, 'winroot');
-    const sysRefused = await rejects(() => f.run({ cwd: path.join(temp, 'winroot', 'sys') }), 'system folder');
-    process.env.WINDIR = originalWindir;
-    check(sysRefused && await rejects(() => f.run({ cwd: path.parse(temp).root }), 'whole drive'), 'refuses system folders and drive roots');
-    t.section('.sandbox-config.json');
-    const localB = { harness: 'codex', sandbox: { memoryMb: 4096, networking: false, headless: true }, toolchains: { node: { version: '18' }, rust: { enabled: false } }, mappings: [{ host: './assets', guest: 'C:\\Assets', readOnly: true }, { host: '../shared', guest: 'C:\\Shared', readOnly: false }], scripts: ['./setup.mjs'] };
-    f.writeLocal(f.workB, localB);
-    check(await rejects(() => f.run({ cwd: f.workB }), '--trust-config') && await rejects(() => f.run({ cwd: f.workB }), 'READ/WRITE'), 'an untrusted .sandbox-config.json is refused and its effects are listed');
-    check(await rejects(() => f.run({ cwd: f.workB, ask: async () => false }), 'has not been approved'), 'answering "no" refuses it');
-    const rB = await f.run({ cwd: f.workB, ask: async () => true });
-    check(rB.harnessName === 'codex' && rB.config.sandbox.memoryMb === 4096 && rB.config.sandbox.headless && !rB.config.toolchains.rust.enabled && rB.config.toolchains.python.enabled && rB.versions.node.source === '.sandbox-config.json', 'approved local settings apply over the defaults (incl. toolchains, headless)');
-    check(rB.config.mappings.some((m) => m.host === f.shared && !m.readOnly) && rB.scripts.includes(path.join(f.workB, 'setup.mjs')), 'relative paths resolve against the folder of .sandbox-config.json');
-    check((await f.run({ cwd: f.workB })).harnessName === 'codex' && (await f.run({ cwd: f.workB, noLocalConfig: true })).harnessName === 'claude' && (await f.run({ cwd: f.workB, harness: 'gemini' })).harnessName === 'gemini', 'approval is remembered; --no-local-config and --harness win');
-    check((await f.run({ cwd: f.workB, headless: false })).config.sandbox.headless === false, '--window beats a local headless setting');
-    f.writeLocal(f.workB, { ...localB, sandbox: { memoryMb: 6144 } });
-    check(await rejects(() => f.run({ cwd: f.workB }), 'has not been approved'), 'changing the file requires approval again');
-    const dirC = path.join(temp, 'work-c');
-    ensureDir(dirC);
-    const bad = async (content, needle) => { f.writeLocal(dirC, content); return rejects(() => f.run({ cwd: dirC, trustConfig: true }), needle); };
-    check(await bad({ storage: { root: 'C:\\x' } }, 'storage is not allowed') && await bad({ harnesses: {} }, 'harnesses is not allowed'), 'local file cannot change storage or agent executables');
-    check(await bad({ claudeProfile: { hostDir: 'C:\\x' } }, 'claudeProfile.hostDir is not allowed') && await bad({ toolchains: { node: { hostDir: 'x' } } }, 'toolchains.node.hostDir is not allowed'), 'local file cannot point at host folders');
-    check(await bad({ sandbox: { memoryMb: 12 } }, 'sandbox.memoryMb:') && await bad({ mappings: [{ host: 'x', guest: 'C:\\Windows\\x', readOnly: true }] }, 'reserved or invalid guest path') && await bad({ provisioning: { git: { access: 'admin' } } }, 'provisioning.git.access:'), 'values are type-checked; reserved guest paths and unknown git modes are rejected');
-    check(await bad('{\n  // a comment\n  "readOnly": tru\n}', 'line 3') && await bad({ _comment: 'old style' }, '_comment is not allowed'), 'broken JSON is reported with line and column; unknown keys are rejected');
-    f.writeLocal(dirC, '// comments and trailing commas are fine\n{\n  "readOnly": true, /* inline */\n}\n');
-    check((await f.run({ cwd: dirC, trustConfig: true })).config.readOnly === true, '.sandbox-config.json may contain comments and trailing commas');
-    f.writeLocal(dirC, { claudeProfile: { copyCredentials: true }, network: { blockPrivateRanges: false }, provisioning: { git: { access: 'full' } } });
-    check(await rejects(() => f.run({ cwd: dirC }), 'copies your Claude LOGIN') && await rejects(() => f.run({ cwd: dirC }), 'turns OFF the LAN block') && await rejects(() => f.run({ cwd: dirC }), 'commit and push'), 'risky settings are called out before approval');
-    fs.rmSync(path.join(dirC, '.sandbox-config.json'));
+import _ from 'lodash';
+import { DEFAULTS, loadConfig } from '../core/config.js';
+import { readJsonc } from '../core/util.js';
+export const configSuite = {
+    name: 'config',
+    title: 'built-in defaults, user config file, config.example.json',
+    run: async (t, f) => {
+        t.section('built-in defaults');
+        const builtIn = loadConfig();
+        t.equal({
+            configPath: builtIn.configPath,
+            guestWorkspace: builtIn.config.guestWorkspace,
+            headless: builtIn.config.sandbox.headless,
+            vGpu: builtIn.config.sandbox.vGpu,
+            gitAccess: builtIn.config.provisioning.git.access,
+        }, { configPath: null, guestWorkspace: 'auto', headless: false, vGpu: false, gitAccess: 'full' }, 'with no user config the built-in defaults apply (auto guest folder, headless off, vGPU off, git full)');
+        t.section('a user config file');
+        const customFile = t.writeJson(t.at('cfg.json'), {
+            sandbox: { headless: true },
+            toolchains: { rust: { enabled: false } },
+            mappings: [{ host: 'rel-folder', guest: 'C:\\Rel', readOnly: true }],
+        });
+        const custom = loadConfig(customFile);
+        t.equal({ headless: custom.config.sandbox.headless, rust: custom.config.toolchains.rust.enabled, python: custom.config.toolchains.python.enabled }, { headless: true, rust: false, python: 'auto' }, 'a config file only needs the keys it changes (deep merge over the defaults)');
+        await t.throws(() => loadConfig(t.at('missing.json')), 'Config file not found', 'an explicit --config that does not exist is an error');
+        t.dir('rel-folder');
+        const relativeRun = await f.run({}, { ...custom.config, storage: f.baseConfig.storage });
+        const mappedHosts = relativeRun.config.mappings.map((m) => m.host);
+        t.check(mappedHosts.includes(t.at('rel-folder')), 'relative mappings in the user config resolve against the config file\'s folder', 'mapped hosts: ' + JSON.stringify(mappedHosts));
+        t.section('config.example.json');
+        const examplePath = path.join(t.packageRoot, 'config.example.json');
+        t.equal(loadConfig(examplePath).config.defaultHarness, 'claude', 'config.example.json is valid');
+        const example = _.omit(readJsonc(examplePath), '$schema');
+        t.check(_.isEqual(example, DEFAULTS), 'config.example.json lists exactly the built-in defaults', 'the differences are in: ' + Object.keys(DEFAULTS).filter((key) => !_.isEqual(example[key], DEFAULTS[key])).join(', '));
+    },
 };

package/dist/selftest/data.test.d.ts

@@ -1,2 +1,2 @@
-import type { Harness } from './harness.js';
-export declare const dataTests: (t: Harness) => void;
+import type { Suite } from './suite.js';
+export declare const dataSuite: Suite;

package/dist/selftest/data.test.js

@@ -1,73 +1,80 @@
-// `sandbox data` target resolution and `sandbox repair` detection (half-installed toolchains, leftovers, links).
+// `sandbox data` and `sandbox clean`: what a clean target may name, how sizes and removal treat links, and which old
+// launch folders, logs and downloads are pruned.
 import fs from 'node:fs';
 import path from 'node:path';
-import { humanBytes, removeTree, resolveCleanTargets, sizeOf } from '../cli/commands/data.js';
-import { deadPidFiles, findHalfInstalled, findLinks, findStagingLeftovers, globalPackages, resolvedVersionsValid } from '../cli/commands/repair.js';
-import { ensureDir, errMsg } from '../core/util.js';
-export const dataTests = (t) => {
-    const { check, write } = t;
-    t.section('data: clean targets');
-    const storage = path.join(t.temp, 'data-store');
-    const dataPath = path.join(storage, 'data', 'default');
-    const resolve = (...inputs) => resolveCleanTargets(inputs, dataPath, storage).map((r) => path.relative(storage, r.path));
-    const rejected = (...inputs) => { try {
-        resolveCleanTargets(inputs, dataPath, storage);
-        return false;
-    }
-    catch (e) {
-        return errMsg(e).length > 0;
-    } };
-    const d = (...parts) => path.join('data', 'default', ...parts);
-    check(resolve('tools/go').join() === d('tools', 'go') && resolve('tools\\go').join() === d('tools', 'go') && resolve('Tools/agents/claude').join() === d('tools', 'agents', 'claude'), 'clean: tools/<name> and tools/agents/<name> resolve inside the data folder (either slash)');
-    check(resolve('databases/postgres-18').join() === d('databases', 'postgres-18') && resolve('logs').join() === d('logs') && resolve('launches').join() === 'launches' && resolve('state/claude').join() === d('state', 'claude'), 'clean: databases/<name>, logs, launches, state/<agent>');
-    check(resolve('tools', 'tools/go', 'tools/go').join() === d('tools') && resolve('all', 'logs').join() === [d(), 'launches'].join(), 'clean: nested and repeated targets collapse; all = the data folder + launches');
-    check(Boolean(resolveCleanTargets(['state/claude'], dataPath, storage)[0].warning?.includes('login')) && Boolean(resolveCleanTargets(['all'], dataPath, storage)[0].warning), 'clean: state and all carry a warning');
-    const bad = ['', '..', 'tools/..', 'tools/../../x', '../data', 'C:\\Windows', 'C:tools', '/etc', '\\\\server\\share', 'tools/*', 'tools/go:stream', 'tools/a/b', 'tools/agents/a/b', 'logs/guest.log', 'accounts', 'sync', 'windows', 'tools/.', 'tools/go.'];
-    const accepted = bad.filter((b) => !rejected(b));
-    check(accepted.length === 0 && rejected(), 'clean: rejects .., absolute paths, drive letters, UNC, wildcards, streams, too deep, unknown areas, nothing (accepted: ' + JSON.stringify(accepted) + ')');
-    t.section('data: sizes and removal never follow links');
-    const sized = path.join(t.temp, 'sized');
-    write(path.join(sized, 'a.bin'), 'x'.repeat(1000));
-    write(path.join(sized, 'sub', 'b.bin'), 'y'.repeat(24));
-    const outside = path.join(t.temp, 'outside');
-    write(path.join(outside, 'keep.txt'), 'z'.repeat(5000));
-    let linked = false;
-    try {
-        fs.symlinkSync(outside, path.join(sized, 'sub', 'escape'), 'junction');
-        linked = true;
-    }
-    catch { /* no junctions here */ }
-    check(sizeOf(sized) === 1024 && humanBytes(1536) === '1.5 KB' && humanBytes(0) === '0 B' && humanBytes(3 * 1024 ** 3) === '3.0 GB', 'data: sizes count real files only' + (linked ? ' (a junction counts 0)' : ''));
-    if (linked)
-        check(findLinks(sized).length === 1, 'repair: finds a junction planted in the data folder');
-    removeTree(sized, t.temp);
-    check(!fs.existsSync(sized) && fs.existsSync(path.join(outside, 'keep.txt')), 'data: removing a folder never deletes what a link inside points to');
-    t.section('repair: detection');
-    const tools = path.join(t.temp, 'repair', 'tools');
-    write(path.join(tools, 'go', '1.23.2', 'bin', 'go.exe'), 'x');
-    ensureDir(path.join(tools, 'go', '1.22.8', 'src'));
-    write(path.join(tools, 'java', 'jdk-21', 'bin', 'java.exe'), 'x');
-    ensureDir(path.join(tools, 'java', 'jdk-17', 'lib'));
-    write(path.join(tools, 'python', 'python-3.12.7', 'python.exe'), 'x');
-    write(path.join(tools, 'nvm', 'settings.txt'), 'x');
-    write(path.join(tools, 'nvm', 'v22.11.0', 'node.exe'), 'x');
-    ensureDir(path.join(tools, 'nvm', 'v20.18.0'));
-    write(path.join(tools, 'git', 'bin', 'bash.exe'), 'x');
-    ensureDir(path.join(tools, 'dotnet', 'sdk'));
-    ensureDir(path.join(tools, 'go', '1.24.0.staging-ab12cd'));
-    ensureDir(path.join(tools, 'node-staging'));
-    ensureDir(path.join(tools, 'rust.staging-0f'));
-    const half = findHalfInstalled(tools).map((h) => path.relative(tools, h.path)).sort();
-    check(half.join() === ['dotnet', 'java\\jdk-17', 'go\\1.22.8', 'nvm', 'nvm\\v20.18.0'].map((p) => p.split('\\').join(path.sep)).sort().join(), 'repair: half-installed toolchains = folder without its program (got ' + half.join(', ') + ')');
-    const staging = findStagingLeftovers(tools).map((p) => path.relative(tools, p)).sort();
-    check(staging.join() === [path.join('go', '1.24.0.staging-ab12cd'), 'node-staging', 'rust.staging-0f'].sort().join(), 'repair: interrupted downloads in tools and one level down (got ' + staging.join(', ') + ')');
-    check(resolvedVersionsValid('{"go":"1.23.2"}') && resolvedVersionsValid('\uFEFF{}') && !resolvedVersionsValid('{"go":') && !resolvedVersionsValid('[1]'), 'repair: resolved-versions.json must be a JSON object');
-    check(globalPackages('{"dependencies":{"agent-sandbox":{"version":"1.0.0"},"npm":{}}}').join() === 'agent-sandbox,npm' && globalPackages('nope').length === 0 && globalPackages('{"dependencies":3}').length === 0, 'repair: reads npm ls -g --json');
-    const run = path.join(t.temp, 'repair', 'run');
-    write(path.join(run, 'watcher-default.pid'), '4242');
-    write(path.join(run, 'watcher-other.pid'), String(process.pid));
-    write(path.join(run, 'watcher-junk.pid'), 'not a pid');
-    write(path.join(run, 'hidden-windows.json'), '[]');
-    const dead = deadPidFiles(run, (pid) => pid === process.pid).map((f) => path.basename(f)).sort();
-    check(dead.join() === 'watcher-default.pid,watcher-junk.pid', 'repair: stale watcher pid files (dead process or junk) are found; a live one is kept');
+import { resolveCleanTargets } from '../cli/commands/data/clean.js';
+import { removeTree } from '../cli/commands/data/remove.js';
+import { findLinks } from '../cli/commands/repair/finders.js';
+import { humanBytes, sizeOf } from '../core/disk.js';
+import { pruneStorage } from '../host/cleanup.js';
+export const dataSuite = {
+    name: 'data',
+    title: 'data clean targets, sizes and removal with links, storage cleanup',
+    run: async (t) => {
+        t.section('clean targets');
+        const storage = t.at('data-store');
+        const dataPath = path.join(storage, 'data', 'default');
+        const resolve = (...inputs) => resolveCleanTargets(inputs, dataPath, storage).map((r) => path.relative(storage, r.path));
+        const inData = (...parts) => path.join('data', 'default', ...parts);
+        t.equal(resolve('tools/go'), [inData('tools', 'go')], 'tools/<name> resolves inside the data folder');
+        t.equal(resolve('tools\\go'), [inData('tools', 'go')], 'either slash works');
+        t.equal(resolve('Tools/agents/claude'), [inData('tools', 'agents', 'claude')], 'tools/agents/<name> resolves, whatever the case');
+        t.equal(resolve('databases/postgres-18'), [inData('databases', 'postgres-18')], 'databases/<name> resolves');
+        t.equal(resolve('logs'), [inData('logs')], 'logs resolves');
+        t.equal(resolve('launches'), ['launches'], 'launches resolves to the storage folder\'s launches');
+        t.equal(resolve('state/claude'), [inData('state', 'claude')], 'state/<agent> resolves');
+        t.equal(resolve('tools', 'tools/go', 'tools/go'), [inData('tools')], 'nested and repeated targets collapse');
+        t.equal(resolve('all', 'logs'), [inData(), 'launches'], '`all` is the data folder plus launches');
+        t.check(Boolean(resolveCleanTargets(['state/claude'], dataPath, storage)[0].warning?.includes('login')), 'cleaning state warns about the login');
+        t.check(Boolean(resolveCleanTargets(['all'], dataPath, storage)[0].warning), 'cleaning everything carries a warning');
+        const badTargets = ['', '..', 'tools/..', 'tools/../../x', '../data', 'C:\\Windows', 'C:tools', '/etc', '\\\\server\\share', 'tools/*', 'tools/go:stream', 'tools/a/b', 'tools/agents/a/b', 'logs/guest.log', 'accounts', 'sync', 'windows', 'tools/.', 'tools/go.'];
+        const accepted = badTargets.filter((target) => {
+            try {
+                resolveCleanTargets([target], dataPath, storage);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        t.equal(accepted, [], 'rejected: .., absolute paths, drive letters, UNC, wildcards, streams, too deep, unknown areas');
+        await t.throws(() => resolveCleanTargets([], dataPath, storage), '', 'rejected: no target at all (that is not "everything")');
+        t.section('sizes and removal never follow links');
+        const sized = t.at('sized');
+        t.write(path.join(sized, 'a.bin'), 'x'.repeat(1000));
+        t.write(path.join(sized, 'sub', 'b.bin'), 'y'.repeat(24));
+        const outside = t.at('outside');
+        t.write(path.join(outside, 'keep.txt'), 'z'.repeat(5000));
+        let linked = false;
+        try {
+            fs.symlinkSync(outside, path.join(sized, 'sub', 'escape'), 'junction');
+            linked = true;
+        }
+        catch { /* no junctions here */ }
+        t.equal(sizeOf(sized), 1024, 'sizes count real files only' + (linked ? ' (a junction counts 0)' : ''));
+        t.equal([humanBytes(1536), humanBytes(0), humanBytes(3 * 1024 ** 3)], ['1.5 KB', '0 B', '3.0 GB'], 'sizes are shown in readable units');
+        if (linked)
+            t.equal(findLinks(sized).length, 1, 'repair finds a junction planted in the data folder');
+        removeTree(sized, t.temp);
+        t.check(!fs.existsSync(sized), 'a folder is removed');
+        t.check(fs.existsSync(path.join(outside, 'keep.txt')), 'removing a folder never deletes what a link inside points to');
+        t.section('storage cleanup');
+        const store = t.at('prune');
+        const aged = (p, days) => { const d = new Date(Date.now() - days * 86400000); fs.utimesSync(p, d, d); };
+        for (const [name, days] of [['old', 9], ['kept', 30], ['new', 1]]) {
+            aged(t.write(path.join(store, 'launches', name, 'agent.wsb'), 'x'), days);
+            aged(path.join(store, 'launches', name), days);
+        }
+        aged(t.write(path.join(store, 'data', 'd', 'logs', 'guest-old.log'), 'x'), 20);
+        t.write(path.join(store, 'data', 'd', 'logs', 'guest-new.log'), 'x');
+        const staging = t.dir('prune', 'data', 'd', 'tools', 'git.staging-ab12');
+        aged(staging, 2);
+        t.dir('prune', 'data', 'd', 'tools', 'node');
+        const pruned = pruneStorage(store, { keep: ['kept'] });
+        const left = (p) => fs.existsSync(path.join(store, p));
+        t.equal(pruned.launches, 1, 'cleanup removes one launch folder');
+        t.equal({ old: left('launches/old'), kept: left('launches/kept'), new: left('launches/new') }, { old: false, kept: true, new: true }, 'cleanup: launch folders older than 7 days go; the running launch and recent ones stay');
+        t.equal({ oldLog: left('data/d/logs/guest-old.log'), newLog: left('data/d/logs/guest-new.log') }, { oldLog: false, newLog: true }, 'cleanup: logs older than 14 days go');
+        t.equal({ interrupted: left('data/d/tools/git.staging-ab12'), realTool: left('data/d/tools/node') }, { interrupted: false, realTool: true }, 'cleanup: interrupted downloads go; real tools stay');
+    },
 };

package/dist/selftest/detect.test.d.ts

@@ -1,2 +1,2 @@
-import type { Harness } from './harness.js';
-export declare const detectTests: (t: Harness) => void;
+import type { Suite } from './suite.js';
+export declare const detectSuite: Suite;

package/dist/selftest/detect.test.js

@@ -1,42 +1,58 @@
-// "Which databases does this project need?": detection from real-world file shapes, and the plan the host builds.
+// "What does this project need?": databases and toolchains detected from project files, and the plans built from them.
 import { databasesFromServices, detectDatabases } from '../core/detect-databases.js';
 import { DEFAULTS } from '../core/config.js';
-import { databaseCatalog, planDatabases } from '../host/project-scan.js';
-import { voltaNode } from '../core/workspace.js';
+import { databaseCatalog, planDatabases } from '../host/database-plan.js';
 import { decideToolchains, resolveToolchains } from '../core/detect-toolchains.js';
-import { parseReleasePage } from '../shared/download.js';
-const found = (files, host = []) => detectDatabases(files, host).map((d) => d.database).join(',');
-export const detectTests = (t) => {
-    const { check } = t;
-    t.section('database detection');
-    const compose = { path: 'docker-compose.yml', text: 'services:\n  db:\n    image: postgres:16-alpine\n  cache:\n    image: "redis:7"\n  dynamo:\n    image: amazon/dynamodb-local:latest\n' };
-    check(found([compose]) === 'postgres,redis,dynamodb', 'compose services: postgres, redis and DynamoDB Local images');
-    check(found([{ path: 'package.json', text: '{"dependencies":{"pg":"^8.11.0","ioredis":"5","@aws-sdk/client-dynamodb":"3"}}' }]) === 'postgres,redis,dynamodb', 'package.json: pg, ioredis, @aws-sdk/client-dynamodb');
-    check(found([{ path: 'package.json', text: '{"dependencies":{"pgadmin-ui":"1","mysql-logger":"2","express":"4"}}' }]) === '', 'package.json: names that only contain a driver name do not count');
-    check(found([{ path: 'prisma/schema.prisma', text: 'datasource db {\n  provider = "mysql"\n  url = env("DATABASE_URL")\n}' }]) === 'mysql', 'Prisma: the datasource provider decides');
-    check(found([{ path: 'requirements.txt', text: 'django==5.0\npsycopg2-binary==2.9\npymongo>=4\n' }]) === 'postgres,mongodb', 'Python requirements: psycopg2 and pymongo');
-    check(found([{ path: 'Api/Api.csproj', text: '<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.0" />' }]) === 'sqlserver', '.NET: EF Core SQL Server provider');
-    check(found([{ path: '.env.example', text: 'DATABASE_URL=postgresql://user:pass@localhost:5432/app\nMONGO_URL=mongodb+srv://cluster/x\n' }]) === 'postgres,mongodb', '.env templates: connection-string schemes');
-    check(found([{ path: 'template.yaml', text: 'Resources:\n  Table:\n    Type: AWS::DynamoDB::Table\n' }]) === 'dynamodb', 'SAM/CloudFormation: a DynamoDB table resource');
-    check(found([{ path: 'go.mod', text: 'require (\n\tgithub.com/jackc/pgx/v5 v5.5.0\n\tgithub.com/aws/aws-sdk-go-v2/service/dynamodb v1.0.0\n)' }]) === 'postgres,dynamodb', 'go.mod: pgx and the DynamoDB SDK');
-    check(found([{ path: 'package.json', text: '{"dependencies":{"knex":"3"}}' }]) === '' && found([{ path: 'package.json', text: '{"dependencies":{"knex":"3"}}' }], ['mysql']) === 'mysql', 'an ORM that names no database uses the one installed on this PC (and nothing without one)');
-    check(databasesFromServices(['postgresql-x64-16', 'MySQL80', 'MSSQL$SQLEXPRESS', 'Spooler', 'Redis']).join() === 'postgres,mysql,sqlserver,redis', 'database services on this PC are recognised by name');
-    const plan = planDatabases({ ...DEFAULTS.databases, mongodb: { ...DEFAULTS.databases.mongodb, enabled: true }, redis: { ...DEFAULTS.databases.redis, enabled: false } }, 'unused', { files: [compose], host: [] });
-    check(plan.map((p) => p.database + '@' + p.version + ':' + p.port).join() === 'postgres@16:5432,mongodb@latest:27017,dynamodb@latest:8000' && plan.find((p) => p.database === 'dynamodb')?.adminPort === 8001, 'plan: "auto" from the project (compose pins Postgres 16), true always, false never; DynamoDB gets its admin UI');
-    const catalog = databaseCatalog({ ...DEFAULTS.databases, postgres: { ...DEFAULTS.databases.postgres, enabled: false, port: 6543 } });
-    check(catalog.map((p) => p.database).join() === 'postgres,mysql,mongodb,redis,dynamodb' && catalog[0].port === 6543, 'sbx-db catalog: every database that can run (not SQL Server), even ones off at boot, with their configured ports');
-    const volta = t.write(t.temp + '\\volta-ws\\package.json', '{"name":"x","volta":{"node":"20.11.1","pnpm":"9.1.0"}}');
-    t.write(t.temp + '\\no-volta-ws\\package.json', '{"name":"y","volta":{"node":"latest; rm -rf"}}');
-    check(voltaNode(volta.replace(/\\package\.json$/, '')) === '20.11.1' && voltaNode(t.temp + '\\no-volta-ws') === null && voltaNode(t.temp + '\\missing') === null, 'Volta: package.json "volta.node" picks the Node version (only a plain version is accepted)');
-    const tc = DEFAULTS.toolchains;
-    const goApi = decideToolchains(tc, ['README.md', 'go.mod', 'api/main.go'], ['python', 'rust']);
-    check(goApi.go.on && goApi.go.reason === 'go.mod' && !goApi.python.on && !goApi.rust.on && !goApi.dotnet.on && !goApi.java.on, 'toolchains: a Go project gets Go and nothing it does not use, whatever this PC has');
-    const fresh = decideToolchains(tc, ['notes.txt'], ['python', 'dotnet']);
-    check(fresh.python.on && fresh.dotnet.on && !fresh.go.on && fresh.python.reason.includes('this PC'), 'toolchains: a folder that is no project yet gets the languages this PC has');
-    const rusty = decideToolchains({ ...tc, python: { ...tc.python, enabled: true } }, ['Cargo.toml'], []);
-    check(rusty.rust.on && rusty.cpp.on && rusty.python.on && rusty.python.reason === 'enabled in config', 'toolchains: Rust brings its C/C++ linker; true in config always wins');
-    check(resolveToolchains(tc, goApi).go.enabled === true && resolveToolchains(tc, goApi).python.enabled === false, 'the sandbox gets plain decisions instead of "auto"');
-    const page = '<a href="/o/r/releases/download/v1/tool-win-x64.zip">x</a><span>sha256:' + 'a'.repeat(64) + '</span><a href="/o/r/releases/download/v1/tool-linux.tar.gz">y</a>';
-    const assets = parseReleasePage(page);
-    check(assets.length === 2 && assets[0].url === 'https://github.com/o/r/releases/download/v1/tool-win-x64.zip' && assets[0].sha256 === 'a'.repeat(64) && assets[1].sha256 === null, 'GitHub release page fallback (API rate limit): assets with their own sha256 only');
+const found = (files, host = []) => detectDatabases(files, host).map((d) => d.database);
+const file = (path, text) => ({ path, text });
+export const detectSuite = {
+    name: 'detect',
+    title: 'database and toolchain detection from project files',
+    run: (t) => {
+        t.section('databases from project files');
+        const compose = file('docker-compose.yml', 'services:\n  db:\n    image: postgres:16-alpine\n  cache:\n    image: "redis:7"\n  dynamo:\n    image: amazon/dynamodb-local:latest\n');
+        t.equal(found([compose]), ['postgres', 'redis', 'dynamodb'], 'compose services: postgres, redis and DynamoDB Local images');
+        t.equal(found([file('package.json', '{"dependencies":{"pg":"^8.11.0","ioredis":"5","@aws-sdk/client-dynamodb":"3"}}')]), ['postgres', 'redis', 'dynamodb'], 'package.json: pg, ioredis, @aws-sdk/client-dynamodb');
+        t.equal(found([file('package.json', '{"dependencies":{"pgadmin-ui":"1","mysql-logger":"2","express":"4"}}')]), [], 'package.json: names that only contain a driver name do not count');
+        t.equal(found([file('prisma/schema.prisma', 'datasource db {\n  provider = "mysql"\n  url = env("DATABASE_URL")\n}')]), ['mysql'], 'Prisma: the datasource provider decides');
+        t.equal(found([file('requirements.txt', 'django==5.0\npsycopg2-binary==2.9\npymongo>=4\n')]), ['postgres', 'mongodb'], 'Python requirements: psycopg2 and pymongo');
+        t.equal(found([file('Api/Api.csproj', '<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.0" />')]), ['sqlserver'], '.NET: EF Core SQL Server provider');
+        t.equal(found([file('.env.example', 'DATABASE_URL=postgresql://user:pass@localhost:5432/app\nMONGO_URL=mongodb+srv://cluster/x\n')]), ['postgres', 'mongodb'], '.env templates: connection-string schemes');
+        t.equal(found([file('template.yaml', 'Resources:\n  Table:\n    Type: AWS::DynamoDB::Table\n')]), ['dynamodb'], 'SAM/CloudFormation: a DynamoDB table resource');
+        t.equal(found([file('go.mod', 'require (\n\tgithub.com/jackc/pgx/v5 v5.5.0\n\tgithub.com/aws/aws-sdk-go-v2/service/dynamodb v1.0.0\n)')]), ['postgres', 'dynamodb'], 'go.mod: pgx and the DynamoDB SDK');
+        const knex = [file('package.json', '{"dependencies":{"knex":"3"}}')];
+        t.equal(found(knex), [], 'an ORM that names no database uses nothing when this PC has none');
+        t.equal(found(knex, ['mysql']), ['mysql'], 'an ORM that names no database uses the one installed on this PC');
+        t.equal(databasesFromServices(['postgresql-x64-16', 'MySQL80', 'MSSQL$SQLEXPRESS', 'Spooler', 'Redis']), ['postgres', 'mysql', 'sqlserver', 'redis'], 'database services on this PC are recognised by name');
+        // Hostile workspace files (a cloned repository is untrusted): detection must stay linear.
+        const hostile = [
+            file('.env', 'Server=a;Database=a;'.repeat(12000)),
+            file('compose.yaml', 'services:\n  x:\n    image: ' + 'postgres'.repeat(20000) + '!\n'),
+            file('appsettings.json', 'Host=a;'.repeat(30000)),
+        ];
+        const started = Date.now();
+        detectDatabases(hostile);
+        const took = Date.now() - started;
+        t.check(took < 2000, 'database detection stays fast on hostile workspace files (no catastrophic backtracking)', 'took ' + took + ' ms');
+        t.section('the database plan');
+        const plan = planDatabases({ ...DEFAULTS.databases, mongodb: { ...DEFAULTS.databases.mongodb, enabled: true }, redis: { ...DEFAULTS.databases.redis, enabled: false } }, 'unused', { files: [compose], host: [] });
+        t.equal(plan.map((p) => p.database + '@' + p.version + ':' + p.port), ['postgres@16:5432', 'mongodb@latest:27017', 'dynamodb@latest:8000'], 'plan: "auto" from the project (compose pins Postgres 16), true always, false never');
+        t.equal(plan.find((p) => p.database === 'dynamodb')?.adminPort, 8001, 'plan: DynamoDB gets its admin UI port');
+        const catalog = databaseCatalog({ ...DEFAULTS.databases, postgres: { ...DEFAULTS.databases.postgres, enabled: false, port: 6543 } });
+        t.equal(catalog.map((p) => p.database), ['postgres', 'mysql', 'mongodb', 'redis', 'dynamodb'], 'sbx-db catalog: every database that can run (not SQL Server), even ones off at boot');
+        t.equal(catalog[0].port, 6543, 'sbx-db catalog: configured ports are used');
+        t.section('toolchains from project files');
+        const tc = DEFAULTS.toolchains;
+        const goProject = decideToolchains(tc, ['README.md', 'go.mod', 'api/main.go'], ['python', 'rust']);
+        t.equal({ go: goProject.go.on, reason: goProject.go.reason }, { go: true, reason: 'go.mod' }, 'toolchains: a Go project gets Go (and says why)');
+        t.equal({ python: goProject.python.on, rust: goProject.rust.on, dotnet: goProject.dotnet.on, java: goProject.java.on }, { python: false, rust: false, dotnet: false, java: false }, 'toolchains: a Go project gets nothing it does not use, whatever this PC has');
+        const fresh = decideToolchains(tc, ['notes.txt'], ['python', 'dotnet']);
+        t.equal({ python: fresh.python.on, dotnet: fresh.dotnet.on, go: fresh.go.on }, { python: true, dotnet: true, go: false }, 'toolchains: a folder that is no project yet gets the languages this PC has');
+        t.includes(fresh.python.reason, 'this PC', 'toolchains: the reason names this PC');
+        const rusty = decideToolchains({ ...tc, python: { ...tc.python, enabled: true } }, ['Cargo.toml'], []);
+        t.equal({ rust: rusty.rust.on, cpp: rusty.cpp.on }, { rust: true, cpp: true }, 'toolchains: Rust brings its C/C++ linker');
+        t.equal({ python: rusty.python.on, reason: rusty.python.reason }, { python: true, reason: 'enabled in config' }, 'toolchains: true in config always wins');
+        const resolved = resolveToolchains(tc, goProject);
+        t.equal({ go: resolved.go.enabled, python: resolved.python.enabled }, { go: true, python: false }, 'the sandbox gets plain decisions instead of "auto"');
+    },
 };