windows-development-sandbox 1.18.4 → 1.23.0

package/dist/host/accounts/source.js

@@ -1,5 +1,30 @@
+// How a sign-in reaches the store on this PC: taken from this PC's own program (fromPc), read from a file you name
+// (fromFile, `sandbox account import <kind> --from <file>`), or typed (fromAnswers, `sandbox account login <kind>`).
+// One module per kind under kinds/; sources.ts lists them.
+import { spawnSync } from 'node:child_process';
 import { fail } from '../../core/util/index.js';
+import { SYSTEM } from '../../shared/system.js';
+import { refuseInSelfTest } from '../test-guard.js';
 import { SERVICE_SPECS } from '../../shared/accounts/index.js';
+/** The value of `name` in `reg query <key> /v <name>` output, or null. */
+export function parseRegValue(text, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const m = new RegExp('^\\s+' + escaped + '\\s+REG_(?:EXPAND_)?SZ\\s+(.*)$', 'im').exec(text);
+    return m ? m[1].trim() : null;
+}
+/** A variable of this Windows user's saved environment, read with reg.exe (by its full path); null when unset. */
+function savedUserVariable(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]{0,100}$/.test(name))
+        return null;
+    refuseInSelfTest("read this PC's saved environment");
+    const r = spawnSync(SYSTEM.reg(), ['query', 'HKCU\\Environment', '/v', name], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 15000,
+        maxBuffer: 64 * 1024,
+    });
+    return r.status === 0 ? parseRegValue(String(r.stdout ?? ''), name) : null;
+}
 /** This PC's folders from the environment (never HOME or USERPROFILE). */
 export function pcEnv() {
     const env = process.env;
@@ -7,9 +32,11 @@ export function pcEnv() {
         localAppData: env.LOCALAPPDATA ?? '',
         appData: env.APPDATA ?? '',
         programData: env.ProgramData ?? env.PROGRAMDATA ?? 'C:\\ProgramData',
+        env,
+        userVariable: savedUserVariable,
     };
 }
 /** What a kind whose host side is not written yet says. */
 export function notAvailableYet(kind) {
-    return fail('Saving a ' + SERVICE_SPECS[kind].label + ' sign-in is not available yet.', 'It comes in a later version of the sandbox.');
+    return fail('Saving a ' + SERVICE_SPECS[kind].label + ' sign-in comes in a later version of the sandbox.', 'Nothing was changed.');
 }

package/dist/host/accounts/sources.js

@@ -1,8 +1,10 @@
 import { appstoreSource } from './kinds/appstore.js';
 import { cfxSource } from './kinds/cfx.js';
+import { cometSource } from './kinds/comet.js';
 import { epicSource } from './kinds/epic.js';
 import { expoSource } from './kinds/expo.js';
 import { keystoreSource } from './kinds/keystore.js';
+import { perplexitySource } from './kinds/perplexity.js';
 import { playSource } from './kinds/play.js';
 import { steamSource } from './kinds/steam.js';
 import { unitySource } from './kinds/unity.js';
@@ -15,4 +17,6 @@ export const HOST_SOURCES = {
     play: playSource,
     expo: expoSource,
     appstore: appstoreSource,
+    perplexity: perplexitySource,
+    comet: cometSource,
 };

package/dist/host/agent-commands/commands.js

@@ -1,4 +1,4 @@
-// (Beta) Agent commands: with agentCommands.enabled, typing an agent's own command on this PC (claude, codex, ...)
+// Agent commands: with agentCommands.enabled, typing an agent's own command on this PC (claude, codex, ...)
 // starts it in a hidden sandbox for the folder you are in and attaches that terminal. Small forwarding files in
 // <storage>\agent-commands go first on YOUR PATH (so they win over npm's and the installers' copies); turning it off
 // removes the files and that one PATH entry. SANDBOX_AGENT_DIRECT=1 runs the real agent on this PC instead.

package/dist/host/agent-commands/forwarders.d.ts

@@ -1,7 +1,19 @@
 import type { AgentCommand } from './commands.js';
 /** Marks files this tool wrote, so only those are ever replaced or removed. */
 export declare const MARKER = "windows-development-sandbox agent command";
+/** What a forwarding file runs: the managed install's launcher when there is one, else node + the entry file. */
+export interface ForwardTarget {
+    readonly node: string;
+    readonly entry: string;
+    /** The managed install's `bin\sandbox.cmd`: it survives updates, which remove the version folder `entry` is in. */
+    readonly launcher?: string;
+}
+/**
+ * Where the forwarding files send the typed command. Under a managed install (installRoot, the folder with `bin`,
+ * `versions` and `node`) that is its launcher; otherwise the entry file of this copy.
+ */
+export declare function forwardTarget(packageRoot: string, installRoot: string | null, node: string): ForwardTarget;
 /** The .cmd file for one agent (cmd, PowerShell and Windows Terminal all run it). */
-export declare function forwardingCmd(a: AgentCommand, node: string, entry: string): string;
+export declare function forwardingCmd(a: AgentCommand, target: ForwardTarget): string;
 /** The same for Git Bash, which looks for a file without an extension. */
-export declare function forwardingSh(a: AgentCommand, node: string, entry: string): string;
+export declare function forwardingSh(a: AgentCommand, target: ForwardTarget): string;

package/dist/host/agent-commands/forwarders.js

@@ -1,12 +1,30 @@
+import path from 'node:path';
 /** Marks files this tool wrote, so only those are ever replaced or removed. */
 export const MARKER = 'windows-development-sandbox agent command';
+/**
+ * Where the forwarding files send the typed command. Under a managed install (installRoot, the folder with `bin`,
+ * `versions` and `node`) that is its launcher; otherwise the entry file of this copy.
+ */
+export function forwardTarget(packageRoot, installRoot, node) {
+    const entry = path.join(packageRoot, 'dist', 'bin', 'sandbox.js');
+    return installRoot ? { node, entry, launcher: path.join(installRoot, 'bin', 'sandbox.cmd') } : { node, entry };
+}
+const posix = (p) => p.replace(/^([A-Za-z]):/, (_m, d) => '/' + d.toLowerCase()).replace(/\\/g, '/');
 /** The .cmd file for one agent (cmd, PowerShell and Windows Terminal all run it). */
-export function forwardingCmd(a, node, entry) {
+export function forwardingCmd(a, target) {
+    const launch = ' launch --harness ' + a.harness + ' --headless --terminal -- %*';
     return [
         '@echo off',
-        'rem ' + MARKER + ' (Beta). Turn off: sandbox agent-commands off. Run the real one: set SANDBOX_AGENT_DIRECT=1',
+        'rem ' + MARKER + '. Turn off: sandbox agent-commands off. Run the real one: set SANDBOX_AGENT_DIRECT=1',
         'if "%SANDBOX_AGENT_DIRECT%"=="1" goto direct',
-        '"' + node + '" "' + entry + '" launch --harness ' + a.harness + ' --headless --terminal -- %*',
+        // A missing program (the tool was uninstalled or moved) runs the real agent instead of failing.
+        ...(target.launcher
+            ? ['if not exist "' + target.launcher + '" goto direct', 'call "' + target.launcher + '"' + launch]
+            : [
+                'if not exist "' + target.node + '" goto direct',
+                'if not exist "' + target.entry + '" goto direct',
+                '"' + target.node + '" "' + target.entry + '"' + launch,
+            ]),
         'exit /b %errorlevel%',
         ':direct',
         'call "' + a.real + '" %*',
@@ -14,20 +32,20 @@ export function forwardingCmd(a, node, entry) {
     ].join('\r\n');
 }
 /** The same for Git Bash, which looks for a file without an extension. */
-export function forwardingSh(a, node, entry) {
-    const posix = (p) => p.replace(/^([A-Za-z]):/, (_m, d) => '/' + d.toLowerCase()).replace(/\\/g, '/');
+export function forwardingSh(a, target) {
     const q = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
+    const launch = ' launch --harness ' + a.harness + ' --headless --terminal -- "$@"';
+    const shLauncher = target.launcher ? posix(target.launcher).replace(/\.cmd$/i, '') : null;
     return [
         '#!/bin/sh',
-        '# ' + MARKER + ' (Beta). Turn off: sandbox agent-commands off. Run the real one: SANDBOX_AGENT_DIRECT=1',
+        '# ' + MARKER + '. Turn off: sandbox agent-commands off. Run the real one: SANDBOX_AGENT_DIRECT=1',
         'if [ "$SANDBOX_AGENT_DIRECT" = "1" ]; then exec ' + q(posix(a.real)) + ' "$@"; fi',
-        'exec ' +
-            q(posix(node)) +
-            ' ' +
-            q(posix(entry)) +
-            ' launch --harness ' +
-            a.harness +
-            ' --headless --terminal -- "$@"',
+        ...(shLauncher
+            ? ['[ -f ' + q(shLauncher) + ' ] || exec ' + q(posix(a.real)) + ' "$@"', 'exec ' + q(shLauncher) + launch]
+            : [
+                '[ -f ' + q(posix(target.entry)) + ' ] || exec ' + q(posix(a.real)) + ' "$@"',
+                'exec ' + q(posix(target.node)) + ' ' + q(posix(target.entry)) + launch,
+            ]),
         '',
     ].join('\n');
 }

package/dist/host/agent-commands/reconcile.d.ts

@@ -1,4 +1,5 @@
 import type { Config } from '../../core/types.js';
+import { type ForwardTarget } from './forwarders.js';
 import { type AgentCommand } from './commands.js';
 export interface Reconciled {
     on: boolean;
@@ -9,4 +10,4 @@ export interface Reconciled {
  * Makes this PC match agentCommands: on = a forwarding file per installed agent and the folder first on your PATH;
  * off = no files, no PATH entry. Only touches files it wrote and its own PATH entry; does nothing when already right.
  */
-export declare function reconcileAgentCommands(config: Config, storageRoot: string, node: string, entry: string): Reconciled;
+export declare function reconcileAgentCommands(config: Config, storageRoot: string, target: ForwardTarget): Reconciled;

package/dist/host/agent-commands/reconcile.js

@@ -5,7 +5,7 @@ import { writeFileAtomic } from '../../shared/io/index.js';
 import { safeRemove } from '../../shared/io/index.js';
 import { MARKER, forwardingCmd, forwardingSh } from './forwarders.js';
 import { commandsDir, cmdSafe, agentCommands } from './commands.js';
-import { editUserPath } from './user-path.js';
+import { editUserPath, userPathHas } from './user-path.js';
 const ownFiles = (dir) => fs.existsSync(dir)
     ? fs
         .readdirSync(dir)
@@ -23,7 +23,7 @@ const ownFiles = (dir) => fs.existsSync(dir)
  * Makes this PC match agentCommands: on = a forwarding file per installed agent and the folder first on your PATH;
  * off = no files, no PATH entry. Only touches files it wrote and its own PATH entry; does nothing when already right.
  */
-export function reconcileAgentCommands(config, storageRoot, node, entry) {
+export function reconcileAgentCommands(config, storageRoot, target) {
     const dir = commandsDir(storageRoot);
     if (!config.agentCommands.enabled) {
         if (!fs.existsSync(dir))
@@ -35,14 +35,14 @@ export function reconcileAgentCommands(config, storageRoot, node, entry) {
             safeRemove(dir, storageRoot);
         return { on: false, commands: [], changed: true };
     }
-    if (!cmdSafe(node) || !cmdSafe(entry))
+    if (![target.node, target.entry, target.launcher ?? ''].every(cmdSafe))
         throw new Error('This tool is installed in a folder whose path has % " or ^, which cannot go into a command file safely.');
     const commands = agentCommands(config, storageRoot);
     ensureDir(dir);
     const wanted = new Map();
     for (const a of commands) {
-        wanted.set(path.join(dir, a.command + '.cmd'), forwardingCmd(a, node, entry));
-        wanted.set(path.join(dir, a.command), forwardingSh(a, node, entry));
+        wanted.set(path.join(dir, a.command + '.cmd'), forwardingCmd(a, target));
+        wanted.set(path.join(dir, a.command), forwardingSh(a, target));
     }
     let changed = false;
     for (const f of ownFiles(dir))
@@ -60,9 +60,8 @@ export function reconcileAgentCommands(config, storageRoot, node, entry) {
             changed = true;
         }
     }
-    const onPath = (process.env.PATH ?? '')
-        .split(path.delimiter)
-        .some((d) => path.resolve(d).toLowerCase() === path.resolve(dir).toLowerCase());
+    // Your PATH as stored (not this process's copy of it, which an older terminal keeps): the registry says if it is on.
+    const onPath = !changed && userPathHas(dir, storageRoot);
     if (changed || !onPath)
         editUserPath(dir, true, storageRoot);
     return { on: true, commands, changed: changed || !onPath };

package/dist/host/agent-commands/user-path.d.ts

@@ -3,3 +3,8 @@
  * <storageRoot>\bin), else native\scripts\edit-user-path.ps1.
  */
 export declare function editUserPath(dir: string, add: boolean, storageRoot: string): void;
+/**
+ * Whether dir is on YOUR PATH as stored in the registry (not this process's copy, which an older terminal keeps stale).
+ * False when it cannot be told: the caller then edits the PATH again, which is harmless.
+ */
+export declare function userPathHas(dir: string, storageRoot: string): boolean;

package/dist/host/agent-commands/user-path.js

@@ -23,3 +23,16 @@ export function editUserPath(dir, add, storageRoot) {
             ' your PATH: ' +
             (result.stderr || result.error?.message || 'exit ' + result.status).trim());
 }
+/**
+ * Whether dir is on YOUR PATH as stored in the registry (not this process's copy, which an older terminal keeps stale).
+ * False when it cannot be told: the caller then edits the PATH again, which is harmless.
+ */
+export function userPathHas(dir, storageRoot) {
+    refuseInSelfTest('read your PATH');
+    const tools = hostToolsExe(storageRoot);
+    const options = { encoding: 'utf8', windowsHide: true };
+    const result = tools
+        ? spawnSync(tools, ['user-path', '--has', dir], options)
+        : spawnSync(SYSTEM.powershell(), nativeScript('edit-user-path.ps1', ['-Dir', dir, '-Query']), options);
+    return result.status === 0;
+}

package/dist/host/github/deliver.d.ts

@@ -10,4 +10,4 @@ export interface GithubDelivery {
     readonly notes: readonly string[];
 }
 /** What this launch hands over. Never throws: a token that cannot be read is a note, and the launch goes on. */
-export declare function prepareGithubToken(config: Config, storageRoot: string, store?: GithubToken, others?: readonly BootWant[]): GithubDelivery;
+export declare function prepareGithubToken(config: Config, storageRoot: string, store?: GithubToken, others?: readonly BootWant[], now?: number): GithubDelivery;

package/dist/host/github/deliver.js

@@ -10,8 +10,26 @@ function stricterProject(config, others) {
 export function githubTokenAllowed(config, others = []) {
     return config.github.shareToken && stricterProject(config, others) === null;
 }
+/** A token that ends within this many days is mentioned at launch. */
+const EXPIRY_NOTE_DAYS = 7;
+/** "Your GitHub token expires in 3 days" (or has expired), from what GitHub said when it was saved. */
+function expiryNotes(tokens, now = Date.now()) {
+    const at = Date.parse(tokens.check()?.expiresAt ?? '');
+    if (Number.isNaN(at))
+        return [];
+    const days = Math.ceil((at - now) / 86_400_000);
+    if (at <= now)
+        return ['Your GitHub token has expired, so GitHub will refuse it. Make a new one in Accounts.'];
+    if (days > EXPIRY_NOTE_DAYS)
+        return [];
+    return [
+        'Your GitHub token expires ' +
+            (days <= 1 ? 'within a day' : 'in ' + days + ' days') +
+            '. Make a new one in Accounts.',
+    ];
+}
 /** What this launch hands over. Never throws: a token that cannot be read is a note, and the launch goes on. */
-export function prepareGithubToken(config, storageRoot, store, others = []) {
+export function prepareGithubToken(config, storageRoot, store, others = [], now = Date.now()) {
     if (!config.github.shareToken)
         return { notes: [] };
     const stricter = stricterProject(config, others);
@@ -46,6 +64,7 @@ export function prepareGithubToken(config, storageRoot, store, others = []) {
         token,
         notes: [
             'Your GitHub token is handed to this sandbox (github.shareToken): the agent can read it and use it for whatever it allows.',
+            ...expiryNotes(tokens, now),
         ],
     };
 }

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

@@ -1,2 +1,3 @@
-export { GithubToken, checkGithubToken, type TokenState } from './token.js';
+export { GithubToken, checkGithubToken, type SavedCheck, type TokenState } from './token.js';
 export { githubTokenAllowed, prepareGithubToken, type GithubDelivery } from './deliver.js';
+export { expiryFromHeader, verifyGithubToken, type GithubCheck, type GithubVerdict } from './verify.js';

package/dist/host/github/index.js

@@ -1,3 +1,4 @@
 // The GitHub token for sandboxes: its encrypted store and whether a launch hands it over.
 export { GithubToken, checkGithubToken } from './token.js';
 export { githubTokenAllowed, prepareGithubToken } from './deliver.js';
+export { expiryFromHeader, verifyGithubToken } from './verify.js';

package/dist/host/github/token.d.ts

@@ -1,5 +1,14 @@
+import { z } from 'zod';
 import { type GithubTokenKind } from '../../shared/github/index.js';
 import { SecretStore } from '../secrets/index.js';
+/** What GitHub said about the token when it was saved (never the token): shown in the status. */
+declare const SavedCheckSchema: z.ZodObject<{
+    login: z.ZodString;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    repoCount: z.ZodNumber;
+    checkedAt: z.ZodString;
+}, z.core.$strip>;
+export type SavedCheck = z.output<typeof SavedCheckSchema>;
 /** What the status may say about the token: never its value. */
 export type TokenState = 'none' | 'saved' | 'unreadable';
 /** The token's kind, or a refusal that says what to do (the message never holds what was typed). */
@@ -10,7 +19,9 @@ export declare class GithubToken {
     constructor(storageRoot: string, secrets?: SecretStore);
     private file;
     /** Checks, encrypts and saves the token (replacing an earlier one). Returns its kind. */
-    save(token: string): GithubTokenKind;
+    save(token: string, check?: SavedCheck): GithubTokenKind;
+    /** What GitHub said when the token was saved: who it is, when it expires, how many repositories (or null). */
+    check(): SavedCheck | null;
     /** The token, decrypted. Only the launch calls this; throws when this Windows user cannot open it. */
     read(): string | null;
     /** Whether a token is saved and can be decrypted by this Windows user (the value is never returned). */
@@ -19,3 +30,4 @@ export declare class GithubToken {
     kind(): GithubTokenKind | null;
     remove(): boolean;
 }
+export {};

package/dist/host/github/token.js

@@ -8,8 +8,16 @@ import { JsonFile } from '../../shared/io/index.js';
 import { GITHUB_TOKEN_KINDS, GithubTokenSchema, githubTokenKind, githubTokenProblem, } from '../../shared/github/index.js';
 import { fail } from '../../core/util/index.js';
 import { SecretStore } from '../secrets/index.js';
+/** What GitHub said about the token when it was saved (never the token): shown in the status. */
+const SavedCheckSchema = z.object({
+    login: z.string().max(100),
+    expiresAt: z.string().max(64).nullable(),
+    repoCount: z.number().int().min(0).max(100000),
+    checkedAt: z.string().max(64),
+});
 const SavedSchema = z.object({
     savedAt: z.string().max(64),
+    check: SavedCheckSchema.optional(),
     kind: z.enum(GITHUB_TOKEN_KINDS),
     sealed: z.string().max(10000),
 });
@@ -31,11 +39,20 @@ export class GithubToken {
         return new JsonFile(SavedSchema, path.join(this.storageRoot, 'github', 'token.json'));
     }
     /** Checks, encrypts and saves the token (replacing an earlier one). Returns its kind. */
-    save(token) {
+    save(token, check) {
         const kind = checkGithubToken(token);
-        this.file().write({ savedAt: new Date().toISOString(), kind, sealed: this.secrets.sealJson({ token }) });
+        this.file().write({
+            savedAt: new Date().toISOString(),
+            kind,
+            sealed: this.secrets.sealJson({ token }),
+            ...(check ? { check } : {}),
+        });
         return kind;
     }
+    /** What GitHub said when the token was saved: who it is, when it expires, how many repositories (or null). */
+    check() {
+        return this.file().read()?.check ?? null;
+    }
     /** The token, decrypted. Only the launch calls this; throws when this Windows user cannot open it. */
     read() {
         const saved = this.file().read();

package/dist/host/github/verify.d.ts

@@ -0,0 +1,27 @@
+import { type RequestFetcher } from '../../shared/download/index.js';
+/** What GitHub told about a token (never the token). */
+export interface GithubCheck {
+    readonly login: string;
+    /** ISO time, or null: it never expires (or GitHub did not say). */
+    readonly expiresAt: string | null;
+    readonly repos: {
+        readonly count: number;
+        readonly sample: readonly string[];
+    };
+    /** A classic token's scopes, as GitHub lists them. */
+    readonly scopes?: string;
+}
+/** The answer: a check, GitHub refusing the token, or GitHub not reachable (the token may still be fine). */
+export type GithubVerdict = {
+    readonly kind: 'ok';
+    readonly check: GithubCheck;
+} | {
+    readonly kind: 'refused';
+    readonly status: number;
+} | {
+    readonly kind: 'unreachable';
+    readonly reason: string;
+};
+/** "2027-02-03 10:00:00 UTC" as an ISO time, or null. */
+export declare function expiryFromHeader(value: string | null): string | null;
+export declare function verifyGithubToken(token: string, fetcher?: RequestFetcher): Promise<GithubVerdict>;

package/dist/host/github/verify.js

@@ -0,0 +1,61 @@
+// Asks GitHub who a token belongs to, when it expires and how many repositories it reaches, right after it was typed,
+// so a wrong or expired token is caught at once. The token goes only in the Authorization header of two requests to
+// api.github.com; the answers are size-limited and read through strict shapes. Nothing here prints the token.
+import { z } from 'zod';
+import { fetchBoundedResponse } from '../../shared/download/index.js';
+const API = 'https://api.github.com';
+const MAX_BYTES = 1024 * 1024;
+/** GitHub's header on a token's answers: "2027-02-03 10:00:00 UTC". */
+const EXPIRY_HEADER = 'github-authentication-token-expiration';
+const UserSchema = z.object({ login: z.string().min(1).max(100) });
+const ReposSchema = z.array(z.object({ full_name: z.string().min(1).max(200) })).max(100);
+/** "2027-02-03 10:00:00 UTC" as an ISO time, or null. */
+export function expiryFromHeader(value) {
+    const match = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}) UTC$/.exec(value?.trim() ?? '');
+    if (!match)
+        return null;
+    const time = Date.parse(match[1] + 'T' + match[2] + 'Z');
+    return Number.isNaN(time) ? null : new Date(time).toISOString();
+}
+export async function verifyGithubToken(token, fetcher = fetchBoundedResponse) {
+    const init = {
+        headers: {
+            Authorization: 'Bearer ' + token,
+            Accept: 'application/vnd.github+json',
+            'X-GitHub-Api-Version': '2022-11-28',
+        },
+    };
+    try {
+        const user = await fetcher(API + '/user', MAX_BYTES, init);
+        if (user.status === 401 || user.status === 403)
+            return { kind: 'refused', status: user.status };
+        if (user.status !== 200)
+            return { kind: 'unreachable', reason: 'GitHub answered ' + user.status + '.' };
+        const who = UserSchema.safeParse(JSON.parse(user.text));
+        if (!who.success)
+            return { kind: 'unreachable', reason: 'GitHub gave an answer this program does not know.' };
+        const expiresAt = expiryFromHeader(user.header(EXPIRY_HEADER));
+        const scopes = user.header('x-oauth-scopes')?.trim();
+        const repos = await fetcher(API + '/user/repos?per_page=100&affiliation=owner,collaborator,organization_member', MAX_BYTES, init);
+        const list = repos.status === 200 ? ReposSchema.safeParse(JSON.parse(repos.text)) : undefined;
+        const names = list?.success ? list.data.map((r) => r.full_name) : [];
+        return {
+            kind: 'ok',
+            check: {
+                login: who.data.login,
+                expiresAt,
+                repos: { count: names.length, sample: names.slice(0, 5) },
+                ...(scopes ? { scopes } : {}),
+            },
+        };
+    }
+    catch (e) {
+        // A timeout, no network, a body that is too big or not JSON: the token itself is not at fault.
+        const reason = e instanceof Error && e.name === 'TimeoutError'
+            ? 'GitHub did not answer in time.'
+            : e instanceof Error && e.message.includes('too big')
+                ? e.message
+                : 'GitHub could not be reached.';
+        return { kind: 'unreachable', reason };
+    }
+}

package/dist/host/launch/hints/fivem.d.ts

@@ -1,3 +1,5 @@
 import type { Toolchains } from '../../../core/types.js';
 import type { ToolchainHints } from './hint.js';
-export declare function fivemHints(_root: string, _settings: Toolchains): ToolchainHints;
+/** The resource manifests in the project (relative paths), at most 3 folders down. */
+export declare function findManifests(root: string): string[];
+export declare function fivemHints(root: string, settings: Toolchains): ToolchainHints;

package/dist/host/launch/hints/fivem.js

@@ -1,3 +1,69 @@
-export function fivemHints(_root, _settings) {
-    return {};
+// FiveM / RedM: toolchain hints from file contents: fxmanifest.lua or __resource.lua up to 3 folders down turns fivem
+// on (resources\[local]\my-resource\fxmanifest.lua), a C# resource dotnet (a manifest that loads *.net.dll, or a
+// .csproj in the resource's folder or one below). Files are found by name and size-checked before they are read, links
+// are never followed and the walk is bounded (the project may be hostile).
+import fs from 'node:fs';
+import path from 'node:path';
+const SKIP = /^(node_modules|\.git|\.hg|\.svn|vendor|target|bin|obj|dist|build|out|cache|\.vs|\.idea|packages)$/i;
+const MANIFEST = /^(fxmanifest|__resource)\.lua$/i;
+const MAX_DEPTH = 3;
+const MAX_FOLDERS = 2000;
+const MAX_MANIFESTS = 200;
+const MAX_BYTES = 64 * 1024;
+const list = (dir) => {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true }).slice(0, 2000);
+    }
+    catch {
+        return [];
+    }
+};
+/** The resource manifests in the project (relative paths), at most 3 folders down. */
+export function findManifests(root) {
+    const found = [];
+    let folders = 0;
+    const walk = (dir, level) => {
+        if (++folders > MAX_FOLDERS || found.length >= MAX_MANIFESTS)
+            return;
+        for (const e of list(dir)) {
+            if (e.isFile() && MANIFEST.test(e.name))
+                found.push(path.relative(root, path.join(dir, e.name)));
+            else if (e.isDirectory() && level < MAX_DEPTH && !SKIP.test(e.name))
+                walk(path.join(dir, e.name), level + 1);
+        }
+    };
+    walk(root, 0);
+    return found;
+}
+const readSmall = (file) => {
+    try {
+        const st = fs.lstatSync(file);
+        return st.isFile() && st.size <= MAX_BYTES ? fs.readFileSync(file, 'utf8') : '';
+    }
+    catch {
+        return '';
+    }
+};
+const hasCsproj = (dir) => list(dir).some((e) => (e.isFile() && /\.csproj$/i.test(e.name)) ||
+    (e.isDirectory() &&
+        !SKIP.test(e.name) &&
+        list(path.join(dir, e.name)).some((f) => f.isFile() && /\.csproj$/i.test(f.name))));
+/** Whether the resource whose manifest this is is written in C# (FiveM loads C# from *.net.dll). */
+function isCsharpResource(root, manifest) {
+    if (/\.net\.dll/i.test(readSmall(path.join(root, manifest))))
+        return true;
+    return hasCsproj(path.dirname(path.join(root, manifest)));
+}
+export function fivemHints(root, settings) {
+    if (settings.fivem.enabled === false)
+        return {};
+    const manifests = findManifests(root);
+    if (!manifests.length)
+        return {};
+    const shown = (rel) => rel.split(path.sep).join('/');
+    const hints = { fivem: shown(manifests[0]) + ' (a FiveM / RedM resource)' };
+    const csharp = manifests.slice(0, 50).find((m) => isCsharpResource(root, m));
+    if (csharp)
+        hints.dotnet = 'a C# FiveM resource (' + shown(csharp) + ')';
+    return hints;
 }

package/dist/host/launch/session-file.js

@@ -32,6 +32,10 @@ export function guestSession(o, parts) {
         projectsDir: PROJECTS_GUEST,
         // Every folder mapped for other projects (roots and projects mapped at boot): the guest accepts projects in them.
         roots: [...parts.boot.roots, ...parts.boot.projects].map((r) => r.guest),
+        mappedProjects: [
+            ...parts.boot.roots.map((r) => ({ host: r.host, guest: r.guest, root: true })),
+            ...parts.boot.projects.map((r) => ({ host: r.host, guest: r.guest })),
+        ],
         ...(o.autoSession === false ? { autoSession: false } : {}),
         harnessName,
         // The environment (it may hold API keys) travels in a one-shot file in <data>\secrets, never in this file.
@@ -65,6 +69,7 @@ export function guestSession(o, parts) {
         loadProfile: loadProfileOf(config),
         pageFileMb: config.sandbox.pageFileMb,
         agentBackstop: config.sandbox.agentMemoryHeadroomMb,
+        codex: config.codex,
         pressureResponse: config.sandbox.pressureResponse,
         apps: config.apps,
         auditProcesses: config.audit.enabled && config.audit.processes,

package/dist/host/launch/toolchains.d.ts

@@ -6,6 +6,7 @@ import { decideToolchains } from '../../core/detect/index.js';
 export declare function decideProjectToolchains(o: Pick<GenerateOptions, 'run' | 'pcLanguages'>): ReturnType<typeof decideToolchains>;
 /**
  * The toolchains a service sign-in may serve that are on for this boot: the launch's own project (its files decide
- * "auto") and the other boot projects that turn one on in their settings.
+ * "auto") and the other boot projects that turn one on in their settings. Plus the apps that use one (Perplexity's
+ * MCP server, Comet), from your apps.install: apps are installed for the launch's settings only.
  */
 export declare function toolchainsOnForBoot(o: Pick<GenerateOptions, 'run' | 'pcLanguages'>, others?: readonly BootWant[]): Set<UsedBy>;

package/dist/host/launch/toolchains.js

@@ -1,4 +1,4 @@
-import { USED_BY } from '../../shared/accounts/index.js';
+import { appUsersOn, USED_BY } from '../../shared/accounts/index.js';
 import { decideToolchains, readPwshScripts, usesPwsh } from '../../core/detect/index.js';
 import { pcLanguages } from './pc-scan.js';
 import { msvcHint, projectEntries, uvHint } from './project-scan.js';
@@ -24,9 +24,11 @@ export function decideProjectToolchains(o) {
 }
 /**
  * The toolchains a service sign-in may serve that are on for this boot: the launch's own project (its files decide
- * "auto") and the other boot projects that turn one on in their settings.
+ * "auto") and the other boot projects that turn one on in their settings. Plus the apps that use one (Perplexity's
+ * MCP server, Comet), from your apps.install: apps are installed for the launch's settings only.
  */
 export function toolchainsOnForBoot(o, others = []) {
     const decisions = decideProjectToolchains(o);
-    return new Set(USED_BY.filter((u) => decisions[u].on || others.some((p) => p.config.toolchains[u].enabled === true)));
+    const toolchains = USED_BY.filter((u) => decisions[u].on || others.some((p) => p.config.toolchains[u].enabled === true));
+    return new Set([...toolchains, ...appUsersOn(o.run.config.apps.install)]);
 }

package/dist/host/profile/accounts.js

@@ -9,6 +9,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
+import { ANTHROPIC_KEY_HINT } from '../../shared/accounts/index.js';
 import { isSafeFileName } from '../../shared/paths/index.js';
 import { JsonFile } from '../../shared/io/index.js';
 import { storageOf } from '../storage/index.js';
@@ -36,10 +37,7 @@ const SealedSchema = z.object({
     email: z.string().max(200).nullable(),
     /** Missing in accounts saved before keys could be: a subscription. */
     kind: z.enum(LOGIN_KINDS).optional(),
-    keyHint: z
-        .string()
-        .regex(/^sk-ant-\.\.\.[A-Za-z0-9_-]{4}$/)
-        .optional(),
+    keyHint: z.string().regex(ANTHROPIC_KEY_HINT).optional(),
     sealed: z.string().max(200000),
 });
 const StoredSchema = z.union([SealedSchema, AccountSchema]);

package/dist/host/profile/claude-login.d.ts

@@ -1,3 +1,4 @@
+import { anthropicKeyProblem } from '../../shared/accounts/index.js';
 /** subscription: claude.ai OAuth; console: the key a Console login made; api-key: a key you gave. */
 export type LoginKind = 'subscription' | 'console' | 'api-key';
 export declare const LOGIN_KINDS: readonly ["subscription", "console", "api-key"];
@@ -16,8 +17,8 @@ export interface CaptureOptions {
     /** ANTHROPIC_API_KEY of this PC: the last place looked at (--from-host only). */
     readonly envKey?: string | null;
 }
-/** What is wrong with a typed or found API key, or null when it has the right shape. Never quotes the key. */
-export declare function apiKeyProblem(key: string): string | null;
+/** What is wrong with a typed or found API key (sk-ant-api or sk-ant-usr), or null. Never quotes the key. */
+export declare const apiKeyProblem: typeof anthropicKeyProblem;
 /** The most of a key that is ever shown: sk-ant-...abcd. */
 export declare function maskApiKey(key: string): string;
 export interface LoginFiles {