windows-development-sandbox 1.17.3 → 1.18.0

package/dist/runtime/view.js

@@ -4442,7 +4442,7 @@ var require_lodash = __commonJS({
         function omitBy(object2, predicate) {
           return pickBy(object2, negate(getIteratee(predicate)));
         }
-        var pick2 = flatRest(function(object2, paths) {
+        var pick3 = flatRest(function(object2, paths) {
           return object2 == null ? {} : basePick(object2, paths);
         });
         function pickBy(object2, predicate) {
@@ -5125,7 +5125,7 @@ var require_lodash = __commonJS({
         lodash.partial = partial2;
         lodash.partialRight = partialRight;
         lodash.partition = partition;
-        lodash.pick = pick2;
+        lodash.pick = pick3;
         lodash.pickBy = pickBy;
         lodash.property = property;
         lodash.propertyOf = propertyOf;
@@ -25866,7 +25866,7 @@ function date4(params) {
 }
 
 // src/shared/paths/guest-paths.ts
-var RESERVED_GUEST = /^C:\\(?:Windows|Program Files|Program Files \(x86\)|ProgramData|Users|AgentLaunch|AgentData|HostTools|nvm|Mirror)(?:\\|$)/i;
+var RESERVED_GUEST = /^C:\\(?:Windows|Program Files|Program Files \(x86\)|ProgramData|Users|AgentLaunch|AgentData|HostTools|nvm|Mirror|PcInstalls)(?:\\|$)/i;
 var MIRROR_LETTER = /^[D-Z]$/;
 var DRIVE_PATH = /^([A-Za-z]):\\(.*)$/;
 var BAD_CHARS = /[<>:"|?*/\x00-\x1f]/;
@@ -26265,8 +26265,119 @@ 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."
+    ),
+    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)."
+    ),
+    derivedDataCache: external_exports.enum(["persisted", "local"]).describe(
+      `"persisted": the engine's local derived data cache (compiled shaders, 10-50 GB) in tools\\unreal\\ddc, kept between sandboxes. "local": Unreal's own place on the sandbox disk (rebuilt every boot).`
+    )
+  }),
+  unity: external_exports.strictObject({
+    enabled: enabled(
+      "Unity: the editor version a project asks for, from Unity's release API (checked against its published hash), installed into tools\\unity\\<version> (6-7 GB each), with the modules you list.",
+      "ProjectSettings/ProjectVersion.txt"
+    ),
+    acceptLicense: external_exports.boolean().describe(
+      "Required to install: you accept the Unity terms of service (https://unity.com/legal/terms-of-service), and the editor needs a Unity licence (Personal is free). A project file cannot accept it for you."
+    ),
+    version: external_exports.string().min(1).describe(
+      '"project" = the version in ProjectSettings/ProjectVersion.txt, or an editor version such as "6000.0.32f1".'
+    ),
+    modules: external_exports.array(external_exports.string().regex(/^[a-z0-9-]+$/)).describe(
+      `Editor modules to add: "android" (4-5 GB, also the Android SDK), "webgl" (1.5 GB), "windows-il2cpp" (adds Visual Studio's C++ parts), "ios" (Xcode project export only: iOS builds need a Mac).`
+    ),
+    hub: external_exports.boolean().describe("Also Unity Hub, with the installed editors listed in it."),
+    keepVersions: external_exports.number().int().min(1).max(20).describe(
+      "How many editor versions to keep in tools\\unity; older ones are removed (the least recently used first)."
+    )
+  }),
+  godot: external_exports.strictObject({
+    enabled: enabled(
+      "Godot from its official builds (checked against the published SHA-512 sums), self-contained in tools\\godot\\<version> with `godot` (the console build) on PATH.",
+      "project.godot"
+    ),
+    version: external_exports.string().min(1).describe(
+      '"project" = the version project.godot was saved with (else the newest stable), or a version such as "4.3".'
+    ),
+    dotnet: EnabledSchema.describe(
+      'The .NET (C#) build of Godot and the .NET SDK: true, false, or "auto" = when the project has a .csproj.'
+    ),
+    exportTemplates: external_exports.boolean().describe("Also the export templates for that version (~1.2 GB), for exporting games."),
+    keepVersions: external_exports.number().int().min(1).max(20).describe("How many Godot versions to keep; older ones are removed (the least recently used first).")
+  }),
+  steam: external_exports.strictObject({
+    enabled: enabled(
+      "SteamCMD (`steamcmd` on PATH, Valve-signed, ~0.3 GB) and `sbx-steam` for logging in, downloading apps and workshop items, and uploading builds (ContentBuilder) and workshop items.",
+      "steam_appid.txt, steam_api64.dll, steam_api.dll, or an app_build / workshop_item .vdf"
+    ),
+    client: external_exports.boolean().describe(
+      "Also the Steam client (1-1.5 GB, in tools\\steam), for testing the Steamworks API, the overlay or in-game uploads. You sign in to it in each sandbox."
+    ),
+    sdkFolder: external_exports.string().describe(
+      "Where the Steamworks SDK is in the sandbox (relative paths are inside the project); it sets STEAMWORKS_SDK. Empty = not set. The SDK is never downloaded (it needs a Steamworks partner login)."
+    )
+  }),
+  fivem: external_exports.strictObject({
+    enabled: enabled(
+      "A FiveM / RedM server (FXServer with txAdmin) for resource development, from the Cfx.re artifacts (the game client is not supported). `sbx-fivem serve` starts it.",
+      "fxmanifest.lua or __resource.lua (up to 3 folders down)"
+    ),
+    acceptLicense: external_exports.boolean().describe(
+      "Required to install: you accept the Cfx.re platform terms (https://fivem.net/terms) and the FXServer licence. A project file cannot accept it for you."
+    ),
+    game: external_exports.enum(["gta5", "rdr3"]).describe('"gta5" = FiveM, "rdr3" = RedM.'),
+    artifact: external_exports.string().regex(/^(recommended|optional|latest|\d+)$/).describe('The server build: "recommended", "optional", "latest", or a build number.'),
+    txAdmin: external_exports.boolean().describe("Start the server with txAdmin (its web panel on port 40120)."),
+    keepVersions: external_exports.number().int().min(1).max(20).describe("How many server builds to keep in tools\\fivem\\artifacts.")
+  }),
+  android: external_exports.strictObject({
+    enabled: enabled(
+      "The Android SDK (command-line tools, platform-tools, build-tools, platforms, NDK and CMake as needed) in tools\\android-sdk, with a JDK. No emulator (Windows Sandbox cannot run one): use a device over the network, or build only.",
+      "a Gradle build using com.android, an AndroidManifest.xml (up to 3 folders down), a .NET MAUI project, or a Flutter / React Native / Godot Android project"
+    ),
+    acceptLicense: external_exports.boolean().describe(
+      "Required to install: you accept the Android SDK licence (https://developer.android.com/studio/terms) and the licences sdkmanager shows. A project file cannot accept them for you."
+    ),
+    platforms: StringsSchema.describe(
+      `Platforms to install, e.g. ["android-35"]; "project" = the compileSdk the project's Gradle files ask for.`
+    ),
+    buildTools: external_exports.string().min(1).describe('"latest" or a build-tools version such as "35.0.0".'),
+    ndk: external_exports.union([external_exports.literal(false), external_exports.string().min(1)]).describe(
+      '"auto" = when the project uses native code (ndkVersion, CMake or ndk-build), false = never, or a version.'
+    ),
+    cmake: external_exports.union([external_exports.literal(false), external_exports.string().min(1)]).describe('"auto" = when the project builds native code with CMake, false = never, or a version.'),
+    packages: Packages("More sdkmanager packages (not the emulator or system images)", '["extras;google;usb_driver"]')
+  }),
+  flutter: external_exports.strictObject({
+    enabled: enabled(
+      "Flutter (with its Dart) from the official releases (checked against their SHA-256), with the Android SDK for Android builds.",
+      "a pubspec.yaml with a flutter: section"
+    ),
+    version: external_exports.string().min(1).describe(
+      '"project" = the version in .fvmrc (else the newest stable), "stable", "beta", or a version such as "3.24.5".'
+    ),
+    windowsDesktop: external_exports.boolean().describe(
+      "Windows desktop builds: needs Visual Studio Build Tools' C++ parts (a real installer: it runs every boot, ~5 GB on the sandbox disk)."
+    ),
+    precache: StringsSchema.describe(
+      'Platforms whose engine files are downloaded ahead (flutter precache), e.g. ["android", "web"].'
     )
   }),
+  dart: external_exports.strictObject({
+    enabled: enabled(
+      "The Dart SDK (without Flutter), checked against its published SHA-256.",
+      "a pubspec.yaml without a flutter: section"
+    ),
+    version: external_exports.string().min(1).describe('"stable", "beta" or a version such as "3.5.4".')
+  }),
+  reactNative: external_exports.strictObject({
+    enabled: enabled(
+      "React Native / Expo: the Android SDK and JDK for Android builds (Node is always there). iOS builds run in EAS Build (the cloud).",
+      "a package.json depending on react-native or expo"
+    ),
+    easCli: external_exports.boolean().describe("Also eas-cli (Expo Application Services) as a global npm package.")
+  }),
   cpp: external_exports.strictObject({
     enabled: enabled(
       "MinGW-w64 GCC with CMake, Ninja, premake5 and mingw32-make (also Rust's linker).",
@@ -26286,7 +26397,8 @@ var ToolchainsSchema = external_exports.strictObject({
     ),
     netfx35: external_exports.boolean().describe(
       ".NET Framework 3.5 runtime (a Windows feature, enabled from Windows Update on every boot; a few minutes)."
-    )
+    ),
+    templates: Packages("Project templates (`dotnet new install`)", '["MonoGame.Templates.CSharp"]')
   }),
   go: external_exports.strictObject({
     enabled: enabled("Go.", "go.mod or go.work"),
@@ -26302,7 +26414,8 @@ var ToolchainsSchema = external_exports.strictObject({
     ),
     version: external_exports.string().min(1).describe(`"lts" (newest LTS) or a major version such as "21". A project's .java-version or .sdkmanrc wins.`),
     maven: external_exports.boolean().describe("Apache Maven (mvn). A project's mvnw works either way."),
-    gradle: external_exports.boolean().describe("Gradle (gradle). A project's gradlew works either way.")
+    gradle: external_exports.boolean().describe("Gradle (gradle). A project's gradlew works either way."),
+    kotlin: external_exports.boolean().describe("Also the Kotlin compiler (kotlinc) from JetBrains' releases. Gradle builds fetch their own.")
   }),
   ruby: external_exports.strictObject({
     enabled: enabled(
@@ -26373,6 +26486,15 @@ var ToolchainsSchema = external_exports.strictObject({
   )
 });
 
+// src/shared/apps/catalogue-gamedev.ts
+var GAMEDEV_APPS = [];
+
+// src/shared/apps/catalogue-mobile.ts
+var MOBILE_APPS = [];
+
+// src/shared/apps/catalogue-modding.ts
+var MODDING_APPS = [];
+
 // src/shared/apps/catalogue.ts
 var gh = (github, asset) => ({ github, asset });
 var RTK_VERSION = "1.0.1";
@@ -26382,7 +26504,7 @@ var HEADROOM_VERSION = "0.41.0";
 var CCUSAGE_VERSION = "20.0.36";
 var PLAYWRIGHT_MCP_VERSION = "0.0.83";
 var CONTEXT7_MCP_VERSION = "4.4.2";
-var APPS = [
+var CORE_APPS = [
   // ---- agent add-ons
   {
     id: "rtk",
@@ -27205,6 +27327,7 @@ var APPS = [
     cli: true
   }
 ];
+var APPS = [...CORE_APPS, ...GAMEDEV_APPS, ...MODDING_APPS, ...MOBILE_APPS];
 
 // src/core/schema/apps.ts
 var CATALOGUE_IDS = APPS.filter((a) => !a.setting).map((a) => a.id);
@@ -27343,6 +27466,185 @@ var GithubSchema = external_exports.strictObject({
   )
 });
 
+// src/shared/accounts/kinds.ts
+var AGENT_CAN_USE = "The agent in the sandbox can use this sign-in while it is there.";
+var ONE_PLACE = "It works in one sandbox at a time: a second sandbox starts without it while the first one runs.";
+var SERVICE_SPECS = {
+  epic: {
+    kind: "epic",
+    label: "Epic Games",
+    usedBy: ["unreal"],
+    sources: ["pc", "sandbox"],
+    singleHolder: true,
+    returns: true,
+    maxBytes: 64 * 1024,
+    warnings: [
+      AGENT_CAN_USE,
+      "A sign-in works in one place at a time: taking this PC's signs the launcher on this PC out the first time a sandbox uses it."
+    ],
+    fields: []
+  },
+  steam: {
+    kind: "steam",
+    label: "Steam (SteamCMD)",
+    usedBy: ["steam"],
+    sources: ["file", "sandbox"],
+    singleHolder: true,
+    returns: true,
+    maxBytes: 768 * 1024,
+    warnings: [
+      AGENT_CAN_USE + " It can upload builds and workshop items to your Steam apps.",
+      ONE_PLACE,
+      "No password is kept: sign in once with sbx-steam login in a sandbox (Steam Guard asks there)."
+    ],
+    fields: []
+  },
+  unity: {
+    kind: "unity",
+    label: "Unity",
+    usedBy: ["unity"],
+    sources: ["pc", "file", "typed", "sandbox"],
+    singleHolder: true,
+    returns: true,
+    maxBytes: 256 * 1024,
+    warnings: [
+      AGENT_CAN_USE,
+      ONE_PLACE,
+      "A Pro seat is handed back when the sandbox stops cleanly; a sandbox closed abruptly may keep it until you return it."
+    ],
+    fields: [
+      { name: "email", label: "Unity ID email", secret: false, optional: true },
+      { name: "password", label: "Unity ID password", secret: true, optional: true },
+      { name: "serial", label: "Serial (Plus or Pro; empty for Personal)", secret: true, optional: true }
+    ]
+  },
+  cfx: {
+    kind: "cfx",
+    label: "Cfx.re (FiveM / RedM server key)",
+    usedBy: ["fivem"],
+    sources: ["typed"],
+    singleHolder: false,
+    returns: false,
+    maxBytes: 4 * 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: "steamWebApiKey",
+        label: "Steam Web API key (optional)",
+        secret: true,
+        optional: true,
+        pattern: /^[A-F0-9]{32}$/
+      }
+    ]
+  },
+  keystore: {
+    kind: "keystore",
+    label: "Android upload keystore",
+    usedBy: ["android"],
+    sources: ["file"],
+    singleHolder: false,
+    returns: false,
+    maxBytes: 512 * 1024,
+    warnings: [AGENT_CAN_USE + " It can sign app updates as you; keep a backup of the keystore elsewhere."],
+    fields: [
+      { name: "storePassword", label: "Keystore password", secret: true },
+      { name: "keyAlias", label: "Key alias", secret: false },
+      { name: "keyPassword", label: "Key password", secret: true }
+    ]
+  },
+  play: {
+    kind: "play",
+    label: "Google Play (service account)",
+    usedBy: ["android"],
+    sources: ["file"],
+    singleHolder: false,
+    returns: false,
+    maxBytes: 128 * 1024,
+    warnings: [AGENT_CAN_USE + " It can publish to Google Play with what the service account is allowed."],
+    fields: []
+  },
+  expo: {
+    kind: "expo",
+    label: "Expo (EAS)",
+    usedBy: ["reactNative"],
+    sources: ["typed"],
+    singleHolder: false,
+    returns: false,
+    maxBytes: 4 * 1024,
+    warnings: [AGENT_CAN_USE + " It can start EAS builds and submissions on your Expo account."],
+    fields: [{ name: "token", label: "Expo access token", secret: true }]
+  },
+  appstore: {
+    kind: "appstore",
+    label: "App Store Connect API key",
+    usedBy: ["reactNative", "flutter"],
+    sources: ["file", "typed"],
+    singleHolder: false,
+    returns: false,
+    maxBytes: 16 * 1024,
+    warnings: [AGENT_CAN_USE + " It can upload and submit apps with what the key is allowed."],
+    fields: [
+      { name: "issuerId", label: "Issuer ID", secret: false },
+      { name: "keyId", label: "Key ID", secret: false, pattern: /^[A-Z0-9]{10}$/ }
+    ]
+  }
+};
+
+// src/core/schema/accounts.ts
+function share(kind, how) {
+  const spec = SERVICE_SPECS[kind];
+  return external_exports.strictObject({
+    share: external_exports.boolean().describe(
+      "Hand your saved " + spec.label + " sign-in to sandboxes that use " + spec.usedBy.join(" or ") + " (" + how + "). Kept encrypted on this PC; " + spec.warnings.join(" ") + " Yours only: a project file can only turn it off."
+    )
+  });
+}
+var AccountsSchema = external_exports.strictObject({
+  epic: share("epic", "sign in to the launcher once in a sandbox, or take this PC's: sandbox account import epic"),
+  steam: share(
+    "steam",
+    "sign in once with sbx-steam login, or: sandbox account import steam --from <steamcmd folder>"
+  ),
+  unity: share("unity", "sign in once in a sandbox, or take this PC's licence: sandbox account import unity"),
+  cfx: share("cfx", "sandbox account login cfx"),
+  keystore: share("keystore", "sandbox account import keystore --from <upload.jks>"),
+  play: share("play", "sandbox account import play --from <service-account.json>"),
+  expo: share("expo", "sandbox account login expo"),
+  appstore: share("appstore", "sandbox account import appstore --from <AuthKey.p8>")
+}).describe(
+  "Service sign-ins for sandboxes (game stores, engines, app signing). Manage them in Accounts: sandbox account status."
+);
+
+// src/core/schema/pc-installs.ts
+var pick2 = (item, what, example) => external_exports.union([external_exports.boolean(), external_exports.array(item)]).describe(
+  what + " of this PC, read-only in the sandbox under C:\\PcInstalls: true = all of them, false = none, or a list (e.g. " + example + "). The agent can read their files."
+);
+var PcInstallsSchema = external_exports.strictObject({
+  steamGames: pick2(
+    external_exports.number().int().positive(),
+    "Steam games (true maps each library; a list of app IDs maps only those games)",
+    "[480, 730]"
+  ),
+  epicGames: pick2(
+    external_exports.string().regex(/^[A-Za-z0-9._-]{1,100}$/),
+    "Epic Games Launcher games (by their app name)",
+    '["Fortnite"]'
+  ),
+  unrealEngines: pick2(
+    external_exports.string().regex(/^(UE_)?\d+\.\d+$/),
+    "Unreal Engine versions installed with the Epic Games Launcher",
+    '["5.4"]'
+  ),
+  unityEditors: pick2(
+    external_exports.string().regex(/^\d+\.\d+\.\d+[abfp]\d+$/),
+    "Unity editors installed with Unity Hub",
+    '["6000.0.32f1"]'
+  )
+}).describe(
+  "Games, engines and editors installed on this PC, mapped read-only into sandboxes (no copy, no room on the sandbox's disk)."
+);
+
 // src/core/schema/config.ts
 var RESERVED_ENV_PREFIX = /^(AGENT_|GIT_|GH_|GITHUB_|NODE_|NPM_CONFIG_(USERCONFIG|GLOBALCONFIG|PREFIX|SCRIPT_SHELL)|SSL_|CLAUDE|ANTHROPIC_|OPENAI_|CODEX_|GEMINI_|GOOGLE_|COPILOT_|AWS_|AZURE_)/i;
 var RESERVED_ENV_SUFFIX = /(_PROXY|_BASE_URL|_ENDPOINT|_CA_BUNDLE|_CA_CERTS)$/i;
@@ -27404,6 +27706,8 @@ var ConfigSchema = external_exports.strictObject({
   network: NetworkSchema,
   vpn: VpnSchema,
   github: GithubSchema,
+  accounts: AccountsSchema,
+  pcInstalls: PcInstallsSchema,
   provisioning: ProvisioningSchema,
   downloads: DownloadsSchema,
   toolchains: ToolchainsSchema,
@@ -27456,6 +27760,8 @@ var LocalOverridesSchema = external_exports.strictObject({
   network: NetworkSchema.pick({ blockPrivateRanges: true, blockHosts: true }).partial(),
   // A project may turn the kill switch on, never off, and never choose a VPN, a server, a file or a login.
   vpn: VpnSchema.pick({ killSwitch: true }).partial(),
+  // A project may only turn a sign-in off (policy: OFF_IS_SAFER); pcInstalls is never here (folders of this PC).
+  accounts: external_exports.strictObject(import_lodash.default.mapValues(AccountsSchema.shape, (shape) => shape.partial())).partial(),
   provisioning: ProvisioningSchema.pick({ copyFromHost: true, fallbackToInstall: true, refresh: true }).extend({ git: GitSchema.partial(), terminal: toggle("Windows Terminal as the sandbox window.").partial() }).partial(),
   downloads: DownloadsSchema.partial(),
   // Every toolchain setting, each one optional (a project usually only switches languages on or pins a version).
@@ -27983,7 +28289,7 @@ var Downloader = class {
    */
   async file(url2, destination, expected = null) {
     const sums = typeof expected === "string" || expected === null ? { sha256: expected } : expected;
-    if (this.requireChecksum && !sums.sha256?.trim() && !sums.sha512?.trim()) {
+    if (this.requireChecksum && !sums.sha256?.trim() && !sums.sha512?.trim() && !sums.sha1?.trim() && !sums.verify) {
       throw new Error(
         "Refusing to download " + path8.basename(destination) + " (" + url2 + "): no checksum is published for it, and downloads.requireChecksum is on. Turn that setting off to allow downloads that cannot be verified."
       );
@@ -27991,7 +28297,7 @@ var Downloader = class {
     const response = await fetchRetry(url2, {}, 3, 20 * 60 * 1e3);
     if (!response.body) throw new Error("Empty response for " + url2);
     fs7.mkdirSync(path8.dirname(destination), { recursive: true });
-    const checks = ["sha256", "sha512"].flatMap((kind) => {
+    const checks = ["sha256", "sha512", "sha1"].flatMap((kind) => {
       const want = sums[kind]?.trim().toLowerCase();
       return want ? [{ want, hash: crypto2.createHash(kind) }] : [];
     });
@@ -28022,6 +28328,7 @@ var Downloader = class {
     try {
       await pipeline(Readable.fromWeb(response.body), tap, fs7.createWriteStream(partial2));
       if (checks.some((c) => c.hash.digest("hex") !== c.want)) throw new Error("Checksum mismatch for " + url2);
+      if (sums.verify) await sums.verify(partial2);
       fs7.rmSync(destination, { force: true });
       fs7.renameSync(partial2, destination);
     } finally {
@@ -28036,7 +28343,12 @@ var Downloader = class {
     const work = stagingFolder(destination);
     try {
       const archive = path8.join(work, options.fileName ?? path8.basename(new URL(url2).pathname));
-      await this.file(url2, archive, { sha256: options.sha256, sha512: options.sha512 });
+      await this.file(url2, archive, {
+        sha256: options.sha256,
+        sha512: options.sha512,
+        sha1: options.sha1,
+        ...options.verify ? { verify: options.verify } : {}
+      });
       const extracted = path8.join(work, "x");
       await extractArchive(archive, extracted, options.members);
       let root = extracted;

package/dist/selftest/accounts.test.js

@@ -2,9 +2,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { AccountStore } from '../host/profile/index.js';
+import { SecretStore } from '../host/secrets/secret-store.js';
 import { DEFAULTS } from '../core/config/index.js';
-import { defaultAccount } from '../app/features/accounts/index.js';
+import { accountsPage, accountsText, agentPage, defaultAccount } from '../app/features/accounts/index.js';
+import { fakeIO } from '../app/kernel/index.js';
+import { runDefinition } from '../app/registry.js';
+import { buildProgram, parseCli } from '../cli/args.js';
 import { MenuOperations } from '../cli/menu/io-menu.js';
+import { menuView } from '../cli/menu/render-view.js';
+import { cliInput, definitionFor } from '../cli/operations/index.js';
+import { AccountsService } from '../cli/services/index.js';
 export const accountsSuite = {
     name: 'accounts',
     title: 'Claude accounts (save, switch, remove, safe names)',
@@ -101,6 +108,7 @@ export const accountsSuite = {
         const plugR = path.join(storage, 'data', 'p5', 'state', 'claude');
         on.syncPlugins(dataP('p5'));
         t.check(fs.existsSync(path.join(plugR, 'plugins', 'cache', 'new.js')), 'launch-time refresh: plugins installed in one data set reach the shared set and the next empty data set');
+        await apiKeyAccounts(t, f);
         t.section('removing and refusing');
         new AccountStore(storage).setDefault('work');
         new AccountStore(storage).remove('work');
@@ -114,3 +122,166 @@ export const accountsSuite = {
         await t.throws(() => new AccountStore(t.at('acct-storage')).save(otherData, 'con', fromHost), 'Invalid account name', 'an account cannot be named after a device (it would open a device)');
     },
 };
+// Made-up keys with the shape of real ones (sk-ant-api03-...), each with its own last four characters.
+const CONSOLE_KEY = 'sk-ant-api03-' + 'c'.repeat(80) + '-Cons';
+const TYPED_KEY = 'sk-ant-api03-' + 't'.repeat(80) + '_Type';
+const ENV_KEY = 'sk-ant-api03-' + 'e'.repeat(80) + '-Envy';
+/** Every file below `root` whose text holds `needle` (relative paths). */
+function filesHolding(root, needle) {
+    if (!fs.existsSync(root))
+        return [];
+    return fs
+        .readdirSync(root, { recursive: true, withFileTypes: true })
+        .filter((d) => d.isFile())
+        .map((d) => path.join(d.parentPath, d.name))
+        .filter((file) => fs.readFileSync(file, 'latin1').includes(needle))
+        .map((file) => path.relative(root, file).replace(/\\/g, '/'));
+}
+/** API key accounts: a Console login or a key, saved from the sandbox, this PC or typed, and switched to and back. */
+async function apiKeyAccounts(t, f) {
+    t.section('API key accounts: saving');
+    const storage = t.at('key-storage');
+    const data = path.join(storage, 'data', 'k');
+    const claude = path.join(data, 'state', 'claude');
+    const store = new AccountStore(storage, false, SecretStore.memory());
+    t.write(path.join(claude, '.credentials.json'), '{"claudeAiOauth":{"refreshToken":"sub-1"},"mcpOAuth":{"m":1}}');
+    t.write(path.join(claude, '.claude.json'), '{"oauthAccount":{"emailAddress":"me@sub"},"other":1}');
+    store.save(data, 'sub', null);
+    // A Console login inside the sandbox: Claude keeps the key it made in .claude.json, no claudeAiOauth.
+    t.write(path.join(claude, '.credentials.json'), '{"mcpOAuth":{"m":1}}');
+    t.writeJson(path.join(claude, '.claude.json'), {
+        oauthAccount: { emailAddress: 'me@console' },
+        primaryApiKey: CONSOLE_KEY,
+        customApiKeyResponses: { approved: [CONSOLE_KEY.slice(-20)], rejected: [] },
+        other: 1,
+    });
+    const consoleSaved = store.save(data, 'console', null);
+    const consoleFile = fs.readFileSync(path.join(storage, 'accounts', 'console.json'), 'utf8');
+    t.check(consoleSaved.kind === 'console' &&
+        consoleSaved.email === 'me@console' &&
+        consoleSaved.keyHint === 'sk-ant-...Cons' &&
+        !consoleFile.includes(CONSOLE_KEY) &&
+        consoleFile.includes('sk-ant-...Cons') &&
+        store.activeFor(data) === 'console', "the sandbox's Console login is saved as a Console account: sealed, with only sk-ant-...last4 readable", consoleFile);
+    const typed = store.saveApiKey(data, 'typed', '  ' + TYPED_KEY + '\n');
+    t.check(typed.kind === 'api-key' && typed.keyHint === 'sk-ant-...Type' && store.activeFor(data) === 'console', 'a typed key is saved as an API key account (trimmed); it is not active until used');
+    for (const [bad, why] of [
+        ['hello', 'a word'],
+        ['sk-ant-oat01-' + 'x'.repeat(60), 'a subscription token'],
+        ['sk-ant-admin01-' + 'x'.repeat(60), 'an Admin key'],
+        ['sk-ant-api03-short', 'a short key'],
+        ['sk-ant-api03-' + 'x'.repeat(60) + '\u001b[31m', 'a key with control characters'],
+    ]) {
+        const message = await t.thrownMessage(() => store.saveApiKey(data, 'bad', bad));
+        t.check(message.includes('not an Anthropic API key') && !message.includes(bad.length > 13 ? bad.slice(13) : bad), 'a key with the wrong shape is refused without being quoted: ' + why, message);
+    }
+    // This PC: a Console key in its .claude.json, else ANTHROPIC_API_KEY; --api-key skips a subscription.
+    const pc = t.dir('key-pc', 'claude');
+    const pcState = t.at('key-pc', '.claude.json');
+    t.write(path.join(pc, '.credentials.json'), '{"claudeAiOauth":{"refreshToken":"pc-sub"}}');
+    t.write(pcState, '{"oauthAccount":{"emailAddress":"me@pc"}}');
+    const pcFiles = { claudeDir: pc, globalStateFile: pcState };
+    t.equal(store.save(data, 'pc-sub', pcFiles, { envKey: ENV_KEY }).kind, 'subscription', 'PC: a subscription first');
+    const pcKey = store.save(data, 'pc-env', pcFiles, { keyOnly: true, envKey: ENV_KEY });
+    t.check(pcKey.kind === 'api-key' && pcKey.email === null && store.read('pc-env')?.apiKey === ENV_KEY, "PC --api-key: this PC's ANTHROPIC_API_KEY is saved (its subscription is skipped)");
+    t.writeJson(pcState, { oauthAccount: { emailAddress: 'me@pc-console' }, primaryApiKey: CONSOLE_KEY });
+    t.equal(store.save(data, 'pc-console', pcFiles, { keyOnly: true, envKey: ENV_KEY }).kind, 'console', "PC --api-key: this PC's Console login comes before ANTHROPIC_API_KEY");
+    await t.throws(() => store.save(data, 'none', { claudeDir: t.dir('key-empty'), globalStateFile: t.at('key-empty', 'x.json') }, { keyOnly: true }), 'No Claude API key found', 'no key anywhere: says so (and how to type one)');
+    // The sandbox is hostile: a planted primaryApiKey that is not a key is never saved.
+    const hostileData = path.join(storage, 'data', 'h');
+    const hostile = path.join(hostileData, 'state', 'claude');
+    t.writeJson(path.join(hostile, '.claude.json'), {
+        primaryApiKey: 'sk-ant-api03-' + 'x'.repeat(40) + '\u001b]52;c;evil\u0007',
+    });
+    await t.throws(() => store.save(hostileData, 'hostile', null), 'No Claude login found', 'a primaryApiKey from the sandbox without the shape of a key is refused');
+    t.section('API key accounts: switching and back');
+    t.write(path.join(claude, '.credentials.json'), '{"claudeAiOauth":{"refreshToken":"console-made"},"mcpOAuth":{"m":2}}');
+    store.activate(data, 'sub');
+    const subState = f.readJson(path.join(claude, '.claude.json'));
+    const subCreds = f.readJson(path.join(claude, '.credentials.json'));
+    t.check(!('primaryApiKey' in subState) &&
+        !subState.customApiKeyResponses.approved.includes(CONSOLE_KEY.slice(-20)) &&
+        subState.oauthAccount.emailAddress === 'me@sub' &&
+        subState.other === 1 &&
+        subCreds.claudeAiOauth.refreshToken === 'sub-1', 'back to a subscription: the key and its approval leave the sandbox, the subscription is in again', JSON.stringify(subState));
+    t.check(store.read('console')?.kind === 'console' && store.read('console')?.apiKey === CONSOLE_KEY, 'a key account is never overwritten with what the sandbox holds when switching away from it');
+    t.write(path.join(claude, '.credentials.json'), '{"claudeAiOauth":{"refreshToken":"sub-2"},"mcpOAuth":{"m":3}}');
+    store.activate(data, 'typed');
+    const keyStateNow = f.readJson(path.join(claude, '.claude.json'));
+    const keyCreds = f.readJson(path.join(claude, '.credentials.json'));
+    t.check(keyStateNow.primaryApiKey === TYPED_KEY &&
+        keyStateNow.customApiKeyResponses.approved.includes(TYPED_KEY.slice(-20)) &&
+        !keyStateNow.customApiKeyResponses.rejected.includes(TYPED_KEY.slice(-20)) &&
+        !('oauthAccount' in keyStateNow) &&
+        keyStateNow.other === 1 &&
+        !('claudeAiOauth' in keyCreds) &&
+        keyCreds.mcpOAuth.m === 3, 'to an API key: the key goes where a Console login keeps it, pre-approved (no prompt); the subscription leaves, MCP logins stay', JSON.stringify({ keyStateNow, keyCreds }));
+    t.includes(JSON.stringify(store.read('sub')?.credentials), 'sub-2', "the outgoing subscription's refreshed tokens are still saved back");
+    t.equal(filesHolding(storage, TYPED_KEY), ['data/k/state/claude/.claude.json'], "the key is in the sandbox's Claude state only: not in the account files, the index, run\\ or logs");
+    store.activate(data, 'console');
+    const consoleState = f.readJson(path.join(claude, '.claude.json'));
+    t.check(consoleState.primaryApiKey === CONSOLE_KEY &&
+        !consoleState.customApiKeyResponses.approved.includes(TYPED_KEY.slice(-20)) &&
+        consoleState.oauthAccount.emailAddress === 'me@console' &&
+        fs.existsSync(path.join(claude, '.credentials.json')), 'key to key: the new key replaces the old one and its approval; the Console account brings its e-mail');
+    t.section('API key accounts: listing, renaming, removing');
+    const rows = store.list(data);
+    const kindOf = (n) => rows.find((r) => r.name === n)?.kind;
+    t.check(kindOf('sub') === 'subscription' && kindOf('console') === 'console' && kindOf('typed') === 'api-key', 'list says the kind of every Claude account');
+    const text = accountsText({
+        agent: 'claude',
+        agents: [{ name: 'claude', kept: true, canSavePc: true, accounts: rows }],
+        services: [],
+    });
+    t.check(text.includes('KIND') &&
+        text.includes('API key sk-ant-...Type') &&
+        text.includes('Console sk-ant-...Cons') &&
+        text.includes('subscription') &&
+        ![TYPED_KEY, CONSOLE_KEY, ENV_KEY].some((k) => text.includes(k.slice(13, 40))), 'the command line table shows the kind and sk-ant-...last4, never the key', text);
+    const claudeRows = { name: 'claude', kept: true, canSavePc: true, accounts: rows };
+    const menu = menuView(agentPage(claudeRows), { category: 'claude', refresh: false });
+    const page = JSON.stringify(accountsPage({ agent: 'claude', agents: [claudeRows], services: [] }));
+    t.check(menu.actions.some((a) => a.key === 'k') &&
+        page.includes('+ Save an API key') &&
+        page.includes('"API key"') &&
+        page.includes('Console sk-ant-...Cons') &&
+        !page.includes(TYPED_KEY.slice(13, 40)), 'menu and web: a Save an API key row (k), and each login says its kind');
+    store.rename('typed', 'free');
+    t.check(store.read('free')?.apiKey === TYPED_KEY && store.meta('free')?.kind === 'api-key' && store.meta('typed') === null, 'rename keeps the key and its kind');
+    store.remove('free');
+    t.equal(filesHolding(path.join(storage, 'accounts'), 'sk-ant-...Type'), [], 'remove deletes the key account');
+    t.section('API key accounts: the operation and the command line');
+    const ctx = {
+        packageRoot: t.dir('key-op', 'package'),
+        options: {},
+        loaded: { config: structuredClone(DEFAULTS), configPath: null, base: t.temp },
+        storageRoot: t.dir('key-op', 'storage'),
+        dataPath: t.dir('key-op', 'storage', 'data', 'o'),
+    };
+    const asked = fakeIO(['sk-ant-api03-nope', TYPED_KEY]);
+    const out = (await runDefinition('accounts.save', ctx, { agent: 'claude', name: 'typed', apiKey: true }, asked.io));
+    const said = JSON.stringify([out, asked.seen]);
+    t.check(asked.seen.questions.length === 2 &&
+        asked.seen.questions.every((q) => q.kind === 'secret') &&
+        asked.seen.questions[1].problem?.includes('sk-ant-api') === true &&
+        out.message === 'Saved account "typed" (API key sk-ant-...Type).' &&
+        !said.includes(TYPED_KEY.slice(13)), 'save --api-key asks for the key hidden, asks again on a bad one, and says only sk-ant-...last4', said);
+    await t.throws(() => runDefinition('accounts.save', ctx, { agent: 'codex', name: 'x', apiKey: true }, fakeIO([]).io), 'for Claude accounts only', 'save --api-key is refused for another agent');
+    t.write(t.at('key-op', 'pc', '.credentials.json'), '{"claudeAiOauth":{"refreshToken":"pc"}}');
+    ctx.loaded.config.claudeProfile.hostDir = t.at('key-op', 'pc');
+    ctx.loaded.config.claudeProfile.globalStateFile = t.at('key-op', 'pc', '.claude.json');
+    const pcSaved = new AccountsService(ctx, { ANTHROPIC_API_KEY: ENV_KEY }).save('pc-key', true, 'claude', true);
+    t.check(pcSaved.kind === 'api-key' && pcSaved.keyHint === 'sk-ant-...Envy', "save --from-host --api-key takes this PC's ANTHROPIC_API_KEY");
+    const used = (await runDefinition('accounts.use', ctx, { agent: 'claude', name: 'pc-key', noRestart: true }, fakeIO([]).io));
+    t.check(used.lines[0] === 'Sandbox now uses "pc-key" (API key sk-ant-...Envy).' &&
+        f.readJson(path.join(ctx.dataPath, 'state', 'claude', '.claude.json')).primaryApiKey === ENV_KEY, 'use switches the sandbox to the key and says which kind it is', used.lines.join('\n'));
+    const save = definitionFor('account', ['save']);
+    const help = buildProgram(() => undefined)
+        .commands.find((c) => c.name() === 'account')
+        .helpInformation();
+    t.check(JSON.stringify(cliInput(save, parseCli(['account', 'save', 'free', '--api-key']))) ===
+        JSON.stringify({ name: 'free', apiKey: true }) &&
+        JSON.stringify(cliInput(save, parseCli(['account', 'save', 'free', '--api-key', '--from-host']))) ===
+            JSON.stringify({ name: 'free', fromHost: true, apiKey: true }) &&
+        help.includes('--api-key'), 'command line: sandbox account save <name> --api-key [--from-host], shown in --help', help);
+}

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

@@ -55,6 +55,7 @@ export const agentPathsSuite = {
             'C:\\AgentData\\state\\codex\\.sandbox-secrets',
             'C:\\AgentData\\state\\codex\\.sandbox\\setup_marker.json',
             'C:\\AgentData\\state\\codex\\.sandbox\\deny_read_acl_state.json',
+            'C:\\AgentData\\state\\codex\\tmp\\arg0',
         ], "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');

package/dist/selftest/android.test.d.ts

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