windows-development-sandbox 1.4.3 → 1.5.0

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

@@ -0,0 +1,273 @@
+// 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.
+import path from 'node:path';
+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 { Text, Theme, } from '../../tui/index.js';
+import { ListPage } from './list-page.js';
+const CATEGORIES = [
+    { id: 'status', label: 'Status', description: 'What the sandbox is doing, its window, and stopping it.' },
+    {
+        id: 'projects',
+        label: 'Projects',
+        description: 'Project roots (folders of projects, opened without a restart) and the projects started before.',
+    },
+    { id: 'databases', label: 'Databases', description: 'Databases the sandbox can run: start and stop them.' },
+];
+const yesNo = (v) => (v === undefined ? '-' : v ? 'yes' : 'no');
+/** 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 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.',
+    }));
+    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 databases = (m.databases ?? []).map((d) => ({
+        value: 'db:' + d.name,
+        label: d.name,
+        hint: d.running ? Theme.ok('running') + Theme.muted(' :' + d.port) : Theme.muted('stopped :' + d.port),
+        category: 'databases',
+        section: 'Databases',
+        description: d.title + '. Enter ' + (d.running ? 'stops' : 'starts') + ' it (the first start downloads it).',
+    }));
+    return {
+        path: [],
+        items: [...status, ...roots, ...projects, ...databases],
+        categories: CATEGORIES,
+        empty: running ? 'Nothing here yet.' : 'No sandbox is running.',
+        actions: sandboxActions,
+        enterLabel: 'run',
+        escapeLabel: 'quit',
+    };
+}
+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' },
+        ];
+}
+export class SandboxPage extends ListPage {
+    ctx;
+    label = 'Sandbox';
+    model;
+    sandbox;
+    projects;
+    constructor(app, ctx) {
+        super(app);
+        this.ctx = ctx;
+        this.sandbox = new SandboxService(ctx);
+        this.projects = new ProjectsService(ctx);
+    }
+    async load() {
+        const report = await this.sandbox.status();
+        const guest = report.sandbox.running && report.sandbox.phase === 'ready' ? this.guestWorkspace() : null;
+        let databases = null;
+        if (guest) {
+            try {
+                databases = await new DatabasesService(this.ctx).list(guest);
+            }
+            catch {
+                /* the sandbox did not answer: the list stays empty */
+            }
+        }
+        this.model = { report, projects: this.projects.list(), databases };
+    }
+    /** The folder `sbx-db` runs in: the sandbox's own workspace. */
+    guestWorkspace() {
+        return new RunDir(this.ctx.dataPath).readSandboxStatus()?.guestWorkspace ?? null;
+    }
+    options() {
+        if (!this.model)
+            throw new Error('The sandbox tab was not loaded');
+        return sandboxOptions(this.model);
+    }
+    async act(result) {
+        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 === 'a')
+                return await this.addRoot();
+            if (key === 'f')
+                return this.forget(id);
+            if (id?.startsWith('db:') && result.kind === 'pick')
+                return await this.toggleDatabase(id.slice(3));
+        }
+        catch (e) {
+            return { notice: Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) };
+        }
+        return {};
+    }
+    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({
+            path: ['Sandbox', 'Add a project root'],
+            label: '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.'),
+        });
+        if (!typed)
+            return {};
+        const { dir, added } = this.projects.addRoot(typed.trim());
+        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.'),
+        };
+    }
+    forget(id) {
+        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)
+            return none;
+        const row = this.model?.databases?.find((d) => d.name === name);
+        const guest = this.guestWorkspace();
+        if (!row || !guest)
+            return {};
+        const action = row.running ? 'stop' : 'start';
+        this.busy((row.running ? 'Stopping ' : 'Starting ') + name + '… the first start downloads it', 'db:' + name);
+        const result = await new DatabasesService(this.ctx).run(action, name, guest);
+        const last = safeText((result.stdout ?? '').trim().split(/\r?\n/).pop() ?? result.message);
+        return {
+            reload: true,
+            notice: result.ok ? Theme.ok(Theme.glyph.ok + ' ' + last) : Theme.error(Theme.glyph.cross + ' ' + last),
+        };
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type Tab } from '../../tui/index.js';
+import type { ConfigFile } from '../settings/config-file.js';
+export type Scope = 'user' | 'project';
+export declare const SCOPES: {
+    scope: Scope;
+    tab: Tab;
+}[];
+/** The line under the tabs: which file is being edited. */
+export declare function scopeStatus(file: ConfigFile): string;

package/dist/cli/menu/pages/scopes.js

@@ -0,0 +1,15 @@
+// The two scopes Settings and Apps edit: your own file ("All projects", blue) and this folder's .sandbox-config.json
+// ("This project", purple).
+import { Text, Theme } from '../../tui/index.js';
+export const SCOPES = [
+    { scope: 'user', tab: { label: 'All projects', badge: 'YOURS', paint: Theme.scopeGlobal } },
+    { scope: 'project', tab: { label: 'This project', badge: 'PROJECT', paint: Theme.scopeProject } },
+];
+/** The line under the tabs: which file is being edited. */
+export function scopeStatus(file) {
+    return ((file.isProject ? Theme.project('●') : Theme.accent('●')) +
+        Theme.muted(' Editing ') +
+        Text.middle(file.file, 80) +
+        (file.exists ? '' : Theme.muted(' (created when you save)')) +
+        (file.isProject ? Theme.muted('  · only what a project may set; needs your approval at the next launch') : ''));
+}

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

@@ -0,0 +1,20 @@
+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 { 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 list for the sessions tab. Pure. */
+export declare function sessionsOptions(m: SessionsModel): ListOptions<string>;
+export declare class SessionsPage extends ListPage<string> {
+    readonly label = "Sessions";
+    private model;
+    private readonly service;
+    constructor(app: App, ctx: Context);
+    protected load(): Promise<void>;
+    protected options(): ListOptions<string>;
+    protected act(result: ListResult<string>): Promise<Outcome<string>>;
+}

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

@@ -0,0 +1,94 @@
+// 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';
+import { ListPage } from './list-page.js';
+/** 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',
+    };
+}
+export class SessionsPage extends ListPage {
+    label = 'Sessions';
+    model = { sandboxRunning: false, sessions: [] };
+    service;
+    constructor(app, ctx) {
+        super(app);
+        this.service = new SessionsService(ctx);
+    }
+    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)));
+        }
+    }
+    options() {
+        return sessionsOptions(this.model);
+    }
+    async act(result) {
+        if (result.kind === 'pick')
+            return { exit: { kind: 'run', argv: ['attach', result.value] } };
+        if (result.kind !== 'action')
+            return {};
+        if (result.key === 'l')
+            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)) };
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
+import type { ConfigFile } from '../settings/config-file.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 declare class SettingsPage extends ListPage<string> {
+    private readonly files;
+    private readonly draft;
+    readonly label = "Settings";
+    readonly stages = true;
+    private scope;
+    private readonly editor;
+    constructor(app: App, files: Record<Scope, ConfigFile>, draft: Draft);
+    private get file();
+    protected load(): Promise<void>;
+    protected options(): ListOptions<string>;
+    /** Stages a value; your own file never keeps a line that only repeats the default. */
+    private stage;
+    protected act(result: ListResult<string>): Promise<Outcome<string>>;
+}

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

@@ -0,0 +1,207 @@
+// Tab 5: every setting, for all projects or just this project (two scopes), grouped into categories on the left and
+// searchable, with each value, its default and its description. 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 { NEVER_LOOSER } from '../../../core/local-config/index.js';
+import { errMsg } from '../../../core/util/index.js';
+import { Text, Theme, } from '../../tui/index.js';
+import { CATEGORIES, categoryOf, nameOf } from '../settings/categories.js';
+import { formatValue } from '../settings/format.js';
+import { ValueEditor } from '../settings/value-editor.js';
+import { SCOPES, scopeStatus } from './scopes.js';
+import { ListPage } from './list-page.js';
+/** Every editable setting with the category and heading it is shown under. */
+export function settingsOf(file) {
+    return file.schema.children().flatMap(([top, node]) => {
+        const category = categoryOf(top);
+        if (!category)
+            return [];
+        const several = category.keys.filter((k) => file.schema.child(k)).length > 1;
+        if (!node.isSection)
+            return [
+                {
+                    key: [top],
+                    node,
+                    category: category.id,
+                    section: several && category.id !== 'general' ? nameOf(top) : undefined,
+                },
+            ];
+        return node.leaves([top]).map(({ key, node: leaf }) => {
+            const heading = [
+                several ? nameOf(top) : undefined,
+                key.length > 2 ? key.slice(1, -1).map(nameOf).join(' › ') : undefined,
+            ]
+                .filter(Boolean)
+                .join(' › ');
+            return { key, node: leaf, category: category.id, section: heading || undefined };
+        });
+    });
+}
+/** What the file will say for a setting once the staged changes are saved (undefined = not set there). */
+function written(file, draft, key) {
+    return draft.has(file, key) ? draft.value(file, key) : file.valueInFile(key);
+}
+/** What is in effect for a setting once the staged changes are saved. */
+function effective(file, draft, key, config) {
+    if (file.isProject)
+        return written(file, draft, key);
+    return draft.has(file, key) ? (draft.value(file, key) ?? file.defaultOf(key)) : _.get(config, key);
+}
+/** Plain words for settings whose key is jargon (the key itself stays in the details pane). */
+const LABELS = {
+    mappings: 'Extra folders from this PC',
+    'sandbox.vGpu': 'Graphics acceleration',
+    'sandbox.headless': 'Hide the sandbox window',
+    'sandbox.memoryMb': 'Memory (MB)',
+    'sandbox.pageFileMb': 'Swap file (MB)',
+    'network.dns': 'DNS servers',
+    'projects.wsbShare': 'Add folders while the sandbox runs',
+    'projects.all': 'Map all known projects at start',
+    'claudeProfile.hostDir': 'Claude folder on this PC',
+    'claudeProfile.globalStateFile': 'Claude state file on this PC',
+};
+function labelOf(key) {
+    return LABELS[key.join('.')] ?? Text.humanize(key[key.length - 1]);
+}
+function item(s, files, scope, draft, config) {
+    const file = files[scope];
+    const id = s.key.join('.');
+    const set = written(file, draft, s.key) !== undefined;
+    const unsaved = draft.has(file, s.key);
+    const yours = effective(files.user, draft, s.key, config);
+    const project = files.project;
+    const inProject = project.schema.leaves().some((l) => l.key.join('.') === id)
+        ? written(project, draft, s.key)
+        : undefined;
+    const paint = file.isProject ? Theme.project : Theme.changed;
+    const value = file.isProject && !set
+        ? Theme.muted('all projects: ') + formatValue(yours, 40)
+        : formatValue(effective(file, draft, s.key, config));
+    const details = [
+        Theme.muted('Setting       ') + id,
+        Theme.muted('All projects  ') +
+            formatValue(yours, 40) +
+            Theme.muted(written(files.user, draft, s.key) === undefined ? '  (built-in default)' : '  (your file)'),
+        Theme.muted('This project  ') +
+            (inProject === undefined ? Theme.muted('not set') : Theme.project(Text.strip(formatValue(inProject, 40)))),
+        ...(!file.isProject ? [Theme.muted('Default       ') + formatValue(file.defaultOf(s.key), 40)] : []),
+        ...(unsaved ? [Theme.warn('Unsaved: Ctrl+S saves, z undoes this change.')] : []),
+        ...(file.isProject && NEVER_LOOSER.includes(id)
+            ? [Theme.warn(Theme.glyph.lock + ' A project can only make this stricter than your own setting.')]
+            : []),
+    ];
+    return {
+        value: id,
+        label: labelOf(s.key),
+        hint: unsaved
+            ? paint(Text.strip(value)) + ' ' + Theme.warn('*')
+            : set
+                ? paint(Text.strip(value)) + ' ' + paint(Theme.glyph.changed)
+                : value,
+        description: s.node.description,
+        details,
+        section: s.section,
+        category: s.category,
+        keywords: id,
+        flip: s.node.editor === 'boolean',
+    };
+}
+/** The list for the settings tab. Pure (reads the files it is given). */
+export function settingsOptions(files, scope, draft) {
+    const file = files[scope];
+    const config = file.userConfig();
+    const settings = settingsOf(file);
+    const categories = CATEGORIES.filter((c) => settings.some((s) => s.category === c.id)).map((c) => ({
+        id: c.id,
+        label: c.label,
+        description: c.description,
+    }));
+    return {
+        path: [],
+        status: scopeStatus(file),
+        tabs: { items: SCOPES.map((x) => x.tab), active: SCOPES.findIndex((x) => x.scope === scope) },
+        items: settings.map((s) => item(s, files, scope, draft, config)),
+        categories,
+        actions: [
+            { key: 'r', label: file.isProject ? 'remove' : 'reset' },
+            { key: 'z', label: 'undo' },
+        ],
+        enterLabel: 'edit',
+        escapeLabel: 'quit',
+    };
+}
+export class SettingsPage extends ListPage {
+    files;
+    draft;
+    label = 'Settings';
+    stages = true;
+    scope = 'user';
+    editor;
+    constructor(app, files, draft) {
+        super(app);
+        this.files = files;
+        this.draft = draft;
+        this.editor = new ValueEditor(app, {
+            suggestions: (key) => ['defaultHarness', 'harness'].includes(key.join('.'))
+                ? Object.keys(this.files.user.userConfig().harnesses)
+                : undefined,
+        });
+    }
+    get file() {
+        return this.files[this.scope];
+    }
+    load() {
+        return Promise.resolve();
+    }
+    options() {
+        return settingsOptions(this.files, this.scope, this.draft);
+    }
+    /** Stages a value; your own file never keeps a line that only repeats the default. */
+    stage(key, value) {
+        const file = this.file;
+        if (!file.isProject &&
+            value !== undefined &&
+            _.isEqual(value, file.defaultOf(key)) &&
+            file.valueInFile(key) === undefined)
+            this.draft.unstage(file, key);
+        else
+            this.draft.stage(file, key, value);
+    }
+    async act(result) {
+        if (result.kind === 'tab') {
+            this.scope = SCOPES[result.index].scope;
+            return {};
+        }
+        if (result.kind !== 'pick' && result.kind !== 'action')
+            return {};
+        if (result.value === undefined)
+            return {};
+        const setting = settingsOf(this.file).find((s) => s.key.join('.') === result.value);
+        if (!setting)
+            return {};
+        if (result.kind === 'action') {
+            if (result.key === 'z') {
+                this.draft.unstage(this.file, setting.key);
+                return {};
+            }
+            this.stage(setting.key, undefined);
+            return {};
+        }
+        if (result.value === 'apps.install')
+            return { notice: Theme.muted('Choose apps on the Apps tab (press 4); the list is picked there, not typed.') };
+        try {
+            const config = this.file.userConfig();
+            const current = this.file.isProject
+                ? (written(this.file, this.draft, setting.key) ?? _.get(config, setting.key))
+                : effective(this.file, this.draft, setting.key, config);
+            const path = ['Settings', ...setting.key.slice(0, -1).map(nameOf), labelOf(setting.key)];
+            const edited = await this.editor.edit(path, setting.key, setting.node, current);
+            if (edited)
+                this.stage(setting.key, edited.value);
+        }
+        catch (e) {
+            return { notice: Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) };
+        }
+        return {};
+    }
+}