windows-development-sandbox 1.20.0 → 1.23.1

package/dist/guest/boot/boot.js

@@ -4,11 +4,14 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { writeGuides } from './guide.js';
 import { setupToolchains } from '../toolchains/index.js';
+import { mergeToolchains } from '../toolchains/setup.js';
+import { tool } from '../toolchains/tool-env.js';
+import { installedAddon } from '../setup/agent-addons.js';
 import { agents } from '../agents/agent-installer.js';
 import { agentArguments, agentShims, codexArguments, sbxAgentText, shimText } from '../agents/agent-files.js';
 import { codexBootConfig, resetMachineBound, restoreLocalState } from '../agents/local-state.js';
 import { installShellPath } from '../setup/shell-path.js';
-import { linkProfileDirs } from '../agents/profile-links.js';
+import { linkProfileDirsAsync } from '../agents/profile-links.js';
 import { restoreClaudeMem } from '../setup/claude-mem.js';
 import { syncClaudeProfile } from '../setup/claude-profile.js';
 import { agentEnv, persistEnvironment } from '../setup/environment.js';
@@ -17,7 +20,7 @@ import { applyAllowOnly, proxyEnv } from '../network/allow-only.js';
 import { applyNetworkPolicy, networkProblems } from '../network/firewall.js';
 import { writeManagedSettings } from '../setup/managed-policy.js';
 import { writeAddonMcpServers } from '../setup/addon-mcp.js';
-import { startHeadroom } from '../setup/headroom.js';
+import { awaitHeadroom, spawnHeadroom } from '../setup/headroom.js';
 import { applyPersonalization } from '../setup/desktop.js';
 import { keepBrowsersOffGpu } from '../setup/browser-gpu.js';
 import { setupGitConfig } from '../setup/git-identity.js';
@@ -34,39 +37,20 @@ 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 { BOOT_DEFS, STAGES, stageTitle } from './graph.js';
+import { BootRunner, bootSummary, seconds } from './runner.js';
+import { installPools } from '../runtime/pools.js';
 import { primaryProject, saveProjectStatus } from './project-status.js';
 import { dryRun, isWin, localDir, logsDir, run, toolsDir } from '../runtime/paths.js';
-import { log, logPath, warn } from '../runtime/log.js';
+import { log, logPath, runQuiet, warn, withLogContext } from '../runtime/log.js';
 import { mkdirp } from '../runtime/fs.js';
 import { session, workspace } from '../runtime/session.js';
 import { applyBootEnvironment, BOOT_SECRETS_VARIABLE, takeSecrets } from '../runtime/secrets.js';
-import { setSandboxStatus } from '../runtime/status.js';
+import { setBackgroundWork, setSandboxStatus } from '../runtime/status.js';
 import { errMsg } from '../../core/util/errors.js';
-const STEPS = 9;
 const PRIMARY_POLLS = 600;
 const POLL_MS = 500;
 const VSCODE_LANGUAGES = ['python', 'java', 'go', 'rust', 'cpp', 'msvc', 'dotnet', 'ruby', 'php', 'deno', 'pwsh'];
-/** Step n of STEPS: a line in the window and the host's progress (the short title, with what is set up in it). */
-function step(n, title) {
-    log('\n\x1b[36m[' + n + '/' + STEPS + '] ' + title + '\x1b[0m');
-    setSandboxStatus(n === 1 ? 'booting' : 'provisioning', '[' + n + '/' + STEPS + '] ' + title, {
-        step: n,
-        steps: STEPS,
-        title: title.replace(/ \(.*\)$/, ''),
-        active: [],
-        done: 0,
-        total: 0,
-    });
-}
-/** Runs work that may fail without stopping the boot (a warning says what failed). */
-async function soft(what, work) {
-    try {
-        await work();
-    }
-    catch (e) {
-        warn(what + ' failed (continuing): ' + errMsg(e));
-    }
-}
 function startDaemon(env, secrets) {
     spawn(process.execPath, [path.join(path.dirname(process.argv[1]), 'daemon.js')], {
         detached: true,
@@ -142,13 +126,49 @@ function vscodeLanguages() {
     const toolchains = session.toolchains;
     return VSCODE_LANGUAGES.filter((t) => wanted(toolchains[t]?.enabled ?? false, t));
 }
-/** One boot of the sandbox, step by step: each step is a method, in the order they run. */
+/** Headroom's own marker: the app was installed in an earlier boot (so the Apps step will not replace its folder). */
+function headroomInstalledBefore() {
+    return (!session.provisioning.refresh &&
+        installedAddon('headroom') !== null &&
+        fs.existsSync(path.join(tool('apps', 'headroom'), '.agent-sandbox-app')));
+}
+/** Warns and goes on (a step inside a task that must not stop the rest of that task). */
+async function soft(what, work) {
+    try {
+        await work();
+    }
+    catch (e) {
+        warn(what + ' failed (continuing): ' + errMsg(e));
+    }
+}
+/** One boot of the sandbox: a graph of tasks (graph.ts) run by the BootRunner, each task a method below. */
 export class Boot {
+    // The shared boot state: each field is written by one task (graph.ts says which); readers come after that task.
     ptyHost = null;
     lan = session.networking ? 'open' : 'offline';
+    tools = null;
+    dbBin = null;
+    allowSummary = [];
+    vscodeSummary = [];
+    env = {};
+    toolVars = [];
+    summary = [];
+    headroom = null;
     gitAccess = session.provisioning.git.access ?? 'full';
-    /** What the host handed over in its one-shot file (read and deleted at the start of run()). */
-    secrets = {};
+    /** What the host handed over in its one-shot file (read and deleted in the prelude; never changed afterwards). */
+    secrets = Object.freeze({});
+    basePath = '';
+    startedAt = Date.now();
+    openGate = () => undefined;
+    gate = new Promise((resolve) => {
+        this.openGate = resolve;
+    });
+    /** The boot is ready: the runner no longer writes the status (the session owns it). */
+    ready = false;
+    lastStatus = null;
+    activeSteps = [];
+    stepsDone = 0;
+    stepsTotal = 0;
     async run() {
         log('Agent sandbox: ' +
             session.project +
@@ -160,151 +180,305 @@ export class Boot {
             logPath);
         if (!fs.statSync(workspace, { throwIfNoEntry: false })?.isDirectory())
             throw new Error('Workspace folder is missing in the sandbox: ' + workspace);
+        this.basePath = process.env.PATH ?? '';
         mkdirp(toolsDir);
         mkdirp(run.root);
-        this.secrets = takeSecrets(session.launchId);
-        await this.serviceAccounts();
+        // The prelude is sequential: it changes process.env, so it ends before any task starts a program.
+        this.secrets = await this.takeSecretsAndAccounts();
         applyBootEnvironment(this.secrets.harnessEnvironment);
         prepareGithubFolder(this.secrets.githubToken);
-        await this.networkAndSessionHost();
-        await this.hooksAndDesktop();
-        const { tools, env } = await this.developerTools();
-        await this.vpn();
-        await this.gitIdentity(env);
-        await this.claude(tools, env);
-        await this.agent(env);
-        this.preAgentHooks(env);
-        await this.start(env);
+        installPools();
+        const runner = new BootRunner(BOOT_DEFS, this.tasks(), {
+            say: (line, quiet) => (quiet ? runQuiet(() => log(line)) : log(line)),
+            warn: (line, quiet) => (quiet ? runQuiet(() => warn(line)) : warn(line)),
+            now: () => Date.now(),
+            dryRun,
+            stages: STAGES,
+            stageTitle: (n) => this.stageTitle(n),
+            status: (s) => {
+                this.lastStatus = s;
+                this.publish();
+            },
+            inContext: (ctx, work) => withLogContext({ prefix: ctx.prefix, quiet: ctx.quiet }, work),
+        });
+        await runner.run('foreground');
+        const background = this.backgroundNames();
+        log(bootSummary(Date.now() - this.startedAt, runner.results(), background, logPath));
+        if (dryRun) {
+            // Same graph, one task at a time: the background tasks run in place, right after the session.
+            this.openGate();
+            await runner.run('background');
+            return;
+        }
+        this.openGate();
+        const later = runner.run('background');
+        // The viewer owns the console now: the background tasks write to the log file only.
+        if (session.harness && session.autoSession !== false && process.stdin.isTTY) {
+            await viewSession(session.launchId);
+            log('\nThis window stays open in ' + workspace + '. Other sessions keep running in their own tabs.');
+        }
+        await later.catch((e) => warn('Background work failed: ' + errMsg(e)));
+    }
+    stageTitle(n) {
+        return stageTitle(n, { ...(session.vpn ? { vpnServer: session.vpn.server } : {}), agent: session.harnessName });
+    }
+    /** The names shown for work that goes on after the boot is ready. */
+    backgroundNames() {
+        const t = this.tools;
+        if (!t?.later)
+            return [];
+        const later = t.names.filter((n) => !(n in t.steps));
+        return later.length ? [later.slice(0, 3).join(', ') + (later.length > 3 ? ' ...' : '')] : [];
     }
     /**
-     * Your saved service sign-ins (accounts.<kind>.share) go to their tools before anything opens them, and leave memory
-     * at once; what they give the agent (EXPO_TOKEN ...) joins its environment (in memory only).
+     * The host's one-shot file, read once. Your saved service sign-ins (accounts.<kind>.share) go to their tools before
+     * anything opens them, and leave memory at once; what they give the agent (EXPO_TOKEN ...) joins its environment
+     * (in memory only).
      */
-    async serviceAccounts() {
-        const given = this.secrets.serviceAccounts;
-        this.secrets = { ...this.secrets, serviceAccounts: undefined };
-        if (dryRun || (!given && !session.accountLeases?.length))
+    async takeSecretsAndAccounts() {
+        const taken = takeSecrets(session.launchId);
+        const given = taken.serviceAccounts;
+        let secrets = { ...taken, serviceAccounts: undefined };
+        if (!dryRun && (given || session.accountLeases?.length)) {
+            try {
+                const env = await applyServiceAccounts(given, {
+                    leased: session.accountLeases ?? [],
+                    say: (line) => log(line),
+                });
+                if (Object.keys(env).length)
+                    secrets = { ...secrets, harnessEnvironment: { ...env, ...secrets.harnessEnvironment } };
+            }
+            catch (e) {
+                warn('Service sign-ins failed (continuing): ' + errMsg(e));
+            }
+        }
+        return Object.freeze(secrets);
+    }
+    /** The host's progress line: the runner's stage, the tasks that run now, and what the toolchain scheduler runs. */
+    publish() {
+        const s = this.lastStatus;
+        if (!s || this.ready)
             return;
-        await soft('Service sign-ins', async () => {
-            const env = await applyServiceAccounts(given, { leased: session.accountLeases ?? [], say: (line) => log(line) });
-            if (Object.keys(env).length)
-                this.secrets = { ...this.secrets, harnessEnvironment: { ...env, ...this.secrets.harnessEnvironment } };
+        setSandboxStatus(s.phase, s.message, {
+            step: s.step,
+            steps: STAGES,
+            title: this.stageTitle(s.step).replace(/ \(.*\)$/, ''),
+            active: [...s.running.map((name) => ({ name })), ...this.activeSteps],
+            done: this.stepsDone,
+            total: this.stepsTotal,
         });
     }
-    async networkAndSessionHost() {
-        step(1, 'Network and session host');
-        if (isWin && !dryRun && session.attach.enabled)
-            await soft('Building the session host', () => {
-                this.ptyHost = ensurePtyHost();
-            });
-        await soft('Private-network blocking', async () => {
-            this.lan = await applyNetworkPolicy(this.ptyHost);
-        });
-        await soft('Audit', enableProcessAudit);
+    /** Every task of the graph. */
+    tasks() {
+        return {
+            // 1 - network and session host
+            ptyhost: () => {
+                if (isWin && !dryRun && session.attach.enabled)
+                    this.ptyHost = ensurePtyHost();
+            },
+            network: async () => {
+                this.lan = await applyNetworkPolicy(this.ptyHost);
+            },
+            audit: () => enableProcessAudit(),
+            // 2 - pre-provision hooks and desktop
+            hooksPreProvision: () => runHooks('pre-provision', process.env),
+            desktop: () => applyPersonalization(),
+            browserGpu: () => keepBrowsersOffGpu(),
+            // 3 - developer tools
+            toolchains: () => this.toolchains(),
+            dbCommands: () => {
+                if (!dryRun)
+                    this.dbBin = writeDbCommand();
+            },
+            allowOnly: async () => {
+                if (await applyAllowOnly())
+                    this.allowSummary = ['network: only network.allowOnly hosts (refused: logs\\netproxy.log)'];
+            },
+            vscode: () => this.vscode(),
+            env: () => this.environment(),
+            bootEnv: () => this.bootEnv(),
+            // 4 - VPN
+            vpn: async () => {
+                if (session.vpn)
+                    await setupVpn(this.secrets, this.ptyHost);
+            },
+            // 5 - git
+            gitConfig: () => setupGitConfig(this.env),
+            githubLogin: async () => {
+                const token = this.secrets.githubToken;
+                if (token)
+                    await loginGithub(token, this.env);
+            },
+            // 6 - Claude settings
+            claudeProfile: async () => {
+                if (session.harnessName === 'claude')
+                    await syncClaudeProfile(this.secrets.claudeCredentials);
+            },
+            claudeMem: () => restoreClaudeMem(),
+            agentState: async () => {
+                // All three touch the agents' state folders: one task, in this order, each failing on its own.
+                await soft('Agent files of the last sandbox', resetMachineBound);
+                await soft('Codex settings', codexBootConfig);
+                await soft('Agent databases restore', restoreLocalState);
+            },
+            headroomSpawn: async () => {
+                // Early only when the proxy is installed already (the Apps step must not replace a running one).
+                if (headroomInstalledBefore())
+                    await spawnHeadroom(this.headroomAgentEnv());
+            },
+            mcpServers: () => {
+                writeAddonMcpServers();
+            },
+            headroomReady: async () => {
+                this.headroom = await awaitHeadroom(this.headroomAgentEnv());
+            },
+            managedSettings: () => writeManagedSettings(this.gitAccess, this.headroom),
+            guide: () => {
+                writeGuides(this.summary, this.lan);
+            },
+            // 7 - agent
+            profileLinks: () => linkProfileDirsAsync(session.agentProfileDirs ?? {}),
+            agentProvision: async () => {
+                if (session.harness)
+                    await agents.provision(session.harnessName, session.harness, this.env);
+            },
+            // 8 - pre-agent hooks
+            hooksPreAgent: () => runHooks('pre-agent', this.env),
+            // 9 - start
+            session: () => this.start(),
+            // After the first session runs
+            toolchainsLater: () => this.toolchainsLater(),
+            prune: () => {
+                pruneToolLeftovers();
+            },
+        };
     }
-    async hooksAndDesktop() {
-        step(2, 'Pre-provision hooks and desktop');
-        runHooks('pre-provision', process.env);
-        await soft('Personalisation', applyPersonalization);
-        await soft('Browsers without the GPU', keepBrowsersOffGpu);
+    /** The agent environment before the toolchains are known (the proxy needs no PATH of theirs). */
+    headroomAgentEnv() {
+        return agentEnv({ vars: { ...session.toolchains.environment, ...proxyEnv() }, prepend: [], append: [] });
     }
-    /** Toolchains, databases, apps, the network proxy and VS Code; then the agent environment, saved machine-wide. */
-    async developerTools() {
-        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, {
+    /** Foreground toolchain steps and databases and apps; Visual Studio and what needs it wait for the background. */
+    async toolchains() {
+        const deferHeavy = !dryRun && !session.vpn && !(session.network.allowOnly ?? []).length;
+        this.tools = await setupToolchains(session.toolchains, session.versions, {
             gitEnabled: session.provisioning.git.enabled,
             gitAccess: this.gitAccess,
             hostGit: session.hostTools.git,
             refresh: session.provisioning.refresh,
             databases: session.databases ?? [],
             apps: session.apps,
+            deferHeavy,
             ...(session.pcInstalls ? { pcInstalls: session.pcInstalls } : {}),
+        }, {
+            progress: (p) => {
+                this.activeSteps = p.active;
+                this.stepsDone = p.done;
+                this.stepsTotal = p.total;
+                this.publish();
+            },
+            // Headroom is installed by the Apps step on a first boot: start it as soon as that step is done.
+            onDone: (name) => {
+                if (name === 'Apps')
+                    void spawnHeadroom(this.headroomAgentEnv()).catch((e) => warn('Headroom proxy failed (continuing): ' + errMsg(e)));
+            },
+        }, { gate: this.gate });
+    }
+    vscode() {
+        const vscode = session.toolchains.vscode;
+        const tools = this.tools;
+        if (!vscode.enabled || vscode.setup === false)
+            return;
+        // configureVscode only adds lines to `summary`: they are collected here and merged by the bootEnv task.
+        const lines = [];
+        configureVscode({ vars: tools.vars, prepend: tools.prepend, append: tools.append, summary: lines }, {
+            toolchains: ['node', ...vscodeLanguages()],
+            databases: (session.databases ?? []).map((d) => d.database),
+            config: vscode,
+            workspace,
         });
-        for (const p of networkProblems())
-            tools.summary.push('PROTECTION MISSING: ' + p);
-        if (!dryRun)
-            tools.prepend.push(writeDbCommand());
+        this.vscodeSummary = lines;
+    }
+    /** The agent environment, saved machine-wide, and the PATH of new shells. */
+    async environment() {
+        const tools = this.tools;
         // 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)');
+        const vars = { ...tools.vars, ...proxyEnv() };
+        this.toolVars = Object.keys(vars);
+        this.env = agentEnv({
+            vars,
+            prepend: [...tools.prepend, ...(this.dbBin ? [this.dbBin] : [])],
+            append: tools.append,
         });
-        const vscode = session.toolchains.vscode;
-        if (vscode.enabled && vscode.setup !== false)
-            await soft('VS Code setup', () => configureVscode(tools, {
-                toolchains: ['node', ...vscodeLanguages()],
-                databases: (session.databases ?? []).map((d) => d.database),
-                config: vscode,
-                workspace,
-            }));
-        const env = agentEnv(tools);
-        persistEnvironment(env, Object.keys(tools.vars));
+        await persistEnvironment(this.env, this.toolVars);
         await soft('Shell start-up PATH', installShellPath);
+    }
+    /** What the tools left: lines for the guide and status, and what later projects start from. */
+    bootEnv() {
+        const tools = this.tools;
+        this.summary = this.summaryLines(tools.summary);
         saveBootEnv({
-            basePath,
-            toolVars: Object.keys(tools.vars),
+            basePath: this.basePath,
+            toolVars: this.toolVars,
             steps: tools.steps,
-            summary: tools.summary,
+            summary: this.summary,
             lan: this.lan,
         });
-        saveProjectStatus(primaryProject(), workspace, 'ready', 'Ready', session.databases ?? [], tools.summary);
-        for (const line of tools.summary)
+        saveProjectStatus(primaryProject(), workspace, 'ready', 'Ready', session.databases ?? [], this.summary);
+        for (const line of this.summary)
             log('  ' + line);
-        await soft('Cleaning old tool builds', () => pruneToolLeftovers());
-        return { tools, env };
     }
-    /** vpn.enabled: the tunnel and its kill switch, before anything else uses the network (git, the agent). */
-    async vpn() {
-        step(4, session.vpn ? 'VPN (' + session.vpn.server + ')' : 'VPN (off)');
-        if (!session.vpn)
-            return;
-        await soft('VPN', async () => {
-            await setupVpn(this.secrets, this.ptyHost);
-        });
+    /** The toolchains' lines, then the missing protections, allowOnly and VS Code (in this order). */
+    summaryLines(toolchainLines) {
+        return [
+            ...toolchainLines,
+            ...networkProblems().map((p) => 'PROTECTION MISSING: ' + p),
+            ...this.allowSummary,
+            ...this.vscodeSummary,
+        ];
     }
-    async gitIdentity(env) {
-        step(5, 'Git identity');
-        await soft('Git config', () => setupGitConfig(env));
-        // After the VPN (gh checks the token with GitHub) and the git config (setup-git adds to it).
-        const token = this.secrets.githubToken;
-        if (token) {
-            this.secrets = { ...this.secrets, githubToken: undefined };
-            await soft('GitHub token', () => loginGithub(token, env));
+    /** Visual Studio and what depends on it (after the session has started): merged into the environment again. */
+    async toolchainsLater() {
+        const tools = this.tools;
+        if (!tools?.later)
+            return;
+        const name = this.backgroundNames()[0] ?? 'Visual Studio';
+        const began = Date.now();
+        setBackgroundWork([{ name, state: 'running' }]);
+        log('Background: ' + name + ' (installing)');
+        try {
+            const part = await tools.later;
+            const steps = { ...tools.steps, ...part.steps };
+            const all = mergeToolchains(session.toolchains, tools.names, steps);
+            const vars = { ...all.vars, ...proxyEnv() };
+            const env = agentEnv({
+                vars,
+                prepend: [...all.prepend, ...(this.dbBin ? [this.dbBin] : [])],
+                append: all.append,
+            });
+            // Additive: nothing the boot or a project added since is taken away.
+            await persistEnvironment(env, Object.keys(vars), true);
+            this.summary = this.summaryLines(all.summary);
+            saveBootEnv({
+                basePath: this.basePath,
+                toolVars: Object.keys(vars),
+                steps,
+                summary: this.summary,
+                lan: this.lan,
+            });
+            saveProjectStatus(primaryProject(), workspace, 'ready', 'Ready', session.databases ?? [], this.summary);
+            await soft('Sandbox guide for the agent', () => writeGuides(this.summary, this.lan));
+            setBackgroundWork([{ name, state: 'done' }]);
+            log('Background done in ' + seconds(Date.now() - began) + ': ' + name);
+        }
+        catch (e) {
+            setBackgroundWork([{ name, state: 'failed' }]);
+            throw e;
         }
     }
-    async claude(tools, env) {
-        step(6, 'Claude settings, history and claude-mem');
-        if (session.harnessName === 'claude')
-            await soft('Claude settings', () => syncClaudeProfile(this.secrets.claudeCredentials));
-        await soft('claude-mem restore', restoreClaudeMem);
-        await soft('Agent files of the last sandbox', resetMachineBound);
-        await soft('Codex settings', codexBootConfig);
-        await soft('Agent databases restore', restoreLocalState);
-        // Agent add-ons: MCP servers in the sandbox's Claude Code, and the Headroom proxy before the managed settings point
-        // Claude Code at it (the guide reads them back, so it comes last).
-        let headroom = null;
-        await soft('MCP servers from Apps', writeAddonMcpServers);
-        await soft('Headroom proxy', async () => {
-            headroom = await startHeadroom(env);
-        });
-        await soft('Claude managed settings', () => writeManagedSettings(this.gitAccess, headroom));
-        await soft('Sandbox guide for the agent', () => writeGuides(tools.summary, this.lan));
-    }
-    async agent(env) {
-        step(7, 'Agent: ' + session.harnessName);
-        linkProfileDirs(session.agentProfileDirs ?? {});
-        if (session.harness)
-            await agents.provision(session.harnessName, session.harness, env);
-    }
-    preAgentHooks(env) {
-        step(8, 'Pre-agent hooks');
-        runHooks('pre-agent', env);
-    }
-    /** Ready: starts the session daemon and, with an agent, its first session, shown in this window. */
-    async start(env) {
-        step(9, 'Starting ' + session.harnessName);
+    /** Ready: starts the session daemon and, with an agent, its first session (shown in this window by run()). */
+    async start() {
+        const env = this.env;
+        this.ready = true;
         setSandboxStatus('ready', 'Ready');
         // No agent, or a restart that adds a project (the host opens its sessions itself once the sandbox is ready).
         if (!session.harness || session.autoSession === false) {
@@ -339,9 +513,6 @@ export class Boot {
         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.');
-        if (process.stdin.isTTY)
-            await viewSession(session.launchId);
-        log('\nThis window stays open in ' + workspace + '. Other sessions keep running in their own tabs.');
     }
 }
 export function runBoot() {