windows-development-sandbox 1.10.0 → 1.11.4

package/dist/cli/menu/pages/sandbox-page.d.ts

@@ -1,11 +1,12 @@
+import { type ProjectsList } from '../../../app/features/projects/index.js';
 import { type SandboxStatus } from '../../../app/features/sandbox/index.js';
 import type { Context } from '../../commands/context.js';
-import { type DatabaseRow, type ProjectsListing } from '../../services/index.js';
+import { type DatabaseRow } from '../../services/index.js';
 import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
 import { ListPage, type Outcome } from './list-page.js';
 export interface SandboxModel {
     readonly report: SandboxStatus;
-    readonly projects: ProjectsListing;
+    readonly projects: ProjectsList;
     /** Null: the sandbox is not running or did not answer. */
     readonly databases: DatabaseRow[] | null;
     /** The agent "Start the sandbox" offers while nothing runs. */
@@ -17,7 +18,6 @@ export declare class SandboxPage extends ListPage<string> {
     private readonly ctx;
     readonly label = "Sandbox";
     private model;
-    private readonly projects;
     private readonly operations;
     constructor(app: App, ctx: Context);
     protected load(): Promise<void>;
@@ -27,7 +27,5 @@ export declare class SandboxPage extends ListPage<string> {
     protected act(result: ListResult<string>): Promise<Outcome<string>>;
     private defaultAgent;
     private noSandbox;
-    private addRoot;
-    private forget;
     private toggleDatabase;
 }

package/dist/cli/menu/pages/sandbox-page.js

@@ -1,13 +1,13 @@
-// Section 3: the sandbox as a whole. Status (the sandbox view: its facts, the window, stopping it), Projects (roots and
-// known projects) and Databases (start and stop), each a category on the left.
-import fs from 'node:fs';
-import path from 'node:path';
+// Section 3: the sandbox as a whole. Status (the sandbox view: its facts, the window, stopping it), Projects (the
+// projects view: roots, the projects and the all-projects setting) and Databases (start and stop), each a category on
+// the left.
+import { listProjects, projectsPage } from '../../../app/features/projects/index.js';
 import { sandboxPage, sandboxStatus } from '../../../app/features/sandbox/index.js';
 import { readQuery } from '../../../app/registry.js';
 import { errMsg, safeText } from '../../../core/util/index.js';
 import { RunDir } from '../../../shared/channel/index.js';
-import { DatabasesService, ProjectsService } from '../../services/index.js';
-import { Text, Theme, } from '../../tui/index.js';
+import { DatabasesService } from '../../services/index.js';
+import { Theme } from '../../tui/index.js';
 import { MenuOperations } from '../io-menu.js';
 import { menuView } from '../render-view.js';
 import { ListPage } from './list-page.js';
@@ -24,38 +24,24 @@ const CATEGORIES = [
 function statusView(m) {
     return menuView(sandboxPage(m.report), { category: 'status', prefix: 'status:', refresh: false });
 }
+/** The projects category: the projects view's rows and keys (no prefix: `@add-root`, `root:`, `project:`). */
+function projectsView(m) {
+    return menuView(projectsPage(m.projects), { category: 'projects', refresh: false });
+}
+/** The category whose rows and keys are open (the one the cursor is in). */
+function viewFor(m, category) {
+    if (category === 'projects')
+        return projectsView(m);
+    if (category === 'status' || category === undefined)
+        return statusView(m);
+    return undefined;
+}
 /** The list for the sandbox tab. Pure. */
 export function sandboxOptions(m) {
     const running = m.report.sandbox.running;
     const status = statusView(m);
+    const projects = projectsView(m);
     const statusItems = [...(running ? [] : startRows(m.defaultAgent, 'status')), ...status.items];
-    const addRoot = {
-        value: ADD_ROOT,
-        label: '+ Add a project root…',
-        category: 'projects',
-        section: 'Project roots',
-        description: 'Pick a folder that holds your projects: every project in it (also new ones) opens without a restart.',
-    };
-    const roots = m.projects.roots.map((r) => ({
-        value: 'root:' + r,
-        label: Text.middle(r, 60),
-        hint: Theme.muted('root'),
-        category: 'projects',
-        section: 'Project roots',
-        description: 'Every project in this folder (also new ones) opens without a restart. f removes the root.',
-    }));
-    const projects = m.projects.projects.map((p) => ({
-        value: 'project:' + p.folder,
-        label: Text.middle(p.folder, 60),
-        hint: p.running ?? (p.root ? 'in a root' : p.excluded ? 'excluded' : p.mappedAtStart ? 'mapped' : '-'),
-        category: 'projects',
-        section: 'Projects',
-        description: p.here ? 'This is the folder you started the menu in.' : undefined,
-        details: [
-            Theme.muted('At start   ') + (p.root ? 'root' : p.excluded ? 'excluded' : p.mappedAtStart ? 'mapped' : '-'),
-            Theme.muted('In sandbox ') + (p.running ?? '-'),
-        ],
-    }));
     const noDatabases = m.databases
         ? []
         : running
@@ -80,14 +66,17 @@ export function sandboxOptions(m) {
     }));
     return {
         path: [],
-        items: [...statusItems, addRoot, ...roots, ...projects, ...databases, ...noDatabases],
+        items: [...statusItems, ...projects.items, ...databases, ...noDatabases],
         categories: CATEGORIES,
         empty: 'Nothing here yet.',
-        actions: (category) => category === 'projects' || category === 'databases' ? sandboxActions(category) : [...status.actions, REFRESH],
-        enterLabel: (category, id) => status.enterLabel(category, id) || enterLabel(id ?? '', m),
+        actions: (category) => category === 'projects'
+            ? [...projects.actions, REFRESH]
+            : category === 'databases'
+                ? [REFRESH]
+                : [...status.actions, REFRESH],
+        enterLabel: (category, id) => viewFor(m, category)?.enterLabel(category, id) || enterLabel(id ?? '', m),
     };
 }
-const ADD_ROOT = '@add-root';
 const REFRESH = { key: 'l', label: 'refresh', importance: 3 };
 /** The rows that start a sandbox, shown where the sandbox has to run for anything to be there. */
 function startRows(agent, category) {
@@ -113,32 +102,18 @@ function startRows(agent, category) {
 function enterLabel(id, m) {
     if (id.startsWith('act:start'))
         return 'start';
-    if (id === ADD_ROOT)
-        return 'choose folder';
     if (id.startsWith('db:'))
         return m.databases?.find((d) => 'db:' + d.name === id)?.running ? 'stop' : 'start';
     return '';
 }
-function sandboxActions(category) {
-    if (category === 'projects')
-        return [
-            { key: 'a', label: 'add root', importance: 1 },
-            { key: 'f', label: 'remove root', importance: 1, applies: (id) => id.startsWith('root:') },
-            { key: 'f', label: 'forget project', importance: 1, applies: (id) => id.startsWith('project:') },
-            REFRESH,
-        ];
-    return [REFRESH];
-}
 export class SandboxPage extends ListPage {
     ctx;
     label = 'Sandbox';
     model;
-    projects;
     operations;
     constructor(app, ctx) {
         super(app);
         this.ctx = ctx;
-        this.projects = new ProjectsService(ctx);
         this.operations = new MenuOperations(app, ctx);
     }
     async load() {
@@ -153,7 +128,12 @@ export class SandboxPage extends ListPage {
                 /* the sandbox did not answer: the list stays empty */
             }
         }
-        this.model = { report, projects: this.projects.list(), databases, defaultAgent: this.defaultAgent() };
+        this.model = {
+            report,
+            projects: await readQuery(listProjects, this.ctx),
+            databases,
+            defaultAgent: this.defaultAgent(),
+        };
     }
     /** The folder `sbx-db` runs in: the sandbox's own workspace. */
     guestWorkspace() {
@@ -170,19 +150,14 @@ export class SandboxPage extends ListPage {
         try {
             if (key === 'l')
                 return { reload: true };
-            const chosen = this.model ? statusView(this.model).resolve(result) : undefined;
+            // Only the open category's keys and rows: a key of one category must not fire in another.
+            const chosen = this.model ? viewFor(this.model, this.category)?.resolve(result) : undefined;
             if (chosen?.kind === 'action')
                 return await this.operations.perform(chosen.action, [this.label], (text) => this.busy(text, id));
             if (id === 'act:start' && !key)
                 return { exit: { kind: 'run', argv: ['launch', '--harness', this.defaultAgent()] } };
             if (id === 'act:start-bare' && !key)
                 return { exit: { kind: 'run', argv: ['start'] } };
-            if (id === ADD_ROOT && !key)
-                return await this.addRoot();
-            if (key === 'a')
-                return await this.addRoot();
-            if (key === 'f')
-                return await this.forget(id);
             if (id?.startsWith('db:') && result.kind === 'pick')
                 return await this.toggleDatabase(id.slice(3));
         }
@@ -197,59 +172,6 @@ export class SandboxPage extends ListPage {
     noSandbox() {
         return this.model?.report.sandbox.running ? null : { notice: Theme.warn('No sandbox is running.') };
     }
-    async addRoot() {
-        const picked = await this.app.pickPath({
-            path: ['Sandbox', 'Add a project root'],
-            title: 'Choose the folder that holds your projects',
-            about: [
-                'Every project inside it (also new ones) opens without a restart. Every agent in the sandbox can see them.',
-            ],
-            use: 'add this root',
-            validate: (v) => (fs.existsSync(v) ? true : 'That folder does not exist.'),
-        });
-        if (!picked)
-            return {};
-        const { dir, added } = this.projects.addRoot(picked);
-        return {
-            reload: true,
-            notice: added
-                ? Theme.ok(Theme.glyph.ok + ' Added the root ' + dir + '.') + Theme.muted(' It applies from the next start.')
-                : Theme.muted(dir + ' is a root already.'),
-        };
-    }
-    async forget(id) {
-        const root = id?.startsWith('root:');
-        if (!id || (!root && !id.startsWith('project:')))
-            return {};
-        const folder = id.slice(root ? 5 : 8);
-        const ok = await this.app.ask((root ? 'Remove the root ' : 'Forget ') + path.basename(folder) + '?', [
-            root
-                ? 'Its projects are no longer opened without a restart.'
-                : 'The project is dropped from your list of projects.',
-            'Nothing in ' + folder + ' is touched.',
-        ], root ? 'Remove' : 'Forget', true);
-        if (!ok)
-            return {};
-        if (id.startsWith('root:')) {
-            const { dir, removed } = this.projects.removeRoot(id.slice(5));
-            return {
-                reload: true,
-                notice: removed
-                    ? Theme.ok(Theme.glyph.ok + ' Removed the root ' + dir + '.')
-                    : Theme.muted(dir + ' was not a root.'),
-            };
-        }
-        if (id?.startsWith('project:')) {
-            const { dir, removed } = this.projects.forget(id.slice(8));
-            return {
-                reload: true,
-                notice: removed
-                    ? Theme.ok(Theme.glyph.ok + ' Forgot ' + dir + '.') + Theme.muted(' Nothing in the folder was touched.')
-                    : Theme.muted(dir + ' was not in your projects.'),
-            };
-        }
-        return {};
-    }
     async toggleDatabase(name) {
         const none = this.noSandbox();
         if (none)

package/dist/cli/menu/pages/settings-page.d.ts

@@ -1,14 +1,27 @@
 import { settingsOf, type ConfigFile, type Setting } from '../../../app/features/settings/index.js';
 import type { Context } from '../../commands/context.js';
-import { type App, type ListItem, type ListOptions, type ListResult } from '../../tui/index.js';
+import { type App, type ListAction, type ListItem, type ListOptions, type ListResult } from '../../tui/index.js';
 import type { Draft } from '../settings/draft.js';
 import { type Scope } from './scopes.js';
 import { ListPage, type Outcome } from './list-page.js';
 export { settingsOf, type Setting };
-/** The row in General that opens the data folder flow (your own settings only). */
+/** The rows in General that export and import your settings (the page's actions of the settings feature). */
+export declare const EXPORT_SETTINGS = "@export-settings";
+export declare const IMPORT_SETTINGS = "@import-settings";
+export declare function shareSettingsRows(): {
+    value: string;
+    label: string;
+    hint: string;
+    description: string;
+}[];
+/** The row in General that changes the data folder (your own settings only): the storage area's operation runs it. */
 export declare const DATA_FOLDER = "@data-folder";
+/** The row in Network that sets the VPN login (its operations are the VPN feature's). */
+export declare const VPN_LOGIN = "@vpn-login";
+/** The row in Security that saves the GitHub token for sandboxes (its operations are the GitHub feature's). */
+export declare const GITHUB_TOKEN = "@github-token";
 /** The list for the settings section. Pure (reads the files it is given). `extra` are rows that are not settings. */
-export declare function settingsOptions(files: Record<Scope, ConfigFile>, scope: Scope, draft: Draft, extra?: readonly ListItem<string>[]): ListOptions<string>;
+export declare function settingsOptions(files: Record<Scope, ConfigFile>, scope: Scope, draft: Draft, extra?: readonly ListItem<string>[], extraActions?: readonly ListAction<string>[]): ListOptions<string>;
 export declare class SettingsPage extends ListPage<string> {
     private readonly files;
     private readonly draft;
@@ -17,6 +30,11 @@ export declare class SettingsPage extends ListPage<string> {
     readonly stages = true;
     private scope;
     private readonly editor;
+    private readonly operations;
+    /** The VPN status without asking the sandbox: the login row needs only the login's state. */
+    private vpn;
+    /** Whether a GitHub token is saved (never the token): the token row needs only its state. */
+    private github;
     constructor(app: App, files: Record<Scope, ConfigFile>, draft: Draft, ctx: Context);
     private get file();
     protected load(): Promise<void>;

package/dist/cli/menu/pages/settings-page.js

@@ -3,17 +3,38 @@
 // ***) are the settings feature's; this page lays the unsaved changes over them: changes are staged in the Draft
 // (marked *) and written with Ctrl+S; Enter edits, r resets to the default, z undoes an unsaved change.
 import _ from 'lodash';
-import { CATEGORIES, labelOf, nameOf, settingRow, settingsOf, } from '../../../app/features/settings/index.js';
-import { valueText } from '../../../app/kernel/index.js';
+import { CATEGORIES, labelOf, listSettings, nameOf, settingRow, settingsOf, settingsPage, } from '../../../app/features/settings/index.js';
+import { changeDataFolder } from '../../../app/features/storage/index.js';
+import { vpnLogin, vpnLoginRowOf, vpnLogout, vpnStatus } from '../../../app/features/vpn/index.js';
+import { githubLogin, githubLogout, githubStatus, githubTokenRowOf, } from '../../../app/features/github/index.js';
+import { action, valueText } from '../../../app/kernel/index.js';
+import { readQuery } from '../../../app/registry.js';
 import { errMsg } from '../../../core/util/index.js';
 import { Text, Theme, } from '../../tui/index.js';
-import { dataFolderRow, DataFolderFlow } from '../data-folder.js';
-import { EXPORT_SETTINGS, IMPORT_SETTINGS, ShareSettingsFlow, shareSettingsRows } from '../share-settings.js';
-import { VpnLoginFlow, vpnLoginRow, VPN_LOGIN } from '../vpn-login.js';
+import { MenuOperations } from '../io-menu.js';
 import { ValueEditor } from '../settings/value-editor.js';
 import { SCOPES, scopeStatus } from './scopes.js';
 import { ListPage } from './list-page.js';
 export { settingsOf };
+/** The rows in General that export and import your settings (the page's actions of the settings feature). */
+export const EXPORT_SETTINGS = '@export-settings';
+export const IMPORT_SETTINGS = '@import-settings';
+export function shareSettingsRows() {
+    return [
+        {
+            value: EXPORT_SETTINGS,
+            label: 'Export settings…',
+            hint: '.json',
+            description: 'Write the settings you changed to a .json file you can share with a team. Secrets, the data folder and folders or files of this PC are left out.',
+        },
+        {
+            value: IMPORT_SETTINGS,
+            label: 'Import settings…',
+            hint: '.json',
+            description: 'Read a settings file someone shared, see what it would change, and apply it once you say yes. Secrets, the data folder and paths in it are never taken.',
+        },
+    ];
+}
 /** The files with the menu's unsaved changes laid over them. */
 function draftSource(draft) {
     const written = (file, key) => draft.has(file, key) ? draft.value(file, key) : file.valueInFile(key);
@@ -69,10 +90,24 @@ function current(file, draft, key, config) {
     const source = draftSource(draft);
     return file.isProject ? (source.written(file, key) ?? _.get(config, key)) : source.effective(file, key, config);
 }
-/** The row in General that opens the data folder flow (your own settings only). */
+/** The row in General that changes the data folder (your own settings only): the storage area's operation runs it. */
 export const DATA_FOLDER = '@data-folder';
+/** The row in Network that sets the VPN login (its operations are the VPN feature's). */
+export const VPN_LOGIN = '@vpn-login';
+const VPN_PATH = ['Settings', 'Network', 'VPN login'];
+/** The row in Security that saves the GitHub token for sandboxes (its operations are the GitHub feature's). */
+export const GITHUB_TOKEN = '@github-token';
+const GITHUB_PATH = ['Settings', 'Security & privacy', 'GitHub token'];
+/** The row's words: where the saved data is, and what Enter does. */
+function dataFolderRow(ctx) {
+    return {
+        label: 'Data folder',
+        hint: ctx.storageRoot,
+        description: 'Where your tools, logins, history and logs are kept between sandboxes. Press Enter to move them to another folder or drive, or to use a different folder.',
+    };
+}
 /** The list for the settings section. Pure (reads the files it is given). `extra` are rows that are not settings. */
-export function settingsOptions(files, scope, draft, extra = []) {
+export function settingsOptions(files, scope, draft, extra = [], extraActions = []) {
     const file = files[scope];
     const config = files.user.userConfig();
     // The Data folder row stands in for the storage folder setting (changing it moves the data, which is asked about).
@@ -95,8 +130,9 @@ export function settingsOptions(files, scope, draft, extra = []) {
         actions: [
             { key: 'r', label: file.isProject ? 'remove' : 'reset to default', applies: (id) => set.has(id) },
             { key: 'z', label: 'undo', applies: (id) => unsaved.has(id) },
+            ...extraActions,
         ],
-        enterLabel: (_category, id) => id === DATA_FOLDER || id === VPN_LOGIN
+        enterLabel: (_category, id) => id === DATA_FOLDER || id === VPN_LOGIN || id === GITHUB_TOKEN
             ? 'change'
             : id === EXPORT_SETTINGS || id === IMPORT_SETTINGS
                 ? 'open'
@@ -111,11 +147,26 @@ export class SettingsPage extends ListPage {
     stages = true;
     scope = 'user';
     editor;
+    operations;
+    /** The VPN status without asking the sandbox: the login row needs only the login's state. */
+    vpn = {
+        enabled: false,
+        provider: 'nordvpn',
+        protocol: 'udp',
+        country: '',
+        killSwitch: true,
+        login: 'none',
+        loginSavedAt: null,
+        running: null,
+    };
+    /** Whether a GitHub token is saved (never the token): the token row needs only its state. */
+    github = { shareToken: false, gitAccess: 'full', token: 'none', kind: null, savedAt: null };
     constructor(app, files, draft, ctx) {
         super(app);
         this.files = files;
         this.draft = draft;
         this.ctx = ctx;
+        this.operations = new MenuOperations(app, ctx);
         this.editor = new ValueEditor(app, {
             suggestions: (key) => ['defaultHarness', 'harness'].includes(key.join('.'))
                 ? Object.keys(this.files.user.userConfig().harnesses)
@@ -125,15 +176,24 @@ export class SettingsPage extends ListPage {
     get file() {
         return this.files[this.scope];
     }
-    load() {
-        return Promise.resolve();
+    async load() {
+        this.vpn = await readQuery(vpnStatus, this.ctx, { tunnel: false });
+        this.github = await readQuery(githubStatus, this.ctx, {});
     }
     options() {
         const row = dataFolderRow(this.ctx);
         return settingsOptions(this.files, this.scope, this.draft, [
             { value: DATA_FOLDER, category: 'general', ...row },
-            { value: VPN_LOGIN, category: 'network', ...vpnLoginRow(this.ctx) },
+            { value: VPN_LOGIN, category: 'network', ...vpnLoginRowOf(this.vpn) },
+            { value: GITHUB_TOKEN, category: 'security', ...githubTokenRowOf(this.github) },
             ...shareSettingsRows().map((r) => ({ ...r, category: 'general' })),
+        ], [
+            ...(this.vpn.login !== 'none'
+                ? [{ key: 'x', label: 'delete VPN login', applies: (id) => id === VPN_LOGIN }]
+                : []),
+            ...(this.github.token !== 'none'
+                ? [{ key: 'x', label: 'delete GitHub token', applies: (id) => id === GITHUB_TOKEN }]
+                : []),
         ]);
     }
     /** Stages a value; your own file never keeps a line that only repeats the default. */
@@ -159,20 +219,32 @@ export class SettingsPage extends ListPage {
         if (result.value === DATA_FOLDER) {
             if (result.kind !== 'pick')
                 return {};
-            const exit = await new DataFolderFlow(this.app, this.ctx).run();
-            return exit ? { exit } : { reload: true };
+            return this.operations.perform(action(changeDataFolder, {}), [this.label, 'Data folder'], (text) => this.busy(text));
         }
         if (result.value === EXPORT_SETTINGS || result.value === IMPORT_SETTINGS) {
             if (result.kind !== 'pick')
                 return {};
-            const flow = new ShareSettingsFlow(this.app, this.ctx);
-            const notice = await (result.value === EXPORT_SETTINGS ? flow.export() : flow.import());
-            return { reload: true, notice };
+            const exporting = result.value === EXPORT_SETTINGS;
+            const page = settingsPage(await readQuery(listSettings, this.ctx, { scope: 'user' }));
+            const wanted = exporting ? 'settings.export' : 'settings.import';
+            const act = page.actions?.find((a) => a.kind === 'operation' && a.op === wanted);
+            if (!act)
+                return {};
+            return this.operations.perform(act, ['Settings', exporting ? 'Export settings' : 'Import settings']);
         }
         if (result.value === VPN_LOGIN) {
+            if (result.kind === 'action' && result.key === 'x')
+                return this.operations.perform(action(vpnLogout, {}), VPN_PATH, (t) => this.busy(t));
+            if (result.kind !== 'pick')
+                return {};
+            return this.operations.perform(action(vpnLogin, {}), VPN_PATH, (t) => this.busy(t));
+        }
+        if (result.value === GITHUB_TOKEN) {
+            if (result.kind === 'action' && result.key === 'x')
+                return this.operations.perform(action(githubLogout, {}), GITHUB_PATH, (t) => this.busy(t));
             if (result.kind !== 'pick')
                 return {};
-            return { reload: true, notice: await new VpnLoginFlow(this.app, this.ctx).run() };
+            return this.operations.perform(action(githubLogin, {}), GITHUB_PATH, (t) => this.busy(t));
         }
         const setting = settingsOf(this.file).find((s) => s.key.join('.') === result.value);
         if (!setting)

package/dist/cli/menu/render-view.js

@@ -37,6 +37,7 @@ export function menuView(page, o = {}) {
         if (e.action)
             enter.set(prefix + EMPTY_ROW, e.action);
     }
+    // Section.text (a log's lines) is not a row: the menu shows a log on the normal screen (menu.ts view), not here.
     for (const section of page.sections) {
         const heading = section.title ?? page.title;
         for (const f of section.facts ?? [])
@@ -55,7 +56,7 @@ export function menuView(page, o = {}) {
                 value: id,
                 label: safeText(item.label),
                 hint: paint(item.hint, item.tone),
-                description: item.description,
+                description: [item.description, item.keys].filter(Boolean).join(' ') || undefined,
                 details: item.details?.map(safeText),
                 section: item.group ?? heading,
                 keywords: item.keywords,

package/dist/cli/menu/settings/index.d.ts

@@ -1,2 +1 @@
 export { Draft, type DraftResult } from './draft.js';
-export { diffText, exportSettings, planImport, skippedLine, type DiffLine, type ImportPlan, type Pruned, type Skipped, } from './share.js';

package/dist/cli/menu/settings/index.js

@@ -1,4 +1,4 @@
-// The menu's settings editing: staged changes (Ctrl+S saves them), sharing settings, and the editors for each kind of
-// value. What the settings are, their files and rows live in the settings feature (src/app/features/settings).
+// The menu's settings editing: staged changes (Ctrl+S saves them) and the editors for each kind of value. What the
+// settings are, their files, rows and sharing (export, import) live in the settings feature
+// (src/app/features/settings).
 export { Draft } from './draft.js';
-export { diffText, exportSettings, planImport, skippedLine, } from './share.js';

package/dist/cli/menu/views.js

@@ -1,11 +1,39 @@
 // The shared core's views the menu shows, and in which section (the parity self-test reads this list: an operation or
 // query is reachable in the menu when a view here offers it). Settings is drawn by its own page over the same rows,
 // because the menu stages changes until Ctrl+S.
+import { agentsView } from '../../app/features/agents/index.js';
+import { dataView } from '../../app/features/data/index.js';
+import { accountsView } from '../../app/features/accounts/index.js';
+import { appsView } from '../../app/features/apps/index.js';
+import { healthView } from '../../app/features/health/index.js';
+import { logsView } from '../../app/features/logs/index.js';
+import { projectsView } from '../../app/features/projects/index.js';
 import { sandboxView } from '../../app/features/sandbox/index.js';
 import { sessionsView } from '../../app/features/sessions/index.js';
+import { storageView } from '../../app/features/storage/index.js';
 import { settingsView } from '../../app/features/settings/index.js';
+import { engineView } from '../../app/features/engine/index.js';
+import { updatesView } from '../../app/features/updates/index.js';
+import { webView } from '../../app/features/web/index.js';
+import { vpnView } from '../../app/features/vpn/index.js';
+import { githubView } from '../../app/features/github/index.js';
 export const MENU_VIEWS = [
+    { view: agentsView, section: 'Agents' },
     { view: sessionsView, section: 'Sessions' },
     { view: sandboxView, section: 'Sandbox' },
     { view: settingsView, section: 'Settings' },
+    { view: accountsView, section: 'Accounts' },
+    { view: appsView, section: 'Apps' },
+    { view: projectsView, section: 'Sandbox' },
+    { view: healthView, section: 'Maintenance' },
+    { view: dataView, section: 'Maintenance' },
+    { view: storageView, section: 'Maintenance' },
+    { view: logsView, section: 'Maintenance' },
+    { view: updatesView, section: 'Maintenance' },
+    { view: engineView, section: 'Maintenance' },
+    { view: webView, section: 'Maintenance' },
+    // The Settings page draws the VPN row itself (its login is staged with the settings); the view lists its operations.
+    { view: vpnView, section: 'Settings' },
+    // The same for the GitHub token row.
+    { view: githubView, section: 'Settings' },
 ];

package/dist/cli/operations/handler.js

@@ -4,7 +4,7 @@
 import { VIEWS } from '../../app/features/defs.js';
 import { runDefinition } from '../../app/registry.js';
 import { Cancelled } from '../../app/kernel/index.js';
-import { printJson, printPage } from '../output/index.js';
+import { nextStep, printJson, printPage } from '../output/index.js';
 import { cliInput, definitionFor } from './input.js';
 import { cliIO } from './io-cli.js';
 /** The view that shows only this query (its page is the command's text output). */
@@ -22,6 +22,9 @@ function printOutput(def, output, input) {
         const text = def.text(output);
         if (text)
             console.log(text);
+        const next = def.next?.(output);
+        if (next)
+            nextStep(next);
         return;
     }
     const shown = viewOf(def);
@@ -38,12 +41,13 @@ export function definitionHandler(def) {
         try {
             const output = await runDefinition(def.id, ctx, input, io);
             close();
+            const code = def.cli?.exitCode?.(output) ?? 0;
             if (def.cli?.json && ctx.options.json) {
                 printJson(ctx, def.cli.shapeJson ? def.cli.shapeJson(output) : output);
-                return 0;
+                return code;
             }
             printOutput(def, output, def.input.parse(input));
-            return 0;
+            return code;
         }
         catch (e) {
             close();

package/dist/cli/operations/input.d.ts

@@ -1,6 +1,6 @@
 import type { AnyDefinition } from '../../app/kernel/index.js';
 import type { CliOptions } from '../args.js';
-/** The definition a command runs: its own command, or an action of a hand-written one (`config get`). */
+/** The definition a command runs: its own command, or an action of a hand-written one (`config get`, `storage use`). */
 export declare function definitionFor(command: string, positionals: readonly string[]): AnyDefinition | undefined;
 /** The input a command line gives a definition (fields not on the line are left to the schema's defaults). */
 export declare function cliInput(def: AnyDefinition, options: CliOptions): Record<string, unknown>;