windows-development-sandbox 1.20.0 → 1.23.1

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)))

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

@@ -48,6 +48,49 @@ export declare const AppstorePayloadSchema: z.ZodObject<{
     keyId: z.ZodString;
     p8: z.ZodString;
 }, z.core.$strict>;
+/** A Perplexity API key (PERPLEXITY_API_KEY), billed separately from Perplexity Pro. */
+export declare const PerplexityPayloadSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+}, z.core.$strict>;
+/** The only sites whose cookies a Comet sign-in keeps (each with its subdomains). Fixed: never a setting. */
+export declare const COMET_COOKIE_DOMAINS: readonly string[];
+/** At most this many cookies are kept. */
+export declare const MAX_COMET_COOKIES = 200;
+/** Whether a cookie's domain (".www.perplexity.ai", "perplexity.ai" ...) is one of COMET_COOKIE_DOMAINS or below it. */
+export declare function cometCookieDomainAllowed(domain: string): boolean;
+/** One cookie as CDP's Storage.setCookies takes it (expires: seconds since 1970; none for a session cookie). */
+export declare const CometCookieSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+    domain: z.ZodString;
+    path: z.ZodString;
+    expires: z.ZodOptional<z.ZodNumber>;
+    secure: z.ZodBoolean;
+    httpOnly: z.ZodBoolean;
+    sameSite: z.ZodOptional<z.ZodEnum<{
+        Strict: "Strict";
+        Lax: "Lax";
+        None: "None";
+    }>>;
+}, z.core.$strict>;
+export type CometCookie = z.output<typeof CometCookieSchema>;
+/** Comet's sign-in: the allow-listed perplexity.ai cookies only (no passwords, localStorage or history). */
+export declare const CometPayloadSchema: z.ZodObject<{
+    cookies: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        domain: z.ZodString;
+        path: z.ZodString;
+        expires: z.ZodOptional<z.ZodNumber>;
+        secure: z.ZodBoolean;
+        httpOnly: z.ZodBoolean;
+        sameSite: z.ZodOptional<z.ZodEnum<{
+            Strict: "Strict";
+            Lax: "Lax";
+            None: "None";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const PAYLOADS: {
     readonly epic: z.ZodObject<{
         data: z.ZodString;
@@ -89,6 +132,25 @@ export declare const PAYLOADS: {
         keyId: z.ZodString;
         p8: z.ZodString;
     }, z.core.$strict>;
+    readonly perplexity: z.ZodObject<{
+        apiKey: z.ZodString;
+    }, z.core.$strict>;
+    readonly comet: z.ZodObject<{
+        cookies: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            domain: z.ZodString;
+            path: z.ZodString;
+            expires: z.ZodOptional<z.ZodNumber>;
+            secure: z.ZodBoolean;
+            httpOnly: z.ZodBoolean;
+            sameSite: z.ZodOptional<z.ZodEnum<{
+                Strict: "Strict";
+                Lax: "Lax";
+                None: "None";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
 };
 export type Payload<K extends ServiceKind> = z.output<(typeof PAYLOADS)[K]>;
 export type AnyPayload = Payload<ServiceKind>;
@@ -137,6 +199,25 @@ export declare const ServiceAccountsSchema: z.ZodObject<{
         keyId: z.ZodString;
         p8: z.ZodString;
     }, z.core.$strict>>;
+    perplexity: z.ZodOptional<z.ZodObject<{
+        apiKey: z.ZodString;
+    }, z.core.$strict>>;
+    comet: z.ZodOptional<z.ZodObject<{
+        cookies: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            domain: z.ZodString;
+            path: z.ZodString;
+            expires: z.ZodOptional<z.ZodNumber>;
+            secure: z.ZodBoolean;
+            httpOnly: z.ZodBoolean;
+            sameSite: z.ZodOptional<z.ZodEnum<{
+                Strict: "Strict";
+                Lax: "Lax";
+                None: "None";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ServiceAccounts = z.output<typeof ServiceAccountsSchema>;
 /** A launch's id (generate.ts: "<ms>-<6 hex>"). */

package/dist/shared/accounts/payloads.js

@@ -1,7 +1,7 @@
 // The shape of each saved sign-in (what the host seals, what travels in the one-shot secrets file, what a sandbox may
 // hand back). Pure zod, web-safe. Every text is size-bounded: the sandbox may have written it.
 import { z } from 'zod';
-import { SERVICE_KINDS } from './kinds.js';
+import { PERPLEXITY_KEY_PATTERN, SERVICE_KINDS } from './kinds.js';
 const KB = 1024;
 const base64 = (maxBytes) => z
     .string()
@@ -91,6 +91,40 @@ export const AppstorePayloadSchema = z.strictObject({
         .max(8 * KB)
         .regex(/^-----BEGIN PRIVATE KEY-----\r?\n[A-Za-z0-9+/=\r\n]+-----END PRIVATE KEY-----\s*$/),
 });
+/** A Perplexity API key (PERPLEXITY_API_KEY), billed separately from Perplexity Pro. */
+export const PerplexityPayloadSchema = z.strictObject({
+    apiKey: z.string().max(256).regex(PERPLEXITY_KEY_PATTERN),
+});
+/** The only sites whose cookies a Comet sign-in keeps (each with its subdomains). Fixed: never a setting. */
+export const COMET_COOKIE_DOMAINS = ['perplexity.ai'];
+/** At most this many cookies are kept. */
+export const MAX_COMET_COOKIES = 200;
+/** Whether a cookie's domain (".www.perplexity.ai", "perplexity.ai" ...) is one of COMET_COOKIE_DOMAINS or below it. */
+export function cometCookieDomainAllowed(domain) {
+    const host = domain.trim().toLowerCase().replace(/^\./, '');
+    return COMET_COOKIE_DOMAINS.some((d) => host === d || host.endsWith('.' + d));
+}
+/** Printable text without control characters (a cookie the sandbox hands back could hold anything). */
+const cookieText = (min, max) => z
+    .string()
+    .min(min)
+    .max(max)
+    .regex(/^[ -~]*$/);
+/** One cookie as CDP's Storage.setCookies takes it (expires: seconds since 1970; none for a session cookie). */
+export const CometCookieSchema = z.strictObject({
+    name: cookieText(1, 256).regex(/^[^\s;,=]+$/),
+    value: cookieText(0, 8192).regex(/^[^;]*$/),
+    domain: cookieText(1, 253).refine(cometCookieDomainAllowed, 'not a perplexity.ai cookie'),
+    path: cookieText(1, 1024).regex(/^\//),
+    expires: z.number().int().min(0).max(4102444800).optional(),
+    secure: z.boolean(),
+    httpOnly: z.boolean(),
+    sameSite: z.enum(['Strict', 'Lax', 'None']).optional(),
+});
+/** Comet's sign-in: the allow-listed perplexity.ai cookies only (no passwords, localStorage or history). */
+export const CometPayloadSchema = z.strictObject({
+    cookies: z.array(CometCookieSchema).min(1).max(MAX_COMET_COOKIES),
+});
 export const PAYLOADS = {
     epic: EpicPayloadSchema,
     steam: SteamPayloadSchema,
@@ -100,6 +134,8 @@ export const PAYLOADS = {
     play: PlayPayloadSchema,
     expo: ExpoPayloadSchema,
     appstore: AppstorePayloadSchema,
+    perplexity: PerplexityPayloadSchema,
+    comet: CometPayloadSchema,
 };
 /** The secrets-file field: the sign-ins this launch hands over, each optional. */
 export const ServiceAccountsSchema = z.strictObject({
@@ -111,6 +147,8 @@ export const ServiceAccountsSchema = z.strictObject({
     play: PlayPayloadSchema.optional(),
     expo: ExpoPayloadSchema.optional(),
     appstore: AppstorePayloadSchema.optional(),
+    perplexity: PerplexityPayloadSchema.optional(),
+    comet: CometPayloadSchema.optional(),
 });
 /** A launch's id (generate.ts: "<ms>-<6 hex>"). */
 export const LaunchIdSchema = z.string().regex(/^[A-Za-z0-9-]{1,64}$/);

package/dist/shared/apps/agent-addons.d.ts

@@ -43,17 +43,45 @@ export declare const HEADROOM_ENV: Readonly<Record<string, string>>;
 export declare function headroomEnv(base: Readonly<Record<string, string | undefined>>): Record<string, string>;
 /** The guide line while the proxy runs. */
 export declare function headroomGuideLine(logFile: string): string;
-/** A user-scope MCP server in Claude Code's .claude.json. */
-export interface McpServerConfig {
+/** A user-scope MCP server in Claude Code's .claude.json: a program it starts, or a remote server over HTTP. */
+export type McpServerConfig = {
     readonly type: 'stdio';
     readonly command: string;
     readonly args: readonly string[];
     readonly env: Readonly<Record<string, string>>;
-}
+} | {
+    readonly type: 'http';
+    readonly url: string;
+};
 /** The name prefix of the sandbox's own MCP servers: names with it are the sandbox's to add and remove. */
 export declare const ADDON_MCP_PREFIX = "sbx-";
-/** The MCP server of an installed add-on: `node <folder>\<script> <args>` (Node is on PATH in every sandbox). */
-export declare function addonMcpServer(folder: string, mcp: AddonMcp): McpServerConfig;
+/** What the sandbox knows about an installed add-on beyond its folder: its program, and variables found at boot. */
+export interface AddonPlace {
+    /** The add-on's program (for `program` servers). */
+    readonly exe?: string | null;
+    /** Variables only the sandbox can tell (a path), added to the entry's fixed ones. */
+    readonly env?: Readonly<Record<string, string>>;
+}
+/**
+ * The MCP server of an installed add-on: `node <folder>\<script> <args>` (Node is on PATH in every sandbox), its own
+ * program, or its remote address. Null when a program server's program is missing.
+ */
+export declare function addonMcpServer(folder: string, mcp: AddonMcp, place?: AddonPlace): McpServerConfig | null;
+/** An add-on's server as Codex runs it: the Claude Code one, plus the agent variables Codex must pass on. */
+export type CodexMcpServer = McpServerConfig & {
+    readonly envVars?: readonly string[];
+};
+/**
+ * Codex's config.toml with the add-ons' servers as [mcp_servers.<name>] tables: every table of a `known` sbx-...
+ * server is removed first (an add-on turned off), then the servers on are added at the end. Your own servers and
+ * settings stay as they are. A server whose name is used some other way in the file (an inline table, dotted keys)
+ * is left out (`skipped`), so the file never gets the same key twice. `changed` is false when nothing changes.
+ */
+export declare function codexWithAddonMcpServers(toml: string, servers: Readonly<Record<string, CodexMcpServer>>, known: readonly string[]): {
+    toml: string;
+    changed: boolean;
+    skipped: string[];
+};
 /**
  * The user-scope MCP servers with the add-ons' servers set: every sbx-... server that `known` lists and that is not in
  * `servers` is removed (an add-on turned off); servers of your own are never touched.

package/dist/shared/apps/agent-addons.js

@@ -73,10 +73,102 @@ export function headroomGuideLine(logFile) {
 }
 /** The name prefix of the sandbox's own MCP servers: names with it are the sandbox's to add and remove. */
 export const ADDON_MCP_PREFIX = 'sbx-';
-/** The MCP server of an installed add-on: `node <folder>\<script> <args>` (Node is on PATH in every sandbox). */
-export function addonMcpServer(folder, mcp) {
+/**
+ * The MCP server of an installed add-on: `node <folder>\<script> <args>` (Node is on PATH in every sandbox), its own
+ * program, or its remote address. Null when a program server's program is missing.
+ */
+export function addonMcpServer(folder, mcp, place = {}) {
+    if (mcp.url)
+        return { type: 'http', url: mcp.url };
+    const env = { ...(mcp.env ?? {}), ...(place.env ?? {}) };
+    if (mcp.program)
+        return place.exe ? { type: 'stdio', command: place.exe, args: [...(mcp.args ?? [])], env } : null;
+    if (!mcp.script)
+        return null;
     const script = folder.replace(/[\\/]+$/, '') + '\\' + mcp.script.replace(/\//g, '\\');
-    return { type: 'stdio', command: 'node', args: [script, ...(mcp.args ?? [])], env: {} };
+    return { type: 'stdio', command: 'node', args: [script, ...(mcp.args ?? [])], env };
+}
+/** A TOML string (JSON's escapes are TOML's basic-string escapes). */
+const tomlString = (s) => JSON.stringify(s);
+/** A TOML key: bare when it can be, else quoted. */
+const tomlKey = (k) => (/^[A-Za-z0-9_-]+$/.test(k) ? k : tomlString(k));
+/** A table header's dotted key, its parts unquoted ([mcp_servers."sbx-x".env] -> mcp_servers, sbx-x, env). */
+function headerPath(line) {
+    const m = /^\s*\[\[?\s*(.*?)\s*\]\]?\s*(#.*)?$/.exec(line);
+    if (!m)
+        return null;
+    const parts = [];
+    const re = /\s*(?:"((?:[^"\\]|\\.)*)"|'([^']*)'|([A-Za-z0-9_-]+))\s*(\.|$)/y;
+    let at = 0;
+    while (at < m[1].length) {
+        re.lastIndex = at;
+        const part = re.exec(m[1]);
+        if (!part)
+            return null;
+        try {
+            parts.push(part[1] !== undefined ? JSON.parse('"' + part[1] + '"') : (part[2] ?? part[3]));
+        }
+        catch {
+            return null; // An escape JSON does not know: not one of the sandbox's names.
+        }
+        at = re.lastIndex;
+        if (!part[4])
+            break;
+    }
+    return parts;
+}
+/** The TOML tables of one server. */
+function codexServerToml(name, server) {
+    const head = '[mcp_servers.' + tomlKey(name) + ']';
+    const mark = '# Set by the sandbox while this add-on is on in Apps (removed when it is off).';
+    if (server.type === 'http')
+        return [head, mark, 'url = ' + tomlString(server.url)];
+    const lines = [
+        head,
+        mark,
+        'command = ' + tomlString(server.command),
+        'args = [' + server.args.map(tomlString).join(', ') + ']',
+    ];
+    if (server.envVars?.length)
+        lines.push('env_vars = [' + server.envVars.map(tomlString).join(', ') + ']');
+    const env = Object.entries(server.env);
+    if (env.length)
+        lines.push('', '[mcp_servers.' + tomlKey(name) + '.env]', ...env.map(([k, v]) => tomlKey(k) + ' = ' + tomlString(v)));
+    return lines;
+}
+/**
+ * Codex's config.toml with the add-ons' servers as [mcp_servers.<name>] tables: every table of a `known` sbx-...
+ * server is removed first (an add-on turned off), then the servers on are added at the end. Your own servers and
+ * settings stay as they are. A server whose name is used some other way in the file (an inline table, dotted keys)
+ * is left out (`skipped`), so the file never gets the same key twice. `changed` is false when nothing changes.
+ */
+export function codexWithAddonMcpServers(toml, servers, known) {
+    const ours = (p) => p !== null && p[0] === 'mcp_servers' && p.length >= 2 && known.includes(p[1]) && p[1].startsWith(ADDON_MCP_PREFIX);
+    const kept = [];
+    let skipping = false;
+    for (const line of toml.split(/\r?\n/)) {
+        if (/^\s*\[/.test(line))
+            skipping = ours(headerPath(line));
+        if (!skipping)
+            kept.push(line);
+    }
+    while (kept.length && kept[kept.length - 1].trim() === '')
+        kept.pop();
+    const rest = kept.join('\n');
+    const skipped = [];
+    const blocks = [];
+    for (const [name, server] of Object.entries(servers)) {
+        const escaped = name.replace(/[.*+?^${}()|[\]\\-]/g, '\\$&');
+        if (new RegExp('(^|[\\s.{,])["\']?' + escaped + '["\']?\\s*[.=]', 'm').test(rest)) {
+            skipped.push(name);
+            continue;
+        }
+        blocks.push(codexServerToml(name, server).join('\n'));
+    }
+    const text = [rest, ...blocks].filter((b) => b !== '').join('\n\n') + '\n';
+    const normalised = toml.replace(/\r\n/g, '\n');
+    const changed = text !== normalised && !(text === '\n' && normalised === '');
+    return { toml: changed ? text : toml, changed, skipped };
 }
 /**
  * The user-scope MCP servers with the add-ons' servers set: every sbx-... server that `known` lists and that is not in

package/dist/shared/apps/catalogue-agents-web.d.ts

@@ -0,0 +1,14 @@
+import type { AppEntry } from './catalogue.js';
+import type { AppSigner } from '../signer.js';
+/** Pinned packages, installed from the lock files in sandbox\addons\<id> (renewing them: docs/toolchains.md). */
+export declare const PERPLEXITY_MCP_VERSION = "1.3.0";
+export declare const COMET_MCP_VERSION = "2.3.0";
+export declare const CHROME_DEVTOOLS_MCP_VERSION = "1.12.0";
+export declare const BROWSER_USE_VERSION = "0.13.14";
+/** Perplexity Computer's official MCP server (HTTP; OAuth with your Perplexity account; uses Computer credits). */
+export declare const PERPLEXITY_COMPUTER_MCP_URL = "https://www.perplexity.ai/rest/computer/mcp";
+/** Comet's Windows installer: a redirect to the current release (no checksum is published; its signer is checked). */
+export declare const COMET_DOWNLOAD_URL = "https://www.perplexity.ai/rest/browser/download?platform=win_x64&channel=stable";
+/** Who signs Comet: Perplexity AI, Inc., with an EV code-signing certificate from GlobalSign. */
+export declare const COMET_SIGNER: AppSigner;
+export declare const AGENTS_WEB_APPS: readonly AppEntry[];

package/dist/shared/apps/catalogue-agents-web.js

@@ -0,0 +1,112 @@
+/** Pinned packages, installed from the lock files in sandbox\addons\<id> (renewing them: docs/toolchains.md). */
+export const PERPLEXITY_MCP_VERSION = '1.3.0';
+export const COMET_MCP_VERSION = '2.3.0';
+export const CHROME_DEVTOOLS_MCP_VERSION = '1.12.0';
+export const BROWSER_USE_VERSION = '0.13.14';
+/** Perplexity Computer's official MCP server (HTTP; OAuth with your Perplexity account; uses Computer credits). */
+export const PERPLEXITY_COMPUTER_MCP_URL = 'https://www.perplexity.ai/rest/computer/mcp';
+/** Comet's Windows installer: a redirect to the current release (no checksum is published; its signer is checked). */
+export const COMET_DOWNLOAD_URL = 'https://www.perplexity.ai/rest/browser/download?platform=win_x64&channel=stable';
+/** Who signs Comet: Perplexity AI, Inc., with an EV code-signing certificate from GlobalSign. */
+export const COMET_SIGNER = {
+    subject: ['^CN="?PERPLEXITY AI, INC\\.?"?(,|$)', '(^|, )O="?PERPLEXITY AI, INC\\.?"?(,|$)'],
+    issuer: ['^CN=GlobalSign GCC R45 EV CodeSigning CA 2020(,|$)'],
+};
+/** Microsoft Edge, already in every sandbox: the browser Chrome DevTools MCP starts. */
+const EDGE_EXE = 'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe';
+export const AGENTS_WEB_APPS = [
+    {
+        id: 'perplexity-mcp',
+        name: 'Perplexity MCP (API)',
+        category: 'agents',
+        about: "Web search, answers and deep research from Perplexity's API in Claude Code and Codex (perplexity_search, perplexity_ask, perplexity_research, perplexity_reason): Perplexity's own @perplexity-ai/mcp-server. Needs your Perplexity API key in Accounts; API use is billed separately from Perplexity Pro.",
+        size: '30 MB',
+        source: { locked: 'npm', package: '@perplexity-ai/mcp-server', version: PERPLEXITY_MCP_VERSION },
+        exe: 'perplexity-mcp.cmd',
+        service: true,
+        mcp: {
+            name: 'sbx-perplexity',
+            script: 'node_modules/@perplexity-ai/mcp-server/dist/index.js',
+            envVars: ['PERPLEXITY_API_KEY'],
+            codex: true,
+        },
+        plugsInto: 'Claude Code and Codex as the MCP server sbx-perplexity; the key comes from Accounts as PERPLEXITY_API_KEY, never from a file',
+        userOnly: true,
+    },
+    {
+        id: 'perplexity-computer-mcp',
+        name: 'Perplexity Computer MCP',
+        category: 'agents',
+        about: "Hands tasks to Perplexity Computer, Perplexity's cloud agent (it browses and works in its own cloud computer), from Claude Code and Codex: Perplexity's official remote MCP server. Nothing is installed. Sign in with your Perplexity account the first time (Claude Code: /mcp; Codex: codex mcp login sbx-perplexity-computer); tasks spend your Computer credits.",
+        size: '0 MB',
+        source: { remote: true },
+        exe: '',
+        service: true,
+        mcp: { name: 'sbx-perplexity-computer', url: PERPLEXITY_COMPUTER_MCP_URL, codex: true },
+        plugsInto: 'Claude Code and Codex as the remote MCP server sbx-perplexity-computer; its sign-in is kept with your agent login',
+        userOnly: true,
+    },
+    {
+        id: 'comet',
+        name: 'Comet (Perplexity browser)',
+        category: 'browsers',
+        about: "Perplexity's agentic browser (Chromium), unpacked to run portable with its own profile on the sandbox's disk. With accounts.comet.share on, your perplexity.ai sign-in is kept for the next sandboxes. Its assistant acts on the pages it reads, so a page can try to steer it: browse only what you would let it act on.",
+        size: '600 MB',
+        source: { resolve: 'comet' },
+        unpack: 'chromium',
+        exe: 'comet.exe',
+        needs: ['7zip'],
+        signer: COMET_SIGNER,
+        userOnly: true,
+    },
+    {
+        id: 'comet-mcp',
+        name: 'Comet MCP',
+        category: 'agents',
+        about: "Lets Claude Code and Codex hand web tasks to Comet's own assistant and read its answers (hanzili/comet-mcp). Needs the Comet app: start Comet from its shortcut first, so the agent uses the sandbox's Comet profile and your sign-in.",
+        size: '15 MB',
+        source: { locked: 'npm', package: 'comet-mcp', version: COMET_MCP_VERSION },
+        exe: 'comet-mcp.cmd',
+        service: true,
+        mcp: { name: 'sbx-comet', script: 'node_modules/comet-mcp/dist/index.js', codex: true },
+        plugsInto: "Claude Code and Codex as the MCP server sbx-comet, talking to Comet's DevTools on 127.0.0.1:9222",
+        userOnly: true,
+    },
+    {
+        id: 'chrome-devtools-mcp',
+        name: 'Chrome DevTools MCP',
+        category: 'agents',
+        about: "Lets Claude Code and Codex drive and inspect a browser with DevTools: navigate, click, read the console and network, record performance traces (ChromeDevTools/chrome-devtools-mcp). It starts Microsoft Edge with a throwaway profile; Google's usage statistics and CrUX lookups are off.",
+        size: '40 MB',
+        source: { locked: 'npm', package: 'chrome-devtools-mcp', version: CHROME_DEVTOOLS_MCP_VERSION },
+        exe: 'chrome-devtools-mcp.cmd',
+        service: true,
+        mcp: {
+            name: 'sbx-chrome-devtools',
+            script: 'node_modules/chrome-devtools-mcp/build/src/bin/chrome-devtools-mcp.js',
+            args: ['--executablePath', EDGE_EXE, '--isolated', '--no-usage-statistics', '--no-performance-crux'],
+            codex: true,
+        },
+        plugsInto: 'Claude Code and Codex as the MCP server sbx-chrome-devtools (with Edge)',
+        userOnly: true,
+    },
+    {
+        id: 'browser-use-mcp',
+        name: 'Browser Use MCP',
+        category: 'agents',
+        about: "Browser automation for agents from Browser Use (browser-use --mcp): open pages, click, type, read them, and hand a whole task to Browser Use's own agent (that one needs an OpenAI or Anthropic API key). It finds Edge in the sandbox; its telemetry is off.",
+        size: '250 MB',
+        source: { locked: 'uv', package: 'browser-use', version: BROWSER_USE_VERSION },
+        exe: 'browser-use.exe',
+        service: true,
+        mcp: {
+            name: 'sbx-browser-use',
+            program: true,
+            args: ['--mcp'],
+            env: { ANONYMIZED_TELEMETRY: 'false' },
+            codex: true,
+        },
+        plugsInto: 'Claude Code and Codex as the MCP server sbx-browser-use',
+        userOnly: true,
+    },
+];

package/dist/shared/apps/catalogue-modding.js

@@ -1 +1,32 @@
-export const MODDING_APPS = [];
+export const MODDING_APPS = [
+    {
+        id: 'lua-language-server',
+        name: 'Lua Language Server',
+        category: 'cli',
+        about: 'The Lua language server (LuaLS): completion, diagnostics and go-to-definition for Lua in editors and agents that speak LSP. FiveM resources use Lua 5.4 (lua54 in fxmanifest.lua).',
+        size: '15 MB',
+        source: { github: 'LuaLS/lua-language-server', asset: '^lua-language-server-[\\d.]+-win32-x64\\.zip$' },
+        exe: 'lua-language-server.exe',
+        cli: true,
+    },
+    {
+        id: 'stylua',
+        name: 'StyLua',
+        category: 'cli',
+        about: 'An opinionated Lua formatter (`stylua .`), configured with a stylua.toml in the project.',
+        size: '6 MB',
+        source: { github: 'JohnnyMorganz/StyLua', asset: '^stylua-windows-x86_64\\.zip$' },
+        exe: 'stylua.exe',
+        cli: true,
+    },
+    {
+        id: 'selene',
+        name: 'selene',
+        category: 'cli',
+        about: 'A Lua linter (`selene .`), configured with a selene.toml (std = "lua54", and a standard library file for the FiveM / RedM globals).',
+        size: '7 MB',
+        source: { github: 'Kampfkarren/selene', asset: '^selene-[\\d.]+-windows\\.zip$' },
+        exe: 'selene.exe',
+        cli: true,
+    },
+];