windows-development-sandbox 1.18.4 → 1.23.0

package/README.md

@@ -65,6 +65,7 @@ The first start downloads what the project needs (a few minutes, once). Later st
 | **Several projects**      | `sandbox claude` from another project joins the running sandbox, with that project's own folder, tools, versions, databases and environment. Start several agents at once (`--session claude@A --session codex@B`, or the menu) and attach to any of them from any terminal.                                                                                  |
 | **Pick up again**         | After a crash or restart, `sandbox resume` reopens the last sessions. `sandbox restart` restarts the agents in place, and they continue their conversations.                                                                                                                                                                                                  |
 | **Leaves nothing behind** | When an agent's session ends, everything it started ends too, background servers included. Nothing of this tool keeps running on your PC once the sandbox is closed.                                                                                                                                                                                          |
+| **Agent commands**        | Turn them on (menu: Agents, or `sandbox agent-commands on`) and typing `claude`, `codex` ... in any folder starts that agent in a hidden sandbox and attaches your terminal. |
 | **GitHub, safely**        | Give sandboxes a fine-grained GitHub token made just for them (`sandbox github login`, `github.shareToken`). `gh` and `git push` then work inside, and the token is never written to the sandbox's files.                                                                                                                                                     |
 | **Feels like home**       | Your desktop look, Claude settings, MCP servers and conversation history come along, and history syncs back. Saved logins (`sandbox account`) are encrypted for your Windows user.                                                                                                                                                                            |
 
@@ -122,7 +123,6 @@ and keeps all its features.
 | Feature                                                | Status | What it does                                                                                                                                                                                                    |
 | ------------------------------------------------------ | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **Web UI** (`sandbox web`, `web.enabled`)              | Beta   | Agents, live terminals, status, apps, accounts and settings in your browser, with search (Ctrl+K). This PC only, signed in with a token; devices on your network if you allow them. [web-ui.md](docs/web-ui.md) |
-| **Agent commands** (`sandbox agent-commands on`)       | Beta   | Typing `claude`, `codex` ... in any folder starts that agent in a hidden sandbox and attaches your terminal.                                                                                                    |
 | **Contained storage** (`sandbox storage contained on`) | Beta   | Tools, logins and logs in one disk image, mounted only while a sandbox runs. One admin prompt per launch. [Details](docs/configuration.md#contained-storage-beta)                                               |
 | **VPN** (`sandbox vpn`, `vpn.enabled`)                 | Alpha  | The sandbox's traffic through NordVPN, your own OpenVPN profile or a WireGuard config, with a kill switch. A tunnel carrying traffic is not confirmed yet: read [vpn.md](docs/vpn.md) first.                    |
 | **HCS engine** (`sandbox.engine: hcs`)                 | Alpha  | Headless agents in a Hyper-V isolated Server Core container. `sandbox engine check hcs` shows what your PC lacks. Starting it is not enabled yet.                                                               |

package/config.example.json

@@ -68,6 +68,14 @@
   "github": {
     "shareToken": false
   },
+  "codex": {
+    "sandboxMode": "danger-full-access",
+    "approvalPolicy": "never",
+    "model": "",
+    "reasoningEffort": "default",
+    "windowsSandbox": "off",
+    "mcpLoginsInFile": true
+  },
   "accounts": {
     "epic": {
       "share": false
@@ -92,6 +100,12 @@
     },
     "appstore": {
       "share": false
+    },
+    "perplexity": {
+      "share": false
+    },
+    "comet": {
+      "share": false
     }
   },
   "pcInstalls": {
@@ -155,6 +169,7 @@
       "acceptLicense": false,
       "components": [],
       "keepInstallFiles": true,
+      "visualStudio": "full",
       "persistEngines": true,
       "derivedDataCache": "persisted"
     },
@@ -412,7 +427,8 @@
           "CODEX_HOME": "codex"
         },
         "loginFiles": [
-          "auth.json"
+          "auth.json",
+          ".credentials.json"
         ],
         "hostDir": "~/.codex"
       },

package/dist/app/features/access/access.def.js

@@ -3,7 +3,7 @@
 // page; access.run.ts does the work. Everything here is the owner's: a device or another Windows user never manages
 // access, whatever their role.
 import { z } from 'zod';
-import { action, defineOperation, defineQuery, defineView, fieldOf } from '../../kernel/index.js';
+import { action, defineOperation, defineQuery, defineView, fieldOf, link, } from '../../kernel/index.js';
 const RoleSchema = z.enum(['view', 'control']);
 export const DeviceRowSchema = z.object({
     id: z.string().describe('Its id (for revoke)'),
@@ -253,11 +253,14 @@ export function accessPage(o, now = Date.now()) {
                         label: 'Windows sign-in',
                         value: o.windowsSignIn ? 'on' : 'off',
                         tone: o.windowsSignIn ? 'ok' : 'muted',
-                        description: 'They run sandbox remote (or sandbox remote --browser) as themselves. Turn on web.remote.windowsSignIn and list them in web.remote.users (Settings).',
+                        description: 'They sign in to the web UI with their own Windows account. Turn it on and list them in Settings (web.remote.windowsSignIn and web.remote.users).',
                     },
                     ...o.users.map((u, i) => ({ id: 'user-' + i, label: u.name, value: u.role })),
                 ],
                 items: windowsItems,
+                actions: [
+                    link({ kind: 'setting', key: 'web.remote.windowsSignIn' }, 'Windows sign-in setting…', { verb: 'settings' }),
+                ],
             },
         ],
         actions: [action(revokeAllAccess, {}, { key: 'X', verb: 'sign out all' })],

package/dist/app/features/access/access.run.js

@@ -3,7 +3,7 @@
 // remote settings, the firewall rule and the network check of LAN mode. The one-time code is returned once and only
 // its hash is kept.
 import { requireOnPc } from '../../../cli/commands/context.js';
-import { fail } from '../../../core/util/index.js';
+import { fail, failWith } from '../../../core/util/index.js';
 import { AccessStore, addRuleRequest, applyFirewall, chooseLanAddress, lanUrl, networkProblem, networkProfile, removeRuleRequest, showCode, } from '../../../host/remote/index.js';
 import { SecretStore } from '../../../host/secrets/index.js';
 import { protectPrivateFolder } from '../../../host/sharing/index.js';
@@ -68,7 +68,11 @@ export const accessStatusRun = implement(accessStatus, (ctx) => {
 export const allowDeviceRun = implement(allowDevice, (ctx, input) => {
     requireOnPc('web');
     if (!ctx.loaded.config.web.remote.lan.enabled)
-        fail('LAN mode is off, so no device on your network can reach the web UI.', 'Turn it on first: sandbox web lan-on');
+        failWith('LAN mode is off, so no device on your network can reach the web UI.', 'Turn it on first.', {
+            op: 'access.lanOn',
+            label: 'Turn on LAN mode',
+            cli: 'sandbox web lan-on',
+        });
     const { code, expiresAt } = accessStoreOf(ctx).newDeviceCode(input.role);
     const lan = lanStateOf(ctx);
     return { code: showCode(code), expiresAt, role: input.role, address: lan.url, fingerprint: lan.fingerprint };
@@ -76,7 +80,7 @@ export const allowDeviceRun = implement(allowDevice, (ctx, input) => {
 export const revokeAccessRun = implement(revokeAccess, (ctx, input) => {
     requireOnPc('web');
     if (!accessStoreOf(ctx).revoke(input.id))
-        fail('There is no device or sign-in ' + input.id + '.', 'See sandbox web devices.');
+        fail('There is no device or sign-in ' + input.id + '.', 'Check the list of devices and sign-ins.');
     return { message: 'Signed out. Its open pages close within half a minute.' };
 });
 export const revokeAllAccessRun = implement(revokeAllAccess, async (ctx, _input, io) => {

package/dist/app/features/accounts/accounts.def.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { type Page, type Section } from '../../kernel/index.js';
+import { type GithubStatus } from '../github/github.def.js';
 import { type ServicesList } from './services.def.js';
 export declare const AccountRowSchema: z.ZodObject<{
     name: z.ZodString;
@@ -70,10 +71,12 @@ export declare const AccountsListSchema: z.ZodObject<{
         summary: z.ZodNullable<z.ZodString>;
         heldBy: z.ZodNullable<z.ZodString>;
         usedBy: z.ZodArray<z.ZodString>;
+        usedFor: z.ZodString;
         warnings: z.ZodArray<z.ZodString>;
         canImport: z.ZodBoolean;
         canLogin: z.ZodBoolean;
         needsFile: z.ZodBoolean;
+        ready: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AccountsList = z.output<typeof AccountsListSchema>;
@@ -117,10 +120,12 @@ export declare const listAccounts: import("../../kernel/define.js").QueryDef<z.Z
         summary: z.ZodNullable<z.ZodString>;
         heldBy: z.ZodNullable<z.ZodString>;
         usedBy: z.ZodArray<z.ZodString>;
+        usedFor: z.ZodString;
         warnings: z.ZodArray<z.ZodString>;
         canImport: z.ZodBoolean;
         canLogin: z.ZodBoolean;
         needsFile: z.ZodBoolean;
+        ready: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>, "accounts.list">;
 export declare const saveAccount: import("../../kernel/define.js").OperationDef<z.ZodObject<{
@@ -162,7 +167,7 @@ export declare const removeAccount: import("../../kernel/define.js").OperationDe
 /** One agent's card: its save rows and logins (a card to pick from), or the note that its login is not kept. */
 export declare function agentSection(a: AgentAccounts): Section;
 /** The web's page: one card per agent (its logins and the save rows), then one section per service sign-in. */
-export declare function accountsPage(o: AccountsList, services?: ServicesList): Page;
+export declare function accountsPage(o: AccountsList, services?: ServicesList, github?: GithubStatus): Page;
 /**
  * One agent's page for the menu: its section, and the keys of its save rows (s, p) which the menu's key bar shows
  * while the agent's category is open. The keys of a login row (d, r, x) are on the row itself.
@@ -205,10 +210,12 @@ export declare const accountsView: import("../../kernel/define.js").ViewDef<{
             summary: z.ZodNullable<z.ZodString>;
             heldBy: z.ZodNullable<z.ZodString>;
             usedBy: z.ZodArray<z.ZodString>;
+            usedFor: z.ZodString;
             warnings: z.ZodArray<z.ZodString>;
             canImport: z.ZodBoolean;
             canLogin: z.ZodBoolean;
             needsFile: z.ZodBoolean;
+            ready: z.ZodBoolean;
         }, z.core.$strip>>;
     }, z.core.$strip>, "accounts.list">;
     services: import("../../kernel/define.js").QueryDef<z.ZodObject<{
@@ -228,10 +235,35 @@ export declare const accountsView: import("../../kernel/define.js").ViewDef<{
             summary: z.ZodNullable<z.ZodString>;
             heldBy: z.ZodNullable<z.ZodString>;
             usedBy: z.ZodArray<z.ZodString>;
+            usedFor: z.ZodString;
             warnings: z.ZodArray<z.ZodString>;
             canImport: z.ZodBoolean;
             canLogin: z.ZodBoolean;
             needsFile: z.ZodBoolean;
+            ready: z.ZodBoolean;
         }, z.core.$strip>>;
     }, z.core.$strip>, "accounts.services">;
+    github: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+        shareToken: z.ZodBoolean;
+        gitAccess: z.ZodEnum<{
+            readonly: "readonly";
+            none: "none";
+            full: "full";
+        }>;
+        token: z.ZodEnum<{
+            none: "none";
+            saved: "saved";
+            unreadable: "unreadable";
+        }>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            "fine-grained": "fine-grained";
+            classic: "classic";
+        }>>;
+        savedAt: z.ZodNullable<z.ZodString>;
+        login: z.ZodNullable<z.ZodString>;
+        expiresAt: z.ZodNullable<z.ZodString>;
+        repoCount: z.ZodNullable<z.ZodNumber>;
+        checkedAt: z.ZodNullable<z.ZodString>;
+        tokenUrl: z.ZodString;
+    }, z.core.$strip>, "github.status">;
 }, Record<string, never>, "accounts">;

package/dist/app/features/accounts/accounts.def.js

@@ -3,6 +3,7 @@
 // accounts.run.ts does the work over AccountsService.
 import { z } from 'zod';
 import { action, defineOperation, defineQuery, defineView, plural, } from '../../kernel/index.js';
+import { githubLogin, githubLogout, githubStatus, githubSection } from '../github/github.def.js';
 import { setSetting } from '../settings/settings.def.js';
 import { listServices, SERVICE_OPERATIONS, serviceSections, ServiceRowSchema, } from './services.def.js';
 const AgentSchema = z.string().default('claude').describe('whose login: an agent that keeps one (default: claude)');
@@ -279,8 +280,11 @@ export function agentSection(a) {
     };
 }
 /** The web's page: one card per agent (its logins and the save rows), then one section per service sign-in. */
-export function accountsPage(o, services = { services: o.services }) {
-    return { title: 'Accounts', sections: [...o.agents.map(agentSection), ...serviceSections(services)] };
+export function accountsPage(o, services = { services: o.services }, github) {
+    return {
+        title: 'Accounts',
+        sections: [...o.agents.map(agentSection), ...serviceSections(services), ...(github ? [githubSection(github)] : [])],
+    };
 }
 /**
  * One agent's page for the menu: its section, and the keys of its save rows (s, p) which the menu's key bar shows
@@ -306,7 +310,7 @@ export const accountsView = defineView({
     id: 'accounts',
     title: 'Accounts',
     summary: 'Logins saved on this PC for each agent (every launch starts with the default; "Use this login" switches now), and the service sign-ins sandboxes may get (Epic, Steam, Unity, signing keys ...).',
-    queries: { accounts: listAccounts, services: listServices },
+    queries: { accounts: listAccounts, services: listServices, github: githubStatus },
     operations: [
         saveAccount,
         useAccount,
@@ -314,7 +318,9 @@ export const accountsView = defineView({
         renameAccount,
         removeAccount,
         ...SERVICE_OPERATIONS,
+        githubLogin,
+        githubLogout,
         setSetting,
     ],
-    build: ({ accounts, services }) => accountsPage(accounts, services),
+    build: ({ accounts, services, github }) => accountsPage(accounts, services, github),
 });

package/dist/app/features/accounts/accounts.run.d.ts

@@ -35,10 +35,12 @@ export declare const listAccountsRun: import("../../kernel/define.js").Implement
         summary: import("zod").ZodNullable<import("zod").ZodString>;
         heldBy: import("zod").ZodNullable<import("zod").ZodString>;
         usedBy: import("zod").ZodArray<import("zod").ZodString>;
+        usedFor: import("zod").ZodString;
         warnings: import("zod").ZodArray<import("zod").ZodString>;
         canImport: import("zod").ZodBoolean;
         canLogin: import("zod").ZodBoolean;
         needsFile: import("zod").ZodBoolean;
+        ready: import("zod").ZodBoolean;
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "accounts.list">, import("../../../cli/commands/context.js").Context>;
 /** Asks for an API key (one hidden question). The validator answers with fixed texts only, never the key. */

package/dist/app/features/accounts/accounts.run.js

@@ -1,7 +1,7 @@
 // The accounts feature's work: the saved logins of each agent, and saving, using, defaulting, renaming and removing
 // them (through AccountsService). Talks only through io; prints nothing. Emails and the sandbox's own words go through
 // safeText. Logins are never read here: the store keeps them sealed, and outputs hold names, emails and dates only.
-import { fail, safeText } from '../../../core/util/index.js';
+import { fail, failWith, safeText } from '../../../core/util/index.js';
 import { AccountsService } from '../../../cli/services/index.js';
 import { AccountLeases, ServiceAccountStore } from '../../../host/accounts/index.js';
 import { SERVICE_KINDS } from '../../../shared/accounts/index.js';
@@ -48,7 +48,12 @@ async function accountName(io, service, verb, agent, given) {
     }
     const rows = service.list(agent);
     if (!rows.length)
-        fail('No saved accounts.', 'Sign in inside the sandbox, then run: sandbox account save <name>');
+        failWith('No saved accounts.', 'Sign in inside the sandbox, then save the login.', {
+            op: 'accounts.save',
+            input: { agent },
+            label: 'Save a login…',
+            cli: 'sandbox account save <name>',
+        });
     const picked = await io.choose({
         title: 'Which account?',
         choices: rows.map((a) => {

package/dist/app/features/accounts/services.def.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { type Page, type Section } from '../../kernel/index.js';
 /** The kinds, as the help says them (the self-test checks this against shared/accounts SERVICE_KINDS). */
-export declare const SERVICE_NAMES_TEXT = "epic, steam, unity, cfx, keystore, play, expo or appstore";
+export declare const SERVICE_NAMES_TEXT = "epic, steam, unity, cfx, keystore, play, expo, appstore, perplexity or comet";
 export declare const ServiceRowSchema: z.ZodObject<{
     kind: z.ZodString;
     label: z.ZodString;
@@ -16,10 +16,12 @@ export declare const ServiceRowSchema: z.ZodObject<{
     summary: z.ZodNullable<z.ZodString>;
     heldBy: z.ZodNullable<z.ZodString>;
     usedBy: z.ZodArray<z.ZodString>;
+    usedFor: z.ZodString;
     warnings: z.ZodArray<z.ZodString>;
     canImport: z.ZodBoolean;
     canLogin: z.ZodBoolean;
     needsFile: z.ZodBoolean;
+    ready: z.ZodBoolean;
 }, z.core.$strip>;
 export type ServiceRow = z.output<typeof ServiceRowSchema>;
 export declare const ServicesListSchema: z.ZodObject<{
@@ -37,10 +39,12 @@ export declare const ServicesListSchema: z.ZodObject<{
         summary: z.ZodNullable<z.ZodString>;
         heldBy: z.ZodNullable<z.ZodString>;
         usedBy: z.ZodArray<z.ZodString>;
+        usedFor: z.ZodString;
         warnings: z.ZodArray<z.ZodString>;
         canImport: z.ZodBoolean;
         canLogin: z.ZodBoolean;
         needsFile: z.ZodBoolean;
+        ready: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ServicesList = z.output<typeof ServicesListSchema>;
@@ -63,10 +67,12 @@ export declare const listServices: import("../../kernel/define.js").QueryDef<z.Z
         summary: z.ZodNullable<z.ZodString>;
         heldBy: z.ZodNullable<z.ZodString>;
         usedBy: z.ZodArray<z.ZodString>;
+        usedFor: z.ZodString;
         warnings: z.ZodArray<z.ZodString>;
         canImport: z.ZodBoolean;
         canLogin: z.ZodBoolean;
         needsFile: z.ZodBoolean;
+        ready: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>, "accounts.services">;
 export declare const serviceImport: import("../../kernel/define.js").OperationDef<z.ZodObject<{

package/dist/app/features/accounts/services.def.js

@@ -1,13 +1,14 @@
-// Service sign-ins for sandboxes (accounts.<kind>.share): Epic, Steam, Unity, Cfx.re, signing keys and app-store
-// keys. Whether each one is shared and saved (where it came from and when, never its value), taking one from this PC
-// or a file, typing one, and forgetting it. Pure: schemas, labels and page builders; services.run.ts does the work.
-// The kinds live in shared/accounts (a def imports no shared code): the query's rows carry everything a page shows.
+// Service sign-ins for sandboxes (accounts.<kind>.share): Epic, Steam, Unity, Cfx.re, signing keys, app-store keys
+// and Perplexity (its API key, Comet's sign-in). Whether each one is shared and saved (where it came from and when,
+// never its value), taking one from this PC or a file, typing one, and forgetting it. Pure: schemas, labels and page
+// builders; services.run.ts does the work. The kinds live in shared/accounts (a def imports no shared code): the
+// query's rows carry everything a page shows.
 import { z } from 'zod';
 import { action } from '../../kernel/index.js';
 import { defineOperation, defineQuery } from '../../kernel/index.js';
 import { setSetting } from '../settings/settings.def.js';
 /** The kinds, as the help says them (the self-test checks this against shared/accounts SERVICE_KINDS). */
-export const SERVICE_NAMES_TEXT = 'epic, steam, unity, cfx, keystore, play, expo or appstore';
+export const SERVICE_NAMES_TEXT = 'epic, steam, unity, cfx, keystore, play, expo, appstore, perplexity or comet';
 const KindSchema = z
     .string()
     .max(40)
@@ -22,11 +23,13 @@ export const ServiceRowSchema = z.object({
     savedAt: z.string().nullable().describe('When it was saved'),
     summary: z.string().nullable().describe('Which account (never the secret)'),
     heldBy: z.string().nullable().describe('The data set whose sandbox holds it now (one-holder services)'),
-    usedBy: z.array(z.string()).describe('The toolchains it is handed over for'),
+    usedBy: z.array(z.string()).describe('The toolchains (or apps) it is handed over for'),
+    usedFor: z.string().describe('The same, in words ("unreal", "the Comet app")'),
     warnings: z.array(z.string()).describe('What everyone who shares it must know'),
     canImport: z.boolean().describe('It can be taken from this PC or a file (sandbox account import)'),
     canLogin: z.boolean().describe('It can be typed (sandbox account login)'),
     needsFile: z.boolean().describe('Importing it needs --from <file>'),
+    ready: z.boolean().describe('Its sign-in is written; false: the menu and the web leave it out (the CLI says coming)'),
 });
 export const ServicesListSchema = z.object({ services: z.array(ServiceRowSchema) });
 const STATE_TEXT = {
@@ -55,7 +58,8 @@ export function servicesText(o) {
             s.share ? 'on' : 'off',
             STATE_TEXT[s.state],
             day(s.savedAt) || '-',
-            [s.summary, s.heldBy ? 'in use by sandbox ' + s.heldBy : null].filter(Boolean).join(', ') || '-',
+            [s.ready ? s.summary : 'coming', s.heldBy ? 'in use by sandbox ' + s.heldBy : null].filter(Boolean).join(', ') ||
+                '-',
         ]),
     ];
     const widths = table[0].map((_, i) => Math.max(...table.map((r) => r[i].length)));
@@ -125,13 +129,12 @@ function serviceActions(s) {
             : []),
     ];
 }
-/** How to get a first sign-in, in words. */
+/** How to get a first sign-in, in words (the actions below do it). */
 function howTo(s) {
-    const ways = [
-        ...(s.canImport ? ['sandbox account import ' + s.kind + (s.needsFile ? ' --from <file>' : '')] : []),
-        ...(s.canLogin ? ['sandbox account login ' + s.kind] : []),
-    ];
-    return ways.length ? ways.join(', or ') : 'sign in once inside a sandbox';
+    const ways = [...(s.canImport ? ['import it'] : []), ...(s.canLogin ? ['type it in'] : [])];
+    return ways.length
+        ? ways.join(' or ')
+        : "sign in once inside a sandbox (it can't be copied from this PC: Windows locks it to your PC account)";
 }
 /** One service's section: its facts, its warnings and its actions. */
 export function serviceSection(s) {
@@ -139,9 +142,9 @@ export function serviceSection(s) {
         {
             id: s.kind + ':share',
             label: 'Shared with sandboxes',
-            value: s.share ? 'on' : 'off  (sandbox config set accounts.' + s.kind + '.share true)',
+            value: s.share ? 'on' : 'off',
             tone: s.share ? 'ok' : 'muted',
-            description: 'For sandboxes that use ' + s.usedBy.join(' or ') + '. ' + s.warnings.join(' '),
+            description: 'For sandboxes that use ' + s.usedFor + '. ' + s.warnings.join(' '),
         },
         {
             id: s.kind + ':state',
@@ -179,7 +182,7 @@ export function serviceSection(s) {
 }
 /** The sections of every service (appended to the accounts page on the web). */
 export function serviceSections(o) {
-    return o.services.map(serviceSection);
+    return o.services.filter((s) => s.ready).map(serviceSection);
 }
 /** One service's page for the menu: its section, and its actions as keys. */
 export function servicePage(s) {

package/dist/app/features/accounts/services.run.d.ts

@@ -40,10 +40,12 @@ export declare const listServicesRun: import("../../kernel/define.js").Implement
         summary: import("zod").ZodNullable<import("zod").ZodString>;
         heldBy: import("zod").ZodNullable<import("zod").ZodString>;
         usedBy: import("zod").ZodArray<import("zod").ZodString>;
+        usedFor: import("zod").ZodString;
         warnings: import("zod").ZodArray<import("zod").ZodString>;
         canImport: import("zod").ZodBoolean;
         canLogin: import("zod").ZodBoolean;
         needsFile: import("zod").ZodBoolean;
+        ready: import("zod").ZodBoolean;
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "accounts.services">, import("../../../cli/commands/context.js").Context>;
 export declare const serviceImportRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{

package/dist/app/features/accounts/services.run.js

@@ -4,12 +4,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { requireOnPc } from '../../../cli/commands/context.js';
-import { fail, safeText } from '../../../core/util/index.js';
+import { fail, failWith, safeText } from '../../../core/util/index.js';
 import { AccountLeases, forgetEverywhere, HOST_SOURCES, pcEnv, ServiceAccountStore, } from '../../../host/accounts/index.js';
-import { isServiceKind, SERVICE_KINDS, SERVICE_SPECS, } from '../../../shared/accounts/index.js';
+import { isServiceKind, SERVICE_KINDS, SERVICE_SPECS, usedByText, } from '../../../shared/accounts/index.js';
 import { readBoundedFile } from '../../../shared/io/index.js';
 import { implement } from '../../context.js';
 import { cancelled } from '../../kernel/index.js';
+import { isKindReady } from '../../../shared/readiness.js';
 import { listServices, serviceImport, serviceLogin, serviceLogout } from './services.def.js';
 /** One service's row: never the sign-in, and the store's summary through safeText. */
 export function serviceRow(kind, config, store, leases) {
@@ -28,10 +29,12 @@ export function serviceRow(kind, config, store, leases) {
         summary: info?.summary ? safeText(info.summary) : null,
         heldBy: holder ? safeText(holder.dataSet) : null,
         usedBy: [...spec.usedBy],
+        usedFor: usedByText(spec.usedBy),
         warnings: [...spec.warnings],
         canImport: Boolean(source.fromPc || source.fromFile),
         canLogin: Boolean(source.fromAnswers),
         needsFile: Boolean(source.fromFile && !source.fromPc),
+        ready: isKindReady(kind),
     };
 }
 /** The kind an operation is about: the name given (checked), else asked. */
@@ -42,7 +45,7 @@ async function kindOf(io, given, verb, offered = () => true) {
             fail('There is no service called "' + safeText(given) + '".', 'Use one of: ' + SERVICE_KINDS.join(', '));
         return name;
     }
-    const choices = SERVICE_KINDS.filter((k) => offered(SERVICE_SPECS[k])).map((k) => ({
+    const choices = SERVICE_KINDS.filter((k) => isKindReady(k) && offered(SERVICE_SPECS[k])).map((k) => ({
         value: k,
         label: SERVICE_SPECS[k].label,
     }));
@@ -53,10 +56,10 @@ async function kindOf(io, given, verb, offered = () => true) {
         cancelled();
     return picked;
 }
-/** Asks for the kind's fields; optional ones may stay empty. */
-async function askFields(io, spec) {
+/** Asks for the kind's fields (those for typing it, or for a file); optional ones may stay empty. */
+async function askFields(io, spec, mode) {
     const answers = {};
-    for (const field of spec.fields) {
+    for (const field of spec.fields.filter((f) => !f.only || f.only === mode)) {
         const validate = (value) => {
             const v = value.trim();
             if (!v)
@@ -77,18 +80,31 @@ async function askFields(io, spec) {
     }
     return answers;
 }
+/** A kind that only ever comes from a sandbox (Comet): why it cannot be taken from this PC, and what to do instead. */
+function refuseSandboxOnly(spec) {
+    if (spec.sources.length !== 1 || spec.sources[0] !== 'sandbox')
+        return;
+    fail('Your ' + spec.label + " sign-in can't be copied from this PC: Windows locks it to your PC account.", 'Sign in once inside a sandbox (with accounts.' + spec.kind + '.share on): it is kept for the next ones.');
+}
 function savedMessage(kind, share) {
     return ('Saved your ' +
         SERVICE_SPECS[kind].label +
         ' sign-in (encrypted for your Windows user).' +
-        (share ? '' : ' Sandboxes get it once you share it: sandbox config set accounts.' + kind + '.share true'));
+        (share ? '' : ' Sandboxes get it once you turn on Share with sandboxes.'));
 }
 /** Saves a kind's sign-in from this PC's program or from a file, after a confirmation (--yes answers it). */
 export async function importServiceFlow(io, kind, from, deps) {
     const spec = SERVICE_SPECS[kind];
     const source = HOST_SOURCES[kind];
     if (!source.fromPc && !source.fromFile)
-        fail(spec.label + ' cannot be imported.', 'Type it instead: sandbox account login ' + kind);
+        refuseSandboxOnly(spec);
+    if (!source.fromPc && !source.fromFile)
+        failWith(spec.label + ' cannot be imported.', 'Type it instead.', {
+            op: 'accounts.service.login',
+            input: { name: kind },
+            label: 'Sign in…',
+            cli: 'sandbox account login ' + kind,
+        });
     let file = from === undefined ? undefined : path.resolve(from);
     const isFile = (p) => {
         try {
@@ -118,10 +134,11 @@ export async function importServiceFlow(io, kind, from, deps) {
     let payload;
     let saved;
     if (useFile) {
-        const bytes = readBoundedFile(file, spec.maxBytes);
+        const maxBytes = spec.maxFileBytes ?? spec.maxBytes;
+        const bytes = readBoundedFile(file, maxBytes);
         if (!bytes)
-            fail('Cannot read ' + file + ' (missing, a link, or bigger than ' + spec.maxBytes / 1024 + ' KB).');
-        payload = source.fromFile(bytes, await askFields(io, spec));
+            fail('Cannot read ' + file + ' (missing, a link, or bigger than ' + maxBytes / 1024 + ' KB).');
+        payload = source.fromFile(bytes, await askFields(io, spec, 'file'));
         saved = 'file';
     }
     else {
@@ -134,7 +151,11 @@ export async function importServiceFlow(io, kind, from, deps) {
                 spec.label +
                 ' sign-in found on this PC' +
                 (file ? ' in ' + file : '') +
-                (spec.returns ? ' (sign in there first, or sign in once inside a sandbox).' : '.'),
+                (spec.returns
+                    ? ' (sign in there first, or sign in once inside a sandbox).'
+                    : kind === 'perplexity'
+                        ? ' (PERPLEXITY_API_KEY is not set for your Windows user: import a .env file, or type the key).'
+                        : '.'),
         };
     deps.store.save(kind, payload, saved, source.summary(payload));
     for (const w of spec.warnings)
@@ -146,10 +167,17 @@ export async function loginServiceFlow(io, kind, deps) {
     const spec = SERVICE_SPECS[kind];
     const source = HOST_SOURCES[kind];
     if (!source.fromAnswers)
-        fail(spec.label + ' has nothing to type.', spec.sources.includes('sandbox')
-            ? 'Sign in once inside a sandbox (it is kept), or: sandbox account import ' + kind
-            : 'Run: sandbox account import ' + kind + ' --from <file>');
-    const payload = source.fromAnswers(await askFields(io, spec));
+        refuseSandboxOnly(spec);
+    if (!source.fromAnswers)
+        failWith(spec.label + ' has nothing to type.', spec.sources.includes('sandbox')
+            ? 'Sign in once inside a sandbox (it is kept), or import it.'
+            : 'Import it from a file.', {
+            op: 'accounts.service.import',
+            input: { name: kind },
+            label: 'Import…',
+            cli: 'sandbox account import ' + kind + (spec.sources.includes('sandbox') ? '' : ' --from <file>'),
+        });
+    const payload = source.fromAnswers(await askFields(io, spec, 'typed'));
     deps.store.save(kind, payload, 'typed', source.summary(payload));
     for (const w of spec.warnings)
         io.log(w, 'warn');

package/dist/app/features/agent-commands/agent-commands.def.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { type Section } from '../../kernel/index.js';
+export declare const AgentCommandsStatusSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    dir: z.ZodString;
+    found: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        harness: z.ZodString;
+        real: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentCommandsStatus = z.output<typeof AgentCommandsStatusSchema>;
+export declare const agentCommandsStatus: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    enabled: z.ZodBoolean;
+    dir: z.ZodString;
+    found: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        harness: z.ZodString;
+        real: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "agentCommands.status">;
+export declare const agentCommandsOn: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+    on: z.ZodBoolean;
+    commands: z.ZodArray<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>, "agentCommands.on">;
+export declare const agentCommandsOff: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+    on: z.ZodBoolean;
+    commands: z.ZodArray<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>, "agentCommands.off">;
+/** The words printed by `sandbox agent-commands status`. Pure. */
+export declare function agentCommandsText(s: AgentCommandsStatus): string;
+/** What turning them on does, in words (also the message after it). */
+export declare const AGENT_COMMANDS_EXPLAINED = "Typing claude, codex ... in a folder on this PC starts that agent in a hidden sandbox and attaches your terminal. Open a new terminal after turning it on or off. To run the real program once, set SANDBOX_AGENT_DIRECT=1.";
+/** The "Agent commands" section of the agents page: the switch, then one row per agent found. Pure. */
+export declare function agentCommandsSection(s: AgentCommandsStatus): Section;