windows-development-sandbox 1.20.0 → 1.23.1

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

@@ -7,9 +7,11 @@ declare const LeaseSchema: z.ZodObject<{
         play: "play";
         expo: "expo";
         appstore: "appstore";
-        cfx: "cfx";
         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;

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,6 +32,8 @@ 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. */

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/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.

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/claude-login.d.ts

@@ -17,9 +17,9 @@ 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 (sk-ant-api or sk-ant-usr), or null. Never quotes the key. */
+/** What is wrong with a typed or found API key (any Claude Console key), or null. Never quotes the key. */
 export declare const apiKeyProblem: typeof anthropicKeyProblem;
-/** The most of a key that is ever shown: sk-ant-...abcd. */
+/** The most of a key that is ever shown: its prefix (sk-ant-...abcd, skt-ant-...abcd), then its last 4 characters. */
 export declare function maskApiKey(key: string): string;
 export interface LoginFiles {
     readonly claudeDir: string;

package/dist/host/profile/claude-login.js

@@ -14,11 +14,12 @@ import { assertTestWritable } from '../test-guard.js';
 import { hostDataFolder, hostDataRoot } from '../storage/index.js';
 import { assertNoLinks, fail, fileExists, isLink, removeLink, tryReadJson, writeJson } from '../../core/util/index.js';
 export const LOGIN_KINDS = ['subscription', 'console', 'api-key'];
-/** What is wrong with a typed or found API key (sk-ant-api or sk-ant-usr), or null. Never quotes the key. */
+/** What is wrong with a typed or found API key (any Claude Console key), or null. Never quotes the key. */
 export const apiKeyProblem = anthropicKeyProblem;
-/** The most of a key that is ever shown: sk-ant-...abcd. */
+/** The most of a key that is ever shown: its prefix (sk-ant-...abcd, skt-ant-...abcd), then its last 4 characters. */
 export function maskApiKey(key) {
-    return 'sk-ant-...' + key.slice(-4);
+    const prefix = /^[A-Za-z0-9]{1,8}-[A-Za-z]{1,8}-/.exec(key)?.[0] ?? '';
+    return prefix + '...' + key.slice(-4);
 }
 /** What Claude Code records in customApiKeyResponses for a key it may use (its last 20 characters). */
 function approvalOf(key) {

package/dist/host/vpn/nordvpn.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
-/** Reads a URL as text, refusing more than `max` bytes (a server cannot make this PC download without end). */
-export type Fetcher = (url: string, max: number) => Promise<string>;
-export declare function fetchBounded(url: string, max: number): Promise<string>;
+import { fetchBounded, type Fetcher } from '../../shared/download/index.js';
+export { fetchBounded, type Fetcher };
 declare const CountriesSchema: z.ZodArray<z.ZodObject<{
     id: z.ZodNumber;
     name: z.ZodString;
@@ -18,4 +17,3 @@ export declare function findCountry(countries: z.output<typeof CountriesSchema>,
 export declare function recommendedServer(protocol: 'udp' | 'tcp', country: string, fetchText?: Fetcher): Promise<NordServer>;
 /** The server's OpenVPN profile (not yet checked: shared/vpn/ovpn.ts does that). */
 export declare function nordProfile(server: NordServer, protocol: 'udp' | 'tcp', fetchText?: Fetcher): Promise<string>;
-export {};

package/dist/host/vpn/nordvpn.js

@@ -3,35 +3,13 @@
 // is checked here (bounded size, strict shapes, shared/vpn/ovpn.ts) before the sandbox gets it. Nothing here needs
 // the login: the profiles are public.
 import { z } from 'zod';
-import { fetchRetry } from '../../shared/download/index.js';
+import { fetchBounded } from '../../shared/download/index.js';
 import { fail } from '../../core/util/index.js';
 import { MAX_OVPN_BYTES } from '../../shared/vpn/ovpn.js';
 const API = 'https://api.nordvpn.com/v1';
 const CONFIGS = 'https://downloads.nordcdn.com/configs/files';
 const MAX_JSON_BYTES = 2 * 1024 * 1024;
-export async function fetchBounded(url, max) {
-    const response = await fetchRetry(url, {}, 2, 30000);
-    const length = Number(response.headers.get('content-length')) || 0;
-    if (length > max)
-        throw new Error('The answer from ' + new URL(url).host + ' is too big.');
-    const reader = response.body?.getReader();
-    if (!reader)
-        throw new Error('Empty answer from ' + new URL(url).host + '.');
-    const chunks = [];
-    let size = 0;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        size += value.length;
-        if (size > max) {
-            await reader.cancel();
-            throw new Error('The answer from ' + new URL(url).host + ' is too big.');
-        }
-        chunks.push(value);
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
+export { fetchBounded };
 const CountriesSchema = z
     .array(z.object({ id: z.number().int(), name: z.string().max(100), code: z.string().max(4) }))
     .max(400);