windows-development-sandbox 1.20.0 → 1.23.0

package/dist/selftest/ui-text.test.js

@@ -0,0 +1,300 @@
+// What the menu and the web say never tells the user to type a command ("we don't develop a menu to tell people to run
+// commands"): every page of every view, built from sample data, is read for command lines, banned words and command
+// links, and so is every message an operation can fail with (the *.run.ts sources). Text for the command line only
+// is marked (`only: 'cli'` notes, `Empty.cliText`, `next`) and is not read. An exemption names the text and the reason.
+import fs from 'node:fs';
+import path from 'node:path';
+import { sandboxPage } from '../app/features/sandbox/index.js';
+import { sessionsPage } from '../app/features/sessions/index.js';
+import { agentsPage } from '../app/features/agents/index.js';
+import { accountsPage, servicePage } from '../app/features/accounts/index.js';
+import { projectsPage } from '../app/features/projects/index.js';
+import { healthPage } from '../app/features/health/index.js';
+import { dataPage } from '../app/features/data/index.js';
+import { storagePage } from '../app/features/storage/index.js';
+import { logsPage } from '../app/features/logs/index.js';
+import { auditPage, auditListing, listAudit } from '../app/features/audit/index.js';
+import { updatesPage } from '../app/features/updates/index.js';
+import { enginePage } from '../app/features/engine/index.js';
+import { webPage } from '../app/features/web/index.js';
+import { vpnPage } from '../app/features/vpn/index.js';
+import { githubPage } from '../app/features/github/index.js';
+import { accessPage } from '../app/features/access/index.js';
+import { appsPage, listApps } from '../app/features/apps/index.js';
+import { settingsPage } from '../app/features/settings/index.js';
+import { QUERIES } from '../app/features/defs.js';
+import { pageActions } from '../app/kernel/index.js';
+import { readQuery } from '../app/registry.js';
+import { COMMANDS } from '../cli/manifest.js';
+import { renderScreens } from './menu-screens.js';
+import { sampleAccess, sampleAccounts, sampleAgents, sampleAuditLog, sampleContained, sampleData, sampleEngines, sampleHealth, sampleLogs, sampleLogTail, sampleProjects, sampleSessions, sampleStatus, sampleStorage, sampleUpdates, } from './support/web-preview.js';
+/**
+ * Words the menu and the web never show (the glossary fills this in during the wording pass). "(Beta)" is on the
+ * list from the plan but waits for round 3: it is in about twenty setting titles that wording pass renames at once.
+ */
+const BANNED = [/\bnot available yet\b/i];
+/** Text that is allowed to name a command: where, which text, and why. Keep this list short. */
+const EXEMPT = [];
+/** Every visible string of a page: what a person reads in the menu or the web (CLI-only text is left out). */
+export function visibleText(page) {
+    const out = [page.title];
+    const add = (...texts) => {
+        for (const t of texts)
+            if (t)
+                out.push(t);
+    };
+    const act = (a) => add(a.label, a.verb, a.description);
+    if (page.notice && page.notice.only !== 'cli')
+        add(page.notice.text);
+    if (page.empty) {
+        add(page.empty.title, page.empty.text);
+        if (page.empty.action)
+            act(page.empty.action);
+    }
+    for (const a of page.actions ?? [])
+        act(a);
+    for (const s of page.sections) {
+        add(s.title, s.summary, s.description, ...(s.text ?? []));
+        for (const f of s.facts ?? [])
+            add(f.label, f.value, f.description, ...(f.details ?? []));
+        for (const n of s.notes ?? [])
+            if (n.only !== 'cli')
+                add(n.text);
+        for (const a of s.actions ?? [])
+            act(a);
+        for (const i of s.items ?? []) {
+            add(i.label, i.hint, i.description, i.keys, i.disabled, i.group, ...(i.details ?? []), ...(i.badges ?? []).map((b) => b.text));
+            for (const a of [...(i.primary ? [i.primary] : []), ...(i.actions ?? [])])
+                act(a);
+        }
+    }
+    return out;
+}
+/** The commands a person could be told to type: `sandbox <name>` for every command, and the internal `_web`. */
+function commandPattern() {
+    const names = new Set(COMMANDS.map((c) => c.name));
+    const words = [...names].filter((n) => /^[a-z_][a-z0-9-]*$/.test(n)).map((n) => n.replace(/-/g, '\\-'));
+    return new RegExp('\\bsandbox (?:' + words.join('|') + ')\\b');
+}
+/** What is wrong with a text, or undefined. */
+export function textProblem(text, where, command = commandPattern()) {
+    if (EXEMPT.some((e) => e.where === where && text.includes(e.text)))
+        return undefined;
+    const hit = command.exec(text);
+    if (hit)
+        return 'names a command (' + hit[0] + ')';
+    const banned = BANNED.find((b) => b.test(text));
+    if (banned)
+        return 'uses ' + banned;
+    return undefined;
+}
+function serviceRow(over) {
+    return {
+        kind: 'steam',
+        label: 'Steam',
+        share: false,
+        state: 'none',
+        source: null,
+        savedAt: null,
+        summary: null,
+        heldBy: null,
+        usedBy: ['fivem'],
+        usedFor: 'fivem',
+        warnings: ['Steam allows one sign-in at a time.'],
+        canImport: true,
+        canLogin: true,
+        needsFile: false,
+        ready: true,
+        ...over,
+    };
+}
+/** Every page the shared core builds, in the states that print the most text. */
+async function samplePages(dir) {
+    const configPath = path.join(dir, 'config.json');
+    fs.writeFileSync(configPath, '{}\n');
+    fs.mkdirSync(path.join(dir, 'project'), { recursive: true });
+    const ctx = {
+        loaded: { configPath },
+        options: { workspace: path.join(dir, 'project') },
+        storageRoot: path.join(dir, 'storage'),
+        dataPath: path.join(dir, 'data'),
+    };
+    const query = (id) => QUERIES.find((q) => q.id === id);
+    const settings = await readQuery(query('settings.list'), ctx, { scope: 'user' });
+    const apps = (await readQuery(listApps, ctx, { scope: 'user' }));
+    const audit = sampleAuditLog(path.join(dir, 'audit'));
+    const listing = (enabled) => auditListing(audit, { enabled, days: 7, maxMb: 100 }, listAudit.input.parse({}), path.join(dir, 'audit'));
+    const services = (state, share) => ({
+        services: [
+            serviceRow({ state, share, source: state === 'saved' ? 'pc' : null, summary: state === 'saved' ? 'josh' : null }),
+        ],
+    });
+    const health = sampleHealth();
+    const accounts = sampleAccounts();
+    const vpn = (login, enabled) => ({
+        enabled,
+        provider: 'nordvpn',
+        protocol: 'udp',
+        country: 'Netherlands',
+        killSwitch: true,
+        login,
+        loginSavedAt: login === 'saved' ? '2026-10-14T09:30:00.000Z' : null,
+        running: null,
+        lastFailure: null,
+    });
+    const github = (token, shareToken) => ({
+        shareToken,
+        gitAccess: 'full',
+        token,
+        kind: token === 'saved' ? 'fine-grained' : null,
+        savedAt: token === 'saved' ? '2026-10-14T09:30:00.000Z' : null,
+    });
+    const pages = [];
+    const add = (name, page) => pages.push({ name, page });
+    for (const running of [true, false]) {
+        add('sandbox ' + running, sandboxPage(sampleStatus(running)));
+        add('sessions ' + running, sessionsPage(sampleSessions(running)));
+        add('projects ' + running, projectsPage(sampleProjects(running)));
+    }
+    add('projects empty', projectsPage({ all: false, roots: [], exclude: [], projects: [] }));
+    const status = sampleStatus(false);
+    add('sandbox leftover', sandboxPage({ ...status, leftover: { text: 'Windows Sandbox programs are left over.' } }));
+    add('sandbox ended', sandboxPage({ ...status, lastEnd: { text: 'It ended without being closed.', at: '2026-11-01T10:00:00.000Z' } }));
+    add('sandbox no account', sandboxPage({
+        ...sampleStatus(true),
+        sandbox: { ...status.sandbox, running: true, account: null, headless: true },
+    }));
+    add('agents', agentsPage(sampleAgents(), { enabled: false, dir: 'C:/x', found: [] }));
+    add('accounts', accountsPage(accounts, services('saved', true), github('saved', true)));
+    add('accounts none', accountsPage({ ...accounts, agents: accounts.agents.map((a) => ({ ...a, accounts: [] })) }, services('none', false)));
+    for (const state of ['none', 'saved', 'unreadable'])
+        for (const share of [false, true])
+            add('service ' + state + share, servicePage(services(state, share).services[0]));
+    add('health', healthPage(health));
+    add('health none', healthPage({ last: null }));
+    add('data', dataPage(sampleData()));
+    add('storage', storagePage(sampleStorage(), sampleContained()));
+    add('storage unavailable', storagePage(sampleStorage(), {
+        ...sampleContained(),
+        available: false,
+        reasons: ['No.'],
+        fixes: ['Do this.'],
+    }));
+    const logs = sampleLogs();
+    add('logs', logsPage(logs, sampleLogTail({})));
+    add('logs none', logsPage({ ...logs, files: [], crash: false }));
+    add('audit', auditPage(listing(true)));
+    add('audit off', auditPage(listing(false)));
+    const updates = sampleUpdates();
+    add('updates', updatesPage(updates, '1.5.0'));
+    add('updates current', updatesPage({ ...updates, failed: null, previous: null, autoUpdate: false }, null));
+    add('updates unmanaged', updatesPage({ ...updates, managed: false }, null));
+    add('engine', enginePage(sampleEngines()));
+    add('web off', webPage({ running: false, port: null, address: null }));
+    add('web on', webPage({ running: true, port: 47800, address: 'http://127.0.0.1:47800/' }));
+    add('web lan problem', webPage({ running: true, port: 47800, address: 'http://127.0.0.1:47800/', lanProblem: 'No network.' }));
+    add('access', accessPage(sampleAccess()));
+    add('access off', accessPage({
+        ...sampleAccess(),
+        lan: { enabled: false, running: false, address: null, fingerprint: null, problem: null, network: null },
+        devices: [],
+        windows: [],
+        users: [],
+        pending: null,
+    }));
+    for (const login of ['none', 'saved', 'unreadable'])
+        add('vpn ' + login, vpnPage(vpn(login, login === 'saved')));
+    for (const token of ['none', 'saved', 'unreadable'])
+        for (const share of [false, true])
+            add('github ' + token + share, githubPage(github(token, share)));
+    add('settings', settingsPage(settings));
+    add('apps', appsPage(apps));
+    return pages;
+}
+/** Message and fix strings of the operations: lines of *.run.ts files that quote a command. */
+function runSourceLines(root) {
+    const found = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (entry.name.endsWith('.run.ts')) {
+                fs.readFileSync(full, 'utf8')
+                    .split(/\r?\n/)
+                    .forEach((text, i) => {
+                    if (!/^\s*(\/\/|\*|\/\*)/.test(text))
+                        found.push({ where: path.relative(root, full).replace(/\\/g, '/'), line: i + 1, text });
+                });
+            }
+        }
+    };
+    walk(root);
+    return found;
+}
+/** Lines of the run files that may name a command, because only the command line shows them. */
+const CLI_ONLY_LINES = [
+    {
+        where: '*',
+        text: 'cli:',
+        why: 'the command line of an ErrorAction: only the CLI prints it (never sent to the menu or the web)',
+    },
+    {
+        where: 'data/data.run.ts',
+        text: 'storageShare',
+        why: '"sandbox storage" is the name of the storage drive note, not a command',
+    },
+    {
+        where: 'data/data.run.ts',
+        text: 'Name them:',
+        why: 'noTerminal fix: shown only when there is no terminal (the command line)',
+    },
+    {
+        where: 'health/health.run.ts',
+        text: "command: 'sandbox repair'",
+        why: 'the repair log records the command that ran',
+    },
+    { where: 'projects/projects.run.ts', text: 'next:', why: '`next` is printed by the command line only' },
+    { where: 'sandbox/sandbox.run.ts', text: 'Stop it anyway with:', why: 'noTerminal fix: command line only' },
+    {
+        where: 'storage/storage.run.ts',
+        text: "const fix = 'Use: sandbox storage",
+        why: 'noTerminal fix: command line only',
+    },
+];
+export const uiTextSuite = {
+    name: 'ui-text',
+    title: 'menu and web text: no page, message or fix tells the user to run a command',
+    run: async (t) => {
+        const command = commandPattern();
+        t.section('pages');
+        const dir = t.dir('ui-text', 'pages');
+        const pages = await samplePages(dir);
+        const problems = pages.flatMap(({ name, page }) => visibleText(page).flatMap((text) => {
+            const why = textProblem(text, name, command);
+            return why ? [name + ': "' + text.slice(0, 140) + '" ' + why] : [];
+        }));
+        if (process.env.UI_TEXT_DUMP)
+            fs.writeFileSync(process.env.UI_TEXT_DUMP, problems.join('\n'));
+        t.equal(problems, [], 'no page of any view names a command or uses a banned word');
+        const commandLinks = pages.flatMap(({ name, page }) => pageActions(page).flatMap((a) => (a.kind === 'link' && a.target.kind === 'command' ? [name] : [])));
+        t.equal(commandLinks, [], 'no page links to a command line');
+        t.section('messages');
+        const lines = runSourceLines(path.join(process.cwd(), 'src', 'app', 'features'));
+        const loose = lines
+            .filter((l) => command.test(l.text) &&
+            !CLI_ONLY_LINES.some((e) => (e.where === '*' || e.where === l.where) && l.text.includes(e.text)))
+            .map((l) => l.where + ':' + l.line + ' ' + l.text.trim().slice(0, 140));
+        t.equal(loose, [], 'no operation message or fix names a command (use failWith, an action or a CLI-only field)');
+        t.section('menu screens');
+        const screens = renderScreens(t.dir('ui-text', 'screens'));
+        const screenProblems = screens
+            .split('\n')
+            .filter((l) => !l.startsWith('==='))
+            .flatMap((l) => {
+            const why = textProblem(l, 'menu', command);
+            return why ? [l.trim().slice(0, 140) + ' ' + why] : [];
+        });
+        t.equal(screenProblems, [], 'no menu screen names a command');
+    },
+};

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

@@ -3,4 +3,6 @@ export * from './payloads.js';
 export { fingerprint } from './fingerprint.js';
 export { epicSettingsFile, MAX_EPIC_INI_BYTES, readEpicLogin, withEpicLogin, type EpicPayload } from './kinds/epic.js';
 export * from './kinds/steam.js';
+export { PERPLEXITY_ENV, perplexityKeyFromText, perplexitySummary, type PerplexityPayload, } from './kinds/perplexity.js';
+export { cometPayloadFromCookies, cometSummary, cookiesToRestore, type CometPayload } from './kinds/comet.js';
 export * from './anthropic.js';

package/dist/shared/accounts/index.js

@@ -5,4 +5,6 @@ export * from './payloads.js';
 export { fingerprint } from './fingerprint.js';
 export { epicSettingsFile, MAX_EPIC_INI_BYTES, readEpicLogin, withEpicLogin } from './kinds/epic.js';
 export * from './kinds/steam.js';
+export { PERPLEXITY_ENV, perplexityKeyFromText, perplexitySummary, } from './kinds/perplexity.js';
+export { cometPayloadFromCookies, cometSummary, cookiesToRestore } from './kinds/comet.js';
 export * from './anthropic.js';

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

@@ -0,0 +1,12 @@
+import type { CometCookie, Payload } from '../payloads.js';
+export type CometPayload = Payload<'comet'>;
+/**
+ * The sign-in among the cookies Comet reports (every site's, as Storage.getCookies returns them): the allow-listed,
+ * persistent HttpOnly ones, in a fixed order so the same sign-in always looks the same. Null when there is none (signed
+ * out), or when there are more than a sign-in could need.
+ */
+export declare function cometPayloadFromCookies(cookies: readonly unknown[], nowSeconds: number): CometPayload | null;
+/** The cookies still valid now, for Storage.setCookies (an expired one would only be thrown away by Comet). */
+export declare function cookiesToRestore(p: CometPayload, nowSeconds: number): CometCookie[];
+/** One line for the status: how many cookies, never their values. */
+export declare function cometSummary(p: CometPayload): string;

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

@@ -0,0 +1,64 @@
+// Comet's sign-in, as the sandbox keeps it: only the perplexity.ai cookies that hold a sign-in (persistent, HttpOnly),
+// read from Comet over the DevTools protocol (Storage.getCookies) and written back the same way. Pure: the sandbox
+// side (guest/accounts/kinds/comet.ts) talks to Comet, the self-test checks the filter. Never passwords, other sites,
+// localStorage or history: those are not cookies of an allowed domain, and nothing else is asked for.
+import { cometCookieDomainAllowed, CometPayloadSchema, MAX_COMET_COOKIES } from '../payloads.js';
+/** Cloudflare's bot and clearance cookies: tied to one machine and address, and renewed every few minutes. */
+const MACHINE_BOUND = /^(__cf_bm|cf_clearance|_cfuvid|__cflb)$/i;
+/** Expiry is kept to the hour, so a cookie re-sent with a later expiry on every page is not a new sign-in. */
+const EXPIRY_STEP = 3600;
+const SAME_SITE = ['Strict', 'Lax', 'None'];
+/** One CDP cookie as a kept cookie, or null when it is not one to keep. */
+function keptCookie(raw, nowSeconds) {
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    const c = raw;
+    if (typeof c.name !== 'string' || typeof c.value !== 'string' || typeof c.domain !== 'string')
+        return null;
+    if (!cometCookieDomainAllowed(c.domain) || MACHINE_BOUND.test(c.name))
+        return null;
+    // A sign-in is a persistent HttpOnly cookie of the site itself: no session cookies, script cookies or partitions.
+    if (c.httpOnly !== true || c.session === true || c.partitionKey !== undefined)
+        return null;
+    if (typeof c.expires !== 'number' || !Number.isFinite(c.expires) || c.expires <= nowSeconds)
+        return null;
+    const cookie = {
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: typeof c.path === 'string' && c.path ? c.path : '/',
+        expires: Math.floor(c.expires / EXPIRY_STEP) * EXPIRY_STEP,
+        secure: c.secure === true,
+        httpOnly: true,
+        ...(typeof c.sameSite === 'string' && SAME_SITE.includes(c.sameSite)
+            ? { sameSite: c.sameSite }
+            : {}),
+    };
+    const parsed = CometPayloadSchema.shape.cookies.element.safeParse(cookie);
+    return parsed.success ? parsed.data : null;
+}
+/**
+ * The sign-in among the cookies Comet reports (every site's, as Storage.getCookies returns them): the allow-listed,
+ * persistent HttpOnly ones, in a fixed order so the same sign-in always looks the same. Null when there is none (signed
+ * out), or when there are more than a sign-in could need.
+ */
+export function cometPayloadFromCookies(cookies, nowSeconds) {
+    const kept = cookies.flatMap((c) => {
+        const k = keptCookie(c, nowSeconds);
+        return k ? [k] : [];
+    });
+    if (!kept.length || kept.length > MAX_COMET_COOKIES)
+        return null;
+    kept.sort((a, b) => (a.domain + ' ' + a.path + ' ' + a.name < b.domain + ' ' + b.path + ' ' + b.name ? -1 : 1));
+    const parsed = CometPayloadSchema.safeParse({ cookies: kept });
+    return parsed.success ? parsed.data : null;
+}
+/** The cookies still valid now, for Storage.setCookies (an expired one would only be thrown away by Comet). */
+export function cookiesToRestore(p, nowSeconds) {
+    return CometPayloadSchema.parse(p).cookies.filter((c) => c.expires === undefined || c.expires > nowSeconds);
+}
+/** One line for the status: how many cookies, never their values. */
+export function cometSummary(p) {
+    const n = p.cookies.length;
+    return n + ' perplexity.ai sign-in cookie' + (n === 1 ? '' : 's');
+}

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

@@ -0,0 +1,8 @@
+import type { Payload } from '../payloads.js';
+export type PerplexityPayload = Payload<'perplexity'>;
+/** The variable the agent's sessions get, and the one the MCP servers read. */
+export declare const PERPLEXITY_ENV = "PERPLEXITY_API_KEY";
+/** The key in a file's text: its PERPLEXITY_API_KEY line (the last one wins, as in .env files), or the key alone. */
+export declare function perplexityKeyFromText(text: string): PerplexityPayload | null;
+/** pplx-... and the key's last 4 characters, for the status; never the key. */
+export declare function perplexitySummary(p: PerplexityPayload): string;

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

@@ -0,0 +1,37 @@
+// A Perplexity API key: typed, or taken from a file that holds it (a .env line PERPLEXITY_API_KEY=..., or the key
+// alone). Pure text handling: only that one line is read, every other line of a .env file is ignored and never kept.
+import { PerplexityPayloadSchema } from '../payloads.js';
+/** The variable the agent's sessions get, and the one the MCP servers read. */
+export const PERPLEXITY_ENV = 'PERPLEXITY_API_KEY';
+const ENV_LINE = /^\s*(?:export\s+)?PERPLEXITY_API_KEY\s*=\s*(.*)$/;
+/** More lines than a file within the import bound (64 KB) can have. */
+const MAX_LINES = 100_000;
+/** A value as written in a .env line: quotes taken off, a trailing comment dropped. */
+function unquote(raw) {
+    const v = raw.trim();
+    const quoted = /^(["'])(.*)\1$/.exec(v);
+    if (quoted)
+        return quoted[2];
+    return v.replace(/\s+#.*$/, '').trim();
+}
+/** The key in a file's text: its PERPLEXITY_API_KEY line (the last one wins, as in .env files), or the key alone. */
+export function perplexityKeyFromText(text) {
+    const lines = text.replace(/^\uFEFF/, '').split(/\r?\n/, MAX_LINES);
+    let value = null;
+    for (const line of lines) {
+        const m = ENV_LINE.exec(line);
+        if (m)
+            value = unquote(m[1]);
+    }
+    if (value === null) {
+        const words = lines.map((l) => l.trim()).filter((l) => l && !l.startsWith('#'));
+        if (words.length === 1)
+            value = words[0];
+    }
+    const parsed = value === null ? null : PerplexityPayloadSchema.safeParse({ apiKey: value });
+    return parsed?.success ? parsed.data : null;
+}
+/** pplx-... and the key's last 4 characters, for the status; never the key. */
+export function perplexitySummary(p) {
+    return 'pplx-...' + p.apiKey.slice(-4);
+}

package/dist/shared/accounts/kinds.d.ts

@@ -1,8 +1,17 @@
-export declare const SERVICE_KINDS: readonly ["epic", "steam", "unity", "cfx", "keystore", "play", "expo", "appstore"];
+export declare const SERVICE_KINDS: readonly ["epic", "steam", "unity", "cfx", "keystore", "play", "expo", "appstore", "perplexity", "comet"];
 export type ServiceKind = (typeof SERVICE_KINDS)[number];
-/** The toolchains a sign-in serves (it is handed over only when one of them is on for the boot). */
-export type UsedBy = 'unreal' | 'steam' | 'unity' | 'fivem' | 'android' | 'flutter' | 'reactNative' | 'godot' | 'dotnet';
-export declare const USED_BY: readonly UsedBy[];
+/** The toolchains a sign-in can serve (each is a key of `toolchains`). */
+export type ToolchainUser = 'unreal' | 'steam' | 'unity' | 'fivem' | 'android' | 'flutter' | 'reactNative' | 'godot' | 'dotnet';
+/** The apps a sign-in can serve: on when one of APP_USERS' apps is in apps.install. */
+export type AppUser = 'perplexity' | 'comet';
+/** What a sign-in serves (it is handed over only when one of them is on for the boot). */
+export type UsedBy = ToolchainUser | AppUser;
+/** The toolchains a sign-in can serve. */
+export declare const USED_BY: readonly ToolchainUser[];
+/** The apps (apps.install ids) that turn each app user on. */
+export declare const APP_USERS: {
+    readonly [U in AppUser]: readonly string[];
+};
 /** Where a saved sign-in came from: this PC's program, a file you gave, values you typed, or a sandbox. */
 export type AccountSource = 'pc' | 'file' | 'typed' | 'sandbox';
 export declare const ACCOUNT_SOURCES: readonly AccountSource[];
@@ -13,6 +22,8 @@ export interface ServiceField {
     readonly secret: boolean;
     readonly optional?: boolean;
     readonly pattern?: RegExp;
+    /** Asked only by `login` (typed) or only by `import --from` (file); both when not set. */
+    readonly only?: 'typed' | 'file';
 }
 export interface ServiceSpec<K extends ServiceKind = ServiceKind> {
     readonly kind: K;
@@ -26,16 +37,24 @@ export interface ServiceSpec<K extends ServiceKind = ServiceKind> {
     readonly returns: boolean;
     /** The largest payload (its JSON) accepted from a file or a sandbox. */
     readonly maxBytes: number;
+    /** The largest file `import --from` reads, when it holds more than the payload (a .env file); default maxBytes. */
+    readonly maxFileBytes?: number;
     /** Shown on every surface. */
     readonly warnings: readonly string[];
     /** What `login` asks for, or what `import --from` needs besides the file. */
     readonly fields: readonly ServiceField[];
 }
+/** A Perplexity API key: pplx- and its body. */
+export declare const PERPLEXITY_KEY_PATTERN: RegExp;
 export declare const SERVICE_SPECS: {
     readonly [K in ServiceKind]: ServiceSpec<K>;
 };
 /** Where a sandbox leaves a renewed sign-in, under the data folder: state\accounts\<kind>.json. */
 export declare const HANDOFF_PARTS: readonly ["state", "accounts"];
 export declare function isServiceKind(value: string): value is ServiceKind;
-/** Whether a sign-in is wanted when these toolchains are on. */
+/** What a sign-in serves, for a sentence: "unreal", "reactNative or flutter", "the Comet app". */
+export declare function usedByText(usedBy: readonly string[]): string;
+/** The app users that the chosen apps (apps.install) turn on. */
+export declare function appUsersOn(install: readonly string[]): AppUser[];
+/** Whether a sign-in is wanted when these toolchains (and apps) are on. */
 export declare function serviceWanted(kind: ServiceKind, on: ReadonlySet<UsedBy>): boolean;

package/dist/shared/accounts/kinds.js

@@ -2,7 +2,19 @@
 // come from, and the rules for handing it over (one sandbox at a time, handed back when renewed). Pure, web-safe: no
 // Node built-ins. The payload shapes are in payloads.ts, the host side in host/accounts, the sandbox side in
 // guest/accounts.
-export const SERVICE_KINDS = ['epic', 'steam', 'unity', 'cfx', 'keystore', 'play', 'expo', 'appstore'];
+export const SERVICE_KINDS = [
+    'epic',
+    'steam',
+    'unity',
+    'cfx',
+    'keystore',
+    'play',
+    'expo',
+    'appstore',
+    'perplexity',
+    'comet',
+];
+/** The toolchains a sign-in can serve. */
 export const USED_BY = [
     'unreal',
     'steam',
@@ -14,9 +26,16 @@ export const USED_BY = [
     'godot',
     'dotnet',
 ];
+/** The apps (apps.install ids) that turn each app user on. */
+export const APP_USERS = {
+    perplexity: ['perplexity-mcp'],
+    comet: ['comet'],
+};
 export const ACCOUNT_SOURCES = ['pc', 'file', 'typed', 'sandbox'];
 const AGENT_CAN_USE = 'The agent in the sandbox can use this sign-in while it is there.';
 const ONE_PLACE = 'It works in one sandbox at a time: a second sandbox starts without it while the first one runs.';
+/** A Perplexity API key: pplx- and its body. */
+export const PERPLEXITY_KEY_PATTERN = /^pplx-[A-Za-z0-9_-]{8,200}$/;
 export const SERVICE_SPECS = {
     epic: {
         kind: 'epic',
@@ -70,19 +89,28 @@ export const SERVICE_SPECS = {
         kind: 'cfx',
         label: 'Cfx.re (FiveM / RedM server key)',
         usedBy: ['fivem'],
-        sources: ['typed'],
+        sources: ['typed', 'file'],
         singleHolder: false,
         returns: false,
+        // `import cfx --from` reads a whole server.cfg (they often run to tens of KB); the payload itself is tiny.
         maxBytes: 4 * 1024,
+        maxFileBytes: 256 * 1024,
         warnings: [AGENT_CAN_USE + ' Anyone with the key can run a server under your Cfx.re account.'],
         fields: [
-            { name: 'licenseKey', label: 'Server licence key (cfxk_...)', secret: true, pattern: /^cfxk_[A-Za-z0-9_]+$/ },
+            {
+                name: 'licenseKey',
+                label: 'Server licence key (cfxk_...)',
+                secret: true,
+                pattern: /^cfxk_[A-Za-z0-9_]+$/,
+                only: 'typed',
+            },
             {
                 name: 'steamWebApiKey',
                 label: 'Steam Web API key (optional)',
                 secret: true,
                 optional: true,
                 pattern: /^[A-F0-9]{32}$/,
+                only: 'typed',
             },
         ],
     },
@@ -137,6 +165,47 @@ export const SERVICE_SPECS = {
             { name: 'keyId', label: 'Key ID', secret: false, pattern: /^[A-Z0-9]{10}$/ },
         ],
     },
+    perplexity: {
+        kind: 'perplexity',
+        label: 'Perplexity API key',
+        usedBy: ['perplexity'],
+        sources: ['pc', 'file', 'typed'],
+        singleHolder: false,
+        returns: false,
+        maxBytes: 1024,
+        maxFileBytes: 64 * 1024,
+        warnings: [
+            AGENT_CAN_USE + ' It can read the key and spend your API credit: use a separate API key with a spending limit.',
+            'Perplexity Pro does not include API use; the API key is billed separately.',
+            'Only the variable PERPLEXITY_API_KEY of the agent gets it: nothing in the sandbox writes it to a file.',
+        ],
+        fields: [
+            {
+                name: 'apiKey',
+                label: 'Perplexity API key (pplx-...)',
+                secret: true,
+                pattern: PERPLEXITY_KEY_PATTERN,
+                only: 'typed',
+            },
+        ],
+    },
+    comet: {
+        kind: 'comet',
+        label: 'Comet (Perplexity browser)',
+        usedBy: ['comet'],
+        sources: ['sandbox'],
+        singleHolder: false,
+        returns: true,
+        maxBytes: 256 * 1024,
+        warnings: [
+            AGENT_CAN_USE +
+                ' It can act as you in Comet and spend your Perplexity Computer credits; agentic browsing is open to prompt injection from the pages it reads.',
+            "Your Comet sign-in can't be copied from this PC: Windows locks it to your PC account. Sign in once inside a sandbox and it is kept for the next ones.",
+            'Only the perplexity.ai sign-in cookies are kept: never saved passwords, other sites, localStorage or history. Never import your main browser profile.',
+            'Several sandboxes can use it at once: the sign-in the last one hands back is kept.',
+        ],
+        fields: [],
+    },
 };
 /** Where a sandbox leaves a renewed sign-in, under the data folder: state\accounts\<kind>.json. */
 export const HANDOFF_PARTS = ['state', 'accounts'];
@@ -145,7 +214,20 @@ const ANDROID_USERS = ['flutter', 'reactNative', 'godot', 'unity'];
 export function isServiceKind(value) {
     return SERVICE_KINDS.includes(value);
 }
-/** Whether a sign-in is wanted when these toolchains are on. */
+/** How the apps that use a sign-in are named in sentences ("for sandboxes that use ..."). */
+const APP_USER_TEXT = {
+    perplexity: 'the Perplexity MCP app',
+    comet: 'the Comet app',
+};
+/** What a sign-in serves, for a sentence: "unreal", "reactNative or flutter", "the Comet app". */
+export function usedByText(usedBy) {
+    return usedBy.map((u) => (u in APP_USER_TEXT ? APP_USER_TEXT[u] : u)).join(' or ');
+}
+/** The app users that the chosen apps (apps.install) turn on. */
+export function appUsersOn(install) {
+    return Object.keys(APP_USERS).filter((u) => APP_USERS[u].some((id) => install.includes(id)));
+}
+/** Whether a sign-in is wanted when these toolchains (and apps) are on. */
 export function serviceWanted(kind, on) {
     const spec = SERVICE_SPECS[kind];
     if (spec.usedBy.some((u) => on.has(u)))