windows-development-sandbox 1.18.4 → 1.23.0

package/dist/guest/browser/comet.d.ts

@@ -0,0 +1,28 @@
+import { type CometPayload } from '../../shared/accounts/kinds/comet.js';
+import { type DevToolsEndpoint } from './cdp.js';
+/** The port comet-mcp looks for (it connects to a Comet already listening there). */
+export declare const COMET_MCP_PORT = 9222;
+/** The addresses whose cookies are read back (their cookies and the parent domain's). */
+export declare const COMET_COOKIE_URLS: readonly string[];
+/** Comet's profile: on the sandbox's own disk, wiped with it. */
+export declare function cometProfileDir(): string;
+/** Where `--install --silent` puts Comet (the fallback when the installer cannot be unpacked). */
+export declare function installedCometExe(): string;
+/** comet.exe: the portable copy in tools\apps\comet, else the installed one, else null. */
+export declare function cometExe(): string | null;
+/** How Comet is started here: this profile, DevTools on 127.0.0.1 (`port` 0: any free port, written to the profile). */
+export declare function cometLaunchArgs(port: number, profile?: string): string[];
+/** The same as one command line for a shortcut (quoted where it has spaces). */
+export declare function cometShortcutArgs(port: number, profile?: string): string;
+/** Where a Comet running with this profile listens, from its DevToolsActivePort file; null when there is none. */
+export declare function devToolsEndpoint(profile?: string): DevToolsEndpoint | null;
+/**
+ * The sign-in the running Comet holds now (perplexity.ai's own cookies, asked of one of its pages), or null when
+ * Comet is not running with this profile, has no page open, or holds no sign-in. Never asks for another site's cookies.
+ */
+export declare function readCometSignIn(profile?: string): Promise<CometPayload | null>;
+/**
+ * Writes the sign-in into Comet's profile: into the Comet running with it, or into one started without a window for
+ * this and closed again (Comet saves its cookies as it closes). Resolves with the number of cookies written.
+ */
+export declare function restoreCometSignIn(exe: string, payload: CometPayload, profile?: string): Promise<number>;

package/dist/guest/browser/comet.js

@@ -0,0 +1,155 @@
+// Comet (Perplexity's Chromium browser) in this sandbox: where it is, the profile it runs with, and its sign-in over
+// the DevTools port. The profile is on the sandbox's own disk (%LOCALAPPDATA%\AgentSandbox\comet-profile): a profile
+// on the data folder fails (rename-over is refused there, and its cookie key is sealed to this sandbox's Windows user).
+// The sign-in travels instead as the allow-listed perplexity.ai cookies: read with Network.getCookies for those
+// addresses only (other sites' cookies are never asked for), written back with Storage.setCookies. DevTools listen
+// on 127.0.0.1 only. No runtime imports: the sign-in adapter and the self-test load this file.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { cometPayloadFromCookies, cookiesToRestore } from '../../shared/accounts/kinds/comet.js';
+import { readBoundedFile } from '../../shared/io/bounded.js';
+import { localAppData } from '../accounts/adapter.js';
+import { findExe } from '../apps/find-exe.js';
+import { tool } from '../toolchains/tool-env.js';
+import { CdpConnection, parseDevToolsActivePort } from './cdp.js';
+/** The port comet-mcp looks for (it connects to a Comet already listening there). */
+export const COMET_MCP_PORT = 9222;
+/** The addresses whose cookies are read back (their cookies and the parent domain's). */
+export const COMET_COOKIE_URLS = ['https://www.perplexity.ai/', 'https://perplexity.ai/'];
+const START_MS = 30_000;
+const STOP_MS = 15_000;
+/** Comet's profile: on the sandbox's own disk, wiped with it. */
+export function cometProfileDir() {
+    return path.join(localAppData(), 'AgentSandbox', 'comet-profile');
+}
+/** Where `--install --silent` puts Comet (the fallback when the installer cannot be unpacked). */
+export function installedCometExe() {
+    return path.join(localAppData(), 'Perplexity', 'Comet', 'Application', 'comet.exe');
+}
+/** comet.exe: the portable copy in tools\apps\comet, else the installed one, else null. */
+export function cometExe() {
+    const portable = findExe(tool('apps', 'comet'), 'comet.exe');
+    if (portable)
+        return portable;
+    return fs.existsSync(installedCometExe()) ? installedCometExe() : null;
+}
+/** How Comet is started here: this profile, DevTools on 127.0.0.1 (`port` 0: any free port, written to the profile). */
+export function cometLaunchArgs(port, profile = cometProfileDir()) {
+    return [
+        '--user-data-dir=' + profile,
+        '--remote-debugging-port=' + port,
+        '--remote-debugging-address=127.0.0.1',
+        '--no-first-run',
+        '--no-default-browser-check',
+    ];
+}
+/** The same as one command line for a shortcut (quoted where it has spaces). */
+export function cometShortcutArgs(port, profile = cometProfileDir()) {
+    return cometLaunchArgs(port, profile)
+        .map((a) => (/\s/.test(a) ? '"' + a + '"' : a))
+        .join(' ');
+}
+/** Where a Comet running with this profile listens, from its DevToolsActivePort file; null when there is none. */
+export function devToolsEndpoint(profile = cometProfileDir()) {
+    const bytes = readBoundedFile(path.join(profile, 'DevToolsActivePort'), 512);
+    return bytes ? parseDevToolsActivePort(bytes.toString('utf8')) : null;
+}
+/** A connection to the Comet running with this profile, or null when none answers. */
+async function connect(profile) {
+    const endpoint = devToolsEndpoint(profile);
+    if (!endpoint)
+        return null;
+    try {
+        return await CdpConnection.open(endpoint, 5000);
+    }
+    catch {
+        return null; // Not running (a file left by the last start), or not Comet.
+    }
+}
+/**
+ * The sign-in the running Comet holds now (perplexity.ai's own cookies, asked of one of its pages), or null when
+ * Comet is not running with this profile, has no page open, or holds no sign-in. Never asks for another site's cookies.
+ */
+export async function readCometSignIn(profile = cometProfileDir()) {
+    const cdp = await connect(profile);
+    if (!cdp)
+        return null;
+    try {
+        const { targetInfos = [] } = await cdp.call('Target.getTargets');
+        const page = targetInfos.find((t) => t.type === 'page' && typeof t.targetId === 'string');
+        if (!page)
+            return null;
+        const { sessionId } = await cdp.call('Target.attachToTarget', {
+            targetId: page.targetId,
+            flatten: true,
+        });
+        try {
+            const { cookies = [] } = await cdp.call('Network.getCookies', { urls: [...COMET_COOKIE_URLS] }, { sessionId });
+            return cometPayloadFromCookies(Array.isArray(cookies) ? cookies : [], Math.floor(Date.now() / 1000));
+        }
+        finally {
+            await cdp.call('Target.detachFromTarget', { sessionId }).catch(() => undefined);
+        }
+    }
+    finally {
+        cdp.close();
+    }
+}
+/** Waits for a process to end (true), or gives up after `ms` (false). */
+function exited(child, ms) {
+    if (child.exitCode !== null)
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(false), ms);
+        child.once('exit', () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+    });
+}
+/** Comet started without a window on this profile, answering on its DevTools port; throws when it does not. */
+async function startHidden(exe, profile) {
+    fs.mkdirSync(profile, { recursive: true });
+    fs.rmSync(path.join(profile, 'DevToolsActivePort'), { force: true });
+    const child = spawn(exe, [...cometLaunchArgs(0, profile), '--headless=new', 'about:blank'], {
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.on('error', () => undefined); // Reported below as "did not start".
+    const deadline = Date.now() + START_MS;
+    while (Date.now() < deadline && child.exitCode === null) {
+        const cdp = await connect(profile);
+        if (cdp)
+            return { cdp, child };
+        await new Promise((r) => setTimeout(r, 250));
+    }
+    child.kill();
+    throw new Error('Comet did not start (no DevTools answer within ' + START_MS / 1000 + ' s)');
+}
+/**
+ * Writes the sign-in into Comet's profile: into the Comet running with it, or into one started without a window for
+ * this and closed again (Comet saves its cookies as it closes). Resolves with the number of cookies written.
+ */
+export async function restoreCometSignIn(exe, payload, profile = cometProfileDir()) {
+    const cookies = cookiesToRestore(payload, Math.floor(Date.now() / 1000));
+    if (!cookies.length)
+        return 0;
+    const running = await connect(profile);
+    const started = running ? null : await startHidden(exe, profile);
+    const cdp = running ?? started.cdp;
+    try {
+        await cdp.call('Storage.setCookies', { cookies });
+        if (started) {
+            await cdp.call('Browser.close').catch(() => undefined);
+            if (!(await exited(started.child, STOP_MS)))
+                started.child.kill();
+        }
+        return cookies.length;
+    }
+    finally {
+        cdp.close();
+        if (started && started.child.exitCode === null)
+            started.child.kill();
+    }
+}

package/dist/guest/daemon/project-provisioner.js

@@ -54,7 +54,12 @@ function refreshGuide(projects) {
     const boot = readBootEnv();
     if (!boot)
         return;
-    const list = projects.map((p) => ({ guest: p.spec.workspace, host: p.spec.workspaceHost }));
+    const list = projects.map((p) => ({
+        guest: p.spec.workspace,
+        host: p.spec.workspaceHost,
+        name: p.spec.name,
+        tools: p.summary,
+    }));
     try {
         writeGuides(boot.summary, boot.lan, list);
     }

package/dist/guest/daemon/sessions.js

@@ -18,6 +18,7 @@ import { freePort } from '../runtime/ports.js';
 import { primaryProject } from '../boot/project-status.js';
 import { endLeftoverTree, ensurePtyHost, ptyHostLogTail, recordedTrees, startPtyHost, waitForPtyHost, } from '../sessions/pty-host.js';
 import { agents } from '../agents/agent-installer.js';
+import { agentArguments } from '../agents/agent-files.js';
 import { saveClaudeMem } from '../setup/claude-mem.js';
 import { saveLocalState } from '../agents/local-state.js';
 import { projectHooks, runHooks, runHooksAsync } from '../setup/hooks.js';
@@ -108,7 +109,7 @@ const agentProgram = async (req, env, say) => {
     say('Preparing ' + req.harness);
     await agents.provision(req.harness, harness, env, false);
     const launch = agents.resolveLaunch(req.harness, harness);
-    const base = [...launch.args, ...harness.arguments];
+    const base = [...launch.args, ...agentArguments(req.harness, harness, session.codex)];
     return {
         command: commandLine(launch.file, [...base, ...req.args]),
         restartCommand: commandLine(launch.file, [...base, ...(harness.resumeArguments ?? [])]),

package/dist/guest/devtools/fivem.d.ts

@@ -1,2 +1,2 @@
-import { type DevTool } from './devtool.js';
+import type { DevTool } from './devtool.js';
 export declare const fivemTool: DevTool;

package/dist/guest/devtools/fivem.js

@@ -1,7 +1,247 @@
-// sbx-fivem: start the FiveM / RedM server, pick a server build, make a new resource. Not available yet.
-import { notAvailableYet } from './devtool.js';
+// sbx-fivem: start the FiveM / RedM server (plain or with txAdmin), make a server folder or a new resource, pick a
+// server build, get the natives list. The Cfx.re key reaches FXServer only through +exec of its cfg on the sandbox's
+// own disk; it is never written into the project.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { downloader, spawnAsync } from '../../shared/download/index.js';
+import { errMsg } from '../../core/util/errors.js';
+import { toolsDir } from '../runtime/paths.js';
+import { runScript } from '../runtime/process.js';
+import { portOpen } from '../runtime/ports.js';
+import { session } from '../runtime/session.js';
+import { fetchChannels, CHANNELS } from '../toolchains/fivem/artifacts.js';
+import { artifactDir, rememberArtifact, chosenArtifact, installArtifact, installedBuilds, resolveArtifact, secretsCfg, servingBuildDir, txDataDir, } from '../toolchains/fivem/fivem.js';
+import { fivemTemplatesDir, initServerFolder, resourceHome, RESOURCE_LANGS, scaffoldResource, withEnsure, } from '../toolchains/fivem/scaffold.js';
+import { GAME_PORT, servePlan, TXADMIN_PORT } from '../toolchains/fivem/serve-plan.js';
+const USAGE = [
+    'Usage:',
+    '  sbx-fivem serve [--txadmin | --no-txadmin] [--dir <server folder>]   start the server (default: this folder)',
+    '  sbx-fivem init [--dir <folder>]                    a server.cfg (no keys in it) and resources\\[local]',
+    '  sbx-fivem new <name> --lua | --js | --ts | --cs [--dir <folder>]   a new resource',
+    '  sbx-fivem artifact list                            server builds: recommended, latest ..., and the installed ones',
+    '  sbx-fivem artifact use <recommended|optional|latest|build>   install a build and use it from now on',
+    '  sbx-fivem natives                                  download the natives list (JSON) for the game',
+].join('\n');
+const NATIVES = {
+    gta5: ['https://runtime.fivem.net/doc/natives.json', 'https://runtime.fivem.net/doc/natives_cfx.json'],
+    rdr3: [
+        'https://raw.githubusercontent.com/alloc8or/rdr3-nativedb-data/master/natives.json',
+        'https://runtime.fivem.net/doc/natives_cfx.json',
+    ],
+};
+const config = () => session.toolchains.fivem;
+const game = () => config().game;
+function parse(args) {
+    const positionals = [];
+    const flags = new Set();
+    let dir;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--dir') {
+            dir = args[++i];
+            if (!dir)
+                throw new Error('--dir needs a folder');
+        }
+        else if (a.startsWith('--'))
+            flags.add(a.slice(2));
+        else
+            positionals.push(a);
+    }
+    return { positionals, flags, dir: dir === undefined ? undefined : path.resolve(dir) };
+}
+/** The sandbox's IPv4 addresses the PC can use (its Hyper-V network). */
+function addresses() {
+    return Object.values(os.networkInterfaces())
+        .flat()
+        .filter((a) => Boolean(a && a.family === 'IPv4' && !a.internal))
+        .map((a) => a.address);
+}
+/** The newest MariaDB client in tools\mariadb (databases.mysql installs it there). */
+function mariadbClient() {
+    const root = path.join(toolsDir, 'mariadb');
+    let versions = [];
+    try {
+        versions = fs.readdirSync(root).sort().reverse();
+    }
+    catch {
+        return null;
+    }
+    for (const v of versions)
+        for (const exe of ['mariadb.exe', 'mysql.exe']) {
+            const file = path.join(root, v, 'bin', exe);
+            if (fs.existsSync(file))
+                return file;
+        }
+    return null;
+}
+/** The port of the sandbox's running MariaDB, with the "fivem" database made; null when it does not run. */
+async function mysqlForServer() {
+    const own = (session.databases ?? []).find((p) => p.database === 'mysql');
+    const plan = own ?? (session.databaseCatalog ?? []).find((p) => p.database === 'mysql');
+    if (!plan)
+        return null;
+    if (!(await portOpen(plan.port))) {
+        if (own)
+            console.log('MySQL (MariaDB) is not running: sbx-db start mysql, then serve again for oxmysql.');
+        return null;
+    }
+    const client = mariadbClient();
+    if (client)
+        spawnSync(client, ['-h', '127.0.0.1', '-P', String(plan.port), '-u', 'root', '-e', 'CREATE DATABASE IF NOT EXISTS fivem'], { stdio: 'ignore', windowsHide: true });
+    return plan.port;
+}
+function openPorts(ports) {
+    for (const p of ports)
+        try {
+            runScript('add-firewall-port.ps1', ['-Port', String(p.port), '-Protocol', p.protocol, '-Name', p.name]);
+        }
+        catch (e) {
+            console.error('Could not open port ' + p.port + ' in the sandbox firewall (' + errMsg(e) + '): the PC may not reach it.');
+        }
+}
+async function serve(p) {
+    const build = servingBuildDir();
+    if (!build)
+        throw new Error('no FXServer build is installed: run sbx-fivem artifact use recommended');
+    const txAdmin = p.flags.has('txadmin') ? true : p.flags.has('no-txadmin') ? false : config().txAdmin;
+    const serverDir = p.dir ?? process.cwd();
+    if (!txAdmin && !fs.existsSync(path.join(serverDir, 'server.cfg')))
+        throw new Error('no server.cfg in ' + serverDir + ': run sbx-fivem init there (or serve --txadmin)');
+    const secrets = secretsCfg();
+    if (!secrets)
+        console.log('No Cfx.re key in this sandbox: on your PC run sandbox account login cfx and sandbox config set accounts.cfx.share true, then restart the sandbox.' +
+            (txAdmin ? '' : ' FXServer stops without one.'));
+    fs.mkdirSync(txDataDir(), { recursive: true });
+    const plan = servePlan({
+        artifactDir: build,
+        serverDir,
+        game: game(),
+        txAdmin,
+        secretsCfg: secrets,
+        txData: txDataDir(),
+        mysqlPort: await mysqlForServer(),
+    });
+    openPorts(plan.ports);
+    const ips = addresses();
+    const where = ips.length ? ips : ['<the sandbox address>'];
+    console.log('FXServer ' + path.basename(build) + (game() === 'rdr3' ? ' (RedM)' : '') + ' from ' + plan.cwd);
+    console.log('From your PC: in the ' +
+        (game() === 'rdr3' ? 'RedM' : 'FiveM') +
+        ' client press F8 and type: connect ' +
+        where[0] +
+        ':' +
+        GAME_PORT);
+    if (txAdmin) {
+        console.log('txAdmin: http://' + where[0] + ':' + TXADMIN_PORT + ' in a browser on your PC (its PIN is printed below).');
+        if (secrets)
+            console.log('Keep the key out of txData: in the server.cfg txAdmin makes, replace the sv_licenseKey line with: exec "' +
+                secrets.split('\\').join('/') +
+                '"');
+    }
+    return spawnAsync(plan.exe, plan.args, { cwd: plan.cwd, stdio: 'inherit', env: { ...process.env, ...plan.env } });
+}
+function init(p) {
+    const dir = p.dir ?? process.cwd();
+    const wrote = initServerFolder(fivemTemplatesDir(), dir, path.basename(dir), game());
+    console.log(wrote.length ? 'Wrote ' + wrote.join(', ') + ' in ' + dir : dir + ' already has a server.cfg.');
+    console.log('Next: sbx-fivem new <name> --lua (or --js, --ts, --cs), then sbx-fivem serve');
+    return 0;
+}
+const NEXT = {
+    lua: '',
+    js: '',
+    ts: 'npm install, then npm run build (npm run watch keeps building) in ',
+    cs: 'dotnet publish -c Release in Client and in Server of ',
+};
+function newResource(p) {
+    const [name] = p.positionals;
+    const langs = RESOURCE_LANGS.filter((l) => p.flags.has(l));
+    if (!name || langs.length !== 1)
+        throw new Error('give a name and one of --lua, --js, --ts, --cs\n' + USAGE);
+    const folder = p.dir ?? process.cwd();
+    const into = resourceHome(folder);
+    const made = scaffoldResource({ templates: fivemTemplatesDir(), lang: langs[0], name, into, game: game() });
+    console.log('Made ' + made.dir + ' (' + made.files.length + ' files)');
+    const cfg = path.join(folder, 'server.cfg');
+    if (fs.existsSync(cfg)) {
+        const next = withEnsure(fs.readFileSync(cfg, 'utf8'), name);
+        if (next !== null) {
+            fs.writeFileSync(cfg, next);
+            console.log('Added ensure ' + name + ' to ' + cfg);
+        }
+    }
+    else
+        console.log('Add ensure ' + name + ' to your server.cfg.');
+    if (NEXT[langs[0]])
+        console.log('Build it: ' + NEXT[langs[0]] + made.dir);
+    console.log('A running server picks it up with: refresh, then ensure ' + name + ' (in the server console).');
+    return 0;
+}
+async function artifact(p) {
+    const [, action, value] = p.positionals;
+    const installed = installedBuilds();
+    const chosen = chosenArtifact(config().artifact);
+    if (action === 'list' || action === undefined) {
+        try {
+            const channels = await fetchChannels();
+            for (const c of CHANNELS) {
+                const a = channels[c];
+                console.log(c.padEnd(12) +
+                    String(a.build).padEnd(8) +
+                    (a.txAdmin ? 'txAdmin ' + a.txAdmin : '').padEnd(16) +
+                    (installed.includes(a.build) ? 'installed' : ''));
+            }
+        }
+        catch (e) {
+            console.log('Could not look up the builds online (' + errMsg(e) + ').');
+        }
+        console.log('Installed: ' + (installed.length ? installed.join(', ') : 'none') + ' (tools\\fivem\\artifacts)');
+        console.log('In use: ' +
+            (chosen.chosen
+                ? chosen.setting + ' (build ' + chosen.build + ', chosen with artifact use)'
+                : config().artifact + ' (toolchains.fivem.artifact)'));
+        return 0;
+    }
+    if (action !== 'use' || !value)
+        throw new Error(USAGE);
+    const a = await resolveArtifact(value, true);
+    const done = await installArtifact(a, config().keepVersions);
+    rememberArtifact(value === config().artifact ? null : { artifact: value, build: a.build });
+    console.log('FXServer build ' + a.build + (done.fresh ? ' installed' : ' was there') + ' in ' + artifactDir(a.build));
+    console.log('sbx-fivem serve uses it from now on' + (value === config().artifact ? '' : ', and so do the next sandboxes') + '.');
+    return 0;
+}
+async function natives() {
+    const dir = path.join(toolsDir, 'fivem', 'natives', game());
+    for (const url of NATIVES[game()]) {
+        const file = path.join(dir, path.basename(new URL(url).pathname));
+        await downloader.file(url, file);
+        console.log(file);
+    }
+    return 0;
+}
 export const fivemTool = {
     name: 'fivem',
     summary: 'start the FiveM / RedM server, pick a server build, make a new resource',
-    run: () => notAvailableYet('fivem'),
+    async run(args) {
+        const p = parse(args);
+        switch (p.positionals[0]) {
+            case 'serve':
+                return serve(p);
+            case 'init':
+                return init(p);
+            case 'new':
+                return newResource({ ...p, positionals: p.positionals.slice(1) });
+            case 'artifact':
+            case 'artifacts':
+                return artifact(p);
+            case 'natives':
+                return natives();
+            default:
+                console.log(USAGE);
+                return p.positionals[0] === undefined || p.positionals[0] === 'help' ? 0 : 2;
+        }
+    },
 };

package/dist/guest/entries/daemon.js

@@ -7,6 +7,7 @@ import { startProcessCollector } from '../audit/process-audit.js';
 import { safely } from '../daemon/state.js';
 import { log, warn } from '../runtime/log.js';
 import { adoptBootSecrets } from '../runtime/secrets.js';
+import { installPools } from '../runtime/pools.js';
 import { errMsg } from '../../core/util/errors.js';
 import { Daemon } from '../daemon/daemon.js';
 import { startLiveFolders } from '../daemon/live.js';
@@ -16,6 +17,7 @@ import { startAccountWatch } from '../daemon/accounts.js';
 import { startHeartbeat } from '../daemon/heartbeat.js';
 process.on('uncaughtException', (e) => warn('daemon: unexpected error (continuing): ' + (e.stack ?? errMsg(e))));
 process.on('unhandledRejection', (e) => warn('daemon: unexpected error (continuing): ' + errMsg(e)));
+installPools();
 const liveKey = adoptBootSecrets();
 log('Session daemon started (pid ' + process.pid + ').');
 safely('live folders', () => startLiveFolders(liveKey));

package/dist/guest/runtime/log.d.ts

@@ -1,3 +1,15 @@
+/** Who is logging: the task title (a prefix while several tasks run) and whether the console stays silent. */
+export interface LogContext {
+    readonly prefix?: () => string;
+    /** File only: nothing may print once the first session owns the console. */
+    readonly quiet?: boolean;
+}
+/** Runs `work` so that everything it logs (also after awaits) carries `ctx`. */
+export declare function withLogContext<T>(ctx: LogContext, work: () => T): T;
+/** Runs `work` logging to the file only. */
+export declare function runQuiet<T>(work: () => T): T;
+/** One line of the file: an ISO timestamp first (the console shows no times). */
+export declare function fileLine(message: string, at?: Date): string;
 export declare function log(message: string): void;
 export declare function warn(message: string): void;
 export declare const logPath: string;

package/dist/guest/runtime/log.js

@@ -1,22 +1,46 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { logsDir } from './paths.js';
 fs.mkdirSync(logsDir, { recursive: true });
 const logFile = path.join(logsDir, (process.env.AGENT_LOG_PREFIX ?? 'guest') + '-' + new Date().toISOString().replace(/[:.]/g, '-') + '.log');
+const context = new AsyncLocalStorage();
+/** Runs `work` so that everything it logs (also after awaits) carries `ctx`. */
+export function withLogContext(ctx, work) {
+    return context.run(ctx, work);
+}
+/** Runs `work` logging to the file only. */
+export function runQuiet(work) {
+    return context.run({ ...context.getStore(), quiet: true }, work);
+}
+/** One line of the file: an ISO timestamp first (the console shows no times). */
+export function fileLine(message, at = new Date()) {
+    return at.toISOString() + ' ' + message;
+}
 const append = (line) => {
     try {
-        fs.appendFileSync(logFile, line + '\n');
+        fs.appendFileSync(logFile, fileLine(line) + '\n');
     }
     catch {
         /* logging must never break the run */
     }
 };
+const tagged = (message, ctx) => {
+    const prefix = ctx?.prefix?.();
+    return prefix ? prefix + ' | ' + message : message;
+};
 export function log(message) {
-    console.log(message);
-    append(message);
+    const ctx = context.getStore();
+    const line = tagged(message, ctx);
+    if (!ctx?.quiet)
+        console.log(line);
+    append(line);
 }
 export function warn(message) {
-    console.warn('\x1b[33mWARNING: ' + message + '\x1b[0m');
-    append('WARNING: ' + message);
+    const ctx = context.getStore();
+    const line = tagged(message, ctx);
+    if (!ctx?.quiet)
+        console.warn('\x1b[33mWARNING: ' + line + '\x1b[0m');
+    append('WARNING: ' + line);
 }
 export const logPath = logFile;

package/dist/guest/runtime/pools.d.ts

@@ -0,0 +1,24 @@
+import { type SpawnOptions } from 'node:child_process';
+import { heavy, installer, net } from '../../shared/concurrency/index.js';
+export { net, heavy, installer };
+/** Called at the start of the boot and of the daemon: the downloader and the extractor use the pools from then on. */
+export declare function installPools(): void;
+/** Lowers a process (and the children it starts from now on) to below-normal priority; best effort. */
+export declare function belowNormal(pid: number | undefined): void;
+export interface InstallerOptions {
+    /** Below-normal priority for the installer and what it starts (the background Visual Studio). */
+    readonly lowPriority?: boolean;
+    readonly cwd?: string;
+    readonly stdio?: 'ignore' | 'inherit';
+    /** Tests: how long to wait between tries. */
+    readonly waitMs?: number;
+}
+/**
+ * Runs an installer in the one installer slot and starts it again while another process holds the Windows Installer
+ * lock (exit 1618). Resolves with the exit code of the last try.
+ */
+export declare function runInstaller(file: string, args: string[], o?: InstallerOptions): Promise<number>;
+/** runInstaller that throws like execAsync when the installer fails. */
+export declare function runInstallerChecked(file: string, args: string[], o?: InstallerOptions): Promise<void>;
+/** execAsync for heavy local work (npm, uv, rustup ...): one of the two heavy slots. */
+export declare function execHeavy(file: string, args: string[], options?: SpawnOptions): Promise<void>;

package/dist/guest/runtime/pools.js

@@ -0,0 +1,60 @@
+// The guest's work pools: network bodies, heavy local work and installers. A task takes one slot at the leaf (the
+// call that downloads, unpacks or installs), never while it holds another: the limiter refuses nested pools.
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { heavy, installer, net, INSTALLER_WAIT_MS, installerRetry } from '../../shared/concurrency/index.js';
+import { downloader, limitExtraction } from '../../shared/download/index.js';
+import { log } from './log.js';
+import { execAsync } from './process.js';
+export { net, heavy, installer };
+/** Called at the start of the boot and of the daemon: the downloader and the extractor use the pools from then on. */
+export function installPools() {
+    downloader.limit = net;
+    limitExtraction(heavy);
+}
+const BELOW_NORMAL = os.constants.priority.PRIORITY_BELOW_NORMAL;
+/** Lowers a process (and the children it starts from now on) to below-normal priority; best effort. */
+export function belowNormal(pid) {
+    if (pid === undefined)
+        return;
+    try {
+        os.setPriority(pid, BELOW_NORMAL);
+    }
+    catch {
+        /* the process may have ended already; a normal priority only makes it a little slower to share the machine */
+    }
+}
+/**
+ * Runs an installer in the one installer slot and starts it again while another process holds the Windows Installer
+ * lock (exit 1618). Resolves with the exit code of the last try.
+ */
+export async function runInstaller(file, args, o = {}) {
+    for (let attempt = 1;; attempt++) {
+        const code = await installer.run(() => new Promise((resolve, reject) => {
+            const child = spawn(file, args, {
+                stdio: o.stdio ?? 'ignore',
+                windowsHide: true,
+                ...(o.cwd ? { cwd: o.cwd } : {}),
+            });
+            if (o.lowPriority)
+                belowNormal(child.pid);
+            child.once('error', reject);
+            child.once('close', (c) => resolve(c ?? -1));
+        }));
+        if (!installerRetry(code, attempt))
+            return code;
+        log(path.basename(file) + ': another install is running; trying again in a moment (' + attempt + ')');
+        await new Promise((r) => setTimeout(r, o.waitMs ?? INSTALLER_WAIT_MS));
+    }
+}
+/** runInstaller that throws like execAsync when the installer fails. */
+export async function runInstallerChecked(file, args, o = {}) {
+    const code = await runInstaller(file, args, o);
+    if (code !== 0)
+        throw new Error(path.basename(file) + ' ' + args.slice(0, 3).join(' ') + ' failed with exit code ' + code);
+}
+/** execAsync for heavy local work (npm, uv, rustup ...): one of the two heavy slots. */
+export function execHeavy(file, args, options = {}) {
+    return heavy.run(() => execAsync(file, args, options));
+}

package/dist/guest/runtime/process.d.ts

@@ -6,10 +6,14 @@ export declare function execAsync(file: string, args: string[], options?: SpawnO
 export declare function execOutput(file: string, args: string[], options?: SpawnSyncOptions): string;
 /** Runs sandbox\scripts\<name> (a .ps1 in the launch folder) with `args`; throws when it fails. */
 export declare function runScript(name: string, args?: readonly string[]): void;
+/** runScript without blocking the event loop (other boot tasks keep going while the script runs). */
+export declare function runScriptAsync(name: string, args?: readonly string[]): Promise<void>;
 /** runScript for what it prints ('' when it fails). */
 export declare function scriptOutput(name: string, args?: readonly string[], options?: SpawnSyncOptions): string;
 /** Runs sandbox\scripts\<name> with a JSON file (-<param> path) holding `data`, removed afterwards. */
 export declare function runScriptWithJson(name: string, param: string, data: unknown, args?: readonly string[]): void;
+/** runScriptWithJson without blocking the event loop. */
+export declare function runScriptWithJsonAsync(name: string, param: string, data: unknown, args?: readonly string[]): Promise<void>;
 /**
  * Copies a folder with robocopy (fast, restartable), or just the named files in it; exit codes below 8 mean success.
  */