windows-development-sandbox 1.18.4 → 1.20.0

package/dist/runtime/view.js

@@ -25955,6 +25955,22 @@ var DatabasesSchema = external_exports.strictObject({
   })
 });
 
+// src/core/schema/codex.ts
+var CodexSchema = external_exports.strictObject({
+  sandboxMode: external_exports.enum(["danger-full-access", "workspace-write", "read-only"]).describe(
+    "Codex's own sandbox. Inside Windows Sandbox Codex's own sandbox only slows it down (it re-grants file permissions over your profile at every boot), so the default is danger-full-access: Windows Sandbox is the sandbox."
+  ),
+  approvalPolicy: external_exports.enum(["never", "on-request", "on-failure", "untrusted"]).describe('When Codex asks before it runs a command. "never" with danger-full-access starts it with no questions.'),
+  model: external_exports.string().max(100).regex(/^[A-Za-z0-9._:/-]*$/, "letters, digits and . _ : / - only").describe("The model Codex uses. Empty = Codex's own default."),
+  reasoningEffort: external_exports.enum(["default", "minimal", "low", "medium", "high", "xhigh"]).describe(`How hard Codex thinks. "default" = Codex's own default.`),
+  windowsSandbox: external_exports.enum(["off", "unelevated", "elevated"]).describe(
+    `Codex's Windows sandbox mode in its config.toml. "off" removes the setting so Codex does not set up its sandbox users and firewall rules at every boot.`
+  ),
+  mcpLoginsInFile: external_exports.boolean().describe(
+    `Keep the sign-ins of Codex's MCP servers in a file in the saved Codex folder (mcp_oauth_credentials_store = "file"), so they survive between sandboxes. A value you set in config.toml is kept.`
+  )
+});
+
 // src/core/schema/harness.ts
 var SubfolderSchema = external_exports.string().regex(/^(?!.*(^|[\\/])\.\.([\\/]|$))[A-Za-z0-9._ -]+([\\/][A-Za-z0-9._ -]+)*$/, "a plain relative folder");
 var HarnessHomeSchema = external_exports.strictObject({
@@ -26267,6 +26283,9 @@ var ToolchainsSchema = external_exports.strictObject({
     keepInstallFiles: external_exports.boolean().describe(
       "Keep an offline copy of the Visual Studio install files in tools\\visualstudio (~10 GB, made once), so later boots install without downloading them again. Skipped while that disk has too little room."
     ),
+    visualStudio: external_exports.enum(["full", "autosdk"]).describe(
+      `"full": install Visual Studio Community (the engine finds it through the Setup API; ~10 GB, redone every boot). "autosdk" (experimental): skip Visual Studio and build an Unreal AutoSDK tree from the portable MSVC in tools\\unreal\\autosdk (kept between sandboxes); UnrealBuildTool finds MSVC through AutoSDK, but the editor's Visual Studio integration is not available. Needs toolchains.msvc (turned on for you).`
+    ),
     persistEngines: external_exports.boolean().describe(
       "Engines the Epic Games Launcher installs go to tools\\unreal\\engines (kept between sandboxes, 40-60 GB each) and are registered with the launcher again every boot. Off: they go on the sandbox disk and are lost when it closes. Engines installed on this PC can be mapped instead (pcInstalls.unrealEngines)."
     ),
@@ -27723,6 +27742,7 @@ var ConfigSchema = external_exports.strictObject({
   apps: AppsSchema,
   claudeProfile: ClaudeProfileSchema,
   harnesses: external_exports.record(NameSchema, HarnessSchema).describe("Agents that can run in the sandbox."),
+  codex: CodexSchema,
   hooks: external_exports.strictObject({ failFast: external_exports.boolean().describe("Stop when a hook script fails.") }),
   projects: ProjectsSchema.describe(
     "Several projects in one sandbox: folders of projects mapped at every start, and adding folders while it runs."
@@ -27966,6 +27986,8 @@ var ProjectStatusSchema = external_exports.object({
 var VpnStatusSchema = external_exports.object({
   state: external_exports.enum(["off", "starting", "up", "failed"]),
   message: Text(2e3),
+  /** Why it failed, when it did: `auth` (login refused), `unreachable`, `driver`, `timeout` or `other`. */
+  code: external_exports.enum(["auth", "unreachable", "driver", "timeout", "other"]).optional(),
   killSwitch: external_exports.boolean(),
   /** A direct connection was tried after the kill switch was applied: false = it still got out. */
   killSwitchHeld: external_exports.boolean().optional(),

package/dist/selftest/agent-commands.test.js

@@ -1,14 +1,18 @@
-// Agent commands (Beta): which agents get a forwarding command, what the files contain, and that "off" changes nothing.
+// Agent commands: which agents get a forwarding command, what the files contain, and that "off" changes nothing.
 // Everything happens in the test's temp folder with a made-up PATH; your real PATH is never read or written.
 import fs from 'node:fs';
 import path from 'node:path';
 import { DEFAULTS } from '../core/config/index.js';
 import { agentCommands, commandsDir, realAgent } from '../host/agent-commands/index.js';
 import { forwardingCmd, forwardingSh } from '../host/agent-commands/index.js';
-import { reconcileAgentCommands } from '../host/agent-commands/index.js';
+import { forwardTarget, reconcileAgentCommands } from '../host/agent-commands/index.js';
+import { agentCommandsSection } from '../app/features/agent-commands/agent-commands.def.js';
+import { applyAgentCommandsChange } from '../app/features/settings/settings.run.js';
+import { fakeIO } from '../app/kernel/index.js';
+import { runDefinition } from '../app/registry.js';
 export const agentCommandsSuite = {
     name: 'agent-commands',
-    title: 'agent commands (Beta): claude, codex ... forwarded into a hidden sandbox',
+    title: 'agent commands: claude, codex ... forwarded into a hidden sandbox',
     run: async (t) => {
         const storage = t.at('agent-cmd-storage');
         const npmDir = t.at('agent-cmd-npm');
@@ -33,19 +37,53 @@ export const agentCommandsSuite = {
         t.check(!agentCommands(on, storage, unsafeDir).some((a) => a.command === 'aider'), 'an agent in a folder whose path has % or ^ (which cmd.exe would expand) is left alone');
         t.section('the forwarding files');
         const claude = { harness: 'claude', command: 'claude', real: path.join(localBin, 'claude.exe') };
-        const cmd = forwardingCmd(claude, 'C:\\node\\node.exe', 'C:\\tool\\dist\\bin\\sandbox.js');
+        const direct = { node: 'C:\\node\\node.exe', entry: 'C:\\tool\\dist\\bin\\sandbox.js' };
+        const cmd = forwardingCmd(claude, direct);
         t.check(cmd.includes('"C:\\node\\node.exe" "C:\\tool\\dist\\bin\\sandbox.js" launch --harness claude --headless --terminal -- %*') &&
             cmd.includes('if "%SANDBOX_AGENT_DIRECT%"=="1" goto direct') &&
             cmd.includes('call "' + claude.real + '" %*'), 'the .cmd starts the agent in a hidden sandbox attached to this terminal, unless SANDBOX_AGENT_DIRECT=1 (real agent)');
-        const sh = forwardingSh({ ...claude, real: "C:\\Users\\me\\it's\\claude.exe" }, 'C:\\node\\node.exe', 'C:\\tool\\sandbox.js');
+        t.check(cmd.includes('if not exist "C:\\node\\node.exe" goto direct') &&
+            cmd.includes('if not exist "C:\\tool\\dist\\bin\\sandbox.js" goto direct') &&
+            cmd.indexOf('if not exist') < cmd.indexOf('launch --harness'), 'the .cmd runs the real agent when the tool was uninstalled or moved, instead of failing');
+        const managed = forwardTarget('C:\\tool\\versions\\1.0\\package', 'C:\\tool', 'C:\\node\\node.exe');
+        const viaLauncher = forwardingCmd(claude, managed);
+        t.check(managed.launcher === 'C:\\tool\\bin\\sandbox.cmd' &&
+            forwardTarget('C:\\src\\repo', null, 'C:\\node\\node.exe').launcher === undefined &&
+            viaLauncher.includes('call "C:\\tool\\bin\\sandbox.cmd" launch --harness claude --headless --terminal -- %*') &&
+            !viaLauncher.includes('versions') &&
+            forwardingSh(claude, managed).includes("[ -f '/c/tool/bin/sandbox' ] || exec "), 'under a managed install the files call its launcher (it survives updates), else node and the entry file');
+        const sh = forwardingSh({ ...claude, real: "C:\\Users\\me\\it's\\claude.exe" }, {
+            node: 'C:\\node\\node.exe',
+            entry: 'C:\\tool\\sandbox.js',
+        });
         t.check(sh.startsWith('#!/bin/sh') &&
             sh.includes("exec '/c/node/node.exe' '/c/tool/sandbox.js' launch --harness claude --headless --terminal -- \"$@\"") &&
             sh.includes("'/c/Users/me/it'\\''s/claude.exe'"), 'Git Bash gets a shell script with POSIX paths, quoted safely');
         t.section('off changes nothing');
         // Off with nothing set up: nothing to do, no PATH edit (which would be refused during the self-test anyway).
         const fresh = t.at('agent-cmd-fresh');
-        const off = reconcileAgentCommands(DEFAULTS, fresh, 'C:\\node\\node.exe', 'C:\\tool\\sandbox.js');
+        const target = { node: 'C:\\node\\node.exe', entry: 'C:\\tool\\sandbox.js' };
+        const off = reconcileAgentCommands(DEFAULTS, fresh, target);
         t.equal({ on: off.on, changed: off.changed, wrote: fs.existsSync(commandsDir(fresh)) }, { on: false, changed: false, wrote: false }, 'off (the default) writes nothing and leaves your PATH alone');
-        await t.throws(() => reconcileAgentCommands(on, t.at('agent-cmd-on'), 'C:\\node\\node.exe', 'C:\\tool\\sandbox.js'), /self-test|PATH/i, 'turning it on edits your PATH, which the self-test refuses (it never changes this PC)');
+        await t.throws(() => reconcileAgentCommands(on, t.at('agent-cmd-on'), target), /self-test|PATH/i, 'turning it on edits your PATH, which the self-test refuses (it never changes this PC)');
+        t.section('every surface');
+        await t.throws(() => runDefinition('agentCommands.on', {}, {}, fakeIO().io), /self-test|PATH|inside the sandbox/i, 'agentCommands.on refuses in the self-test (it would change this PC)');
+        const reconciled = [];
+        const fakeService = { reconcile: (c) => reconciled.push(c) };
+        const ctx = { loaded: { configPath: undefined } };
+        applyAgentCommandsChange(ctx, 'user', 'agentCommands.enabled', fakeService);
+        applyAgentCommandsChange(ctx, 'user', 'defaultHarness', fakeService);
+        applyAgentCommandsChange(ctx, 'project', 'agentCommands.enabled', fakeService);
+        t.equal(reconciled.length, 1, 'changing agentCommands.* in your settings (any surface) brings this PC in line');
+        const section = agentCommandsSection({
+            enabled: false,
+            dir: 'C:\\x',
+            found: [{ command: 'claude', harness: 'claude', real: 'C:\\r\\claude.exe' }],
+        });
+        const toggle = section.items?.[0].primary;
+        t.check(section.items?.map((i) => i.id).join() === 'agentCommands,agentCommand:claude' &&
+            toggle?.kind === 'operation' &&
+            toggle.op === 'agentCommands.on' &&
+            !JSON.stringify(section).includes('sandbox agent-commands'), 'the Agents page offers the switch as an action and lists each agent found, naming no command');
     },
 };

package/dist/selftest/agent-paths.test.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { DEFAULTS, mergeConfig, validateConfig } from '../core/config/index.js';
 import { isWin } from '../core/util/index.js';
 import { SYSTEM } from '../shared/system.js';
-import { agentCommand, agentShims, bootResetPaths, codexConfigWithoutSandbox, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, shimText, } from '../guest/agents/agent-files.js';
+import { agentCommand, agentShims, bootResetPaths, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, shimText, } from '../guest/agents/agent-files.js';
 import { appendMissing, expandVars, isPinnedNodeDir, parseRegPath, pathKey, planPath, rebuildPath, splitPath, } from '../guest/setup/path-plan.js';
 import { withReloadEnvironment } from '../host/tools/index.js';
 import { HarnessSchema } from '../core/schema/index.js';
@@ -59,17 +59,6 @@ export const agentPathsSuite = {
         ], "codex's DPAPI-sealed sandbox users and setup marker are removed at boot (CryptUnprotectData otherwise)");
         t.check(HarnessSchema.safeParse({ ...DEFAULTS.harnesses.codex, bootReset: ['..\\login'] }).success === false &&
             HarnessSchema.safeParse({ ...DEFAULTS.harnesses.codex, bootReset: ['C:\\Windows'] }).success === false, 'bootReset takes only plain paths below the agent state folder');
-        t.section('codex without its own command sandbox');
-        const userToml = '[tui]\nscreen_reader_detection_done = true\n\n[windows]\nsandbox = "elevated"\n';
-        const off = codexConfigWithoutSandbox(userToml) ?? '';
-        t.check(off.split('\n').find((l) => !l.startsWith('#')) === 'sandbox_mode = "danger-full-access"' &&
-            off.endsWith(userToml), 'sandbox_mode goes above the first table, the rest of the file is kept');
-        t.check(codexConfigWithoutSandbox('') === off.slice(0, off.indexOf('\n\n') + 1), 'a missing config.toml gets just the setting');
-        t.equal([
-            codexConfigWithoutSandbox(off),
-            codexConfigWithoutSandbox('model = "o3"\nsandbox_mode = "workspace-write"\n[windows]\n'),
-        ], [null, null], 'a sandbox_mode already set (by the sandbox or by the user) is left alone');
-        t.check(codexConfigWithoutSandbox('[profiles.x]\nsandbox_mode = "read-only"\n') !== null, 'a sandbox_mode inside a table does not count as the top-level one');
         t.section('PATH planner');
         const present = new Set(['c:\\a', 'c:\\b', 'c:\\c\\d', 'c:\\nvm\\v24.1.0']);
         const exists = (f) => present.has(pathKey(f));

package/dist/selftest/agent-settings.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const agentSettingsSuite: Suite;

package/dist/selftest/agent-settings.test.js

@@ -0,0 +1,94 @@
+// Codex settings (launch flags, config.toml), the Claude environment editor and the one Anthropic key pattern.
+import fs from 'node:fs';
+import { DEFAULTS } from '../core/config/index.js';
+import { CodexSchema } from '../core/schema/index.js';
+import { agentEnv, agentsEnvSet } from '../app/features/agents/index.js';
+import { agentsOptions } from '../cli/menu/pages/agents-page.js';
+import { fakeIO } from '../app/kernel/index.js';
+import { runDefinition } from '../app/registry.js';
+import { agentArguments, agentShims, codexArguments, codexConfigOwned, shimText } from '../guest/agents/agent-files.js';
+import { ANTHROPIC_KEY_PATTERN, anthropicKeyProblem } from '../shared/accounts/index.js';
+import { CLAUDE_ENV, ENV_GROUPS } from '../app/features/agents/claude-env.def.js';
+const CODEX = DEFAULTS.codex;
+export const agentSettingsSuite = {
+    name: 'agent-settings',
+    title: 'Codex settings, Claude environment editor, Anthropic key pattern',
+    run: async (t) => {
+        t.section('codex launch flags');
+        t.equal(codexArguments(CODEX), ['--dangerously-bypass-approvals-and-sandbox'], 'full access + never = the bypass flag');
+        t.equal(codexArguments({ ...CODEX, sandboxMode: 'workspace-write', approvalPolicy: 'on-request' }), ['--sandbox', 'workspace-write', '--ask-for-approval', 'on-request'], 'another mode gets explicit flags');
+        t.equal(codexArguments({ ...CODEX, sandboxMode: 'danger-full-access', approvalPolicy: 'on-failure' }), ['--sandbox', 'danger-full-access', '--ask-for-approval', 'on-failure'], 'the bypass flag is only for full access with no questions');
+        t.equal(codexArguments({ ...CODEX, model: 'gpt-5', reasoningEffort: 'high' }).slice(1), ['-c', 'model="gpt-5"', '-c', 'model_reasoning_effort="high"'], 'model and reasoning effort follow as -c overrides');
+        t.check(CodexSchema.safeParse({ ...CODEX, model: 'x"; evil' }).success === false, 'a model name cannot carry quotes');
+        const codex = DEFAULTS.harnesses.codex;
+        t.equal(agentArguments('codex', codex, CODEX), [...codex.arguments, '--dangerously-bypass-approvals-and-sandbox'], "codex's launch arguments carry the flags");
+        t.equal(agentArguments('claude', DEFAULTS.harnesses.claude, CODEX), [...DEFAULTS.harnesses.claude.arguments], 'other agents do not');
+        const shim = agentShims('C:\\AgentData\\tools', DEFAULTS.harnesses, { codex: codexArguments(CODEX) }).find((s) => s.name === 'codex');
+        const text = shim ? shimText(shim, { node: 'node.exe', script: 'agent.js' }) : '';
+        t.includes(text, '"%SBX_REAL%" --dangerously-bypass-approvals-and-sandbox %*', 'the codex.cmd shim adds the flags');
+        t.excludes(shimText(agentShims('C:\\AgentData\\tools', DEFAULTS.harnesses).find((s) => s.name === 'codex'), { node: 'node.exe', script: 'agent.js' }), 'dangerously', 'a shim without flags passes only %*');
+        t.section('codex config.toml');
+        const old = '# Set by the sandbox: x\nsandbox_mode = "danger-full-access"\n\n[tui]\nscreen_reader_detection_done = true\n\n[windows]\nsandbox = "elevated"\n';
+        const owned = codexConfigOwned(old, CODEX);
+        t.check(!owned.includes('sandbox_mode') && !owned.includes('Set by the sandbox') && !owned.includes('sandbox = '), 'the old sandbox_mode lines and [windows] sandbox are removed', owned);
+        t.check(owned.includes('mcp_oauth_credentials_store = "file"') &&
+            owned.includes('[tui]\nscreen_reader_detection_done = true\n') &&
+            owned.includes('[windows]'), 'MCP logins go to a file; every other line stays', owned);
+        t.equal(codexConfigOwned(owned, CODEX), owned, 'running it again changes nothing');
+        t.includes(codexConfigOwned(old, { ...CODEX, windowsSandbox: 'unelevated' }), '[windows]\nsandbox = "unelevated"', 'a Windows sandbox mode is written when asked for');
+        t.includes(codexConfigOwned('mcp_oauth_credentials_store = "keyring"\n', CODEX), 'mcp_oauth_credentials_store = "keyring"', "a user's own mcp_oauth_credentials_store is kept");
+        t.equal(codexConfigOwned('', { ...CODEX, mcpLoginsInFile: false }), '', 'an empty file stays empty when nothing is owned');
+        t.section('Anthropic key pattern');
+        const body = 'a'.repeat(60);
+        t.check(ANTHROPIC_KEY_PATTERN.test('sk-ant-usr01-' + body) && ANTHROPIC_KEY_PATTERN.test('sk-ant-api03-' + body), 'sk-ant-api03- and sk-ant-usr01- keys are accepted');
+        t.check(!ANTHROPIC_KEY_PATTERN.test('sk-ant-usr1-x') && anthropicKeyProblem('sk-ant-usr1-x') !== null, 'a short or malformed key is refused');
+        t.check(anthropicKeyProblem('sk-ant-usr01-' + body) === null, 'no problem for a user-workspace key');
+        t.section('Claude environment catalogue');
+        const names = CLAUDE_ENV.map((s) => s.name);
+        t.check(new Set(names).size === names.length, 'names are unique');
+        t.check(names.every((n) => /^[A-Z][A-Z0-9_]+$/.test(n)) && CLAUDE_ENV.every((s) => ENV_GROUPS.includes(s.group)), 'names and groups are valid');
+        t.check(names.includes('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS'), 'the subagent limit is there');
+        t.section('Claude environment operations');
+        const configPath = t.at('agent-env', 'config.json');
+        t.write(configPath, '{}\n');
+        const ctx = {
+            packageRoot: t.dir('agent-env', 'package'),
+            options: {},
+            loaded: { config: structuredClone(DEFAULTS), configPath, base: t.temp },
+            storageRoot: t.dir('agent-env', 'storage'),
+            dataPath: t.dir('agent-env', 'storage', 'data', 'o'),
+        };
+        const io = fakeIO([]).io;
+        const set = (name, value) => runDefinition(agentsEnvSet.id, ctx, { agent: 'claude', name, value }, io);
+        const read = async () => (await runDefinition(agentEnv.id, ctx, { agent: 'claude' }, io));
+        await set('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS', '40');
+        let row = (await read()).rows.find((r) => r.name === 'CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS');
+        t.check(row?.set === true && row.value === '40', 'a number is saved and read back');
+        t.includes(fs.readFileSync(configPath, 'utf8'), '"CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS": "40"', 'it is in the settings file');
+        await t.throws(() => set('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS', 'many'), 'whole number', 'a word is refused for a number');
+        await t.throws(() => set('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS', '0'), 'Use a number', 'zero is refused');
+        await set('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS', null);
+        row = (await read()).rows.find((r) => r.name === 'CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS');
+        t.check(row?.set === false, 'an empty value removes it');
+        await t.throws(() => set('ANTHROPIC_API_KEY', 'sk-ant-usr1-x'), 'API key', 'the environment editor refuses a bad key');
+        const key = 'sk-ant-usr01-' + 'k'.repeat(60);
+        await set('ANTHROPIC_API_KEY', key);
+        const shown = JSON.stringify(await read());
+        t.check(!shown.includes(key.slice(13)), 'a secret value is never returned');
+        t.check((await read()).rows.find((r) => r.name === 'ANTHROPIC_API_KEY')?.set === true, 'but it says it is set');
+        const env = await read();
+        const menu = agentsOptions({
+            folder: 'C:/code',
+            defaultAgent: 'claude',
+            agents: [{ name: 'claude', ready: true }],
+            last: undefined,
+            attach: false,
+            window: 'config',
+            hostAgents: [],
+            claudeEnv: env,
+        });
+        t.check(menu.categories?.some((c) => c.id === 'env') === true &&
+            menu.items.some((i) => i.label === 'Subagents at once' || i.label === 'API key'), 'the menu has a Claude environment tab with the variables');
+        await t.throws(() => set('bad name', '1'), '', 'a bad variable name is refused');
+    },
+};

package/dist/selftest/app.test.js

@@ -282,6 +282,7 @@ export const appSuite = {
                 t.check(ops(sample).every((op) => known.has(op)), view.id + ': the page offers only operations its view declares');
         }
         t.section('agents');
+        const noCommands = { enabled: false, dir: 'C:/x', found: [] };
         const agentsSample = agentsPage({
             folder: 'C:\\code\\api',
             defaultAgent: 'claude',
@@ -289,7 +290,7 @@ export const appSuite = {
                 { name: 'codex', ready: false, isDefault: false, removable: true },
                 { name: 'claude', ready: true, isDefault: true, removable: false },
             ],
-        });
+        }, noCommands);
         const agentItems = agentsSample.sections[0].items ?? [];
         const agentKeys = (id) => (agentItems.find((i) => i.id === id)?.actions ?? [])
             .flatMap((a) => (a.kind === 'operation' && a.key ? [a.key] : []))

package/dist/selftest/cli.test.js

@@ -158,6 +158,10 @@ export const cliSuite = {
         });
         multi.handle(key('space'));
         t.equal(multi.handle(key('return')), { done: { kind: 'multi', values: ['a', 'b'] } }, 'list screen: space ticks several');
+        const pasted = new TextScreen({ path: ['T'], label: 'Secret', masked: true });
+        pasted.handle(key('', '\u001b[200~abc\r\n\u001b[201~'));
+        pasted.handle(key('', '[200~d[201~'));
+        t.equal(pasted.handle(key('return')), { done: 'abcd' }, 'text field: the markers around pasted text are dropped');
         const typed = new TextScreen({ path: ['T'], label: 'Port', validate: (v) => (Number(v) > 0 ? true : 'a number') });
         typed.handle(key('x', 'x'));
         const refused = typed.handle(key('return'));

package/dist/selftest/index.js

@@ -28,6 +28,7 @@ import { channelSuite } from './channel.test.js';
 import { heavyLoadSuite } from './heavy-load.test.js';
 import { cliSuite } from './cli.test.js';
 import { agentPathsSuite } from './agent-paths.test.js';
+import { agentSettingsSuite } from './agent-settings.test.js';
 import { cmdlineSuite } from './cmdline.test.js';
 import { configSuite } from './config.test.js';
 import { migrateSuite } from './migrate.test.js';
@@ -140,6 +141,7 @@ export const SUITES = [
     personalizationSuite,
     cmdlineSuite,
     agentPathsSuite,
+    agentSettingsSuite,
     setupSuite,
     dataSuite,
     repairSuite,

package/dist/selftest/menu.test.js

@@ -243,8 +243,8 @@ export const menuSuite = {
             agentList.categories?.map((c) => c.id),
         ], [
             ['repeat', 'agent:codex', 'agent:claude', 'add'],
-            ['start', 'options'],
-        ], 'Agents: Repeat last, the default agent first, the others, then Add an agent; no "On this PC" while it is empty');
+            ['start', 'options', 'host'],
+        ], 'Agents: Repeat last, the default agent first, the others, then Add an agent; "On this PC" always holds the agent commands switch');
         t.check(agentList.items
             .filter((i) => i.category === 'options')
             .map((i) => i.value)
@@ -580,7 +580,9 @@ export const menuSuite = {
             keyFor('x', 'agent:mine') &&
             !keyFor('x', 'agent:codex') &&
             typeof actionList.actions === 'function' &&
-            actionList.actions('start').length === 2 &&
+            actionList.actions('start').length === 3 &&
+            keyFor('e', 'agent:claude') &&
+            !keyFor('e', 'agent:codex') &&
             actionList.actions('options').length === 0, 'Make default shows on any other agent, Remove only on one you added; neither on built-in agents or other rows');
         const agentsFile = ConfigFile.user(t.at('agents-actions', 'config.json'));
         t.write(agentsFile.file, '{\n  // mine\n  "defaultHarness": "claude"\n}\n');

package/dist/selftest/pc-installs.test.js

@@ -11,6 +11,7 @@ import { LocalOverridesSchema } from '../core/schema/index.js';
 import { discoverPcInstalls } from '../host/pc-installs/index.js';
 import { generateSandbox } from '../host/launch/index.js';
 import { isValidGuestPath, PC_INSTALLS_GUEST } from '../shared/paths/index.js';
+import { NOT_READY } from '../shared/readiness.js';
 const PC = { localAppData: '', appData: '', programData: '' };
 export const pcInstallsSuite = {
     name: 'pc-installs',
@@ -70,6 +71,9 @@ export const pcInstallsSuite = {
         t.check(session.pcInstalls?.items.map((i) => i.id).join() === '480,UE_5.4' &&
             !JSON.stringify(session.pcInstalls).includes(game), 'session.json lists them by their place in the sandbox only');
         t.section('detection of the new toolchains');
+        // These toolchains are hidden until written (NOT_READY); their detection rules are tested as if they were ready.
+        const hidden = [...NOT_READY.toolchains];
+        NOT_READY.toolchains.length = 0;
         const tc = structuredClone(DEFAULTS.toolchains);
         const decide = (entries, hints = {}, settingsOf = tc) => decideToolchains(settingsOf, entries, [], hints);
         const godot = decide(['project.godot']);
@@ -92,6 +96,7 @@ export const pcInstallsSuite = {
         t.check(decide(['project.godot'], {}, godotNet).dotnet.on, "Godot's .NET build brings .NET");
         const fivem = decide(['fxmanifest.lua']);
         t.check(!fivem.fivem.on && fivem.fivem.reason.includes('fivem.acceptLicense'), 'the FiveM server is licensed too');
+        NOT_READY.toolchains.push(...hidden);
         t.section('a project never accepts a licence or shares a sign-in');
         t.check(LICENSED_TOOLCHAINS.every((n) => OFF_IS_SAFER.includes('toolchains.' + n + '.acceptLicense')) &&
             OFF_IS_SAFER.includes('accounts.epic.share') &&

package/dist/selftest/persisted-installs.test.js

@@ -6,6 +6,13 @@ import path from 'node:path';
 import { DEFAULTS } from '../core/config/index.js';
 import { assertLocalRoom, ensurePersisted, installRecords, InstallRecordsSchema, LOCAL_RESERVE_BYTES, recordUse, } from '../guest/toolchains/persisted.js';
 import { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, visualStudioWanted, } from '../guest/toolchains/native/vs-request.js';
+import { autosdkLayout, layoutNextStep, unrealUsesAutosdk, vsExitText } from '../guest/toolchains/native/vs-request.js';
+import { freeBytesAt } from '../shared/io/disk.js';
+import { SIGNERS, signerMatches } from '../shared/signer.js';
+import { decideToolchains } from '../core/detect/toolchains.js';
+import { NOT_READY } from '../shared/readiness.js';
+import { ConfigFile } from '../app/features/settings/settings-file.js';
+import { settingsOf } from '../app/features/settings/settings-rows.js';
 import { collectDataEntries } from '../cli/services/data-collect.js';
 const GB = 1024 ** 3;
 export const persistedInstallsSuite = {
@@ -103,5 +110,67 @@ export const persistedInstallsSuite = {
             all.for.join() === 'unreal,flutter,unity' &&
             UNREAL_COMPONENTS.every((c) => all.components.includes(c)) &&
             all.components.includes('Microsoft.VisualStudio.Component.VC.Llvm.Clang'), 'with Unreal: one Community install serves all of them');
+        t.section('Unreal on the portable MSVC (autosdk)');
+        tc.unreal.visualStudio = 'autosdk';
+        const noUnreal = visualStudioWanted(tc);
+        t.check(noUnreal?.product === 'buildtools' && noUnreal.for.join() === 'flutter,unity', 'autosdk: Unreal asks for no Visual Studio (the others still get the Build Tools)');
+        tc.flutter.enabled = false;
+        tc.unity.enabled = false;
+        t.equal(visualStudioWanted(tc), null, 'autosdk alone: no Visual Studio at all');
+        t.check(unrealUsesAutosdk(tc, (s) => s === true) && !unrealUsesAutosdk(DEFAULTS.toolchains), 'autosdk is only when asked');
+        const pairs = autosdkLayout('T:\\msvc', '14.44.35207', '10.0.26100.0', 'T:\\autosdk');
+        t.check(pairs.length === 4 &&
+            pairs[0].to === 'T:\\autosdk\\HostWin64\\Win64\\VS2022\\14.44.35207' &&
+            pairs[0].from === 'T:\\msvc\\VC\\Tools\\MSVC\\14.44.35207' &&
+            pairs[1].from === 'T:\\msvc\\Windows Kits\\10\\Include\\10.0.26100.0' &&
+            pairs[1].to === 'T:\\autosdk\\HostWin64\\Win64\\Windows Kits\\10\\Include\\10.0.26100.0', 'the AutoSDK tree is MSVC under VS2022\\<version> and the SDK under Windows Kits\\10 (copies)');
+        const on = DEFAULTS.toolchains;
+        const auto = {
+            ...structuredClone(on),
+            unreal: { ...on.unreal, visualStudio: 'autosdk', acceptLicense: true },
+        };
+        const decided = decideToolchains(auto, ['Game.uproject'], []);
+        t.check(decided.unreal.on && decided.msvc.on, 'an Unreal project with autosdk turns the portable MSVC on, under its licence');
+        t.section('the Visual Studio layout');
+        t.check(vsExitText(3762504530).includes('crashed') &&
+            vsExitText(-1).includes('exit 4294967295') &&
+            vsExitText(0) === 'installed' &&
+            vsExitText(1602) === 'cancelled' &&
+            vsExitText(8006).includes('running') &&
+            vsExitText(3010).includes('restart') &&
+            vsExitText(5007).includes('refused'), 'installer exit codes are told in words (0xE0434352 is a crash)');
+        const reserve = LOCAL_RESERVE_BYTES;
+        const room = (free) => freeBytesAt(t.dir('layout-room'), () => ({ bavail: free, bsize: 1 })) ?? 0;
+        t.check(layoutNextStep(0, 0, reserve) === 'done' &&
+            layoutNextStep(3762504530, room(40 * GB), reserve) === 'stage' &&
+            layoutNextStep(3762504530, room(20 * GB), reserve) === 'skip' &&
+            layoutNextStep(null, room(40 * GB), reserve) === 'stage', 'a failed layout is built on the sandbox disk only with room for it (12 GB plus the reserve)');
+        t.equal(freeBytesAt(path.join(t.dir('layout-room'), 'not', 'there'), () => ({ bavail: 3, bsize: 2 })), 6, 'free room of a folder that does not exist asks its parent');
+        t.equal(freeBytesAt(t.dir('layout-room'), () => {
+            throw new Error('no');
+        }), null, 'unknown free room is null');
+        t.section('signers');
+        const ms = { subject: SIGNERS.microsoft.subject, issuer: undefined };
+        const msSig = {
+            subject: 'CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US',
+            issuer: 'CN=Microsoft Code Signing PCA',
+        };
+        t.check(signerMatches(msSig, ms) &&
+            !signerMatches({ ...msSig, subject: 'CN=Microsoft Corporation Fake, O=Evil' }, ms) &&
+            !signerMatches(null, ms) &&
+            signerMatches({ subject: 'CN="Valve Corp.", O=Valve', issuer: 'x' }, SIGNERS.valve) &&
+            signerMatches({ subject: 'CN=Unity Technologies ApS', issuer: 'x' }, SIGNERS.unity) &&
+            !signerMatches({ subject: 'CN=Microsoft Corporation', issuer: 'x' }, SIGNERS.valve) &&
+            signerMatches(msSig, { subject: ['^CN=Microsoft'], issuer: ['code signing'] }) &&
+            !signerMatches(msSig, { subject: ['^CN=Microsoft'], issuer: ['nobody'] }), 'a signer matches by subject (and issuer when named), never an empty or unsigned file');
+        t.section('not ready yet');
+        const everything = structuredClone(on);
+        for (const name of NOT_READY.toolchains)
+            everything[name].enabled = 'auto';
+        const found = decideToolchains(everything, ['ProjectVersion.txt', 'project.godot', 'fxmanifest.lua'], ['unity']);
+        t.check(NOT_READY.toolchains.every((n) => !found[n].on), '"auto" never turns on a toolchain that is not written yet, whatever the project holds');
+        const shown = settingsOf(ConfigFile.user(t.at('settings', 'config.json'))).map((r) => r.key.join('.'));
+        t.check(!shown.some((k) => /^toolchains\.(unity|godot|android|flutter|dart|reactNative|fivem)\./.test(k)) &&
+            shown.includes('toolchains.unreal.visualStudio'), 'settings do not list the toolchains that are not written yet');
     },
 };

package/dist/selftest/service-accounts.test.js

@@ -306,7 +306,7 @@ export const serviceAccountsSuite = {
         });
         t.check(empty.message.includes('No saved'), 'no launcher sign-in on this PC: it says so');
         await t.throws(() => loginServiceFlow(fakeIO([]).io, 'epic', { store: flowStore, share: true }), 'nothing to type', 'Epic has nothing to type');
-        await t.throws(() => loginServiceFlow(fakeIO([CFX, '']).io, 'cfx', { store: flowStore, share: true }), 'not available yet', 'a kind whose host side is not written yet says so');
+        await t.throws(() => loginServiceFlow(fakeIO([CFX, '']).io, 'cfx', { store: flowStore, share: true }), 'comes in a later version', 'a kind whose host side is not written yet says so');
         t.check(Boolean(HOST_SOURCES.epic.fromPc) && !HOST_SOURCES.epic.fromAnswers, 'Epic comes from this PC (or a sandbox), never typed');
         const gone = await logoutServiceFlow(fakeIO([true]).io, 'epic', t.dir('svc-flow-root'), flowStore, new AccountLeases(t.dir('svc-flow-root')));
         t.check(gone.deleted && flowStore.state('epic') === 'none', 'forgetting deletes it after asking');

package/dist/selftest/support/engine-golden.js

@@ -67,7 +67,7 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/scripts/enable-vt-input.ps1',
     'sandbox/scripts/expand-archive.ps1',
     'sandbox/scripts/get-gpu-names.ps1',
-    'sandbox/scripts/get-signer.ps1',
+    'sandbox/scripts/get-signature.ps1',
     'sandbox/scripts/install-shell-path.ps1',
     'sandbox/scripts/link-profile-dirs.ps1',
     'sandbox/scripts/new-shortcuts.ps1',

package/dist/selftest/support/fixtures.d.ts

@@ -194,6 +194,7 @@ export declare function createFixtures(t: Harness): {
                 acceptLicense: boolean;
                 components: string[];
                 keepInstallFiles: boolean;
+                visualStudio: "full" | "autosdk";
                 persistEngines: boolean;
                 derivedDataCache: "persisted" | "local";
             };
@@ -429,6 +430,14 @@ export declare function createFixtures(t: Harness): {
             resumeArguments?: string[] | undefined;
             resumeOneArguments?: string[] | undefined;
         }>;
+        codex: {
+            sandboxMode: "danger-full-access" | "workspace-write" | "read-only";
+            approvalPolicy: "never" | "on-request" | "on-failure" | "untrusted";
+            model: string;
+            reasoningEffort: "default" | "minimal" | "low" | "medium" | "high" | "xhigh";
+            windowsSandbox: "off" | "unelevated" | "elevated";
+            mcpLoginsInFile: boolean;
+        };
         hooks: {
             failFast: boolean;
         };

package/dist/selftest/vpn.test.js

@@ -14,7 +14,8 @@ import { ConfigSchema, LocalOverridesSchema } from '../core/schema/index.js';
 import { SecretStore } from '../host/secrets/index.js';
 import { clearSecrets } from '../host/secrets/index.js';
 import { generateSandbox } from '../host/launch/index.js';
-import { findCountry, nordProfile, prepareVpn, wireguardFileProblem, recommendedServer, VpnLogin, vpnLine, vpnNotes, } from '../host/vpn/index.js';
+import { classifyFailure, FAILURE_TEXT } from '../shared/vpn/failure.js';
+import { findCountry, loginProblem, loginWarning, nordProfile, prepareVpn, wireguardFileProblem, recommendedServer, VpnLogin, vpnLine, vpnNotes, } from '../host/vpn/index.js';
 import { RunDir } from '../shared/channel/index.js';
 import { OPENVPN_MSI, WIREGUARD_MSI } from '../shared/vpn/download.js';
 import { cleanServers, ipv4Except, killSwitchCommands, removeKillSwitchCommands, tunnelAddressFromLog, tunnelCommands, } from '../shared/vpn/kill-switch.js';
@@ -221,6 +222,52 @@ export const vpnSuite = {
         t.check(login.state('nordvpn') === 'unreadable', 'a login this Windows user cannot open is reported as unreadable');
         login.remove('nordvpn');
         t.check(login.state('nordvpn') === 'none', 'logout deletes it');
+        t.section('NordVPN login checks and why a tunnel failed');
+        const sampleStatus = () => ({
+            enabled: true,
+            provider: 'nordvpn',
+            protocol: 'udp',
+            country: '',
+            killSwitch: true,
+            login: 'saved',
+            loginSavedAt: '2026-11-02T19:00:00.000Z',
+            running: null,
+            lastFailure: null,
+        });
+        t.check((loginProblem({ username: 'me@example.com', password: 'x' }, 'nordvpn') ?? '').includes('service credentials') &&
+            loginProblem({ username: 'me@example.com', password: 'x' }, 'openvpn-file') === null &&
+            (loginProblem({ username: 'abc', password: 'p[200~w' }, 'nordvpn') ?? '').includes('paste'), 'an e-mail is refused for NordVPN only (it needs the service credentials); hidden paste markers are refused');
+        login.save('nordvpn', { username: '  ' + USERNAME + ' ', password: ' ' + PASSWORD + '  ' });
+        t.equal(login.read('nordvpn'), { username: USERNAME, password: PASSWORD }, 'spaces around the user name and the password are not saved (a pasted login often has them)');
+        t.check(loginWarning({ username: 'x', password: 'y' }, 'openvpn-file') === null &&
+            loginWarning({ username: 'a'.repeat(24), password: 'B'.repeat(24) }, 'nordvpn') === null &&
+            loginWarning({ username: 'a b', password: 'c' }, 'nordvpn') !== null, 'a NordVPN login that does not look like service credentials gets a hint, not a refusal');
+        login.remove('nordvpn');
+        const failed = (log) => classifyFailure(log)?.code;
+        t.equal([
+            failed('AUTH: Received control message: AUTH_FAILED'),
+            failed('TLS Error: TLS key negotiation failed to occur within 60 seconds'),
+            failed('Could not create Wintun interface'),
+            failed('Exiting due to fatal error'),
+            failed('all fine'),
+        ], ['auth', 'unreachable', 'driver', 'other', undefined], 'the OpenVPN log is turned into a stable code the host acts on');
+        const refusedPage = vpnPage({
+            ...sampleStatus(),
+            lastFailure: { code: 'auth', text: FAILURE_TEXT.auth, at: '2026-11-02T19:15:21.000Z' },
+        });
+        const refusedText = pageLines(refusedPage).join('\n');
+        const refusedOps = pageActions(refusedPage).flatMap((a) => (a.kind === 'operation' ? [[a.op, a.label]] : []));
+        t.check(refusedText.includes('Last attempt') &&
+            refusedText.includes('login refused') &&
+            refusedText.includes('service credentials') &&
+            refusedOps.some(([op, label]) => op === 'vpn.login' && label === 'Save the login again…') &&
+            !/sandbox (vpn|config|agent)/.test(refusedText), 'after a refused login the VPN page says so and offers to save the login again, without naming a command');
+        const unreachablePage = vpnPage({
+            ...sampleStatus(),
+            lastFailure: { code: 'unreachable', text: FAILURE_TEXT.unreachable, at: '2026-11-02T19:15:21.000Z' },
+        });
+        t.check(pageActions(unreachablePage).some((a) => a.kind === 'operation' && a.input.key === 'vpn.protocol') &&
+            !pageActions(vpnPage({ ...sampleStatus(), protocol: 'tcp', lastFailure: { code: 'unreachable', text: 'x', at: 'y' } })).some((a) => a.kind === 'operation' && a.input.key === 'vpn.protocol'), 'a server that could not be reached offers TCP instead of UDP (once)');
         t.section('settings: what a project may and may not do');
         t.check(DEFAULTS.vpn.enabled === false && DEFAULTS.vpn.provider === 'nordvpn' && DEFAULTS.vpn.killSwitch === true, 'the VPN is off by default, NordVPN, with the kill switch on');
         t.check(ConfigSchema.safeParse(DEFAULTS).success, 'the defaults are valid');
@@ -458,11 +505,12 @@ export const vpnSuite = {
             login: 'none',
             loginSavedAt: null,
             running: null,
+            lastFailure: null,
         };
         const lines = pageLines(vpnPage(sample)).join('\n');
-        t.check(lines.includes('Next: sandbox vpn login') &&
+        t.check(!/sandbox (vpn|config|agent)/.test(lines) &&
             VPN_WARNINGS.every((w) => lines.includes(w)) &&
-            !lines.includes('Running now'), 'vpn status page: the facts, the next step on the command line only, the warnings', lines);
+            !lines.includes('Running now'), 'vpn status page: the facts and the warnings, no command to type', lines);
         t.equal(pageActions(vpnPage({ ...sample, provider: 'wireguard-file' })).map((a) => a.kind === 'operation' ? a.op : a.kind), ['settings.set'], 'vpn: wireguard needs no login and offers only turning the VPN on or off');
         t.equal(pageActions(vpnPage({ ...sample, login: 'saved', loginSavedAt: '2026-10-14T09:30:00.000Z' })).map((a) => a.kind === 'operation' ? a.op : a.kind), ['settings.set', 'vpn.login', 'vpn.logout'], 'a saved login offers turning the VPN on or off, saving the login again and deleting it');
         t.equal(vpnLoginRowOf(sample).hint, 'not saved', 'the Settings row says not saved when no login is saved');

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

@@ -0,0 +1,5 @@
+export declare const ANTHROPIC_KEY_PATTERN: RegExp;
+/** The only part of a key ever shown: sk-ant-...abcd. */
+export declare const ANTHROPIC_KEY_HINT: RegExp;
+/** What is wrong with a typed or found API key, or null when it has the right shape. Never quotes the key. */
+export declare function anthropicKeyProblem(key: string): string | null;

package/dist/shared/accounts/anthropic.js

@@ -0,0 +1,15 @@
+// The one shape of an Anthropic API key, for the host and the web (no node imports). A key from the Claude Console
+// starts with sk-ant-api, a key from a user workspace with sk-ant-usr.
+export const ANTHROPIC_KEY_PATTERN = /^sk-ant-(api|usr)\d{2}-[A-Za-z0-9_-]{20,400}$/;
+/** The only part of a key ever shown: sk-ant-...abcd. */
+export const ANTHROPIC_KEY_HINT = /^sk-ant-\.\.\.[A-Za-z0-9_-]{4}$/;
+/** What is wrong with a typed or found API key, or null when it has the right shape. Never quotes the key. */
+export function anthropicKeyProblem(key) {
+    if (ANTHROPIC_KEY_PATTERN.test(key))
+        return null;
+    if (key.startsWith('sk-ant-oat'))
+        return 'That is a Claude subscription token (from claude setup-token), not an API key. Save the subscription login instead.';
+    if (key.startsWith('sk-ant-admin'))
+        return 'That is an Admin key: it cannot run Claude. Make an API key instead.';
+    return 'An Anthropic API key starts with sk-ant-api or sk-ant-usr and has only letters, digits, - and _ (copy it from the Claude Console).';
+}

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

@@ -3,3 +3,4 @@ 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 * from './anthropic.js';

package/dist/shared/accounts/index.js

@@ -5,3 +5,4 @@ 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 * from './anthropic.js';