windows-development-sandbox 1.4.1 → 1.4.3

package/dist/guest/{main.js → boot/boot.js}

@@ -1,43 +1,67 @@
-// Guest entry point, started by bootstrap.ps1 in the sandbox window. Provisions everything, starts the session
-// daemon, asks it for the first agent session and then shows that session in this window.
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { writeGuides } from './guide.js';
-import { setupToolchains } from './toolchains/index.js';
-import { provisionHarness, resolveLaunch } from './setup/agents.js';
-import { restoreClaudeMem, syncClaudeProfile } from './setup/claude.js';
-import { agentEnv, persistEnvironment } from './setup/environment.js';
-import { runHooks } from './setup/hooks.js';
-import { applyAllowOnly, applyNetworkPolicy, proxyEnv } from './setup/network.js';
-import { writeManagedSettings } from './setup/policy.js';
-import { applyPersonalization, setupGitConfig } from './setup/user.js';
-import { ensurePtyHost } from './ptyhost.js';
-import { pruneToolLeftovers } from './toolchains/leftovers.js';
-import { wanted } from './toolchains/common.js';
-import { configureVscode } from './toolchains/vscode.js';
-import { enableProcessAudit } from './audit.js';
-import { now, readSession, writeJsonAtomic } from '../shared/rundir.js';
-import { viewSession } from './view.js';
+import { setupToolchains } from '../toolchains/index.js';
+import { provisionHarness, resolveLaunch } from '../agents/agent-installer.js';
+import { restoreClaudeMem } from '../setup/claude-mem.js';
+import { syncClaudeProfile } from '../setup/claude-profile.js';
+import { agentEnv, persistEnvironment } from '../setup/environment.js';
+import { runHooks } from '../setup/hooks.js';
+import { applyAllowOnly, proxyEnv } from '../network/allow-only.js';
+import { applyNetworkPolicy } from '../network/firewall.js';
+import { writeManagedSettings } from '../setup/managed-policy.js';
+import { applyPersonalization } from '../setup/desktop.js';
+import { setupGitConfig } from '../setup/git-identity.js';
+import { ensurePtyHost } from '../sessions/pty-host.js';
+import { pruneToolLeftovers } from '../toolchains/leftovers.js';
+import { wanted } from '../toolchains/detect.js';
+import { configureVscode } from '../toolchains/tools/vscode.js';
+import { enableProcessAudit } from '../audit/process-audit.js';
+import { now } from '../../shared/channel/run-dir.js';
+import { writeJsonAtomic } from '../../shared/io/json.js';
+import { viewSession } from '../sessions/viewer.js';
 import { saveBootEnv } from './boot-env.js';
 import { primaryProject, saveProjectStatus } from './project-status.js';
-import { dataDir, dryRun, errMsg, isWin, localDir, log, logPath, logsDir, mkdirp, run, session, setSandboxStatus, toolsDir, warn, workspace } from './env.js';
+import { dryRun, isWin, localDir, logsDir, run, toolsDir } from '../runtime/paths.js';
+import { log, logPath, warn } from '../runtime/log.js';
+import { mkdirp } from '../runtime/fs.js';
+import { session, workspace } from '../runtime/session.js';
+import { setSandboxStatus } from '../runtime/status.js';
+import { errMsg } from '../../core/util/errors.js';
 const STEPS = 8;
 const step = (n, title) => {
     log('\n\x1b[36m[' + n + '/' + STEPS + '] ' + title + '\x1b[0m');
     // The host shows the short title ("Developer tools") with what is being set up in it.
-    setSandboxStatus(n === 1 ? 'booting' : 'provisioning', '[' + n + '/' + STEPS + '] ' + title, { step: n, steps: STEPS, title: title.replace(/ \(.*\)$/, ''), active: [], done: 0, total: 0 });
+    setSandboxStatus(n === 1 ? 'booting' : 'provisioning', '[' + n + '/' + STEPS + '] ' + title, {
+        step: n,
+        steps: STEPS,
+        title: title.replace(/ \(.*\)$/, ''),
+        active: [],
+        done: 0,
+        total: 0,
+    });
+};
+const soft = async (what, work) => {
+    try {
+        await work();
+    }
+    catch (e) {
+        warn(what + ' failed (continuing): ' + errMsg(e));
+    }
 };
-const soft = async (what, work) => { try {
-    await work();
-}
-catch (e) {
-    warn(what + ' failed (continuing): ' + errMsg(e));
-} };
 const startDaemon = (env) => {
-    spawn(process.execPath, [path.join(path.dirname(process.argv[1]), 'daemon.js')], { detached: true, stdio: 'ignore', windowsHide: true, env: { ...env, AGENT_LOG_PREFIX: 'daemon' } }).unref();
+    spawn(process.execPath, [path.join(path.dirname(process.argv[1]), 'daemon.js')], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        env: { ...env, AGENT_LOG_PREFIX: 'daemon' },
+    }).unref();
 };
-/** `sbx-db` for terminals and `sandbox db`: this boot's Node running runtime\db.js (on the sandbox's disk, rewritten each boot). */
+/**
+ * `sbx-db` for terminals and `sandbox db`: this boot's Node running runtime\db.js (on the sandbox's disk, rewritten
+ * each boot).
+ */
 const writeDbCommand = () => {
     const dir = mkdirp(path.join(localDir, 'bin'));
     const db = path.join(path.dirname(process.argv[1]), 'db.js');
@@ -46,7 +70,7 @@ const writeDbCommand = () => {
 };
 const waitForPrimary = async () => {
     for (let i = 0; i < 600; i++) {
-        const s = readSession(dataDir, session.launchId);
+        const s = run.readSession(session.launchId);
         if (s?.phase === 'running')
             return true;
         if (s?.phase === 'failed' || s?.phase === 'exited') {
@@ -57,18 +81,29 @@ const waitForPrimary = async () => {
     }
     return false;
 };
-const main = async () => {
-    log('Agent sandbox: ' + session.project + ' | workspace ' + workspace + ' | agent ' + session.harnessName + ' | log ' + logPath);
+export const runBoot = async () => {
+    log('Agent sandbox: ' +
+        session.project +
+        ' | workspace ' +
+        workspace +
+        ' | agent ' +
+        session.harnessName +
+        ' | log ' +
+        logPath);
     if (!fs.statSync(workspace, { throwIfNoEntry: false })?.isDirectory())
         throw new Error('Workspace folder is missing in the sandbox: ' + workspace);
     mkdirp(toolsDir);
-    mkdirp(run.run);
+    mkdirp(run.root);
     step(1, 'Network and session host');
     let ptyHost = null;
     if (isWin && !dryRun && session.attach.enabled)
-        await soft('Building the session host', () => { ptyHost = ensurePtyHost(); });
+        await soft('Building the session host', () => {
+            ptyHost = ensurePtyHost();
+        });
     let lan = session.networking ? 'open' : 'offline';
-    await soft('Private-network blocking', async () => { lan = await applyNetworkPolicy(ptyHost); });
+    await soft('Private-network blocking', async () => {
+        lan = await applyNetworkPolicy(ptyHost);
+    });
     await soft('Audit', enableProcessAudit);
     step(2, 'Pre-provision hooks and desktop');
     runHooks('pre-provision', process.env);
@@ -77,18 +112,30 @@ const main = async () => {
     step(3, 'Developer tools (the first start downloads them once; later starts are quick)');
     const basePath = process.env.PATH ?? '';
     const tools = await setupToolchains(session.toolchains, session.versions, {
-        gitEnabled: session.provisioning.git.enabled, gitAccess, hostGit: session.hostTools.git, refresh: session.provisioning.refresh, databases: session.databases ?? [], apps: session.apps,
+        gitEnabled: session.provisioning.git.enabled,
+        gitAccess,
+        hostGit: session.hostTools.git,
+        refresh: session.provisioning.refresh,
+        databases: session.databases ?? [],
+        apps: session.apps,
     });
     if (!dryRun)
         tools.prepend.push(writeDbCommand());
     // network.allowOnly / network.proxy: everything started from now on uses the proxy.
     Object.assign(tools.vars, proxyEnv());
-    await soft('Network: allow only some hosts', async () => { if (await applyAllowOnly())
-        tools.summary.push('network: only network.allowOnly hosts (refused: logs\\netproxy.log)'); });
+    await soft('Network: allow only some hosts', async () => {
+        if (await applyAllowOnly())
+            tools.summary.push('network: only network.allowOnly hosts (refused: logs\\netproxy.log)');
+    });
     const vscode = session.toolchains.vscode;
     if (vscode.enabled && vscode.setup !== false) {
         const languages = ['python', 'java', 'go', 'rust', 'cpp', 'msvc', 'dotnet', 'ruby', 'php', 'deno', 'pwsh'].filter((t) => wanted(session.toolchains[t]?.enabled ?? false, t));
-        await soft('VS Code setup', () => configureVscode(tools, { toolchains: ['node', ...languages], databases: (session.databases ?? []).map((d) => d.database), config: vscode, workspace }));
+        await soft('VS Code setup', () => configureVscode(tools, {
+            toolchains: ['node', ...languages],
+            databases: (session.databases ?? []).map((d) => d.database),
+            config: vscode,
+            workspace,
+        }));
     }
     const env = agentEnv(tools);
     persistEnvironment(env, Object.keys(tools.vars));
@@ -121,12 +168,22 @@ const main = async () => {
     }
     if (dryRun) {
         const launch = resolveLaunch(session.harnessName, session.harness);
-        log('(dry run) would run: ' + [launch.file, ...launch.args, ...session.harness.arguments, ...session.harnessArguments].join(' ') + ' | cwd=' + workspace);
+        log('(dry run) would run: ' +
+            [launch.file, ...launch.args, ...session.harness.arguments, ...session.harnessArguments].join(' ') +
+            ' | cwd=' +
+            workspace);
         runHooks('post-agent', env);
         return;
     }
     startDaemon(env);
-    writeJsonAtomic(run.request(session.launchId), { kind: 'session', id: session.launchId, harness: session.harnessName, args: session.harnessArguments, cwd: workspace, createdAt: now() });
+    writeJsonAtomic(run.requestFile(session.launchId), {
+        kind: 'session',
+        id: session.launchId,
+        harness: session.harnessName,
+        args: session.harnessArguments,
+        cwd: workspace,
+        createdAt: now(),
+    });
     if (!(await waitForPrimary()))
         throw new Error('The agent session did not start. Logs: ' + logsDir);
     log('If Claude asks you to sign in, do it once; the login is saved in persistent storage.');
@@ -134,14 +191,3 @@ const main = async () => {
         await viewSession(session.launchId);
     log('\nThis window stays open in ' + workspace + '. Other sessions keep running in their own tabs.');
 };
-main().catch((e) => {
-    const message = errMsg(e) + (e instanceof Error && e.stack ? '\n' + e.stack : '');
-    try {
-        setSandboxStatus('failed', errMsg(e));
-        fs.writeFileSync(path.join(logsDir, 'guest-error.txt'), message);
-    }
-    catch { /* ignore */ }
-    // The window gets the plain message; the stack trace is in guest-error.txt.
-    console.error('\n\x1b[31mThe sandbox could not start: ' + errMsg(e) + '\x1b[0m\nDetails: ' + path.join(logsDir, 'guest-error.txt'));
-    process.exitCode = 1;
-});

package/dist/guest/{guide.js → boot/guide.js}

@@ -2,7 +2,8 @@
 // global instructions: Claude's CLAUDE.md and Codex's AGENTS.md inside the sandbox. It never travels back to this PC.
 import fs from 'node:fs';
 import path from 'node:path';
-import { claudeDir, dataDir, launchDir, session, stateDir, toolsDir, workspace } from './env.js';
+import { claudeDir, session, stateDir, workspace } from '../runtime/session.js';
+import { dataDir, launchDir, toolsDir } from '../runtime/paths.js';
 const BEGIN = '<!-- agent-sandbox:begin (generated every boot, do not edit) -->';
 const END = '<!-- agent-sandbox:end -->';
 /** Drives other than C: are subst drives onto C:\Mirror\<letter> (mapped folders shown at their PC paths). */
@@ -11,7 +12,13 @@ const mirrorLine = () => {
     const drives = (session.substDrives ?? []).filter((d) => fs.existsSync(d.letter + ':\\'));
     if (!drives.length)
         return [];
-    return ['- ' + drives.map((d) => d.letter + ':').join(', ') + ' = mapped folders at their PC paths (subst onto `' + drives.map((d) => d.target).join('`, `') + '`; real-path tools may print that form).'];
+    return [
+        '- ' +
+            drives.map((d) => d.letter + ':').join(', ') +
+            ' = mapped folders at their PC paths (subst onto `' +
+            drives.map((d) => d.target).join('`, `') +
+            '`; real-path tools may print that form).',
+    ];
 };
 export const sandboxGuide = (toolSummary, lan = 'blocked', projects = []) => [
     BEGIN,
@@ -19,15 +26,33 @@ export const sandboxGuide = (toolSummary, lan = 'blocked', projects = []) => [
     'Wiped on close: everything except the paths below (installers, winget/choco, C:\\Users, Program Files, registry).',
     '- RW, persists: `' + workspace + '` = host folder ' + session.workspaceHost,
     // Projects started from other folders while this sandbox runs: every agent here can see them.
-    ...projects.map((p) => '- RW, persists: `' + p.guest + '` = host folder ' + p.host + ' (another project in this sandbox; your own is `%AGENT_WORKSPACE%`)'),
-    '- RW, persists: `' + toolsDir + '` (toolchains) — put portable exes in `' + path.join(toolsDir, 'bin') + '` (on PATH)',
-    '- RW, persists: `' + stateDir + '` (agent config/history; do not edit logins) · logs: `' + path.join(dataDir, 'logs') + '`',
-    '- RO: `' + launchDir + '` (this boot\'s scripts) · lost on close: everything else, incl. `C:\\nvm` (Node symlink)',
+    ...projects.map((p) => '- RW, persists: `' +
+        p.guest +
+        '` = host folder ' +
+        p.host +
+        ' (another project in this sandbox; your own is `%AGENT_WORKSPACE%`)'),
+    '- RW, persists: `' +
+        toolsDir +
+        '` (toolchains) — put portable exes in `' +
+        path.join(toolsDir, 'bin') +
+        '` (on PATH)',
+    '- RW, persists: `' +
+        stateDir +
+        '` (agent config/history; do not edit logins) · logs: `' +
+        path.join(dataDir, 'logs') +
+        '`',
+    '- RO: `' + launchDir + "` (this boot's scripts) · lost on close: everything else, incl. `C:\\nvm` (Node symlink)",
     ...mirrorLine(),
     '- Tools: ' + toolSummary.join(' · '),
     '- Persistent installs: `npm i -g` (per nvm version), `pip`, `cargo install`, `dotnet tool -g`, `uv tool`, `bun add -g`. Real installers must re-run each boot via a hook (ask the user).',
     '- Mapped folders (workspace, C:\\AgentData) allow NO symlinks or junctions: pnpm runs hoisted (set), npm workspaces / `file:` deps and deno node_modules dirs fail there (use a folder on C:\\ outside them), bun cannot save its lockfile there (`bun install --no-save`).',
-    '- Network: ' + (lan === 'offline' ? 'OFF' : lan === 'blocked' ? 'internet yes, host LAN blocked' : 'internet yes, host LAN NOT blocked this time') + '. Other sessions may share this workspace; the user may be typing from the host.',
+    '- Network: ' +
+        (lan === 'offline'
+            ? 'OFF'
+            : lan === 'blocked'
+                ? 'internet yes, host LAN blocked'
+                : 'internet yes, host LAN NOT blocked this time') +
+        '. Other sessions may share this workspace; the user may be typing from the host.',
     END,
 ].join('\n');
 /** Inserts or replaces the generated section, keeping whatever else the file contains (the host's CLAUDE.md). */

package/dist/guest/{project-env.d.ts → boot/project-env.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const BootEnv: z.ZodObject<{
+export declare const BootEnvSchema: z.ZodObject<{
     basePath: z.ZodString;
     toolVars: z.ZodArray<z.ZodString>;
     steps: z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -15,6 +15,6 @@ export declare const BootEnv: z.ZodObject<{
         offline: "offline";
     }>;
 }, z.core.$strip>;
-export type BootEnvT = z.output<typeof BootEnv>;
+export type BootEnv = z.output<typeof BootEnvSchema>;
 /** The environment a later project starts from: the daemon's own, without the boot project's toolchains. */
-export declare const baseEnvFor: (boot: BootEnvT | null, current?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export declare const baseEnvFor: (boot: BootEnv | null, current?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;

package/dist/guest/{project-env.js → boot/project-env.js}

@@ -1,11 +1,19 @@
 // Pure (no guest state): the environment a project that joined after boot starts from. Kept apart from boot-env.ts,
 // which reads the guest's session, so the host-side tests can import it.
 import { z } from 'zod';
-const Env = z.object({ vars: z.record(z.string(), z.string()), prepend: z.array(z.string()), append: z.array(z.string()), summary: z.array(z.string()) });
-export const BootEnv = z.object({
-    basePath: z.string(), toolVars: z.array(z.string()), steps: z.record(z.string(), Env),
+const EnvSchema = z.object({
+    vars: z.record(z.string(), z.string()),
+    prepend: z.array(z.string()),
+    append: z.array(z.string()),
+    summary: z.array(z.string()),
+});
+export const BootEnvSchema = z.object({
+    basePath: z.string(),
+    toolVars: z.array(z.string()),
+    steps: z.record(z.string(), EnvSchema),
     /** The boot's tool summary and LAN state, for the agent guide that lists every project. */
-    summary: z.array(z.string()), lan: z.enum(['blocked', 'open', 'offline']),
+    summary: z.array(z.string()),
+    lan: z.enum(['blocked', 'open', 'offline']),
 });
 /** Variables the boot set for its own project (its workspace, its toolchains): never inherited by another project. */
 const PROJECT_VARS = /^(AGENT_WORKSPACE|AGENT_PROJECT|AGENT_SANDBOX_WORKSPACE|AGENT_PROJECT_FILE|CARGO_TARGET_DIR|VIRTUAL_ENV)$/i;

package/dist/guest/boot/project-status.d.ts

@@ -0,0 +1,5 @@
+import type { DatabasePlan } from '../../core/types.js';
+import type { ProjectStatus } from '../../shared/channel/schema.js';
+/** The launch folder's project id (older launch folders: derived from its name). */
+export declare const primaryProject: () => string;
+export declare const saveProjectStatus: (name: string, workspace: string, phase: ProjectStatus["phase"], message: string, databases: DatabasePlan[], summary: string[]) => void;

package/dist/guest/boot/project-status.js

@@ -0,0 +1,28 @@
+import { now } from '../../shared/channel/run-dir.js';
+import { writeJsonAtomic } from '../../shared/io/json.js';
+import { hubName } from '../../shared/paths/projects.js';
+import { run } from '../runtime/paths.js';
+import { session } from '../runtime/session.js';
+import { warn } from '../runtime/log.js';
+import { errMsg } from '../../core/util/errors.js';
+/** The launch folder's project id (older launch folders: derived from its name). */
+export const primaryProject = () => session.projectId ?? hubName(session.workspaceHost || session.project, []);
+export const saveProjectStatus = (name, workspace, phase, message, databases, summary) => {
+    try {
+        writeJsonAtomic(run.projectFile(name), {
+            name,
+            workspace,
+            phase,
+            message: message.slice(0, 3500),
+            updatedAt: now(),
+            databases: databases
+                .filter((d) => d.database !== 'sqlserver')
+                .slice(0, 16)
+                .map((d) => ({ database: d.database, port: d.port })),
+            summary: summary.slice(0, 64).map((s) => s.slice(0, 500)),
+        });
+    }
+    catch (e) {
+        warn('Could not write the status of project ' + name + ': ' + errMsg(e));
+    }
+};

package/dist/guest/daemon/daemon.d.ts

@@ -0,0 +1 @@
+export declare const loop: () => void;

package/dist/guest/daemon/daemon.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import { saveClaudeMem } from '../setup/claude-mem.js';
+import { execCommand } from './exec.js';
+import { prepareProject, restartSessions, startSession } from './sessions.js';
+import { live, respond, safely } from './state.js';
+import { run } from '../runtime/paths.js';
+import { warn } from '../runtime/log.js';
+import { errMsg } from '../../core/util/errors.js';
+let lastMemSave = Date.now();
+const handle = (req) => {
+    switch (req.kind) {
+        case 'session':
+            return startSession(req);
+        case 'project':
+            return prepareProject(req);
+        case 'exec':
+            return execCommand(req);
+        case 'restart':
+            return restartSessions(req);
+        case 'ping':
+            return respond(req.id, { ok: true, message: 'pong (' + live.size + ' session(s) running)' });
+    }
+};
+const tick = () => {
+    const { valid, invalid } = run.scanRequests();
+    // Anything in requests/ that is not a valid request (wrong kind, bad id, junk) is deleted unread.
+    for (const file of invalid)
+        safely('removing an invalid request', () => fs.rmSync(file, { recursive: true, force: true }));
+    for (const req of valid) {
+        safely('claiming a request', () => fs.rmSync(run.requestFile(req.id), { force: true }));
+        if (run.readSession(req.id))
+            continue;
+        // Not awaited: starting a session or running a command must not hold up other requests.
+        void Promise.resolve(handle(req)).catch((e) => respond(req.id, { ok: false, message: errMsg(e) }));
+    }
+    if (Date.now() - lastMemSave > 120000) {
+        lastMemSave = Date.now();
+        safely('claude-mem save', saveClaudeMem);
+    }
+};
+export const loop = () => {
+    try {
+        tick();
+    }
+    catch (e) {
+        warn('daemon loop: ' + errMsg(e));
+    }
+    finally {
+        setTimeout(loop, 400);
+    }
+};

package/dist/guest/daemon/exec.js

@@ -1,8 +1,9 @@
 // `exec` requests: a command run for the host in the workspace.
 import { spawn } from 'node:child_process';
 import { SYSTEM } from '../../shared/system.js';
-import { errMsg, exists } from '../env.js';
-import { provisionedFor } from './project.js';
+import { exists } from '../runtime/fs.js';
+import { errMsg } from '../../core/util/errors.js';
+import { provisionedFor } from './project-provisioner.js';
 import { insideWorkspace, respond } from './state.js';
 const MAX_OUTPUT = 1024 * 1024;
 const quoteForCmd = (a) => (/[\s"&|<>^]/.test(a) ? '"' + a.replace(/"/g, '""') + '"' : a);
@@ -19,14 +20,25 @@ export const execCommand = (req) => {
     const child = spawn(SYSTEM.cmd(), ['/d', '/s', '/c', '"chcp 65001>nul & ' + req.command.map(quoteForCmd).join(' ') + '"'], { cwd: req.cwd, env, windowsHide: true, windowsVerbatimArguments: true });
     const output = { stdout: '', stderr: '' };
     // setEncoding decodes across chunks: a multi-byte character split between two reads is not mangled.
-    const collect = (key) => (d) => { if (output[key].length < MAX_OUTPUT)
-        output[key] += d; };
+    const collect = (key) => (d) => {
+        if (output[key].length < MAX_OUTPUT)
+            output[key] += d;
+    };
     child.stdout.setEncoding('utf8').on('data', collect('stdout'));
     child.stderr.setEncoding('utf8').on('data', collect('stderr'));
     const timer = setTimeout(() => child.kill(), Math.min(req.timeoutSeconds, 3600) * 1000);
-    child.on('error', (e) => { clearTimeout(timer); respond(req.id, { ok: false, message: 'Could not run the command: ' + errMsg(e) }); });
+    child.on('error', (e) => {
+        clearTimeout(timer);
+        respond(req.id, { ok: false, message: 'Could not run the command: ' + errMsg(e) });
+    });
     child.on('close', (code) => {
         clearTimeout(timer);
-        respond(req.id, { ok: code === 0, message: code === null ? 'stopped after ' + req.timeoutSeconds + ' s' : 'exit ' + code, exitCode: code ?? -1, stdout: cap(output.stdout), stderr: cap(output.stderr) });
+        respond(req.id, {
+            ok: code === 0,
+            message: code === null ? 'stopped after ' + req.timeoutSeconds + ' s' : 'exit ' + code,
+            exitCode: code ?? -1,
+            stdout: cap(output.stdout),
+            stderr: cap(output.stderr),
+        });
     });
 };

package/dist/guest/daemon/{shutdown.js → idle-shutdown.js}

@@ -1,14 +1,15 @@
 // A headless sandbox with nothing running (or starting) only wastes RAM, so it shuts itself down.
 import { spawnSync } from 'node:child_process';
 import { SYSTEM } from '../../shared/system.js';
-import { scanRequests } from '../../shared/rundir.js';
-import { saveClaudeMem } from '../setup/claude.js';
-import { dataDir, isWin, log, session } from '../env.js';
+import { saveClaudeMem } from '../setup/claude-mem.js';
+import { isWin, run } from '../runtime/paths.js';
+import { log } from '../runtime/log.js';
+import { session } from '../runtime/session.js';
 import { live, pending, safely } from './state.js';
 export const maybeShutdown = () => {
     if (!session.headless || !isWin)
         return;
-    const idle = () => live.size === 0 && pending.starting === 0 && scanRequests(dataDir).valid.length === 0;
+    const idle = () => live.size === 0 && pending.starting === 0 && run.scanRequests().valid.length === 0;
     if (!idle())
         return;
     setTimeout(() => {

package/dist/guest/daemon/{project.d.ts → project-provisioner.d.ts}

@@ -1,6 +1,6 @@
-import type { ProjectSpecT } from '../../shared/schema.js';
+import type { ProjectSpec } from '../../shared/channel/schema.js';
 export interface Provisioned {
-    spec: ProjectSpecT;
+    spec: ProjectSpec;
     env: NodeJS.ProcessEnv;
     summary: string[];
 }
@@ -11,4 +11,4 @@ export declare const provisionedProjects: () => Provisioned[];
  * Provisions a project (or joins the run already doing it: two sessions requested at once wait for the same one).
  * `say` gets the progress lines.
  */
-export declare const provisionProject: (spec: ProjectSpecT, say: (message: string) => void) => Promise<Provisioned>;
+export declare const provisionProject: (spec: ProjectSpec, say: (message: string) => void) => Promise<Provisioned>;

package/dist/guest/daemon/{project.js → project-provisioner.js}

@@ -6,28 +6,38 @@
 // variables only added, never replaced). A failure is that project's alone.
 import fs from 'node:fs';
 import path from 'node:path';
-import { isWithin } from '../../shared/projects.js';
+import { isWithin } from '../../shared/paths/projects.js';
 import { insideWorkspace } from './state.js';
-import { baseEnvFor, readBootEnv } from '../boot-env.js';
-import { dryRun, errMsg, exists, localDir, log, mkdirp, session, warn } from '../env.js';
-import { writeGuides } from '../guide.js';
-import { withProject } from '../project-context.js';
-import { saveProjectStatus } from '../project-status.js';
+import { baseEnvFor, readBootEnv } from '../boot/boot-env.js';
+import { dryRun, localDir } from '../runtime/paths.js';
+import { exists, mkdirp } from '../runtime/fs.js';
+import { log, warn } from '../runtime/log.js';
+import { session } from '../runtime/session.js';
+import { errMsg } from '../../core/util/errors.js';
+import { writeGuides } from '../boot/guide.js';
+import { withProject } from '../runtime/project-context.js';
+import { saveProjectStatus } from '../boot/project-status.js';
 import { addMachineEnvironment, agentEnv } from '../setup/environment.js';
 import { projectHooks, runHooksAsync } from '../setup/hooks.js';
 import { setupToolchains } from '../toolchains/index.js';
-/** By project name (lower case). The same spec again is free; a changed one (its config was edited) provisions again. */
+/**
+ * By project name (lower case). The same spec again is free; a changed one (its config was edited) provisions again.
+ */
 const projects = new Map();
 /** The last finished provisioning of each project (kept while a changed spec provisions again). */
 const ready = new Map();
 /** The provisioned project containing this folder, if any (exec in its folders uses its environment). */
-export const provisionedFor = (cwd) => [...ready.values()].filter((p) => isWithin(p.spec.workspace, cwd)).sort((a, b) => b.spec.workspace.length - a.spec.workspace.length)[0] ?? null;
+export const provisionedFor = (cwd) => [...ready.values()]
+    .filter((p) => isWithin(p.spec.workspace, cwd))
+    .sort((a, b) => b.spec.workspace.length - a.spec.workspace.length)[0] ?? null;
 export const provisionedProjects = () => [...ready.values()];
 /** `set` lines for a .cmd file. Values are quoted; a value with a line break cannot be set this way and is left out. */
-const cmdSet = (env, names) => names.filter((n) => env[n] !== undefined && !/[\r\n]/.test(String(env[n]))).map((n) => '@set "' + n + '=' + String(env[n]).replace(/%/g, '%%') + '"');
+const cmdSet = (env, names) => names
+    .filter((n) => env[n] !== undefined && !/[\r\n]/.test(String(env[n])))
+    .map((n) => '@set "' + n + '=' + String(env[n]).replace(/%/g, '%%') + '"');
 /**
- * A terminal for the project inside the sandbox: `sbx-shell <name>` (from any terminal tab) opens cmd in its folder with
- * its environment. Written to the sandbox's own disk.
+ * A terminal for the project inside the sandbox: `sbx-shell <name>` (from any terminal tab) opens cmd in its folder
+ * with its environment. Written to the sandbox's own disk.
  */
 const writeShell = (spec, env, names) => {
     const dir = mkdirp(path.join(localDir, 'projects', spec.name));
@@ -35,8 +45,12 @@ const writeShell = (spec, env, names) => {
     fs.writeFileSync(path.join(dir, 'shell.cmd'), ['@call "' + path.join(dir, 'env.cmd') + '"', '@cd /d "' + spec.workspace + '"', '@title ' + spec.name, ''].join('\r\n'));
     const bin = mkdirp(path.join(localDir, 'bin'));
     fs.writeFileSync(path.join(bin, 'sbx-shell.cmd'), [
-        '@if "%~1"=="" (echo Usage: sbx-shell ^<project^>   ^(a terminal in that project with its tools^) & dir /b "' + path.join(localDir, 'projects') + '" & exit /b 2)',
-        '@if not exist "' + path.join(localDir, 'projects') + '\\%~1\\shell.cmd" (echo No project %~1 in this sandbox. & exit /b 2)',
+        '@if "%~1"=="" (echo Usage: sbx-shell ^<project^>   ^(a terminal in that project with its tools^) & dir /b "' +
+            path.join(localDir, 'projects') +
+            '" & exit /b 2)',
+        '@if not exist "' +
+            path.join(localDir, 'projects') +
+            '\\%~1\\shell.cmd" (echo No project %~1 in this sandbox. & exit /b 2)',
         '@cmd /k ""' + path.join(localDir, 'projects') + '\\%~1\\shell.cmd""',
         '',
     ].join('\r\n'));
@@ -59,7 +73,11 @@ const refreshGuide = async () => {
 };
 const provision = async (spec, say) => {
     if (!insideWorkspace(spec.workspace) || !exists(spec.workspace)) {
-        throw new Error('Project folder ' + spec.workspace + ' (' + spec.workspaceHost + ') is not visible inside the sandbox. Stop the sandbox (sandbox stop) and start it from that folder, or add its parent folder to projects.roots.');
+        throw new Error('Project folder ' +
+            spec.workspace +
+            ' (' +
+            spec.workspaceHost +
+            ') is not visible inside the sandbox. Stop the sandbox (sandbox stop) and start it from that folder, or add its parent folder to projects.roots.');
     }
     saveProjectStatus(spec.name, spec.workspace, 'provisioning', 'Setting up ' + spec.name, spec.databases, []);
     log('Project ' + spec.name + ': setting up ' + spec.workspace + ' (' + spec.workspaceHost + ')');
@@ -77,7 +95,13 @@ const provision = async (spec, say) => {
         hostGit: session.hostTools.git,
         refresh: false,
         databases: spec.databases,
-    }, { report: (m) => { saveProjectStatus(spec.name, spec.workspace, 'provisioning', m, spec.databases, []); say(m); }, reuse: boot?.steps }));
+    }, {
+        report: (m) => {
+            saveProjectStatus(spec.name, spec.workspace, 'provisioning', m, spec.databases, []);
+            say(m);
+        },
+        reuse: boot?.steps,
+    }));
     tools.prepend.push(path.join(localDir, 'bin'));
     const env = agentEnv(tools, { workspace: spec.workspace, project: spec.name, base });
     const specFile = path.join(mkdirp(path.join(localDir, 'projects', spec.name)), 'project.json');
@@ -86,7 +110,13 @@ const provision = async (spec, say) => {
     // New terminal tabs see the new tools too, after everything the boot project has (never in place of it).
     addMachineEnvironment(tools.vars, [...tools.prepend, ...tools.append], true);
     try {
-        writeShell(spec, env, [...Object.keys(tools.vars), 'AGENT_WORKSPACE', 'AGENT_PROJECT', 'AGENT_SANDBOX_WORKSPACE', 'AGENT_PROJECT_FILE']);
+        writeShell(spec, env, [
+            ...Object.keys(tools.vars),
+            'AGENT_WORKSPACE',
+            'AGENT_PROJECT',
+            'AGENT_SANDBOX_WORKSPACE',
+            'AGENT_PROJECT_FILE',
+        ]);
     }
     catch (e) {
         warn('sbx-shell for ' + spec.name + ': ' + errMsg(e));
@@ -113,15 +143,23 @@ export const provisionProject = (spec, say) => {
         return known.work.finally(() => known.listeners.delete(say));
     }
     const listeners = new Set([say]);
-    const broadcast = (message) => { for (const l of listeners)
-        try {
-            l(message);
-        }
-        catch { /* a listener's write failing never stops provisioning */ } };
+    const broadcast = (message) => {
+        for (const l of listeners)
+            try {
+                l(message);
+            }
+            catch {
+                /* a listener's write failing never stops provisioning */
+            }
+    };
     const work = provision(spec, broadcast);
     const entry = { key, work, listeners };
     projects.set(id, entry);
-    work.then((done) => { entry.done = done; ready.set(id, done); return refreshGuide(); }, (e) => {
+    work.then((done) => {
+        entry.done = done;
+        ready.set(id, done);
+        return refreshGuide();
+    }, (e) => {
         warn('Project ' + spec.name + ' could not be set up: ' + errMsg(e));
         saveProjectStatus(spec.name, spec.workspace, 'failed', errMsg(e), spec.databases, []);
         // The next session for it tries again.