windows-development-sandbox 1.10.0 → 1.11.4

package/README.md

@@ -5,6 +5,7 @@
 **A throwaway Windows machine for every project, with or without an AI agent.**
 
 [![Release](https://img.shields.io/github/v/release/JoshDiDuca/windows-development-sandbox?label=release)](https://github.com/JoshDiDuca/windows-development-sandbox/releases/latest)
+[![npm](https://img.shields.io/npm/v/windows-development-sandbox?logo=npm&label=npm)](https://www.npmjs.com/package/windows-development-sandbox)
 [![CI](https://github.com/JoshDiDuca/windows-development-sandbox/actions/workflows/ci.yml/badge.svg)](https://github.com/JoshDiDuca/windows-development-sandbox/actions/workflows/ci.yml)
 ![Windows 10/11 Pro, Enterprise, Education](https://img.shields.io/badge/Windows-10%20%7C%2011%20Pro-0078D4)
 ![MIT](https://img.shields.io/badge/license-MIT-green)
@@ -22,21 +23,24 @@ irm https://github.com/JoshDiDuca/windows-development-sandbox/releases/latest/do
 ```
 
 It checks your PC, offers to turn on Windows Sandbox, and asks **1) Just me** or **2) Everyone on this PC** (needs
-admin). It uses a private copy of Node.js just for this tool; nothing else is installed system-wide. `sandbox update`
-installs newer versions, and can do it by itself.
+admin). It brings its own private copy of Node.js; nothing else is installed system-wide, and no Start menu shortcut
+unless you ask for one. `sandbox update` installs newer versions (and can do it by itself); a version that fails to
+start is rolled back automatically, and `sandbox update --rollback` goes back one by hand.
+
 Needs Windows 10/11 **Pro, Enterprise or Education**. Have Node.js 20+? `npm install -g windows-development-sandbox`
-works too. [Scopes, options, upgrading, uninstall](docs/install.md)
+works too. [Scopes, options (`-Version`, `-StartMenuShortcut` ...), upgrading, uninstall](docs/install.md)
 
 ## Use
 
 ```powershell
 cd C:\code\my-app
 
-sandbox            # the menu: start agents, sessions, apps, every setting, diagnostics ...
+sandbox            # the menu: agents, sessions, apps, every setting, diagnostics ...
 sandbox claude     # Claude Code in a sandbox for this folder (or: claude-sandbox)
 sandbox claude -t  # ... in this terminal (Ctrl+] detaches, the session keeps running)
 sandbox start      # just the sandbox, no agent
 sandbox opencode   # any supported agent by name
+sandbox web open   # (Beta) the web UI in your browser, signed in
 ```
 
 The first start downloads what the project needs (a few minutes, once). After that, starts take seconds.
@@ -55,43 +59,86 @@ The first start downloads what the project needs (a few minutes, once). After th
 | **Agents** | Claude Code, Codex, Gemini, opencode, Qwen, Crush, Copilot, Kilo, Amp, Cline, Continue, Kimi, Aider, DeepSeek agents |
 | **Smart** | Detects what the project needs from its files, respects version files, installs in parallel and reuses everything |
 | **Several projects** | `sandbox claude` from another project joins the running sandbox: its own folder, tools, versions, databases and environment, set up on demand. Start several agents at once (`--session claude@A --session codex@B`, or the menu) and attach to any of them from any terminal |
-| **Agent commands** (Beta) | `sandbox agent-commands on`: typing `claude`, `codex` ... in any folder starts it in a hidden sandbox and attaches your terminal |
-| **Feels like home** | Your desktop look, Claude settings, MCP servers and conversation history come along; history syncs back |
+| **Picks up where you left off** | After a crash or a restart, `sandbox resume` reopens the last sessions; `sandbox restart` restarts the agents in place and they continue their conversation |
+| **Feels like home** | Your desktop look, Claude settings, MCP servers and conversation history come along; history syncs back. Logins you save (`sandbox account`) are kept encrypted for your Windows user |
+
+## Built for heavy workloads
+
+The sandbox behaves like a well-run PC of its own size: under load it slows down, it does not fail, and it never takes
+your PC down with it. Nothing needs setting up.
+
+- **Sized to what your PC can hold.** The sandbox gets only the memory your PC can keep in RAM for it, with room kept
+  for your PC itself (and more with vGPU on).
+- **Builds within a budget.** Agents see the processors and memory they may really use, and every session gets a
+  matching number of build jobs and links, written to `run\budget.json` for agents to plan with.
+- **Graduated throttling.** As memory fills, a governor in the sandbox turns one dial in steps: build programs get
+  lower CPU and memory priority, then a smaller share of the CPU, then compilers take turns while the waiting ones move
+  to the paging file. Builds get slower; nothing is stopped or killed, and agents, shells and Windows are never touched.
+- **Your PC has a say.** A watchdog on your PC watches its memory, CPU and disks and asks the sandbox to ease off, at
+  once and all the way when your PC is nearly out of memory.
+- **A last resort that only protects.** Only at the very edge of the sandbox's own memory limit, where Windows inside
+  it would otherwise start failing, is a build refused memory so that the sandbox stays up.
+- **Answers after the fact.** `sandbox doctor` checks your paging file, and `sandbox logs --crash` explains a past
+  freeze or crash: the gap, blue screens, hardware and memory events, and whether vGPU was on.
+
+Details and settings: [troubleshooting](docs/troubleshooting.md#the-sandbox-closes-under-heavy-load) and
+[configuration](docs/configuration.md#cpu-ram-and-gpu).
 
 ## Commands
 
 | Command | |
 |---|---|
-| `sandbox` | the menu, a full-screen app: start agents, attach to sessions, pick apps, edit every setting (yours and the project's), all commands, with search |
+| `sandbox` | the menu, a full-screen app with a left navigation: start agents, attach to sessions, pick apps, edit every setting (yours and the project's), all commands, with search |
 | `sandbox <agent>`, `claude-sandbox` | start an agent; `-t` for this terminal, `--headless` for no window |
 | `sandbox start` | the sandbox without an agent |
 | `sandbox attach` / `sessions` / `status` | work with a running sandbox (this folder's project first) |
+| `sandbox restart` / `resume` | restart the agents in place; reopen the last sessions |
 | `sandbox projects` | the projects a sandbox can open without a restart: roots, `all`, exclude |
 | `sandbox db [start\|stop <name>]` | list, start or stop databases (`sbx-db` inside) |
 | `sandbox exec -- <cmd>` | run a command inside |
-| `sandbox agent-commands on\|off` | (Beta) make the agents installed on this PC start in a sandbox |
-| `sandbox --version` | the installed version |
+| `sandbox config get\|set\|reset\|list` | read and change any setting from the command line (`export` / `import` to share them) |
+| `sandbox account` | save, switch and rename agent logins |
+| `sandbox web` | (Beta) the web UI: start, stop, status, open |
 | `sandbox stop` / `hide` / `show` | shut down, hide or show the window |
-| `sandbox data` / `data clean` | what's stored and how big, and freeing space |
+| `sandbox data` / `storage` | what's stored and how big, freeing space, moving the data folder |
 | `sandbox setup` / `doctor` / `repair` | check this PC, see what will be installed, fix common problems |
+| `sandbox logs [-f] [--crash]` | the sandbox log, or the report of the last crash |
+| `sandbox update [--rollback]` / `--version` | update (or go back one version); the installed version |
 
 All commands and options: [docs/commands.md](docs/commands.md)
 
+## Beta and alpha features
+
+These are off until you turn them on, and one setting turns each off again. Windows Sandbox stays the default and
+keeps every feature it has.
+
+| Feature | Status | |
+|---|---|---|
+| **Web UI** (`sandbox web`, `web.enabled`) | Beta | Agents, sessions with live terminals, the sandbox's status, apps, accounts and every setting in your browser, with search (Ctrl+K) and a folder picker; on this PC only (loopback, signed in with a token). `web.openOnLaunch` opens it with every sandbox. [web-ui.md](docs/web-ui.md) |
+| **Agent commands** (`sandbox agent-commands on`) | Beta | Typing `claude`, `codex` ... in any folder starts it in a hidden sandbox and attaches your terminal |
+| **Contained storage** (`sandbox storage contained on`) | Beta | Tools, logins and logs in one disk image per data set, mounted only while a sandbox runs. One admin prompt per launch. [engines](docs/design/engines.md) |
+| **VPN** (`sandbox vpn`, `vpn.enabled`) | Alpha | The sandbox's traffic through NordVPN, your own OpenVPN profile or a WireGuard config, with a kill switch. Not yet tried on a real PC: read [vpn.md](docs/vpn.md) first |
+| **HCS engine** (`sandbox.engine: hcs`, `sandbox engine`) | 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 |
+
 ## Known gaps
 
-Adding a folder to a RUNNING sandbox needs Windows 11 24H2+ with the updated Windows Sandbox (`wsb share`, untested).
-On older Windows, folders inside a project root open at once and anything else offers a restart. Details, and how to
-get `wsb`: [several projects](docs/projects.md#adding-folders-to-a-running-sandbox-wsb-share).
+- Adding a folder to a RUNNING sandbox needs Windows 11 24H2+ with the updated Windows Sandbox (`wsb share`,
+  untested). On older Windows, folders inside a project root open at once and anything else offers a restart.
+  [Details, and how to get `wsb`](docs/projects.md#adding-folders-to-a-running-sandbox-wsb-share).
+- Windows Sandbox runs one sandbox at a time per PC; every project and agent shares it.
+- What is planned next: [roadmap](docs/roadmap.md).
 
 ## Documentation
 
-- [Install](docs/install.md): requirements, other ways to install, upgrading
+All docs, with one line each: [docs/README.md](docs/README.md). The main ones:
+
+- [Install](docs/install.md): requirements, other ways to install, upgrading, rolling back
 - [Commands](docs/commands.md): every command and option, the menu, sessions and attaching
 - [Tools and databases](docs/toolchains.md): languages, package managers, databases, agents, what is tested
 - [Configuration](docs/configuration.md): settings, project files, paths, accounts, hooks
 - [Several projects](docs/projects.md): project roots, adding a project to a running sandbox, what each agent can see
-- [Changelog](CHANGELOG.md): what shipped in each version
 - [Security](docs/security.md): how your PC is protected, secrets, git access
-- [VPN](docs/vpn.md): send the sandbox through NordVPN (or your own OpenVPN profile), with a kill switch
-- [Troubleshooting](docs/troubleshooting.md): common problems and fixes
+- [Web UI](docs/web-ui.md) (Beta) and [VPN](docs/vpn.md) (Alpha)
+- [Troubleshooting](docs/troubleshooting.md): common problems, freezes and crash reports
+- [Changelog](CHANGELOG.md) and [roadmap](docs/roadmap.md): what shipped, what is next
 - [Development](docs/development.md): building, testing, releasing (code layout in [CLAUDE.md](CLAUDE.md))

package/config.example.json

@@ -64,6 +64,9 @@
     "configFile": "",
     "killSwitch": true
   },
+  "github": {
+    "shareToken": false
+  },
   "provisioning": {
     "copyFromHost": true,
     "fallbackToInstall": true,
@@ -218,7 +221,8 @@
     "enabled": true,
     "reuseSession": true,
     "auto": false,
-    "autoHide": false
+    "autoHide": false,
+    "confirmCtrlC": true
   },
   "web": {
     "enabled": false,

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

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { type Page, type Section } from '../../kernel/index.js';
+export declare const AccountRowSchema: z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodNullable<z.ZodString>;
+    isDefault: z.ZodBoolean;
+    isActive: z.ZodBoolean;
+    savedAt: z.ZodString;
+}, z.core.$strip>;
+export type AccountRow = z.output<typeof AccountRowSchema>;
+export declare const AgentAccountsSchema: z.ZodObject<{
+    name: z.ZodString;
+    kept: z.ZodBoolean;
+    canSavePc: z.ZodBoolean;
+    accounts: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        email: z.ZodNullable<z.ZodString>;
+        isDefault: z.ZodBoolean;
+        isActive: z.ZodBoolean;
+        savedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentAccounts = z.output<typeof AgentAccountsSchema>;
+export declare const AccountsListSchema: z.ZodObject<{
+    agent: z.ZodString;
+    agents: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kept: z.ZodBoolean;
+        canSavePc: z.ZodBoolean;
+        accounts: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            email: z.ZodNullable<z.ZodString>;
+            isDefault: z.ZodBoolean;
+            isActive: z.ZodBoolean;
+            savedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AccountsList = z.output<typeof AccountsListSchema>;
+/** The name rule of a saved login: what the store accepts. */
+export declare const NAME_RULE = "Use letters, digits, - and _ (up to 40).";
+/** `sandbox account list`: the table of one agent, as the command line has always padded it. */
+export declare function accountsText(o: AccountsList): string;
+export declare const listAccounts: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+    agent: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    agent: z.ZodString;
+    agents: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kept: z.ZodBoolean;
+        canSavePc: z.ZodBoolean;
+        accounts: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            email: z.ZodNullable<z.ZodString>;
+            isDefault: z.ZodBoolean;
+            isActive: z.ZodBoolean;
+            savedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "accounts.list">;
+export declare const saveAccount: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    agent: z.ZodDefault<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    fromHost: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>, "accounts.save">;
+export declare const useAccount: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    agent: z.ZodDefault<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    noRestart: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    lines: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, "accounts.use">;
+export declare const defaultAccount: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    agent: z.ZodDefault<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "accounts.default">;
+export declare const renameAccount: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    agent: z.ZodDefault<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "accounts.rename">;
+export declare const removeAccount: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    agent: z.ZodDefault<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "accounts.remove">;
+/** 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). */
+export declare function accountsPage(o: AccountsList): 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.
+ */
+export declare function agentPage(a: AgentAccounts): Page;
+export declare const accountsView: import("../../kernel/define.js").ViewDef<{
+    accounts: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+        agent: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        agent: z.ZodString;
+        agents: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kept: z.ZodBoolean;
+            canSavePc: z.ZodBoolean;
+            accounts: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                email: z.ZodNullable<z.ZodString>;
+                isDefault: z.ZodBoolean;
+                isActive: z.ZodBoolean;
+                savedAt: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, "accounts.list">;
+}, Record<string, never>, "accounts">;

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

@@ -0,0 +1,243 @@
+// Accounts: the saved logins of every agent that keeps one, and what to do with them (save, use, default, rename,
+// remove). Pure: schemas, labels, the CLI hints of the `account` command's actions, the view and its page builders.
+// accounts.run.ts does the work over AccountsService.
+import { z } from 'zod';
+import { action, defineOperation, defineQuery, defineView, plural, } from '../../kernel/index.js';
+const AgentSchema = z.string().default('claude').describe('whose login: an agent that keeps one (default: claude)');
+const NameSchema = z.string().optional().describe('account name');
+export const AccountRowSchema = z.object({
+    name: z.string().describe('The saved login'),
+    email: z.string().nullable().describe('Its email, when the agent says'),
+    isDefault: z.boolean().describe('New launches start with it'),
+    isActive: z.boolean().describe('The sandbox uses it now'),
+    savedAt: z.string().describe('When it was saved (ISO time)'),
+});
+export const AgentAccountsSchema = z.object({
+    name: z.string().describe('The agent'),
+    kept: z.boolean().describe('Its login can be saved and switched'),
+    canSavePc: z.boolean().describe("This PC's login can be saved"),
+    accounts: z.array(AccountRowSchema).describe('Its saved logins (empty when not kept)'),
+});
+export const AccountsListSchema = z.object({
+    agent: z.string().describe('The agent asked for (the command line table shows only it)'),
+    agents: z.array(AgentAccountsSchema).describe('Every agent, Claude first'),
+});
+const MessageSchema = z.object({ message: z.string().describe('What happened') });
+/** The name rule of a saved login: what the store accepts. */
+export const NAME_RULE = 'Use letters, digits, - and _ (up to 40).';
+/** `sandbox account list`: the table of one agent, as the command line has always padded it. */
+export function accountsText(o) {
+    const rows = o.agents.find((a) => a.name === o.agent)?.accounts ?? [];
+    if (!rows.length)
+        return o.agent === 'claude'
+            ? "No saved accounts. Sign in inside the sandbox, then: sandbox account save <name>   (or --from-host to save this PC's login)"
+            : 'No saved ' +
+                o.agent +
+                ' accounts. Sign in inside the sandbox, then: sandbox account save <name> --agent ' +
+                o.agent;
+    const table = [
+        ['', 'NAME', 'EMAIL', 'SAVED'],
+        ...rows.map((a) => [
+            (a.isActive ? '*' : ' ') + (a.isDefault ? 'D' : ' '),
+            a.name,
+            a.email ?? '-',
+            a.savedAt.slice(0, 16).replace('T', ' '),
+        ]),
+    ];
+    const widths = table[0].map((_, i) => Math.max(...table.map((r) => r[i].length)));
+    const lines = table.map((r) => r.map((cell, i) => (i === r.length - 1 ? cell : cell.padEnd(widths[i] + 2))).join(''));
+    return [...lines, '', '* = active in the sandbox   D = default for new launches'].join('\n');
+}
+export const listAccounts = defineQuery({
+    id: 'accounts.list',
+    title: 'Accounts',
+    summary: 'Claude logins: list, save, use, set the default, remove',
+    input: z.object({ agent: AgentSchema }),
+    output: AccountsListSchema,
+    text: accountsText,
+    cli: {
+        name: 'account',
+        action: 'list',
+        json: true,
+        flags: { agent: { flag: '--agent', value: 'name', choices: 'harnesses', label: 'Agent' } },
+        // `sandbox account list --json` has always printed the rows of the one agent.
+        shapeJson: (o) => o.agents.find((a) => a.name === o.agent)?.accounts ?? [],
+    },
+});
+export const saveAccount = defineOperation({
+    id: 'accounts.save',
+    title: "Save the sandbox's login",
+    summary: "save the sandbox's (or this PC's) login under a name",
+    input: z.object({
+        agent: AgentSchema,
+        name: NameSchema,
+        fromHost: z.boolean().default(false).describe("(save) save this PC's login instead of the sandbox's"),
+    }),
+    output: z.object({ name: z.string().describe('The saved login'), message: z.string().describe('What happened') }),
+    text: (o) => o.message,
+    cli: {
+        name: 'account',
+        action: 'save',
+        positional: ['name'],
+        flags: { agent: { flag: '--agent' }, fromHost: { flag: '--from-host' } },
+    },
+});
+export const useAccount = defineOperation({
+    id: 'accounts.use',
+    title: 'Use this login',
+    summary: 'make the sandbox use a saved login (running sessions restart)',
+    input: z.object({
+        agent: AgentSchema,
+        name: NameSchema,
+        noRestart: z.boolean().default(false).describe('(use) do not restart running sessions'),
+    }),
+    output: z.object({ lines: z.array(z.string()).describe('What happened, line by line') }),
+    text: (o) => o.lines.join('\n'),
+    cli: {
+        name: 'account',
+        action: 'use',
+        positional: ['name'],
+        flags: { agent: { flag: '--agent' }, noRestart: { flag: '--no-restart' } },
+    },
+});
+export const defaultAccount = defineOperation({
+    id: 'accounts.default',
+    title: 'Make default',
+    summary: 'the login new launches start with',
+    input: z.object({ agent: AgentSchema, name: NameSchema }),
+    output: MessageSchema,
+    text: (o) => o.message,
+    cli: { name: 'account', action: 'default', positional: ['name'], flags: { agent: { flag: '--agent' } } },
+});
+export const renameAccount = defineOperation({
+    id: 'accounts.rename',
+    title: 'Rename…',
+    summary: 'give a saved login another name (it keeps working)',
+    input: z.object({
+        agent: AgentSchema,
+        name: NameSchema,
+        to: z.string().optional().describe('(rename) the new name'),
+    }),
+    output: MessageSchema,
+    text: (o) => o.message,
+    cli: {
+        name: 'account',
+        action: 'rename',
+        positional: ['name'],
+        flags: { agent: { flag: '--agent' }, to: { flag: '--to' } },
+    },
+});
+export const removeAccount = defineOperation({
+    id: 'accounts.remove',
+    title: 'Remove…',
+    summary: 'delete a saved login (you would sign in again)',
+    danger: true,
+    input: z.object({ agent: AgentSchema, name: NameSchema }),
+    output: MessageSchema,
+    text: (o) => o.message,
+    cli: {
+        name: 'account',
+        action: 'remove',
+        positional: ['name'],
+        flags: { agent: { flag: '--agent' } },
+        yes: '(remove) do not ask first',
+    },
+});
+/** One agent's save rows (the sandbox's login, and this PC's when it can be saved). */
+function saveItems(a) {
+    return [
+        {
+            id: '@save-sandbox',
+            label: "+ Save the sandbox's login…",
+            group: 'Save a login',
+            description: 'Saves the ' + a.name + ' login you signed in with inside the sandbox, under a name you choose.',
+            primary: action(saveAccount, { agent: a.name, fromHost: false }, { verb: 'save', label: "Save the sandbox's login" }),
+        },
+        ...(a.canSavePc
+            ? [
+                {
+                    id: '@save-pc',
+                    label: "+ Save this PC's login…",
+                    group: 'Save a login',
+                    description: 'Saves the ' + a.name + ' login of this PC, under a name you choose.',
+                    primary: action(saveAccount, { agent: a.name, fromHost: true }, { verb: 'save', label: "Save this PC's login" }),
+                },
+            ]
+            : []),
+    ];
+}
+/** One saved login: its state in the hint and badges, Enter or a click uses it, d/r/x change it. */
+function loginItem(a, r) {
+    const hint = [r.isActive ? 'in the sandbox' : '', r.isDefault ? 'default' : ''].filter(Boolean).join(' · ');
+    return {
+        id: a.name + ':' + r.name,
+        label: r.name,
+        group: 'Saved logins',
+        icon: a.name,
+        hint,
+        badges: [
+            ...(r.isActive ? [{ text: 'in the sandbox', tone: 'ok' }] : []),
+            ...(r.isDefault ? [{ text: 'default', tone: 'accent' }] : []),
+        ],
+        description: 'Choose it to make the sandbox use this login.',
+        details: ['Agent  ' + a.name, 'Email  ' + (r.email ?? '-'), 'Saved  ' + r.savedAt.slice(0, 16).replace('T', ' ')],
+        primary: action(useAccount, { agent: a.name, name: r.name }, { verb: 'use' }),
+        actions: [
+            action(defaultAccount, { agent: a.name, name: r.name }, { key: 'd', verb: 'make default', importance: 1 }),
+            action(renameAccount, { agent: a.name, name: r.name }, { key: 'r', verb: 'rename', importance: 2 }),
+            action(removeAccount, { agent: a.name, name: r.name }, { key: 'x', verb: 'remove', importance: 1 }),
+        ],
+    };
+}
+/** One agent's card: its save rows and logins (a card to pick from), or the note that its login is not kept. */
+export function agentSection(a) {
+    if (!a.kept)
+        return {
+            id: a.name,
+            title: a.name,
+            summary: 'not kept between sandboxes',
+            items: [
+                {
+                    id: 'info:' + a.name,
+                    label: "This agent's login is not kept between sandboxes",
+                    tone: 'muted',
+                    description: 'Sign in again in each new sandbox, or use an API key in the agent’s environment.',
+                },
+            ],
+        };
+    return {
+        id: a.name,
+        title: a.name,
+        summary: a.accounts.length ? plural(a.accounts.length, 'saved login') : 'no saved login yet',
+        description: 'Saved ' + a.name + ' logins.',
+        cards: true,
+        items: [...saveItems(a), ...a.accounts.map((r) => loginItem(a, r))],
+    };
+}
+/** The web's page: one card per agent (its logins and the save rows). */
+export function accountsPage(o) {
+    return { title: 'Accounts', sections: o.agents.map(agentSection) };
+}
+/**
+ * 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.
+ */
+export function agentPage(a) {
+    const keys = a.kept
+        ? [
+            action(saveAccount, { agent: a.name, fromHost: false }, { key: 's', verb: 'save sandbox login', importance: 3 }),
+            ...(a.canSavePc
+                ? [action(saveAccount, { agent: a.name, fromHost: true }, { key: 'p', verb: 'save PC login', importance: 3 })]
+                : []),
+        ]
+        : [];
+    return { title: 'Accounts', sections: [agentSection(a)], actions: keys };
+}
+export const accountsView = defineView({
+    id: 'accounts',
+    title: 'Accounts',
+    summary: 'Logins saved on this PC, per agent. Use puts one into the sandbox; new launches start with the default.',
+    queries: { accounts: listAccounts },
+    operations: [saveAccount, useAccount, defaultAccount, renameAccount, removeAccount],
+    build: ({ accounts }) => accountsPage(accounts),
+});

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

@@ -0,0 +1,51 @@
+export declare const listAccountsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{
+    agent: import("zod").ZodDefault<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    agent: import("zod").ZodString;
+    agents: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        kept: import("zod").ZodBoolean;
+        canSavePc: import("zod").ZodBoolean;
+        accounts: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            email: import("zod").ZodNullable<import("zod").ZodString>;
+            isDefault: import("zod").ZodBoolean;
+            isActive: import("zod").ZodBoolean;
+            savedAt: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, "accounts.list">, import("../../../cli/commands/context.js").Context>;
+export declare const saveAccountRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    agent: import("zod").ZodDefault<import("zod").ZodString>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    fromHost: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "accounts.save">, import("../../../cli/commands/context.js").Context>;
+export declare const useAccountRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    agent: import("zod").ZodDefault<import("zod").ZodString>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    noRestart: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    lines: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, "accounts.use">, import("../../../cli/commands/context.js").Context>;
+export declare const defaultAccountRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    agent: import("zod").ZodDefault<import("zod").ZodString>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "accounts.default">, import("../../../cli/commands/context.js").Context>;
+export declare const renameAccountRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    agent: import("zod").ZodDefault<import("zod").ZodString>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    to: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "accounts.rename">, import("../../../cli/commands/context.js").Context>;
+export declare const removeAccountRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    agent: import("zod").ZodDefault<import("zod").ZodString>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "accounts.remove">, import("../../../cli/commands/context.js").Context>;