windows-development-sandbox 1.5.0 → 1.9.0

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

@@ -1,11 +1,15 @@
-// Tab 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.' },
@@ -16,57 +20,29 @@ 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 off = running ? {} : { disabled: 'No sandbox is running.' };
-    const sessions = m.report.projects.reduce((n, p) => n + p.sessions.length, 0) + m.report.otherSessions.length;
-    const 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))),
-        }),
-        row('act:show', 'Show the window', '', {
-            section: 'Actions',
-            description: 'Brings the sandbox window to the front.',
-            ...off,
-        }),
-        row('act:hide', 'Hide the window', '', {
-            section: 'Actions',
-            description: 'Hides the window; sbx-show inside the sandbox (or Show the window here) brings it back.',
-            ...off,
-        }),
-        row('act:stop', 'Stop the sandbox…', '', {
-            section: 'Actions',
-            description: 'Shuts the sandbox down; history and claude-mem sync back when it closes.',
-            ...off,
-        }),
-    ];
+    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…',
+        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.',
+        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,
@@ -80,6 +56,20 @@ export function sandboxOptions(m) {
             Theme.muted('In sandbox ') + (p.running ?? '-'),
         ],
     }));
+    const noDatabases = m.databases
+        ? []
+        : running
+            ? [
+                {
+                    value: 'info:db',
+                    label: 'The sandbox is not ready yet',
+                    category: 'databases',
+                    section: 'Databases',
+                    description: 'Its databases are listed once it is ready. l looks again.',
+                    disabled: 'Not ready yet: l looks again.',
+                },
+            ]
+            : startRows(m.defaultAgent, 'databases');
     const databases = (m.databases ?? []).map((d) => ({
         value: 'db:' + d.name,
         label: d.name,
@@ -90,42 +80,69 @@ export function sandboxOptions(m) {
     }));
     return {
         path: [],
-        items: [...status, ...roots, ...projects, ...databases],
+        items: [...statusItems, addRoot, ...roots, ...projects, ...databases, ...noDatabases],
         categories: CATEGORIES,
-        empty: running ? 'Nothing here yet.' : 'No sandbox is running.',
-        actions: sandboxActions,
-        enterLabel: 'run',
-        escapeLabel: 'quit',
+        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),
     };
 }
+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) {
+    return [
+        {
+            value: 'act:start',
+            label: 'Start the sandbox with ' + agent,
+            hint: Theme.muted('default agent'),
+            category,
+            section: 'No sandbox is running',
+            description: 'Starts the sandbox and ' + agent + ' in this folder.',
+        },
+        {
+            value: 'act:start-bare',
+            label: 'Start the sandbox without an agent',
+            category,
+            section: 'No sandbox is running',
+            description: 'Tools and databases only.',
+        },
+    ];
+}
+/** What Enter does on a row of Projects and Databases ("" = the row only shows information). */
+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' },
-            { key: 'f', label: 'forget / remove' },
-        ];
-    return category === 'databases'
-        ? []
-        : [
-            { key: 'w', label: 'show window' },
-            { key: 'h', label: 'hide window' },
-            { key: 'x', label: 'stop' },
+            { 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;
-    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) {
@@ -136,7 +153,7 @@ export class SandboxPage extends ListPage {
                 /* the sandbox did not answer: the list stays empty */
             }
         }
-        this.model = { report, projects: this.projects.list(), databases };
+        this.model = { report, projects: this.projects.list(), databases, defaultAgent: this.defaultAgent() };
     }
     /** The folder `sbx-db` runs in: the sandbox's own workspace. */
     guestWorkspace() {
@@ -151,16 +168,21 @@ export class SandboxPage extends ListPage {
         const id = result.kind === 'pick' || result.kind === 'action' ? result.value : undefined;
         const key = result.kind === 'action' ? result.key : undefined;
         try {
-            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 === '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 (key === 'a')
                 return await this.addRoot();
             if (key === 'f')
-                return this.forget(id);
+                return await this.forget(id);
             if (id?.startsWith('db:') && result.kind === 'pick')
                 return await this.toggleDatabase(id.slice(3));
         }
@@ -169,62 +191,25 @@ export class SandboxPage extends ListPage {
         }
         return {};
     }
+    defaultAgent() {
+        return this.ctx.loaded.config.defaultHarness;
+    }
     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.') + Theme.muted(' sbx-show brings it back.'),
-        };
-    }
-    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 typed = await this.app.text({
+        const picked = await this.app.pickPath({
             path: ['Sandbox', 'Add a project root'],
-            label: 'Folder that holds your projects',
+            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.',
             ],
-            validate: (v) => (v.trim() ? true : 'Type a folder.'),
+            use: 'add this root',
+            validate: (v) => (fs.existsSync(v) ? true : 'That folder does not exist.'),
         });
-        if (!typed)
+        if (!picked)
             return {};
-        const { dir, added } = this.projects.addRoot(typed.trim());
+        const { dir, added } = this.projects.addRoot(picked);
         return {
             reload: true,
             notice: added
@@ -232,8 +217,20 @@ export class SandboxPage extends ListPage {
                 : Theme.muted(dir + ' is a root already.'),
         };
     }
-    forget(id) {
-        if (id?.startsWith('root:')) {
+    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,

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,18 +1,16 @@
+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[];
-}
+/** 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);
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;

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

@@ -1,94 +1,41 @@
-// Tab 2: the agent sessions of the running sandbox. Enter shows one in this terminal (the one thing that leaves the
-// menu), r restarts the agents.
-import { errMsg, safeText } from '../../../core/util/index.js';
-import { isSandboxRunning } from '../../../host/sandbox/index.js';
-import { ago } from '../../output/index.js';
-import { SessionsService, viewerText } from '../../services/index.js';
-import { Theme } from '../../tui/index.js';
+// Section 2: the agent sessions of the running sandbox, as the sessions view shows them (src/app/features/sessions).
+// Enter shows one in this terminal (the one thing that leaves the menu), r restarts the agents.
+import { listSessions, sessionsPage } from '../../../app/features/sessions/index.js';
+import { readQuery } from '../../../app/registry.js';
+import { MenuOperations } from '../io-menu.js';
+import { menuView } from '../render-view.js';
 import { ListPage } from './list-page.js';
+function view(m) {
+    return menuView(sessionsPage({ ...m, wide: false }));
+}
 /** The list for the sessions tab. Pure. */
 export function sessionsOptions(m) {
-    return {
-        path: [],
-        intro: m.sandboxRunning
-            ? undefined
-            : 'No sandbox is running. Start one on the Start tab (1); its sessions are listed here.',
-        items: m.sessions.map((s) => ({
-            value: s.id,
-            label: safeText(s.harness) + '  ' + safeText(s.projectName ?? '-'),
-            hint: s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : '') + '  ' + ago(s.startedAt),
-            section: s.here ? "This folder's project" : 'Other sessions',
-            description: s.phase === 'running'
-                ? 'Enter shows this session in this terminal (Ctrl+] detaches; the session keeps running).'
-                : undefined,
-            details: [
-                Theme.muted('Session   ') + s.id,
-                Theme.muted('Folder    ') + safeText(s.cwd),
-                Theme.muted('Attached  ') + viewerText(s.viewers),
-            ],
-            ...(s.phase === 'running' ? {} : { disabled: 'This session has ended.' }),
-        })),
-        empty: 'No sessions yet.',
-        actions: [
-            { key: 'r', label: 'restart agents', importance: 1 },
-            { key: 'o', label: 'reopen last sessions', importance: 2 },
-            { key: 'l', label: 'refresh', importance: 3 },
-        ],
-        enterLabel: 'attach',
-        escapeLabel: 'quit',
-    };
+    const v = view(m);
+    return { path: [], items: v.items, actions: v.actions, enterLabel: v.enterLabel };
 }
 export class SessionsPage extends ListPage {
+    ctx;
     label = 'Sessions';
-    model = { sandboxRunning: false, sessions: [] };
-    service;
+    model;
+    operations;
     constructor(app, ctx) {
         super(app);
-        this.service = new SessionsService(ctx);
+        this.ctx = ctx;
+        this.operations = new MenuOperations(app, ctx);
+        this.model = { sandboxRunning: false, sessions: [], defaultAgent: ctx.loaded.config.defaultHarness };
     }
     async load() {
-        const sandboxRunning = isSandboxRunning();
-        try {
-            const list = sandboxRunning ? await this.service.list() : [];
-            this.model = { sandboxRunning, sessions: this.service.ordered(list) };
-        }
-        catch (e) {
-            this.model = { sandboxRunning, sessions: [] };
-            this.say(Theme.error(Theme.glyph.cross + ' ' + errMsg(e)));
-        }
+        this.model = await readQuery(listSessions, this.ctx);
     }
     options() {
         return sessionsOptions(this.model);
     }
     async act(result) {
-        if (result.kind === 'pick')
-            return { exit: { kind: 'run', argv: ['attach', result.value] } };
-        if (result.kind !== 'action')
+        const chosen = view(this.model).resolve(result);
+        if (!chosen)
             return {};
-        if (result.key === 'l')
+        if (chosen.kind === 'refresh')
             return { reload: true };
-        if (result.key === 'o')
-            return { exit: { kind: 'run', argv: ['resume'] } };
-        if (!this.model.sandboxRunning)
-            return { notice: Theme.warn('No sandbox is running.') };
-        const scope = this.service.restartScope(false);
-        const what = scope.guest ? 'the agents of ' + scope.projectName : 'every agent';
-        const ok = await this.app.ask('Restart ' + what + '?', [
-            'The agents are started again and continue their conversations where they can.',
-            ...(scope.notAProject
-                ? [scope.folder + ' is not a project of the running sandbox: every session restarts.']
-                : []),
-        ], 'Restart');
-        if (!ok)
-            return {};
-        try {
-            return {
-                reload: true,
-                notice: Theme.ok(Theme.glyph.ok + ' ' + safeText(await this.service.restart(null, scope.guest))),
-            };
-        }
-        catch (e) {
-            return { notice: Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) };
-        }
+        return this.operations.perform(chosen.action, [this.label], (text) => this.busy(text));
     }
 }

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

@@ -1,27 +1,23 @@
-import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
-import type { ConfigFile } from '../settings/config-file.js';
+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 { Draft } from '../settings/draft.js';
-import type { SchemaNode } from '../settings/schema-node.js';
 import { type Scope } from './scopes.js';
 import { ListPage, type Outcome } from './list-page.js';
-export interface Setting {
-    readonly key: string[];
-    readonly node: SchemaNode;
-    readonly category: string;
-    readonly section?: string;
-}
-/** Every editable setting with the category and heading it is shown under. */
-export declare function settingsOf(file: ConfigFile): Setting[];
-/** The list for the settings tab. Pure (reads the files it is given). */
-export declare function settingsOptions(files: Record<Scope, ConfigFile>, scope: Scope, draft: Draft): ListOptions<string>;
+export { settingsOf, type Setting };
+/** The row in General that opens the data folder flow (your own settings only). */
+export declare const DATA_FOLDER = "@data-folder";
+/** 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 class SettingsPage extends ListPage<string> {
     private readonly files;
     private readonly draft;
+    private readonly ctx;
     readonly label = "Settings";
     readonly stages = true;
     private scope;
     private readonly editor;
-    constructor(app: App, files: Record<Scope, ConfigFile>, draft: Draft);
+    constructor(app: App, files: Record<Scope, ConfigFile>, draft: Draft, ctx: Context);
     private get file();
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;