windows-development-sandbox 1.7.0 → 1.9.0

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

@@ -1,6 +1,16 @@
 // The common shape of a tab that is a list: it loads its data, builds a list screen from it, and acts on what the list
-// returns. After every action the list is built again from fresh data, on the same entry.
+// returns. After every action the list is built again from fresh data, on the same entry. Opening a tab never makes
+// the keys wait for a slow load: after a moment the tab shows "Loading…" (or the data it had), and the list is built
+// when the data is there.
 import { ListScreen, } from '../../tui/index.js';
+import { errMsg } from '../../../core/util/index.js';
+import { Theme } from '../../tui/index.js';
+/** A tab whose data is not here after this long shows "Loading…" instead of holding up the keys. */
+const QUICK_LOAD_MS = 120;
+/** What a tab shows before its data has arrived. */
+function loadingOptions() {
+    return { path: [], items: [], empty: 'Loading…' };
+}
 export class ListPage {
     app;
     stages = false;
@@ -10,6 +20,14 @@ export class ListPage {
     focused = true;
     /** The entry that was last acted on: the cursor returns to it when the section opens again. */
     lastFocus;
+    /** A search to start the next list with (restored from the last run); used once. */
+    pendingQuery;
+    /** The data has arrived at least once (until then the list is "Loading…"). */
+    loaded = false;
+    /** Counts loads, so that a slow one that was overtaken does not replace newer data. */
+    generation = 0;
+    /** A category asked for before the data arrived: it opens when it does. */
+    wantedCategory;
     constructor(app) {
         this.app = app;
     }
@@ -17,6 +35,10 @@ export class ListPage {
     initialFocus() {
         return undefined;
     }
+    /** The data has not arrived yet (the tab shows "Loading…"). */
+    get loading() {
+        return !this.loaded;
+    }
     get capturing() {
         return this.list?.isSearching ?? false;
     }
@@ -24,10 +46,24 @@ export class ListPage {
     get category() {
         return this.list?.currentCategory;
     }
+    /** The search typed in the list ('' when none). */
+    get search() {
+        return this.list?.searchText ?? '';
+    }
+    /** Shows the list with this search typed (the menu opens on the search it was left on). */
+    restoreSearch(text) {
+        this.pendingQuery = text;
+        if (this.loaded)
+            this.rebuild(undefined);
+    }
     categories() {
         return this.screen().categories;
     }
     async selectCategory(id) {
+        if (!this.loaded) {
+            this.wantedCategory = id;
+            return;
+        }
         this.screen().setCategory(id);
         await this.afterKey();
     }
@@ -41,7 +77,15 @@ export class ListPage {
     }
     /** A list from the current data; its categories are shown by the menu's navigation. */
     build(extra) {
-        const list = new ListScreen({ ...this.options(), ...extra, categoryNav: 'external', escapeLabel: 'sections' });
+        const startQuery = this.pendingQuery;
+        this.pendingQuery = undefined;
+        const list = new ListScreen({
+            ...(this.loaded ? this.options() : loadingOptions()),
+            startQuery,
+            ...extra,
+            categoryNav: 'external',
+            escapeLabel: 'sections',
+        });
         list.setActive(this.focused);
         return list;
     }
@@ -49,14 +93,68 @@ export class ListPage {
     ticked() {
         return this.list?.ticked() ?? [];
     }
+    /** Loads the data again; a slow load does not hold up the keys (the tab keeps what it showed, then updates). */
     async open() {
-        await this.load();
-        // Back on the entry used last, when it is still in the category that is open.
-        const wanted = this.lastFocus ?? this.initialFocus();
+        await this.reload(true);
+    }
+    /**
+     * Loads the data and waits for it at most QUICK_LOAD_MS. In time, the list is built here (`build`) or by the caller;
+     * later, the list is built when the data arrives, on the entry and search the user has moved to meanwhile.
+     */
+    async reload(build) {
+        const mine = ++this.generation;
+        let late = false;
+        let timer;
+        const quick = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                late = true;
+                resolve();
+            }, QUICK_LOAD_MS);
+        });
+        const arrived = this.loadData().then(() => {
+            if (mine !== this.generation)
+                return;
+            this.loaded = true;
+            if (late)
+                this.rebuildLate();
+            else if (build)
+                this.rebuildOpened();
+        });
+        await Promise.race([arrived, quick]);
+        clearTimeout(timer);
+    }
+    async loadData() {
+        try {
+            await this.load();
+        }
+        catch (e) {
+            this.say(Theme.error(Theme.glyph.cross + ' ' + errMsg(e)));
+        }
+    }
+    /** Back on the entry used last, when it is still in the category that is open. */
+    rebuildOpened() {
+        this.rebuildOn(this.lastFocus ?? this.initialFocus());
+        this.openWantedCategory();
+    }
+    /** Data that came after the keys stopped waiting: the cursor and the search stay where the user moved them. */
+    rebuildLate() {
+        if (this.list)
+            this.pendingQuery ??= this.list.searchText || undefined;
+        this.rebuildOn(this.list?.current);
+        this.openWantedCategory();
+        this.app.requestRedraw();
+    }
+    rebuildOn(wanted) {
         const open = this.list?.currentCategory;
         const item = wanted === undefined ? undefined : this.options().items.find((i) => i.value === wanted);
         this.rebuild(item && (!open || !item.category || item.category === open) ? wanted : undefined);
     }
+    openWantedCategory() {
+        if (!this.wantedCategory)
+            return;
+        this.list?.setCategory(this.wantedCategory);
+        this.wantedCategory = undefined;
+    }
     /** Builds the list again, on `focus` when it is still there. */
     rebuild(focus, notice) {
         const startCategory = this.list?.currentCategory;
@@ -83,8 +181,12 @@ export class ListPage {
         const outcome = result.kind === 'back' ? { exit: { kind: 'quit' } } : await this.act(result);
         if (outcome.exit)
             return { done: outcome.exit };
-        if (outcome.reload)
-            await this.load();
+        // What the action changed (a stop, a restart) is known to the menu before the page loads again. An action that
+        // loads nothing again changed nothing the menu shows, so the keys do not wait for it.
+        if (outcome.reload) {
+            await this.app.afterAction();
+            await this.reload(false);
+        }
         const here = result.kind === 'pick' || result.kind === 'action' ? result.value : undefined;
         this.lastFocus = outcome.focus ?? here ?? this.lastFocus;
         this.rebuild(outcome.focus ?? here, outcome.notice);

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

@@ -4,8 +4,6 @@ import { type DataEntry } from '../../commands/data/collect.js';
 import type { RepairResult } from '../../commands/repair/types.js';
 import { type LogFile, type SetupReport, type UpdateStatus } from '../../services/index.js';
 import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
-import type { Step } from '../../tui/index.js';
-import type { ShellExit } from '../shell.js';
 import { ListPage, type Outcome } from './list-page.js';
 export interface MaintenanceModel {
     /** The data folder row (where the sandbox keeps its data). */
@@ -54,7 +52,6 @@ export declare class MaintenancePage extends ListPage<string> {
     private doctorRows;
     private repairRows;
     private setupReport;
-    private seen;
     private settings;
     private readonly migrate;
     private readonly health;
@@ -65,8 +62,6 @@ export declare class MaintenancePage extends ListPage<string> {
     private model;
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;
-    /** Opening a category loads what it shows (the cheap ones; data is measured on request). */
-    protected afterKey(): Promise<Step<ShellExit>>;
     private readSettings;
     private updateStatus;
     /** The Updates category: look, install, go back, switch automatic updates. */

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

@@ -148,6 +148,18 @@ export function maintenanceOptions(m) {
         hint: humanBytes(f.bytes) + '  ' + ago(f.modified),
         description: 'Enter shows the end of this log in the terminal.',
     }));
+    // The checks take seconds (programs are run), so they are not made while you move through the categories.
+    const check = m.doctor === null && m.setup === null
+        ? [
+            {
+                value: 'health:check',
+                label: 'Check this PC',
+                category: 'health',
+                section: 'Doctor',
+                description: 'Looks at this PC: Windows features, the install, the folders and the sandbox. It takes a few seconds, so it only runs when you ask.',
+            },
+        ]
+        : [];
     const doctor = (m.doctor ?? []).map(([name, detail], i) => ({
         value: 'doctor:' + i,
         label: name,
@@ -225,7 +237,7 @@ export function maintenanceOptions(m) {
     return {
         path: [],
         categories: CATEGORIES,
-        items: [...updates, ...settings, ...dataItems(m), ...doctor, ...repair, ...setup, ...logs, ...more],
+        items: [...updates, ...settings, ...dataItems(m), ...check, ...doctor, ...repair, ...setup, ...logs, ...more],
         empty: 'Nothing here yet.',
         actions: maintenanceActions(m),
         enterLabel: (_category, id) => enterLabel(id ?? '', m),
@@ -241,6 +253,8 @@ function enterLabel(id, m) {
         return 'choose what';
     if (id === 'repair:run')
         return 'check and fix';
+    if (id === 'health:check')
+        return 'check';
     if (id === 'updates:latest')
         return m.latest ? 'install' : 'look';
     if (id === 'updates:auto')
@@ -271,7 +285,7 @@ function maintenanceActions(m) {
                 const canEnable = m.setup !== null && !('error' in m.setup) && m.setup.canEnable;
                 return [
                     { key: 'f', label: 'check and fix' },
-                    { key: 'l', label: 'check again' },
+                    { key: 'l', label: m.doctor ? 'check again' : 'check' },
                     ...(canEnable ? [{ key: 'e', label: 'turn on Windows Sandbox' }] : []),
                 ];
             }
@@ -313,7 +327,6 @@ export class MaintenancePage extends ListPage {
     doctorRows = null;
     repairRows = null;
     setupReport = null;
-    seen;
     settings = { pending: [] };
     migrate;
     health;
@@ -362,21 +375,6 @@ export class MaintenancePage extends ListPage {
     options() {
         return maintenanceOptions(this.model());
     }
-    /** Opening a category loads what it shows (the cheap ones; data is measured on request). */
-    async afterKey() {
-        const category = this.category;
-        if (category === this.seen)
-            return;
-        this.seen = category;
-        if (category !== 'health' || (this.doctorRows && this.setupReport))
-            return;
-        if (!this.doctorRows)
-            await this.loadDoctor();
-        if (!this.setupReport)
-            await this.loadSetup();
-        this.rebuild(undefined);
-        return;
-    }
     readSettings() {
         try {
             this.settings = { pending: this.migrate.plan() };
@@ -493,7 +491,7 @@ export class MaintenancePage extends ListPage {
             if (this.category === 'health') {
                 if (key === 'f' || id === 'repair:run')
                     return this.repair();
-                if (key === 'l') {
+                if (key === 'l' || id === 'health:check') {
                     await this.loadDoctor();
                     await this.loadSetup();
                     return {};

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

@@ -1,9 +1,10 @@
+import { type SandboxStatus } from '../../../app/features/sandbox/index.js';
 import type { Context } from '../../commands/context.js';
-import { type DatabaseRow, type ProjectsListing, type SandboxReport } from '../../services/index.js';
+import { type DatabaseRow, type ProjectsListing } 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: SandboxReport;
+    readonly report: SandboxStatus;
     readonly projects: ProjectsListing;
     /** Null: the sandbox is not running or did not answer. */
     readonly databases: DatabaseRow[] | null;
@@ -16,8 +17,8 @@ export declare class SandboxPage extends ListPage<string> {
     private readonly ctx;
     readonly label = "Sandbox";
     private model;
-    private readonly sandbox;
     private readonly projects;
+    private readonly operations;
     constructor(app: App, ctx: Context);
     protected load(): Promise<void>;
     /** The folder `sbx-db` runs in: the sandbox's own workspace. */
@@ -26,9 +27,6 @@ export declare class SandboxPage extends ListPage<string> {
     protected act(result: ListResult<string>): Promise<Outcome<string>>;
     private defaultAgent;
     private noSandbox;
-    private show;
-    private hide;
-    private stop;
     private addRoot;
     private forget;
     private toggleDatabase;

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

@@ -1,12 +1,15 @@
-// Section 3: the sandbox as a whole. Status (a card, the window, stopping it), Projects (roots and known projects) and
-// Databases (start and stop), each a category on the left.
+// 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';
+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 { ago } from '../../output/index.js';
-import { DatabasesService, ProjectsService, SandboxService, } from '../../services/index.js';
+import { DatabasesService, ProjectsService } from '../../services/index.js';
 import { Text, Theme, } from '../../tui/index.js';
+import { MenuOperations } from '../io-menu.js';
+import { menuView } from '../render-view.js';
 import { ListPage } from './list-page.js';
 const CATEGORIES = [
     { id: 'status', label: 'Status', description: 'What the sandbox is doing, its window, and stopping it.' },
@@ -17,51 +20,15 @@ const CATEGORIES = [
     },
     { id: 'databases', label: 'Databases', description: 'Databases the sandbox can run: start and stop them.' },
 ];
-const yesNo = (v) => (v === undefined ? '-' : v ? 'yes' : 'no');
+/** The status category: the sandbox view's rows (prefixed, so they never clash with the projects' rows). */
+function statusView(m) {
+    return menuView(sandboxPage(m.report), { category: 'status', prefix: 'status:', refresh: false });
+}
 /** The list for the sandbox tab. Pure. */
 export function sandboxOptions(m) {
-    const { sandbox, repoGuard } = m.report;
-    const running = sandbox.running;
-    const row = (id, label, hint, extra = {}) => ({
-        value: id,
-        label,
-        hint,
-        category: 'status',
-        section: 'Sandbox',
-        ...extra,
-    });
-    const sessions = m.report.projects.reduce((n, p) => n + p.sessions.length, 0) + m.report.otherSessions.length;
-    const status = [
-        ...(running ? [] : startRows(m.defaultAgent, 'status')),
-        row('info:state', 'State', running ? Theme.ok(Theme.glyph.on + ' ' + sandbox.phase) : Theme.muted(Theme.glyph.off + ' stopped'), { description: sandbox.message ? safeText(sandbox.message) : undefined }),
-        row('info:uptime', 'Up for', sandbox.startedAt && running ? ago(sandbox.startedAt).replace(' ago', '') : '-'),
-        row('info:daemon', 'Sandbox agent', running ? safeText(sandbox.daemon) : '-'),
-        row('info:window', 'Window', running ? (sandbox.headless ? 'hidden' : 'shown') : '-'),
-        row('info:sessions', 'Sessions', running ? String(sessions) : '-'),
-        row('info:account', 'Claude account', sandbox.account ?? '-'),
-        row('info:sync', 'History sync running', yesNo(sandbox.syncWatcher)),
-        row('info:guard', 'Repo guard', repoGuard.guarded +
-            ' folder(s) guarded' +
-            (repoGuard.findings.length ? ', ' + repoGuard.findings.length + ' change(s) neutralised' : ''), {
-            details: repoGuard.findings.slice(-8).map((f) => Theme.warn(safeText(f))),
-        }),
-        ...(running
-            ? [
-                row('act:show', 'Show the window', '', {
-                    section: 'Actions',
-                    description: 'Brings the sandbox window to the front.',
-                }),
-                row('act:hide', 'Hide the window', '', {
-                    section: 'Actions',
-                    description: 'Hides the window. Show the window brings it back.',
-                }),
-                row('act:stop', 'Stop the sandbox…', '', {
-                    section: 'Actions',
-                    description: 'Shuts the sandbox down; your history syncs back when it closes.',
-                }),
-            ]
-            : []),
-    ];
+    const running = m.report.sandbox.running;
+    const status = statusView(m);
+    const statusItems = [...(running ? [] : startRows(m.defaultAgent, 'status')), ...status.items];
     const addRoot = {
         value: ADD_ROOT,
         label: '+ Add a project root…',
@@ -113,11 +80,11 @@ export function sandboxOptions(m) {
     }));
     return {
         path: [],
-        items: [...status, addRoot, ...roots, ...projects, ...databases, ...noDatabases],
+        items: [...statusItems, addRoot, ...roots, ...projects, ...databases, ...noDatabases],
         categories: CATEGORIES,
         empty: 'Nothing here yet.',
-        actions: (category) => sandboxActions(category, running),
-        enterLabel: (_category, id) => enterLabel(id ?? '', m),
+        actions: (category) => category === 'projects' || category === 'databases' ? sandboxActions(category) : [...status.actions, REFRESH],
+        enterLabel: (category, id) => status.enterLabel(category, id) || enterLabel(id ?? '', m),
     };
 }
 const ADD_ROOT = '@add-root';
@@ -142,14 +109,8 @@ function startRows(agent, category) {
         },
     ];
 }
-/** What Enter does on a row ("" = the row only shows information). */
+/** What Enter does on a row of Projects and Databases ("" = the row only shows information). */
 function enterLabel(id, m) {
-    if (id === 'act:show')
-        return 'show';
-    if (id === 'act:hide')
-        return 'hide';
-    if (id === 'act:stop')
-        return 'stop';
     if (id.startsWith('act:start'))
         return 'start';
     if (id === ADD_ROOT)
@@ -158,7 +119,7 @@ function enterLabel(id, m) {
         return m.databases?.find((d) => 'db:' + d.name === id)?.running ? 'stop' : 'start';
     return '';
 }
-function sandboxActions(category, running) {
+function sandboxActions(category) {
     if (category === 'projects')
         return [
             { key: 'a', label: 'add root', importance: 1 },
@@ -166,31 +127,22 @@ function sandboxActions(category, running) {
             { key: 'f', label: 'forget project', importance: 1, applies: (id) => id.startsWith('project:') },
             REFRESH,
         ];
-    if (category === 'databases')
-        return [REFRESH];
-    return running
-        ? [
-            { key: 'w', label: 'show window', importance: 3 },
-            { key: 'h', label: 'hide window', importance: 3 },
-            { key: 'x', label: 'stop', importance: 1 },
-            REFRESH,
-        ]
-        : [REFRESH];
+    return [REFRESH];
 }
 export class SandboxPage extends ListPage {
     ctx;
     label = 'Sandbox';
     model;
-    sandbox;
     projects;
+    operations;
     constructor(app, ctx) {
         super(app);
         this.ctx = ctx;
-        this.sandbox = new SandboxService(ctx);
         this.projects = new ProjectsService(ctx);
+        this.operations = new MenuOperations(app, ctx);
     }
     async load() {
-        const report = await this.sandbox.status();
+        const report = await readQuery(sandboxStatus, this.ctx);
         const guest = report.sandbox.running && report.sandbox.phase === 'ready' ? this.guestWorkspace() : null;
         let databases = null;
         if (guest) {
@@ -218,18 +170,15 @@ export class SandboxPage extends ListPage {
         try {
             if (key === 'l')
                 return { reload: true };
+            const chosen = this.model ? statusView(this.model).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 (id === 'act:show' || key === 'w')
-                return this.show();
-            if (id === 'act:hide' || key === 'h')
-                return await this.hide();
-            if (id === 'act:stop' || key === 'x')
-                return await this.stop();
             if (key === 'a')
                 return await this.addRoot();
             if (key === 'f')
@@ -248,47 +197,6 @@ export class SandboxPage extends ListPage {
     noSandbox() {
         return this.model?.report.sandbox.running ? null : { notice: Theme.warn('No sandbox is running.') };
     }
-    show() {
-        const none = this.noSandbox();
-        if (none)
-            return none;
-        this.sandbox.showWindow();
-        return { notice: Theme.ok(Theme.glyph.ok + ' Window shown.') };
-    }
-    async hide() {
-        const none = this.noSandbox();
-        if (none)
-            return none;
-        await this.sandbox.hideWindow();
-        return {
-            reload: true,
-            notice: Theme.ok(Theme.glyph.ok + ' Window hidden.'),
-        };
-    }
-    async stop() {
-        const none = this.noSandbox();
-        if (none)
-            return none;
-        const plan = this.sandbox.stopPlan();
-        const named = plan.running.map((s) => safeText(s.harness) + ' in ' + safeText(s.project ?? path.win32.basename(s.cwd)));
-        const lines = [
-            plan.running.length
-                ? 'Stopping ends ' +
-                    plan.running.length +
-                    ' session' +
-                    (plan.running.length === 1 ? '' : 's') +
-                    ': ' +
-                    named.join(', ') +
-                    '.'
-                : 'No session is running.',
-            ...(plan.others.length ? [plan.others.length + ' of them belong to other projects.'] : []),
-            'History and claude-mem sync back when it closes.',
-        ];
-        if (!(await this.app.ask('Stop the sandbox?', lines, 'Stop', true)))
-            return {};
-        await this.sandbox.shutdown(plan.sandbox);
-        return { reload: true, notice: Theme.ok(Theme.glyph.ok + ' The sandbox is shutting down.') };
-    }
     async addRoot() {
         const picked = await this.app.pickPath({
             path: ['Sandbox', 'Add a project root'],

package/dist/cli/menu/pages/scopes.d.ts

@@ -1,5 +1,5 @@
 import { type Tab } from '../../tui/index.js';
-import type { ConfigFile } from '../settings/config-file.js';
+import type { ConfigFile } from '../../../app/features/settings/index.js';
 export type Scope = 'user' | 'project';
 export declare const SCOPES: {
     scope: Scope;

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

@@ -1,23 +1,17 @@
+import { type SessionsList } from '../../../app/features/sessions/index.js';
 import type { Context } from '../../commands/context.js';
-import { type ListedSession } from '../../services/index.js';
-import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
+import type { App, ListOptions, ListResult } from '../../tui/index.js';
 import { ListPage, type Outcome } from './list-page.js';
-export interface SessionsModel {
-    readonly sandboxRunning: boolean;
-    /** Newest first, this folder's project first. */
-    readonly sessions: readonly ListedSession[];
-    /** The agent "Start" offers while there is no session. */
-    readonly defaultAgent: string;
-}
+/** What the page shows: the sessions query's result (the folder column is never shown here). */
+export type SessionsModel = Omit<SessionsList, 'wide'>;
 /** The list for the sessions tab. Pure. */
 export declare function sessionsOptions(m: SessionsModel): ListOptions<string>;
 export declare class SessionsPage extends ListPage<string> {
     private readonly ctx;
     readonly label = "Sessions";
     private model;
-    private readonly service;
+    private readonly operations;
     constructor(app: App, ctx: Context);
-    private defaultAgent;
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;
     protected act(result: ListResult<string>): Promise<Outcome<string>>;