windows-development-sandbox 1.4.0 → 1.4.3

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

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const layoutSuite: Suite;

package/dist/selftest/layout.test.js

@@ -0,0 +1,131 @@
+// The architecture rules, checked on the compiled output (dist/**/*.js): which areas may import which, the guest's
+// portable core, the pure guest files the host and tests may load without the guest runtime's side effects, and no
+// import cycles. The bundled dist/runtime is left out (it has no imports).
+import fs from 'node:fs';
+import path from 'node:path';
+const STATIC = /^\s*(?:import|export)\b[^;]*?\bfrom\s*(['"])([^'"\n]+)\1;?\s*$|^\s*import\s*(['"])([^'"\n]+)\3;?\s*$/gm;
+const DYNAMIC = /\bimport\(\s*(['"])([^'"\n]+)\1\s*\)/g;
+const PORTABLE_CORE = [
+    /^core\/types\.js$/,
+    /^core\/schema\//,
+    /^core\/detect\/(toolchains|versions)\.js$/,
+    /^core\/util\/errors\.js$/,
+];
+const PURE_GUEST = [
+    'guest/git/decision.js',
+    'guest/setup/git-rules.js',
+    'guest/boot/project-env.js',
+    'guest/audit/parse.js',
+    'guest/sessions/cmdline.js',
+    'guest/toolchains/catalogue.js',
+    'guest/toolchains/tools/vscode-profile.js',
+];
+const SIDE_EFFECTS = ['guest/runtime/session.js', 'guest/runtime/log.js'];
+const readModules = (dist) => {
+    const files = fs
+        .readdirSync(dist, { recursive: true, encoding: 'utf8' })
+        .map((f) => f.split(path.sep).join('/'))
+        .filter((f) => f.endsWith('.js') && !f.startsWith('runtime/'));
+    const modules = new Map();
+    for (const file of files) {
+        const text = fs.readFileSync(path.join(dist, file), 'utf8');
+        const resolve = (spec) => path.posix.normalize(path.posix.join(path.posix.dirname(file), spec));
+        const statics = [];
+        const bare = [];
+        for (const m of text.matchAll(STATIC)) {
+            const spec = m[2] ?? m[4];
+            if (spec.startsWith('.'))
+                statics.push(resolve(spec));
+            else
+                bare.push(spec);
+        }
+        const dynamics = [...text.matchAll(DYNAMIC)]
+            .map((m) => m[2])
+            .filter((s) => s.startsWith('.'))
+            .map(resolve);
+        modules.set(file, { statics, dynamics, bare });
+    }
+    return modules;
+};
+/** Every file reached from `start` through static imports (start included). */
+const closure = (modules, start) => {
+    const seen = new Set();
+    const visit = (f) => {
+        if (seen.has(f))
+            return;
+        seen.add(f);
+        for (const d of modules.get(f)?.statics ?? [])
+            visit(d);
+    };
+    visit(start);
+    return seen;
+};
+const findCycle = (modules) => {
+    const state = new Map();
+    const stack = [];
+    const visit = (f) => {
+        state.set(f, 'open');
+        stack.push(f);
+        for (const d of modules.get(f)?.statics ?? []) {
+            if (state.get(d) === 'open')
+                return [...stack.slice(stack.indexOf(d)), d];
+            if (!state.has(d)) {
+                const found = visit(d);
+                if (found)
+                    return found;
+            }
+        }
+        stack.pop();
+        state.set(f, 'done');
+        return null;
+    };
+    for (const f of modules.keys()) {
+        if (state.has(f))
+            continue;
+        const found = visit(f);
+        if (found)
+            return found;
+    }
+    return null;
+};
+const area = (file) => file.split('/')[0];
+const list = (items) => items.slice(0, 10).join('\n') + (items.length > 10 ? '\n...' : '');
+export const layoutSuite = {
+    name: 'layout',
+    title: 'architecture rules on the compiled code (areas, portable core, pure guest files, cycles)',
+    run: (t) => {
+        const modules = readModules(path.join(t.packageRoot, 'dist'));
+        const files = [...modules.keys()];
+        t.check(files.length > 100 && modules.has('guest/entries/main.js'), 'the compiled code is there to check');
+        t.section('areas');
+        const guestFiles = files.filter((f) => area(f) === 'guest');
+        const guestReach = new Set(guestFiles.flatMap((f) => [...closure(modules, f)]));
+        const guestBad = [...guestReach].filter((f) => ['host', 'cli', 'sync', 'selftest'].includes(area(f)) ||
+            (area(f) === 'core' && !PORTABLE_CORE.some((p) => p.test(f))));
+        t.check(!guestBad.length, 'guest code reaches no host, cli, sync or selftest file, and only the portable core', list(guestBad));
+        const hostSide = files.filter((f) => ['host', 'cli', 'core', 'sync', 'shared'].includes(area(f)));
+        const intoGuest = hostSide.flatMap((f) => [...modules.get(f).statics, ...modules.get(f).dynamics]
+            .filter((d) => area(d) === 'guest')
+            .map((d) => f + ' -> ' + d));
+        t.check(!intoGuest.length, 'host, cli, core, sync and shared import no guest file', list(intoGuest));
+        t.section('pure guest files');
+        for (const pure of PURE_GUEST) {
+            t.check(modules.has(pure), pure + ' exists');
+            const reached = [...closure(modules, pure)].filter((f) => SIDE_EFFECTS.includes(f));
+            t.check(!reached.length, pure + ' never loads the guest runtime (session.json, log folder)', list(reached));
+        }
+        const guard = 'guest/entries/gitguard.js';
+        const guardReach = [...closure(modules, guard)].filter((f) => f !== guard && f !== 'guest/git/decision.js');
+        const guardBare = [...closure(modules, guard)]
+            .flatMap((f) => modules.get(f)?.bare ?? [])
+            .filter((b) => !b.startsWith('node:'));
+        t.check(!guardReach.length && !guardBare.length, 'the git guard loads only git/decision.js and Node built-ins', list([...guardReach, ...guardBare]));
+        t.section('imports');
+        const cycle = findCycle(modules);
+        t.check(!cycle, 'no static import cycles', cycle?.join(' -> '));
+        const intoEntries = files.flatMap((f) => [...modules.get(f).statics, ...modules.get(f).dynamics]
+            .filter((d) => d.startsWith('guest/entries/'))
+            .map((d) => f + ' -> ' + d));
+        t.check(!intoEntries.length, 'nothing imports an entry point (guest/entries)', list(intoEntries));
+    },
+};

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

@@ -1,2 +1,2 @@
-import type { Suite } from './suite.js';
+import type { Suite } from './support/suite.js';
 export declare const linksSuite: Suite;

package/dist/selftest/links.test.js

@@ -2,11 +2,11 @@
 // must never write, delete or walk through them.
 import fs from 'node:fs';
 import path from 'node:path';
-import { activateAccount, saveAccount } from '../host/accounts.js';
-import { resetRunDir, sendRequest } from '../host/channel.js';
-import { pruneStorage } from '../host/cleanup.js';
-import { assertNoLinks } from '../core/util.js';
-import { syncHistoryIn } from '../sync/history.js';
+import { AccountStore } from '../host/profile/index.js';
+import { SandboxChannel } from '../host/channel/index.js';
+import { pruneStorage } from '../host/storage/index.js';
+import { assertNoLinks } from '../core/util/index.js';
+import { syncHistoryIn } from '../sync/index.js';
 export const linksSuite = {
     name: 'links',
     title: 'links planted by the sandbox are never followed',
@@ -19,10 +19,15 @@ export const linksSuite = {
         t.section('writes under the data folder');
         fs.symlinkSync(victim, path.join(data, 'state', 'claude'), 'junction');
         await t.throws(() => assertNoLinks(data, path.join(data, 'state', 'claude', 'x.json')), 'is a link', 'any host write under the data folder through a junction is refused');
-        await t.throws(() => activateAccount(storage, data, 'any'), 'Unknown account', 'accounts never read through a sandbox junction');
-        await t.throws(() => saveAccount(storage, data, 'a', null), 'is a link', 'accounts never write through a sandbox junction');
+        await t.throws(() => new AccountStore(storage).activate(data, 'any'), 'Unknown account', 'accounts never read through a sandbox junction');
+        await t.throws(() => new AccountStore(storage).save(data, 'a', null), 'is a link', 'accounts never write through a sandbox junction');
         t.section('history sync');
-        const sides = { hostClaudeDir: t.at('link-host'), guestClaudeDir: t.at('link-guest'), hostWorkspace: 'D:\\Code\\my-app', guestWorkspace: 'C:\\Workspace\\my-app' };
+        const sides = {
+            hostClaudeDir: t.at('link-host'),
+            guestClaudeDir: t.at('link-guest'),
+            hostWorkspace: 'D:\\Code\\my-app',
+            guestWorkspace: 'C:\\Workspace\\my-app',
+        };
         t.dir('link-guest', 'projects');
         fs.symlinkSync(victim, path.join(sides.guestClaudeDir, 'projects', 'C--Workspace-my-app'), 'junction');
         t.write(path.join(sides.hostClaudeDir, 'projects', 'D--Code-my-app', 's.jsonl'), '{}\n');
@@ -35,10 +40,10 @@ export const linksSuite = {
         t.section('the run folder and cleanup');
         t.dir('evil-storage', 'data', 'd', 'run');
         fs.symlinkSync(victim, path.join(data, 'run', 'requests'), 'junction');
-        await t.throws(() => sendRequest(data, { kind: 'ping', id: 'p1', createdAt: '' }), 'is a link', 'requests are never written through a junction');
-        t.check(!fs.existsSync(path.join(victim, 'p1.json')), 'nothing was written into the junction\'s target');
+        await t.throws(() => new SandboxChannel(data).send({ kind: 'ping', id: 'p1', createdAt: '' }), 'is a link', 'requests are never written through a junction');
+        t.check(!fs.existsSync(path.join(victim, 'p1.json')), "nothing was written into the junction's target");
         fs.symlinkSync(victim, path.join(data, 'run', 'sessions'), 'junction');
-        resetRunDir(data);
+        new SandboxChannel(data).reset();
         t.check(!fs.existsSync(path.join(data, 'run', 'sessions')), 'resetting the run folder removes a junction itself...');
         t.check(fs.existsSync(precious), '... never its target');
         fs.symlinkSync(victim, path.join(data, 'logs'), 'junction');

package/dist/selftest/live-daemon.test.d.ts

@@ -1,2 +1,2 @@
-import type { Suite } from './suite.js';
+import type { Suite } from './support/suite.js';
 export declare const liveDaemonSuite: Suite;

package/dist/selftest/live-daemon.test.js

@@ -2,8 +2,8 @@
 // cmd.exe standing in for the agent. One daemon serves all the checks below, in order (compiling ptyhost is slow).
 import fs from 'node:fs';
 import path from 'node:path';
-import { queryViewers } from '../shared/pty-client.js';
-import { copyCmdAsFakeAgent, openViewer, sees, startDaemon, tail, viewersWhen, WAIT } from './live.js';
+import { queryViewers } from '../shared/pty/index.js';
+import { copyCmdAsFakeAgent, openViewer, sees, startDaemon, tail, viewersWhen, WAIT } from './support/live.js';
 export const liveDaemonSuite = {
     name: 'live-daemon',
     title: 'live: session daemon + ptyhost (start, attach, viewers, exec, restart, exit)',
@@ -16,7 +16,10 @@ export const liveDaemonSuite = {
         copyCmdAsFakeAgent(data);
         const session = f.readJson(gen.sessionPath);
         Object.assign(session, { workspace, attach: { enabled: true } });
-        Object.assign(session.harness, { arguments: ['/d', '/k', 'echo LIVE-AGENT-READY'], resumeArguments: ['/d', '/k', 'echo LIVE-AGENT-RESUMED'] });
+        Object.assign(session.harness, {
+            arguments: ['/d', '/k', 'echo LIVE-AGENT-READY'],
+            resumeArguments: ['/d', '/k', 'echo LIVE-AGENT-RESUMED'],
+        });
         t.writeJson(gen.sessionPath, session);
         const daemon = startDaemon(t, f, { launchPath: gen.launchPath, data, workspace });
         const viewers = [];
@@ -34,7 +37,7 @@ export const liveDaemonSuite = {
             const viewer = await openViewer(attach);
             viewers.push(viewer);
             const sawReady = await sees(t, viewer, 'LIVE-AGENT-READY');
-            t.check(Boolean(sawReady), 'an attached client sees the agent\'s screen', 'screen so far: ' + tail(viewer.output()) + '\n' + daemon.diagnostics());
+            t.check(Boolean(sawReady), "an attached client sees the agent's screen", 'screen so far: ' + tail(viewer.output()) + '\n' + daemon.diagnostics());
             viewer.type('echo TYPED-%USERNAME:~0,0%OK');
             const sawTyped = await sees(t, viewer, 'TYPED-OK');
             t.check(Boolean(sawTyped), 'keystrokes reach the agent', 'screen so far: ' + tail(viewer.output()));
@@ -59,7 +62,13 @@ export const liveDaemonSuite = {
             t.equal(daemon.status('live1')?.phase, 'running', 'the session keeps running when a terminal closes');
             t.equal(await queryViewers({ ...local, token: 'wrong-token' }, 10000), null, 'the viewer query needs the session token too');
             t.section('live: exec and requests');
-            daemon.request({ kind: 'exec', id: 'exec1', command: ['echo', 'hello from exec'], cwd: workspace, timeoutSeconds: 30 });
+            daemon.request({
+                kind: 'exec',
+                id: 'exec1',
+                command: ['echo', 'hello from exec'],
+                cwd: workspace,
+                timeoutSeconds: 30,
+            });
             const exec = await daemon.response('exec1');
             t.check(Boolean(exec?.ok && exec.stdout?.includes('hello from exec')), 'exec runs a command in the sandbox and returns its output', JSON.stringify(exec));
             daemon.request({ kind: 'exec', id: 'exec2', command: ['dir'], cwd: 'C:\\Windows', timeoutSeconds: 30 });
@@ -78,9 +87,12 @@ export const liveDaemonSuite = {
             t.check(Boolean(sawResumed), 'restart relaunches the agent with its resume arguments while attached', 'screen so far: ' + tail(viewer.output()) + '\n' + daemon.diagnostics());
             viewer.type('exit 3');
             const gotExit = await t.waitFor(() => viewer.exitCode() !== null, WAIT.exit);
-            const ended = await t.waitFor(() => { const s = daemon.status('live1'); return s?.phase === 'exited' ? s : null; }, WAIT.exit);
-            t.equal(gotExit ? viewer.exitCode() : null, 3, 'the agent\'s exit code reaches the attached client');
-            t.equal(ended?.exitCode, 3, 'the agent\'s exit code reaches the session status');
+            const ended = await t.waitFor(() => {
+                const s = daemon.status('live1');
+                return s?.phase === 'exited' ? s : null;
+            }, WAIT.exit);
+            t.equal(gotExit ? viewer.exitCode() : null, 3, "the agent's exit code reaches the attached client");
+            t.equal(ended?.exitCode, 3, "the agent's exit code reaches the session status");
         }
         finally {
             for (const v of viewers)

package/dist/selftest/live-git.test.d.ts

@@ -1,2 +1,2 @@
-import type { Suite } from './suite.js';
+import type { Suite } from './support/suite.js';
 export declare const liveGitSuite: Suite;

package/dist/selftest/live-git.test.js

@@ -3,8 +3,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { findOnPath } from '../core/util.js';
-import { CSC } from './live.js';
+import { findOnPath } from '../core/util/index.js';
+import { CSC } from './support/live.js';
 export const liveGitSuite = {
     name: 'live-git',
     title: 'live: the git access guard (compiled git.exe stand-in, Git Bash)',
@@ -17,7 +17,12 @@ export const liveGitSuite = {
         }
         const gen = await f.launch();
         const shimDir = t.dir('gitshim');
-        const compiled = spawnSync(CSC, ['/nologo', '/optimize', '/out:' + path.join(shimDir, 'git.exe'), path.join(gen.launchPath, 'sandbox', 'gitshim.cs')], { encoding: 'utf8' });
+        const compiled = spawnSync(CSC, [
+            '/nologo',
+            '/optimize',
+            '/out:' + path.join(shimDir, 'git.exe'),
+            path.join(gen.launchPath, 'sandbox', 'gitshim.cs'),
+        ], { encoding: 'utf8' });
         t.check(compiled.status === 0, 'gitshim.cs compiles with the .NET Framework compiler', compiled.stdout + compiled.stderr);
         if (compiled.status !== 0)
             return;
@@ -54,7 +59,11 @@ export const liveGitSuite = {
         }
         const posix = (p) => p.replace(/\\/g, '/');
         const bashEnv = t.write(t.at('gitshim', 'bashenv.sh'), 'git() { "' + posix(process.execPath) + '" "' + posix(guard) + '" "$@"; }\nexport -f git\n');
-        const viaBash = spawnSync(bash, ['-c', 'git commit -m x'], { cwd: repo, env: { ...env('readonly'), BASH_ENV: posix(bashEnv) }, encoding: 'utf8' });
+        const viaBash = spawnSync(bash, ['-c', 'git commit -m x'], {
+            cwd: repo,
+            env: { ...env('readonly'), BASH_ENV: posix(bashEnv) },
+            encoding: 'utf8',
+        });
         t.check(viaBash.status === 128 && viaBash.stderr.includes('read-only'), 'readonly: git inside Git Bash goes through the guard too (BASH_ENV)', 'exit ' + viaBash.status + ' ' + viaBash.stderr);
     },
 };

package/dist/selftest/live-network.test.d.ts

@@ -1,2 +1,2 @@
-import type { Suite } from './suite.js';
+import type { Suite } from './support/suite.js';
 export declare const liveNetworkSuite: Suite;

package/dist/selftest/live-network.test.js

@@ -3,9 +3,9 @@
 import net from 'node:net';
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
-import { startPortForwards } from '../host/port-forward.js';
-import { PROXY_PORT, relayPort } from '../shared/netpolicy.js';
-import { CSC } from './live.js';
+import { startPortForwards } from '../host/network/index.js';
+import { PROXY_PORT, relayPort } from '../shared/network/index.js';
+import { CSC } from './support/live.js';
 /** A TCP server that answers every line with "echo:<line>". */
 const echoServer = (port = 0) => new Promise((resolve) => {
     const server = net.createServer((s) => s.on('data', (d) => s.write('echo:' + d.toString())));
@@ -16,11 +16,17 @@ const portOf = (server) => server.address().port;
 const talk = (port, preamble, text) => new Promise((resolve) => {
     const socket = net.connect(port, '127.0.0.1');
     let got = '';
-    socket.on('data', (d) => { got += d.toString(); if (preamble && got.includes('\r\n\r\n') && got.startsWith('HTTP/1.1 200') && !got.includes('echo:'))
-        socket.write(text); });
+    socket.on('data', (d) => {
+        got += d.toString();
+        if (preamble && got.includes('\r\n\r\n') && got.startsWith('HTTP/1.1 200') && !got.includes('echo:'))
+            socket.write(text);
+    });
     socket.on('error', () => resolve(got));
     socket.on('connect', () => socket.write(preamble || text));
-    setTimeout(() => { socket.destroy(); resolve(got); }, 1500);
+    setTimeout(() => {
+        socket.destroy();
+        resolve(got);
+    }, 1500);
 });
 export const liveNetworkSuite = {
     name: 'live-network',
@@ -30,9 +36,18 @@ export const liveNetworkSuite = {
         t.section('allowOnly proxy');
         const gen = await f.launch({}, { config: { ...f.baseConfig, network: { ...f.baseConfig.network, allowOnly: ['localhost'] } } });
         const echo = await echoServer();
-        const proxy = spawn(process.execPath, [path.join(gen.launchPath, 'runtime', 'netproxy.js')], { env: { ...process.env, AGENT_LAUNCH_DIR: gen.launchPath, AGENT_DATA_DIR: t.dir('netproxy-data') }, stdio: 'ignore' });
+        const proxy = spawn(process.execPath, [path.join(gen.launchPath, 'runtime', 'netproxy.js')], {
+            env: { ...process.env, AGENT_LAUNCH_DIR: gen.launchPath, AGENT_DATA_DIR: t.dir('netproxy-data') },
+            stdio: 'ignore',
+        });
         try {
-            const up = await t.waitFor(() => new Promise((resolve) => { const s = net.connect(PROXY_PORT, '127.0.0.1', () => { s.destroy(); resolve(true); }); s.on('error', () => resolve(false)); }), 10000, 200);
+            const up = await t.waitFor(() => new Promise((resolve) => {
+                const s = net.connect(PROXY_PORT, '127.0.0.1', () => {
+                    s.destroy();
+                    resolve(true);
+                });
+                s.on('error', () => resolve(false));
+            }), 10000, 200);
             t.check(Boolean(up), 'the proxy listens on localhost');
             const allowed = await talk(PROXY_PORT, 'CONNECT localhost:' + portOf(echo) + ' HTTP/1.1\r\nHost: localhost\r\n\r\n', 'hi');
             t.check(allowed.startsWith('HTTP/1.1 200') && allowed.includes('echo:hi'), 'an allowed host is tunnelled through', allowed);
@@ -54,7 +69,7 @@ export const liveNetworkSuite = {
         const forwarded = await talk(pcPort, '', 'ping');
         stop();
         relay.close();
-        t.equal(forwarded, 'echo:ping', 'localhost:<pc> on this PC reaches the sandbox\'s relay');
+        t.equal(forwarded, 'echo:ping', "localhost:<pc> on this PC reaches the sandbox's relay");
         t.section('cargo shim');
         const out = path.join(t.dir('cargoshim'), 'cargo.exe');
         const compiled = spawnSync(CSC, ['/nologo', '/optimize', '/out:' + out, path.join(gen.launchPath, 'sandbox', 'cargoshim.cs')], { encoding: 'utf8' });

package/dist/selftest/live-projects.test.d.ts

@@ -1,2 +1,2 @@
-import type { Suite } from './suite.js';
+import type { Suite } from './support/suite.js';
 export declare const liveProjectsSuite: Suite;

package/dist/selftest/live-projects.test.js

@@ -4,10 +4,10 @@
 // Toolchain installers run as a dry run (no downloads); everything else is real. cmd.exe stands in for the agent.
 import fs from 'node:fs';
 import path from 'node:path';
-import { projectSpec } from '../host/join.js';
-import { resizeFrame } from '../shared/pty-client.js';
-import { readJsonFile } from '../shared/rundir.js';
-import { copyCmdAsFakeAgent, openViewer, sees, startDaemon, tail, viewersWhen } from './live.js';
+import { projectSpec } from '../host/projects/index.js';
+import { resizeFrame } from '../shared/pty/index.js';
+import { readJsonFile } from '../shared/io/index.js';
+import { copyCmdAsFakeAgent, openViewer, sees, startDaemon, tail, viewersWhen } from './support/live.js';
 export const liveProjectsSuite = {
     name: 'live-projects',
     title: 'live: two projects, several sessions, several viewers',
@@ -21,11 +21,25 @@ export const liveProjectsSuite = {
         copyCmdAsFakeAgent(data);
         const session = f.readJson(gen.sessionPath);
         // B's root appears at its own path here (like guestWorkspace "mirror"), so host and guest paths are the same.
-        Object.assign(session, { workspace: f.workA, attach: { enabled: true }, projectsDir: t.at('live-projects'), roots: [root], projectId: 'work-a' });
-        Object.assign(session.harness, { arguments: ['/d', '/k', 'echo AGENT-READY'], resumeArguments: ['/d', '/k', 'echo AGENT-RESUMED'] });
+        Object.assign(session, {
+            workspace: f.workA,
+            attach: { enabled: true },
+            projectsDir: t.at('live-projects'),
+            roots: [root],
+            projectId: 'work-a',
+        });
+        Object.assign(session.harness, {
+            arguments: ['/d', '/k', 'echo AGENT-READY'],
+            resumeArguments: ['/d', '/k', 'echo AGENT-RESUMED'],
+        });
         t.writeJson(gen.sessionPath, session);
         const local = t.at('live-multi-local');
-        const daemon = startDaemon(t, f, { launchPath: gen.launchPath, data, workspace: f.workA, env: { AGENT_LOCAL_DIR: local, AGENT_DRY_RUN: '1', AGENT_MANAGED_DIR: t.at('live-managed') } });
+        const daemon = startDaemon(t, f, {
+            launchPath: gen.launchPath,
+            data,
+            workspace: f.workA,
+            env: { AGENT_LOCAL_DIR: local, AGENT_DRY_RUN: '1', AGENT_MANAGED_DIR: t.at('live-managed') },
+        });
         const viewers = [];
         const view = async (attach, cols = 100) => {
             const v = await openViewer(attach, { cols });
@@ -49,9 +63,13 @@ export const liveProjectsSuite = {
             if (notRunning.length > 0)
                 return;
             t.equal([a1.project, b1.project, b2.project], ['work-a', 'projB', 'projB'], 'each session knows its project');
-            const log = fs.readdirSync(path.join(data, 'logs')).filter((n) => n.startsWith('daemon')).map((n) => fs.readFileSync(path.join(data, 'logs', n), 'utf8')).join('\n');
+            const log = fs
+                .readdirSync(path.join(data, 'logs'))
+                .filter((n) => n.startsWith('daemon'))
+                .map((n) => fs.readFileSync(path.join(data, 'logs', n), 'utf8'))
+                .join('\n');
             t.equal((log.match(/Project projB: setting up/g) ?? []).length, 1, 'two sessions for the same new project at once share one setup (no second provisioning run)');
-            t.equal(readJsonFile(path.join(daemon.run, 'projects', 'projB.json'))?.phase, 'ready', 'the project\'s setup status is written for the host (sandbox status)');
+            t.equal(readJsonFile(path.join(daemon.run, 'projects', 'projB.json'))?.phase, 'ready', "the project's setup status is written for the host (sandbox status)");
             t.section('live: each session has its own folder and environment');
             const views = await Promise.all(all.map((s) => view(s.attach)));
             for (const v of views)
@@ -59,13 +77,13 @@ export const liveProjectsSuite = {
             for (const v of views)
                 v.type('echo P=%AGENT_PROJECT% W=%AGENT_WORKSPACE% B=[%LIVE_B%]');
             const bSees = await sees(t, views[2], 'P=projB W=' + projB + ' B=[b-env]');
-            t.check(Boolean(bSees), 'B\'s first session runs with B\'s workspace, project and variables', tail(views[2].output()));
-            t.check(Boolean(await sees(t, views[3], 'B=[b-env]')), 'B\'s second session runs with B\'s variables', tail(views[3].output()));
+            t.check(Boolean(bSees), "B's first session runs with B's workspace, project and variables", tail(views[2].output()));
+            t.check(Boolean(await sees(t, views[3], 'B=[b-env]')), "B's second session runs with B's variables", tail(views[3].output()));
             // (The daemon here runs without the boot's environment, so A's own AGENT_* variables are not set at all.)
-            t.check(Boolean(await sees(t, views[0], 'B=[%LIVE_B%]')), 'A\'s first session is untouched by B (B\'s variables never reach it)', tail(views[0].output()));
-            t.check(Boolean(await sees(t, views[1], 'B=[%LIVE_B%]')), 'A\'s second session is untouched by B', tail(views[1].output()));
+            t.check(Boolean(await sees(t, views[0], 'B=[%LIVE_B%]')), "A's first session is untouched by B (B's variables never reach it)", tail(views[0].output()));
+            t.check(Boolean(await sees(t, views[1], 'B=[%LIVE_B%]')), "A's second session is untouched by B", tail(views[1].output()));
             views[2].type('echo CWD=%CD%.');
-            t.check(Boolean(await sees(t, views[2], 'CWD=' + projB + '.')), 'B\'s session starts in B\'s folder', tail(views[2].output()));
+            t.check(Boolean(await sees(t, views[2], 'CWD=' + projB + '.')), "B's session starts in B's folder", tail(views[2].output()));
             t.section('live: several viewers on one session');
             const second = await view(b1.attach, 60);
             const two = await viewersWhen(t, b1.attach, (v) => v.viewers === 2);
@@ -91,9 +109,16 @@ export const liveProjectsSuite = {
             daemon.request({ kind: 'exec', id: 'xb', command: ['echo', '%LIVE_B%'], cwd: projB, timeoutSeconds: 30 });
             daemon.request({ kind: 'exec', id: 'xa', command: ['echo', '[%LIVE_B%]'], cwd: f.workA, timeoutSeconds: 30 });
             const [xb, xa] = await Promise.all([daemon.response('xb'), daemon.response('xa')]);
-            t.check(Boolean(xb?.stdout?.includes('b-env')), 'exec in B\'s folder gets B\'s environment', JSON.stringify(xb));
-            t.check(Boolean(xa?.stdout?.includes('[%LIVE_B%]')), 'exec in A\'s folder gets A\'s', JSON.stringify(xa));
-            daemon.request({ kind: 'session', id: 'bad1', harness: 'claude', args: [], cwd: f.workB, project: { ...spec, name: 'outside', workspace: f.workB } });
+            t.check(Boolean(xb?.stdout?.includes('b-env')), "exec in B's folder gets B's environment", JSON.stringify(xb));
+            t.check(Boolean(xa?.stdout?.includes('[%LIVE_B%]')), "exec in A's folder gets A's", JSON.stringify(xa));
+            daemon.request({
+                kind: 'session',
+                id: 'bad1',
+                harness: 'claude',
+                args: [],
+                cwd: f.workB,
+                project: { ...spec, name: 'outside', workspace: f.workB },
+            });
             const bad = await daemon.started('bad1');
             t.check(bad?.phase === 'failed' && bad.message.includes('not visible inside the sandbox'), 'a project outside the launch folder, the roots and C:\\Projects is refused', JSON.stringify(bad));
             daemon.request({ kind: 'session', id: 'bad2', harness: 'claude', args: [], cwd: f.workA, project: spec });
@@ -102,8 +127,8 @@ export const liveProjectsSuite = {
             daemon.request({ kind: 'restart', id: 'rb', harness: null, cwd: projB });
             t.equal((await daemon.response('rb'))?.message, 'restarted 2 session(s)', 'restart scoped to a project restarts only its sessions');
             t.check(fs.existsSync(path.join(local, 'projects', 'projB', 'shell.cmd')), 'sbx-shell projB has a shell script');
-            t.includes(fs.readFileSync(path.join(local, 'projects', 'projB', 'env.cmd'), 'utf8'), 'LIVE_B=b-env', 'sbx-shell projB opens with B\'s environment');
-            t.check(fs.existsSync(path.join(local, 'bin', 'sbx-shell.cmd')), 'sbx-shell is on the sandbox\'s PATH');
+            t.includes(fs.readFileSync(path.join(local, 'projects', 'projB', 'env.cmd'), 'utf8'), 'LIVE_B=b-env', "sbx-shell projB opens with B's environment");
+            t.check(fs.existsSync(path.join(local, 'bin', 'sbx-shell.cmd')), "sbx-shell is on the sandbox's PATH");
         }
         finally {
             for (const v of viewers)
@@ -119,7 +144,9 @@ export const liveProjectsSuite = {
                     await t.waitFor(() => v.exitCode() !== null, 10000);
                     v.close();
                 }
-                catch { /* already gone */ }
+                catch {
+                    /* already gone */
+                }
             }
             await daemon.stop();
         }

package/dist/selftest/live-terminal.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const liveTerminalSuite: Suite;