windows-development-sandbox 1.18.4 → 1.23.0

package/dist/guest/toolchains/step-scheduler.d.ts

@@ -0,0 +1,51 @@
+import { type ToolEnv } from './tool-env.js';
+import type { ToolchainStep } from './step.js';
+/** Where the scheduler's warnings and the boot status go (injected, so tests need neither the log nor session.json). */
+export interface SchedulerSink {
+    warn(message: string): void;
+    status(message: string, progress: {
+        active: {
+            name: string;
+            percent?: number;
+        }[];
+        done: number;
+        total: number;
+    }): void;
+}
+export interface RunOptions {
+    /** Progress lines ("Installing Go, Rust (3 of 9 done)"); default: the sandbox's boot status. */
+    report?: (message: string) => void;
+    /** What machine-wide (shared) steps contributed at boot: reused instead of run again. */
+    reuse?: Record<string, ToolEnv>;
+    /** The boot: gets what runs now instead of the scheduler writing the sandbox status itself. */
+    progress?: (p: {
+        active: {
+            name: string;
+            percent?: number;
+        }[];
+        done: number;
+        total: number;
+    }) => void;
+    /** A step finished (installed, failed or reused). */
+    onDone?: (name: string) => void;
+}
+export declare class StepScheduler {
+    private readonly sink;
+    private readonly parallel;
+    /** One lock per kind of step ("Node 20" and "Node 22" share nvm's folders): held while that step runs, in any run. */
+    private readonly locks;
+    /** The step a download belongs to (several run at once), for its progress. */
+    private readonly currentStep;
+    /** Downloads started ahead of their steps (by name), until the step has used them. */
+    private readonly fetches;
+    constructor(sink: SchedulerSink, parallel?: number);
+    /**
+     * Starts the downloads of these steps now (once per step); `run` waits for a step's own download before it installs.
+     * Failures are not reported here: the install downloads again and reports the real reason.
+     */
+    startFetches(steps: readonly ToolchainStep[]): void;
+    /** Runs the steps (each with its own environment) and returns each step's environment, in plan order. */
+    run(steps: readonly ToolchainStep[], o: RunOptions): Promise<Map<string, ToolEnv>>;
+    /** Runs `work` once no other step of the same kind (first word of the name) is running. */
+    private exclusive;
+}

package/dist/guest/toolchains/step-scheduler.js

@@ -0,0 +1,147 @@
+// Runs the planned steps in parallel, a few at a time, after the steps they depend on. One lock per kind of step is
+// held across runs: the boot and projects that join later never install two Nodes (or two Gos) at once.
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { downloader } from '../../shared/download/index.js';
+import { errMsg } from '../../core/util/errors.js';
+import { emptyEnv } from './tool-env.js';
+/** How many installers run at once: enough to overlap downloads with installs, few enough not to thrash the disk. */
+const PARALLEL = 4;
+/** Runs one installer; a failure is reported and skipped so it never blocks the other toolchains. */
+async function runReported(sink, name, env, work) {
+    try {
+        await work();
+    }
+    catch (e) {
+        sink.warn(name +
+            ' could not be set up and is skipped; everything else still works, and the next start tries again. Reason: ' +
+            errMsg(e));
+        env.summary.push(name + ': FAILED');
+    }
+}
+export class StepScheduler {
+    sink;
+    parallel;
+    /** One lock per kind of step ("Node 20" and "Node 22" share nvm's folders): held while that step runs, in any run. */
+    locks = new Map();
+    /** The step a download belongs to (several run at once), for its progress. */
+    currentStep = new AsyncLocalStorage();
+    /** Downloads started ahead of their steps (by name), until the step has used them. */
+    fetches = new Map();
+    constructor(sink, parallel = PARALLEL) {
+        this.sink = sink;
+        this.parallel = parallel;
+    }
+    /**
+     * Starts the downloads of these steps now (once per step); `run` waits for a step's own download before it installs.
+     * Failures are not reported here: the install downloads again and reports the real reason.
+     */
+    startFetches(steps) {
+        for (const s of steps) {
+            if (!s.fetch || this.fetches.has(s.name))
+                continue;
+            this.fetches.set(s.name, this.currentStep
+                .run(s.name, async () => s.fetch())
+                .catch(() => {
+                /* install downloads again and says why it failed */
+            }));
+        }
+    }
+    /** Runs the steps (each with its own environment) and returns each step's environment, in plan order. */
+    async run(steps, o) {
+        const envs = new Map(steps.map((s) => [s.name, emptyEnv()]));
+        const finished = new Map();
+        const running = new Set();
+        const waiting = [];
+        let done = 0;
+        // The boot (no `report`) also publishes structured progress: what runs now, how far its download is, how many are
+        // done.
+        const percent = new Map();
+        const active = () => [...running].map((name) => ({ name, ...(percent.has(name) ? { percent: percent.get(name) } : {}) }));
+        const say = o.report ??
+            ((message) => o.progress
+                ? o.progress({ active: active(), done, total: steps.length })
+                : this.sink.status(message, { active: active(), done, total: steps.length }));
+        const report = () => {
+            if (running.size)
+                say('Installing ' + [...running].join(', ') + ' (' + done + ' of ' + steps.length + ' done)');
+        };
+        this.startFetches(steps.filter((s) => !(s.shared && o.reuse?.[s.name])));
+        if (!o.report)
+            downloader.watch(() => {
+                const name = this.currentStep.getStore();
+                return name
+                    ? (fraction) => {
+                        percent.set(name, Math.round(fraction * 100));
+                        report();
+                    }
+                    : null;
+            });
+        for (const s of steps) {
+            // Dependencies first (they are earlier in the plan, so their promises exist), then a free slot.
+            finished.set(s.name, (async () => {
+                await Promise.all((s.after ?? []).map((name) => finished.get(name)));
+                const env = envs.get(s.name);
+                const reused = s.shared ? o.reuse?.[s.name] : undefined;
+                if (reused) {
+                    envs.set(s.name, structuredClone(reused));
+                    done++;
+                    o.onDone?.(s.name);
+                    return;
+                }
+                // Its download (started above, before the dependencies finished) is in by now, or still coming.
+                await this.fetches.get(s.name);
+                this.fetches.delete(s.name);
+                while (running.size >= this.parallel)
+                    await new Promise((r) => waiting.push(r));
+                running.add(s.name);
+                report();
+                try {
+                    await this.currentStep.run(s.name, () => this.exclusive(s.name, () => runReported(this.sink, s.name, env, async () => s.install(env))));
+                }
+                finally {
+                    running.delete(s.name);
+                    percent.delete(s.name);
+                    done++;
+                    report();
+                    waiting.shift()?.();
+                    o.onDone?.(s.name);
+                }
+            })());
+        }
+        try {
+            await Promise.all(finished.values());
+        }
+        finally {
+            if (!o.report)
+                downloader.watch(null);
+        }
+        o.progress?.({ active: [], done, total: steps.length });
+        if (!o.report && !o.progress)
+            this.sink.status('Set up ' + steps.length + ' toolchains and databases', {
+                active: [],
+                done,
+                total: steps.length,
+            });
+        return envs;
+    }
+    /** Runs `work` once no other step of the same kind (first word of the name) is running. */
+    async exclusive(name, work) {
+        const key = name.split(' ')[0].toLowerCase();
+        const previous = this.locks.get(key) ?? Promise.resolve();
+        let release = () => undefined;
+        const mine = new Promise((r) => {
+            release = r;
+        });
+        const chained = previous.then(() => mine);
+        this.locks.set(key, chained);
+        await previous;
+        try {
+            return await work();
+        }
+        finally {
+            release();
+            if (this.locks.get(key) === chained)
+                this.locks.delete(key);
+        }
+    }
+}

package/dist/guest/toolchains/step.d.ts

@@ -11,6 +11,12 @@ export interface ToolchainOptions {
     apps?: Config['apps'];
     /** pcInstalls: this PC's games, engines and editors mapped read-only (session.json). */
     pcInstalls?: PcInstallManifest;
+    /**
+     * Boot only: the heavy installs (Visual Studio, and what depends on it) run in the background after the agent has
+     * started. Off with a VPN or network.allowOnly (their firewall would cut the downloads), in a dry run and when a
+     * project joins a running sandbox.
+     */
+    deferHeavy?: boolean;
 }
 /** What a toolchain module's step gets besides its settings. */
 export interface ToolCtx {
@@ -30,5 +36,12 @@ export interface ToolchainStep {
      * git guard): a project added after boot reuses what the boot's run contributed instead of running it again.
      */
     readonly shared?: boolean;
+    /**
+     * Download only what `install` will need (no-op when it is there). The scheduler starts every step's fetch at once,
+     * outside the step slots and `after`; only the net pool limits them. A failure is ignored: install downloads again.
+     */
+    fetch?(): Promise<void>;
+    /** At boot, runs after the agent has started (the steps that depend on it follow it). */
+    readonly background?: boolean;
     install(env: ToolEnv): Promise<void> | void;
 }

package/dist/guest/toolchains/tools/git.js

@@ -94,6 +94,22 @@ const pointAtOwnCertificates = (root) => {
     if (fixed !== text)
         fs.writeFileSync(config, fixed);
 };
+/**
+ * Coreutils' link.exe (hard links) next to MSVC's linker: Git Bash puts its own /usr/bin first on PATH, whatever the
+ * Windows PATH says, so a msvc Rust build ran the wrong `link` (os error 1392). Renamed; nobody needs it here.
+ */
+const hideCoreutilsLink = (usrBin) => {
+    const link = path.join(usrBin, 'link.exe');
+    if (!exists(link))
+        return;
+    try {
+        fs.rmSync(path.join(usrBin, 'link-coreutils.exe'), { force: true });
+        fs.renameSync(link, path.join(usrBin, 'link-coreutils.exe'));
+    }
+    catch (e) {
+        warn("Could not rename Git's coreutils link.exe (MSVC link may be shadowed in Git Bash): " + errMsg(e));
+    }
+};
 export async function setupGit(env, hostCopy, refresh, access) {
     const root = tool('git');
     const bash = path.join(root, 'bin', 'bash.exe');
@@ -130,6 +146,8 @@ export async function setupGit(env, hostCopy, refresh, access) {
         throw new Error('bash.exe missing after installing Git');
     pointAtOwnCertificates(root);
     env.vars.CLAUDE_CODE_GIT_BASH_PATH = bash;
+    // usr\bin is on PATH for Git's tools in cmd and PowerShell, last (path-plan.ts keeps MSVC before it).
+    hideCoreutilsLink(path.join(root, 'usr', 'bin'));
     env.append.push(path.join(root, 'usr', 'bin'));
     const version = execOutput(gitExe, ['--version']).replace(/^git version /, '');
     if (access === 'full') {

package/dist/guest/vpn/openvpn.js

@@ -4,7 +4,8 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { downloader, spawnAsync } from '../../shared/download/index.js';
+import { runInstaller } from '../runtime/pools.js';
+import { downloader } from '../../shared/download/index.js';
 import { SYSTEM } from '../../shared/system.js';
 import { dryRun, isWin, toolsDir } from '../runtime/paths.js';
 import { exists, mkdirp } from '../runtime/fs.js';
@@ -48,9 +49,7 @@ export async function ensureOpenVpn() {
     repairServiceQueries();
     log('VPN: installing OpenVPN');
     const logFile = path.join(toolsDir, 'downloads', 'openvpn-install.log');
-    const code = await spawnAsync(SYSTEM.msiexec(), ['/i', msi, '/qn', '/norestart', '/l*v', logFile], {
-        stdio: 'ignore',
-    });
+    const code = await runInstaller(SYSTEM.msiexec(), ['/i', msi, '/qn', '/norestart', '/l*v', logFile]);
     // 3010: installed, a restart is wanted (nothing here needs one).
     if (code !== 0 && code !== 3010)
         throw new Error('The OpenVPN installer failed (exit ' + code + '). Its log: ' + logFile);

package/dist/guest/vpn/tunnel.d.ts

@@ -1,6 +1,9 @@
+import { type VpnFailureCode } from '../../shared/vpn/failure.js';
 export interface TunnelOutcome {
     readonly ok: boolean;
     readonly message: string;
+    /** Why it failed (when it did), for the host to act on. */
+    readonly code?: VpnFailureCode;
     /** The tunnel's own address (what the kill switch lets through). */
     readonly tunnelIp?: string;
 }

package/dist/guest/vpn/tunnel.js

@@ -6,21 +6,14 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { classifyFailure } from '../../shared/vpn/failure.js';
 import { tunnelAddressFromLog } from '../../shared/vpn/kill-switch.js';
 import { logsDir } from '../runtime/paths.js';
 import { log } from '../runtime/log.js';
 const DONE = 'Initialization Sequence Completed';
 /** Why the log says OpenVPN stopped, in a short plain sentence (or null when it does not say). */
 export function failureReason(text) {
-    if (/AUTH_FAILED/i.test(text))
-        return 'the VPN refused the login (for NordVPN use the service credentials, not your account password)';
-    if (/TLS Error: TLS key negotiation failed|TLS handshake failed/i.test(text))
-        return 'it could not reach the VPN server (the network blocks it, or the server is down)';
-    if (/All wintun adapters on this system are in use|Cannot open TUN\/TAP|Could not create Wintun|ovpn-dco.*(error|failed)/i.test(text))
-        return 'the network driver for the tunnel could not be used';
-    if (/Exiting due to fatal error/i.test(text))
-        return 'OpenVPN stopped with an error';
-    return null;
+    return classifyFailure(text)?.reason ?? null;
 }
 const tail = (text, lines = 12) => text.trim().split(/\r?\n/).slice(-lines).join('\n');
 /** Connects. Never leaves the login on disk; kills OpenVPN when the tunnel does not come up in time. */
@@ -57,17 +50,22 @@ export async function startTunnel(o) {
                 const tunnelIp = tunnelAddressFromLog(text) ?? undefined;
                 return { ok: true, message: 'the tunnel is up', ...(tunnelIp ? { tunnelIp } : {}) };
             }
-            const reason = failureReason(text);
+            const failure = classifyFailure(text);
+            const reason = failure?.reason ?? null;
             if (exited !== null || reason) {
                 if (exited === null)
                     child.kill();
                 keepLog();
-                return { ok: false, message: (reason ?? 'OpenVPN stopped') + '. ' + tail(text, 4) };
+                return {
+                    ok: false,
+                    code: failure?.code ?? 'other',
+                    message: (reason ?? 'OpenVPN stopped') + '. ' + tail(text, 4),
+                };
             }
             if (Date.now() > deadline) {
                 child.kill();
                 keepLog();
-                return { ok: false, message: 'the tunnel did not come up in time. ' + tail(text, 4) };
+                return { ok: false, code: 'timeout', message: 'the tunnel did not come up in time. ' + tail(text, 4) };
             }
             await new Promise((r) => setTimeout(r, 500));
         }

package/dist/guest/vpn/vpn.js

@@ -123,6 +123,7 @@ export async function setupVpn(secrets, ptyHostExe) {
             warn('VPN: the kill switch did not hold: a direct connection still got out. If the tunnel drops, traffic leaves through your normal connection.');
     };
     setVpnStatus('starting', 'Starting the VPN');
+    let failureCode;
     try {
         if (!session.networking)
             throw new Error('networking is off for this sandbox');
@@ -178,6 +179,7 @@ export async function setupVpn(secrets, ptyHostExe) {
         if (!result.ok) {
             if (wireguardExe)
                 await removeWireguardTunnel(wireguardExe);
+            failureCode = result.code;
             throw new Error(result.message);
         }
         if (!result.tunnelIp || !hasAdapter(result.tunnelIp))
@@ -207,7 +209,10 @@ export async function setupVpn(secrets, ptyHostExe) {
                 ? ' The kill switch is on, so this sandbox has NO internet access.'
                 : ' The kill switch could NOT close the network, so this sandbox is ONLINE through your normal connection, without the VPN.';
         warn('VPN failed: ' + reason + after);
-        setVpnStatus('failed', reason, killSwitch ? { killSwitchHeld: held } : {});
+        setVpnStatus('failed', reason, {
+            code: failureCode ?? 'other',
+            ...(killSwitch ? { killSwitchHeld: held } : {}),
+        });
         return false;
     }
 }

package/dist/guest/vpn/wireguard.js

@@ -7,7 +7,8 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { downloader, spawnAsync } from '../../shared/download/index.js';
+import { runInstaller } from '../runtime/pools.js';
+import { downloader } from '../../shared/download/index.js';
 import { SYSTEM } from '../../shared/system.js';
 import { WIREGUARD_MSI } from '../../shared/vpn/download.js';
 import { handshakeDone, serviceRunning } from '../../shared/vpn/wireguard.js';
@@ -46,9 +47,15 @@ export async function ensureWireguard() {
     log('VPN: installing WireGuard');
     const logFile = path.join(toolsDir, 'downloads', 'wireguard-install.log');
     // DO_NOT_LAUNCH: the installer would otherwise start the manager window.
-    const code = await spawnAsync(SYSTEM.msiexec(), ['/i', msi, '/qn', '/norestart', 'DO_NOT_LAUNCH=1', '/l*v', logFile], {
-        stdio: 'ignore',
-    });
+    const code = await runInstaller(SYSTEM.msiexec(), [
+        '/i',
+        msi,
+        '/qn',
+        '/norestart',
+        'DO_NOT_LAUNCH=1',
+        '/l*v',
+        logFile,
+    ]);
     if (code !== 0 && code !== 3010)
         throw new Error('The WireGuard installer failed (exit ' + code + '). Its log: ' + logFile);
     if (!exists(exe))

package/dist/host/accounts/deliver.js

@@ -9,6 +9,8 @@ function howToSave(spec) {
         return "sign in to the Epic Games Launcher in this sandbox once, or take this PC's: sandbox account import epic";
     if (spec.kind === 'steam')
         return 'sign in once in this sandbox with sbx-steam login';
+    if (spec.kind === 'comet')
+        return 'sign in to Comet once in this sandbox, and it is kept for the next ones';
     if (spec.returns)
         return 'sign in once in this sandbox, or: sandbox account import ' + spec.kind;
     return spec.sources.includes('typed')
@@ -56,6 +58,11 @@ export function prepareServiceAccounts(i) {
                 if (spec.returns)
                     leased.push(kind);
             }
+            else if (spec.returns) {
+                // Several sandboxes may use it at once: each gets its own lease, so each may hand a renewed one back.
+                leases.claimShared(kind, dataSet, i.launchId, payload ? fingerprint(payload) : null);
+                leased.push(kind);
+            }
             if (unreadable) {
                 notes.push('Your saved ' +
                     spec.label +

package/dist/host/accounts/handoff.js

@@ -61,12 +61,8 @@ export function takeHandoffs(dataPath, final, store = new ServiceAccountStore(st
             const spec = SERVICE_SPECS[kind];
             const bytes = readBoundedFile(file, spec.maxBytes + ENVELOPE_BYTES);
             const parsed = bytes ? handoffSchema(kind).safeParse(JSON.parse(bytes.toString('utf8'))) : null;
-            const lease = leases.holder(kind);
-            if (parsed?.success &&
-                spec.returns &&
-                lease &&
-                lease.dataSet === dataSet &&
-                lease.launchId === parsed.data.launchId) {
+            const lease = leases.leaseOf(kind, dataSet);
+            if (parsed?.success && spec.returns && lease && lease.launchId === parsed.data.launchId) {
                 const payload = parsed.data.payload;
                 store.save(kind, payload, 'sandbox', HOST_SOURCES[kind].summary(payload));
                 ok = true;

package/dist/host/accounts/index.d.ts

@@ -2,5 +2,5 @@ export { accountsDir, ServiceAccountStore, type AccountInfo, type AccountState }
 export { AccountLeases, type ClaimResult, type Lease } from './leases.js';
 export { prepareServiceAccounts, type AccountDelivery, type DeliveryInput } from './deliver.js';
 export { forgetEverywhere, handoffDir, takeHandoffs } from './handoff.js';
-export { notAvailableYet, pcEnv, type HostSource, type PcEnv } from './source.js';
+export { notAvailableYet, parseRegValue, pcEnv, type HostSource, type PcEnv } from './source.js';
 export { HOST_SOURCES } from './sources.js';

package/dist/host/accounts/index.js

@@ -4,5 +4,5 @@ export { accountsDir, ServiceAccountStore } from './store.js';
 export { AccountLeases } from './leases.js';
 export { prepareServiceAccounts } from './deliver.js';
 export { forgetEverywhere, handoffDir, takeHandoffs } from './handoff.js';
-export { notAvailableYet, pcEnv } from './source.js';
+export { notAvailableYet, parseRegValue, pcEnv } from './source.js';
 export { HOST_SOURCES } from './sources.js';

package/dist/host/accounts/kinds/cfx.d.ts

@@ -1,2 +1,2 @@
-import { type HostSource } from '../source.js';
+import type { HostSource } from '../source.js';
 export declare const cfxSource: HostSource<'cfx'>;

package/dist/host/accounts/kinds/cfx.js

@@ -1,7 +1,50 @@
-import { notAvailableYet } from '../source.js';
+// Cfx.re: a FiveM / RedM server licence key from the keymaster (https://portal.cfx.re), and an optional Steam Web API
+// key. Typed with `sandbox account login cfx`, or read from a server.cfg with `sandbox account import cfx --from`.
+import { CfxPayloadSchema } from '../../../shared/accounts/index.js';
+import { fail } from '../../../core/util/index.js';
+import { decodeText } from '../../../shared/io/index.js';
+const MAX_LINES = 20_000;
+const LICENSE_LINE = /^\s*(?:set[rs]?\s+)?sv_licenseKey\s+"?([^"\s]+)"?/i;
+const STEAM_LINE = /^\s*set[rs]?\s+steam_webApiKey\s+"?([A-Fa-f0-9]{32})"?/i;
+/** The line without a `#` or `//` comment (quotes are respected). */
+function withoutComment(line) {
+    let quoted = false;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (c === '"')
+            quoted = !quoted;
+        else if (!quoted && (c === '#' || (c === '/' && line[i + 1] === '/')))
+            return line.slice(0, i);
+    }
+    return line;
+}
 export const cfxSource = {
-    fromAnswers(_answers) {
-        return notAvailableYet('cfx');
+    fromFile(bytes) {
+        let licenseKey = '';
+        let steamWebApiKey = '';
+        for (const raw of decodeText(bytes).text.split(/\r?\n/, MAX_LINES)) {
+            const line = withoutComment(raw);
+            const key = LICENSE_LINE.exec(line);
+            if (key)
+                licenseKey = key[1];
+            const steam = STEAM_LINE.exec(line);
+            if (steam)
+                steamWebApiKey = steam[1].toUpperCase();
+        }
+        if (!licenseKey)
+            fail('That server.cfg has no sv_licenseKey.', 'Type the key instead: sandbox account login cfx');
+        const parsed = CfxPayloadSchema.safeParse({ licenseKey, ...(steamWebApiKey ? { steamWebApiKey } : {}) });
+        if (!parsed.success)
+            fail('The sv_licenseKey in that server.cfg is not a Cfx.re server key (cfxk_...).', 'Copy the key from https://portal.cfx.re (Server keys) and run: sandbox account login cfx');
+        return parsed.data;
     },
-    summary: () => null,
+    fromAnswers(answers) {
+        const licenseKey = (answers.licenseKey ?? '').trim();
+        const steamWebApiKey = (answers.steamWebApiKey ?? '').trim().toUpperCase();
+        const parsed = CfxPayloadSchema.safeParse({ licenseKey, ...(steamWebApiKey ? { steamWebApiKey } : {}) });
+        if (!parsed.success)
+            fail('That is not a Cfx.re server key (cfxk_...) or a Steam Web API key (32 hex characters).', 'Copy the key from https://portal.cfx.re (Server keys) and run: sandbox account login cfx');
+        return parsed.data;
+    },
+    summary: (p) => 'server key' + (p.steamWebApiKey ? ' and Steam Web API key' : ''),
 };

package/dist/host/accounts/kinds/comet.d.ts

@@ -0,0 +1,2 @@
+import type { HostSource } from '../source.js';
+export declare const cometSource: HostSource<'comet'>;

package/dist/host/accounts/kinds/comet.js

@@ -0,0 +1,6 @@
+// Comet: nothing to take from this PC. Its sign-in there is sealed to your Windows account (and reading another
+// browser's cookies is what password stealers do), so it only ever comes from a sandbox you signed in in.
+import { cometSummary } from '../../../shared/accounts/index.js';
+export const cometSource = {
+    summary: (p) => cometSummary(p),
+};

package/dist/host/accounts/kinds/perplexity.d.ts

@@ -0,0 +1,2 @@
+import type { HostSource } from '../source.js';
+export declare const perplexitySource: HostSource<'perplexity'>;

package/dist/host/accounts/kinds/perplexity.js

@@ -0,0 +1,30 @@
+// Perplexity: an API key, taken from this PC (`sandbox account import perplexity`: PERPLEXITY_API_KEY of this
+// terminal, else of your saved Windows user environment), from a file that holds it (`--from .env`: only its
+// PERPLEXITY_API_KEY line is read), or typed (`sandbox account login perplexity`). The key is never printed.
+import { fail } from '../../../core/util/index.js';
+import { PERPLEXITY_ENV, PerplexityPayloadSchema, perplexityKeyFromText, perplexitySummary, } from '../../../shared/accounts/index.js';
+import { decodeText } from '../../../shared/io/index.js';
+/** A key value as it may sit in a variable (quotes and spaces around it taken off). */
+const keyFrom = (value) => {
+    const parsed = PerplexityPayloadSchema.safeParse({ apiKey: (value ?? '').trim().replace(/^(["'])(.*)\1$/, '$2') });
+    return parsed.success ? parsed.data : null;
+};
+export const perplexitySource = {
+    /** PERPLEXITY_API_KEY of this PC: this terminal's environment first, then your saved user environment. */
+    fromPc(pc) {
+        return keyFrom(pc.env?.[PERPLEXITY_ENV]) ?? keyFrom(pc.userVariable?.(PERPLEXITY_ENV));
+    },
+    fromFile(bytes) {
+        const key = perplexityKeyFromText(decodeText(bytes).text);
+        if (!key)
+            fail('That file holds no Perplexity API key.', 'Name a .env file with a line PERPLEXITY_API_KEY=pplx-..., or type the key: sandbox account login perplexity');
+        return key;
+    },
+    fromAnswers(answers) {
+        const parsed = PerplexityPayloadSchema.safeParse({ apiKey: (answers.apiKey ?? '').trim() });
+        if (!parsed.success)
+            fail('That is not a Perplexity API key.', 'Copy it from perplexity.ai/account/api/keys: it starts with pplx-.');
+        return parsed.data;
+    },
+    summary: (p) => perplexitySummary(p),
+};

package/dist/host/accounts/leases.d.ts

@@ -3,13 +3,15 @@ import { type ServiceKind } from '../../shared/accounts/index.js';
 declare const LeaseSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         unity: "unity";
-        steam: "steam";
-        epic: "epic";
-        cfx: "cfx";
         keystore: "keystore";
         play: "play";
         expo: "expo";
         appstore: "appstore";
+        steam: "steam";
+        epic: "epic";
+        cfx: "cfx";
+        perplexity: "perplexity";
+        comet: "comet";
     }>;
     dataSet: z.ZodString;
     launchId: z.ZodString;
@@ -29,6 +31,10 @@ export declare class AccountLeases {
     private all;
     private keep;
     holder(kind: ServiceKind): Lease | null;
+    /** The kind's lease that this data set holds, if any. */
+    leaseOf(kind: ServiceKind, dataSet: string): Lease | null;
+    /** A lease for this data set and launch beside the other data sets' (a sign-in several sandboxes may use). */
+    claimShared(kind: ServiceKind, dataSet: string, launchId: string, delivered: string | null): void;
     /** The lease for this data set and launch, unless another data set's sandbox still runs with it. */
     claim(kind: ServiceKind, dataSet: string, launchId: string, delivered: string | null, isRunning: (dataSet: string) => boolean): ClaimResult;
     release(kind: ServiceKind, dataSet: string): void;

package/dist/host/accounts/leases.js

@@ -1,6 +1,7 @@
 // Which data set holds a one-holder sign-in (Epic, Steam, Unity work in one place at a time), in host-only storage
 // (<storage>\accounts\leases.json). A launch claims the lease even when nothing is saved yet, so a first sign-in made
-// in that sandbox can come back; a lease whose sandbox no longer runs is stale and is taken over.
+// in that sandbox can come back; a lease whose sandbox no longer runs is stale and is taken over. A sign-in several
+// sandboxes may use at once (Comet) has one lease per data set (claimShared): each may hand it back, the last wins.
 import path from 'node:path';
 import { z } from 'zod';
 import { JsonFile } from '../../shared/io/index.js';
@@ -14,7 +15,8 @@ const LeaseSchema = z.object({
     /** The fingerprint of what was handed over (null: nothing saved yet). */
     delivered: z.string().max(128).nullable(),
 });
-const LeasesSchema = z.object({ leases: z.array(LeaseSchema).max(SERVICE_KINDS.length) });
+/** Room for one lease per kind, plus one per data set for the kinds several sandboxes share. */
+const LeasesSchema = z.object({ leases: z.array(LeaseSchema).max(SERVICE_KINDS.length * 64) });
 export class AccountLeases {
     file;
     constructor(storageRoot) {
@@ -29,6 +31,15 @@ export class AccountLeases {
     holder(kind) {
         return this.all().find((l) => l.kind === kind) ?? null;
     }
+    /** The kind's lease that this data set holds, if any. */
+    leaseOf(kind, dataSet) {
+        return this.all().find((l) => l.kind === kind && l.dataSet === dataSet) ?? null;
+    }
+    /** A lease for this data set and launch beside the other data sets' (a sign-in several sandboxes may use). */
+    claimShared(kind, dataSet, launchId, delivered) {
+        const lease = { kind, dataSet, launchId, issuedAt: new Date().toISOString(), delivered };
+        this.keep([...this.all().filter((l) => !(l.kind === kind && l.dataSet === dataSet)), lease]);
+    }
     /** The lease for this data set and launch, unless another data set's sandbox still runs with it. */
     claim(kind, dataSet, launchId, delivered, isRunning) {
         const held = this.holder(kind);

package/dist/host/accounts/source.d.ts

@@ -1,10 +1,16 @@
 import type { Payload, ServiceKind } from '../../shared/accounts/index.js';
-/** This PC's profile folders (passed in, so the self-test uses its own). */
+/** This PC's profile folders and environment (passed in, so the self-test uses its own). */
 export interface PcEnv {
     readonly localAppData: string;
     readonly appData: string;
     readonly programData: string;
+    /** The environment the command runs with (a variable set in this terminal). */
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    /** A variable of this Windows user's saved environment (HKCU\Environment), or null when it is not set. */
+    readonly userVariable?: (name: string) => string | null;
 }
+/** The value of `name` in `reg query <key> /v <name>` output, or null. */
+export declare function parseRegValue(text: string, name: string): string | null;
 export interface HostSource<K extends ServiceKind> {
     /** This PC's program's sign-in (`from`: another folder to read it from), or null when it has none. */
     fromPc?(pc: PcEnv, from?: string): Payload<K> | null;