windows-development-sandbox 1.5.0 → 1.9.0

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

@@ -0,0 +1,176 @@
+// The agent sessions of the running sandbox: the list (live) and restarting the agents. Pure: schemas, labels and the
+// view; sessions.run.ts does the work. A running session links to its terminal (attach in the menu, the terminal page
+// in the web UI).
+import { z } from 'zod';
+import { action, ago, defineOperation, defineQuery, defineView, link, } from '../../kernel/index.js';
+const ViewersSchema = z.object({ viewers: z.number(), remote: z.number() });
+/** A session as every surface may see it: never its attach address or token. */
+export const SessionRowSchema = z.object({
+    id: z.string().describe('The session'),
+    launchId: z.string(),
+    harness: z.string().describe('The agent'),
+    cwd: z.string().describe('Its folder in the sandbox'),
+    project: z.string().optional(),
+    phase: z.enum(['starting', 'running', 'exited', 'failed']).describe('What it is doing'),
+    message: z.string(),
+    updatedAt: z.string(),
+    startedAt: z.string().describe('When it started'),
+    conversation: z.string().optional(),
+    exitCode: z.number().optional(),
+    projectName: z.string().optional().describe('The project it runs in'),
+    here: z.boolean().optional().describe('In the project of the current folder'),
+    /** Terminals attached (from this PC and in the sandbox); null: an older session that cannot say. */
+    viewers: ViewersSchema.nullable().optional(),
+    /** It runs and its terminal can be reached from this PC. */
+    canOpen: z.boolean(),
+});
+export const SessionsListSchema = z.object({
+    sandboxRunning: z.boolean(),
+    /** The agent offered when nothing runs. */
+    defaultAgent: z.string(),
+    /** The folder column is wanted (sandbox sessions --wide). */
+    wide: z.boolean(),
+    /** "Running, started by alice (shared with you)" when the sandbox is another user's. */
+    owner: z.string().optional(),
+    sessions: z.array(SessionRowSchema),
+});
+/** "1 here, 0 in sandbox" for a session's viewers. */
+export function viewerText(v) {
+    return v === undefined
+        ? '-'
+        : v === null
+            ? 'unknown (older session)'
+            : v.remote + ' here, ' + (v.viewers - v.remote) + ' in sandbox';
+}
+/** This folder's project first, newest first within each group. */
+export function orderedSessions(list) {
+    const newest = (a, b) => (a.startedAt < b.startedAt ? 1 : -1);
+    return [...list.filter((s) => s.here).sort(newest), ...list.filter((s) => !s.here).sort(newest)];
+}
+export const listSessions = defineQuery({
+    id: 'sessions.list',
+    title: 'Sessions',
+    summary: 'list agent sessions and who is attached',
+    input: z.object({ wide: z.boolean().default(false).describe("also show each session's folder") }),
+    output: SessionsListSchema,
+    live: { everyMs: 2500 },
+    cli: {
+        name: 'sessions',
+        group: 'Sessions',
+        json: true,
+        flags: { wide: { flag: '--wide', noMenu: true } },
+        // The --json shape `sandbox sessions` has always printed: the session records, without the web's field.
+        shapeJson: (o) => o.sessions.map(({ canOpen: _canOpen, ...s }) => s),
+    },
+});
+export const restartSessions = defineOperation({
+    id: 'sessions.restart',
+    title: 'Restart agents',
+    summary: "restart this project's running agents in place; they resume their conversation",
+    input: z.object({
+        harness: z.string().optional().describe('only this agent'),
+        all: z.boolean().default(false).describe("every project's sessions, not only this folder's"),
+    }),
+    output: z.object({ message: z.string().describe("The sandbox's answer") }),
+    text: (o) => o.message,
+    cli: {
+        name: 'restart',
+        group: 'Agents',
+        flags: {
+            harness: { flag: '--harness', shownAs: '--agent', value: 'name', choices: 'harnesses' },
+            all: { flag: '--all' },
+        },
+    },
+});
+function sessionItem(s, wide) {
+    const state = s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : '');
+    const running = s.phase === 'running';
+    return {
+        id: s.id,
+        label: s.harness + '  ' + (s.projectName ?? '-'),
+        hint: state + '  ' + ago(s.startedAt),
+        badges: [{ text: s.phase, tone: running ? 'ok' : s.phase === 'failed' ? 'danger' : 'muted' }],
+        group: s.here ? "This folder's project" : 'Other sessions',
+        marked: s.here,
+        description: running
+            ? "Opens this session's terminal (in a terminal, Ctrl+] detaches; the session keeps running)."
+            : undefined,
+        details: ['Session   ' + s.id, 'Folder    ' + s.cwd, 'Attached  ' + viewerText(s.viewers)],
+        cells: {
+            here: s.here ? '*' : '',
+            id: s.id,
+            agent: s.harness,
+            project: s.projectName ?? '-',
+            state,
+            attached: viewerText(s.viewers),
+            ...(wide ? { folder: s.cwd } : {}),
+            started: ago(s.startedAt),
+        },
+        ...(running && s.canOpen ? { primary: link({ kind: 'terminal', session: s.id }, 'Open', { verb: 'attach' }) } : {}),
+        ...(running ? {} : { disabled: 'This session has ended.' }),
+        ...(running && !s.canOpen ? { disabled: 'Not reachable from this PC.' } : {}),
+    };
+}
+/** The sessions page: one list (a table on the command line), this folder's project first. */
+export function sessionsPage(o) {
+    const sessions = orderedSessions(o.sessions);
+    const agent = o.defaultAgent;
+    const start = link({ kind: 'start-agent', agent }, 'Start ' + agent, { verb: 'start' });
+    // Only ended sessions (from the last sandbox): starting one is the next step.
+    const startSection = sessions.length && !sessions.some((s) => s.phase === 'running' || s.phase === 'starting')
+        ? [{ id: 'start', actions: [{ ...start, description: 'Starts ' + agent + ' in this folder.' }] }]
+        : [];
+    return {
+        title: 'Sessions',
+        ...(o.owner ? { notice: { text: o.owner, tone: 'accent' } } : {}),
+        sections: [
+            {
+                id: 'sessions',
+                columns: [
+                    { key: 'here', label: '' },
+                    { key: 'id', label: 'ID' },
+                    { key: 'agent', label: 'AGENT' },
+                    { key: 'project', label: 'PROJECT' },
+                    { key: 'state', label: 'STATE' },
+                    { key: 'attached', label: 'ATTACHED' },
+                    ...(o.wide ? [{ key: 'folder', label: 'FOLDER' }] : []),
+                    { key: 'started', label: 'STARTED' },
+                ],
+                items: sessions.map((s) => sessionItem(s, o.wide)),
+                notes: [
+                    ...(sessions.some((s) => s.here) ? [{ text: '* = the project of this folder', tone: 'muted' }] : []),
+                    ...(o.wide
+                        ? []
+                        : [{ text: 'Folders: sandbox sessions --wide', tone: 'muted', only: 'cli' }]),
+                ],
+            },
+            ...startSection,
+        ],
+        actions: [
+            ...(sessions.length
+                ? [action(restartSessions, { all: false }, { key: 'r', verb: 'restart agents', importance: 1 })]
+                : []),
+            link({ kind: 'command', argv: ['resume'] }, 'Reopen last sessions', {
+                key: 'o',
+                verb: 'reopen last sessions',
+                importance: 2,
+            }),
+        ],
+        empty: {
+            title: o.sandboxRunning ? 'No sessions' : 'No sandbox is running',
+            text: o.sandboxRunning
+                ? 'No agent is running. Start ' + agent + ' in this folder.'
+                : 'Starting ' + agent + ' starts the sandbox too; its session is listed here.',
+            action: start,
+            cliText: 'No sessions. Start one with: sandbox claude',
+        },
+    };
+}
+export const sessionsView = defineView({
+    id: 'sessions',
+    title: 'Sessions',
+    summary: 'The agent sessions of the running sandbox: open one, restart the agents.',
+    queries: { sessions: listSessions },
+    operations: [restartSessions],
+    build: ({ sessions }) => sessionsPage(sessions),
+});

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

@@ -0,0 +1,39 @@
+export declare const listSessionsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{
+    wide: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    sandboxRunning: import("zod").ZodBoolean;
+    defaultAgent: import("zod").ZodString;
+    wide: import("zod").ZodBoolean;
+    owner: import("zod").ZodOptional<import("zod").ZodString>;
+    sessions: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        launchId: import("zod").ZodString;
+        harness: import("zod").ZodString;
+        cwd: import("zod").ZodString;
+        project: import("zod").ZodOptional<import("zod").ZodString>;
+        phase: import("zod").ZodEnum<{
+            failed: "failed";
+            starting: "starting";
+            running: "running";
+            exited: "exited";
+        }>;
+        message: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+        startedAt: import("zod").ZodString;
+        conversation: import("zod").ZodOptional<import("zod").ZodString>;
+        exitCode: import("zod").ZodOptional<import("zod").ZodNumber>;
+        projectName: import("zod").ZodOptional<import("zod").ZodString>;
+        here: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        viewers: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
+            viewers: import("zod").ZodNumber;
+            remote: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>>;
+        canOpen: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, "sessions.list">, import("../../../cli/commands/context.js").Context>;
+export declare const restartSessionsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    harness: import("zod").ZodOptional<import("zod").ZodString>;
+    all: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "sessions.restart">, import("../../../cli/commands/context.js").Context>;

package/dist/app/features/sessions/sessions.run.js

@@ -0,0 +1,58 @@
+// The sessions feature's work: the list (as this user may see it under the sharing rules) and restarting the agents.
+import { safeText } from '../../../core/util/index.js';
+import { hostEndpoint } from '../../../host/channel/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { requireOnPc, requireRunning } from '../../../cli/commands/context.js';
+import { lookAtSandbox, useSharedSandbox } from '../../../cli/commands/shared-use.js';
+import { SessionsService } from '../../../cli/services/index.js';
+import { implement, typedConfirm } from '../../context.js';
+import { cancelled } from '../../kernel/index.js';
+import { listSessions, restartSessions } from './sessions.def.js';
+/** A listed session as the surfaces see it: no attach address or token, text from the sandbox made safe. */
+function sessionRow(s) {
+    const { attach: _attach, ...rest } = s;
+    return {
+        ...rest,
+        harness: safeText(s.harness),
+        cwd: safeText(s.cwd),
+        ...(s.project !== undefined ? { project: safeText(s.project) } : {}),
+        message: safeText(s.message).slice(0, 300),
+        ...(s.conversation !== undefined ? { conversation: safeText(s.conversation) } : {}),
+        ...(s.projectName !== undefined ? { projectName: safeText(s.projectName) } : {}),
+        canOpen: s.phase === 'running' && hostEndpoint(s) !== null,
+    };
+}
+export const listSessionsRun = implement(listSessions, async (asked, input) => {
+    // Another user's sandbox: shared, its sessions are listed from their folders; not shared, only whose it is.
+    const view = lookAtSandbox(asked);
+    const base = {
+        sandboxRunning: isSandboxRunning(),
+        defaultAgent: asked.loaded.config.defaultHarness,
+        wide: input.wide,
+        ...(view.line ? { owner: view.line } : {}),
+    };
+    if (view.limited)
+        return { ...base, sessions: [] };
+    const list = await new SessionsService(view.ctx).list();
+    return { ...base, sessions: list.map(sessionRow) };
+});
+export const restartSessionsRun = implement(restartSessions, async (ctx, input, io) => {
+    requireOnPc('restart');
+    requireRunning();
+    await useSharedSandbox(ctx, { kind: 'owner-only', what: 'restart the agents' }, typedConfirm(io));
+    const service = new SessionsService(ctx);
+    const scope = service.restartScope(input.all);
+    if (scope.notAProject)
+        io.log(scope.folder + ' is not a project of the running sandbox: restarting every session.', 'muted');
+    const what = scope.guest ? 'the agents of ' + scope.projectName : 'every agent';
+    const yes = await io.confirm({
+        title: 'Restart ' + what + '?',
+        lines: ['The agents are started again and continue their conversations where they can.'],
+        yes: 'Restart',
+        implied: true,
+    });
+    if (!yes)
+        cancelled();
+    io.progress('Restarting the agents' + (scope.guest ? ' of ' + scope.projectName : ''));
+    return { message: safeText(await service.restart(input.harness ?? null, scope.guest)) };
+});

package/dist/{cli/menu/settings/categories.d.ts → app/features/settings/categories.def.d.ts}

@@ -5,5 +5,9 @@ export interface SettingsCategory {
     keys: string[];
 }
 export declare const CATEGORIES: SettingsCategory[];
+/** Settings not listed here because their own section covers them (Apps: the catalogue and your own programs). */
+export declare const SETTINGS_ELSEWHERE: readonly string[];
 export declare function nameOf(key: string): string;
 export declare function categoryOf(topKey: string): SettingsCategory | undefined;
+/** The label of a setting. */
+export declare function labelOf(key: readonly string[]): string;

package/dist/{cli/menu/settings/categories.js → app/features/settings/categories.def.js}

@@ -1,31 +1,26 @@
-// How the settings are grouped on screen: categories in the sidebar, readable names for sections and toolchains. Every
-// top-level setting of both files must belong to a category (a self-test checks it), so nothing is ever hidden.
-import { Text } from '../../tui/index.js';
+// How the settings are grouped on every surface: categories (the menu's navigation, the web's tabs), readable names for
+// sections and toolchains, and plain words for settings whose key is jargon. Every top-level setting of both files must
+// belong to a category or be covered by another section (a self-test checks it), so nothing is ever hidden. Pure.
+import { humanize } from '../../kernel/index.js';
 export const CATEGORIES = [
     {
         id: 'general',
         label: 'General',
-        description: 'Which agent starts, where the project appears in the sandbox, and extra folders from this PC.',
+        description: 'Which agent starts, where the project appears in the sandbox, extra folders from this PC, and where the sandbox keeps its data.',
         keys: ['defaultHarness', 'harness', 'guestWorkspace', 'readOnly', 'mappings', 'scripts'],
     },
     {
         id: 'machine',
         label: 'Sandbox machine',
-        description: 'Memory, CPU, window, GPU, clipboard, audio and network of the sandbox itself.',
-        keys: ['sandbox'],
+        description: 'Memory, CPU, window, GPU, clipboard, audio and networking of the sandbox itself, and its desktop look (theme, accent colour, taskbar, wallpaper).',
+        keys: ['sandbox', 'personalization'],
     },
     {
         id: 'languages',
         label: 'Languages & tools',
-        description: 'Toolchains installed in the sandbox. "auto" follows your project\'s files and what this PC has.',
+        description: 'Toolchains installed in the sandbox. "auto" follows the files of your project and what this PC has.',
         keys: ['toolchains'],
     },
-    {
-        id: 'apps',
-        label: 'Apps',
-        description: 'Desktop apps installed in the sandbox: editors, database clients, API clients, game engines ... (also: Apps catalogue on the home screen).',
-        keys: ['apps'],
-    },
     {
         id: 'databases',
         label: 'Databases',
@@ -34,21 +29,15 @@ export const CATEGORIES = [
     },
     {
         id: 'agents',
-        label: 'Agents & attaching',
-        description: 'The agents you can start, attaching your terminal to them, and the (Beta) agent commands.',
-        keys: ['harnesses', 'attach', 'agentCommands'],
-    },
-    {
-        id: 'claude',
-        label: 'Claude profile',
-        description: 'Which of your Claude settings, history and memory are copied in and synced back.',
-        keys: ['claudeProfile'],
+        label: 'Agents & sessions',
+        description: 'The agents you can start (also: Agents section), attaching your terminal to them, the (Beta) web UI and agent commands, which of your Claude settings are copied in, and reopening sessions.',
+        keys: ['harnesses', 'attach', 'web', 'agentCommands', 'claudeProfile', 'resume'],
     },
     {
         id: 'network',
         label: 'Network',
-        description: 'What the sandbox can reach: your LAN, only some hosts, blocked hosts, DNS, a proxy, and ports forwarded from this PC to servers inside. (No network at all: Sandbox machine > Networking.)',
-        keys: ['network'],
+        description: 'What the sandbox can reach: your LAN, only some hosts, blocked hosts, DNS, a proxy, ports forwarded from this PC to servers inside, and a VPN (with a login set here). (No network at all: Sandbox machine > Networking.)',
+        keys: ['network', 'vpn'],
     },
     {
         id: 'security',
@@ -56,42 +45,28 @@ export const CATEGORIES = [
         description: 'Git-ignored files kept out, secrets kept out of the sandbox, download checks, what is kept on this PC, and sharing your sandbox with other Windows users.',
         keys: ['workspaceFilter', 'audit', 'secrets', 'downloads', 'storage', 'sharing'],
     },
-    {
-        id: 'setup',
-        label: 'Setup & hooks',
-        description: 'How tools get into the sandbox (copied from this PC or downloaded), Git, the terminal, and hook scripts.',
-        keys: ['provisioning', 'hooks'],
-    },
     {
         id: 'projects',
-        label: 'Projects',
-        description: 'Several projects in one sandbox: project roots mapped at every start, adding folders while it runs.',
-        keys: ['projects'],
-    },
-    {
-        id: 'resume',
-        label: 'Reopening sessions',
-        description: 'Open the sessions of the last sandbox again when a new one starts, or after a crash.',
-        keys: ['resume'],
-    },
-    {
-        id: 'desktop',
-        label: 'Desktop look',
-        description: 'Copy your theme, accent colour, taskbar and wallpaper into the sandbox.',
-        keys: ['personalization'],
+        label: 'Projects & setup',
+        description: 'Several projects in one sandbox (roots mapped at every start, adding folders while it runs), how tools get into the sandbox (copied from this PC or downloaded), Git, the terminal, and hook scripts.',
+        keys: ['projects', 'provisioning', 'hooks'],
     },
 ];
+/** Settings not listed here because their own section covers them (Apps: the catalogue and your own programs). */
+export const SETTINGS_ELSEWHERE = ['apps'];
 /** Readable names for sections and toolchains (anything missing gets a name made from its key). */
 const NAMES = {
     sandbox: 'Sandbox machine',
     attach: 'Attaching your terminal',
     agentCommands: 'Agent commands (Beta)',
+    web: 'Web UI (Beta)',
     provisioning: 'Provisioning',
     downloads: 'Downloads',
     secrets: 'Secrets',
     claudeProfile: 'Claude profile',
     storage: 'Storage on this PC',
     network: 'Network',
+    vpn: 'VPN',
     hooks: 'Hooks',
     personalization: 'Desktop look',
     projects: 'Projects',
@@ -131,8 +106,27 @@ const NAMES = {
     audit: 'Audit log',
 };
 export function nameOf(key) {
-    return NAMES[key] ?? Text.humanize(key);
+    return NAMES[key] ?? humanize(key);
 }
 export function categoryOf(topKey) {
     return CATEGORIES.find((c) => c.keys.includes(topKey));
 }
+/** Plain words for settings whose key is jargon (the key itself stays in the details). */
+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)',
+    'sandbox.agentMemoryHeadroomMb': 'Memory kept free from agents (MB)',
+    'sandbox.pressureResponse': 'Slow builds down when memory runs low',
+    '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',
+};
+/** The label of a setting. */
+export function labelOf(key) {
+    return LABELS[key.join('.')] ?? humanize(key[key.length - 1]);
+}

package/dist/app/features/settings/index.d.ts

@@ -0,0 +1,5 @@
+export * from './categories.def.js';
+export * from './settings.def.js';
+export * from './settings-file.js';
+export * from './settings-rows.js';
+export * from './settings.run.js';

package/dist/app/features/settings/index.js

@@ -0,0 +1,6 @@
+// The settings feature: categories and labels, the rows of a file, get / set / reset, and the view.
+export * from './categories.def.js';
+export * from './settings.def.js';
+export * from './settings-file.js';
+export * from './settings-rows.js';
+export * from './settings.run.js';

package/dist/{cli/menu/settings/config-file.d.ts → app/features/settings/settings-file.d.ts}

@@ -1,5 +1,5 @@
 import type { Config } from '../../../core/types.js';
-import { SchemaNode } from './schema-node.js';
+import { SchemaNode } from '../../kernel/index.js';
 /** The user's own config, or a project's .sandbox-config.json (a smaller schema; nothing is merged with defaults). */
 export type SettingsTarget = 'user' | 'project';
 /** What the value is in this JSON text (undefined when it is not set there). */

package/dist/{cli/menu/settings/config-file.js → app/features/settings/settings-file.js}

@@ -8,7 +8,7 @@ import _ from 'lodash';
 import { DEFAULTS, loadConfig, mergeConfig, userConfigPath } from '../../../core/config/index.js';
 import { LOCAL_CONFIG_NAME } from '../../../core/local-config/index.js';
 import { ConfigSchema, describeIssues, LocalOverridesSchema } from '../../../core/schema/index.js';
-import { SchemaNode } from './schema-node.js';
+import { SchemaNode } from '../../kernel/index.js';
 /** What the value is in this JSON text (undefined when it is not set there). */
 export function fileValue(text, key) {
     return _.get(parse(text) ?? {}, key);

package/dist/app/features/settings/settings-rows.d.ts

@@ -0,0 +1,35 @@
+import type { Config } from '../../../core/types.js';
+import { type SchemaNode } from '../../kernel/index.js';
+import type { Scope, SettingRow } from './settings.def.js';
+import type { ConfigFile } from './settings-file.js';
+/** One editable setting with the category and heading it is shown under. */
+export interface Setting {
+    readonly key: string[];
+    readonly node: SchemaNode;
+    readonly category: string;
+    readonly section?: string;
+}
+/** Every editable setting of a file, each in its category (settings covered by another section are left out). */
+export declare function settingsOf(file: ConfigFile): Setting[];
+/** Your own settings and this folder's project file. */
+export type SettingsFiles = Readonly<Record<Scope, ConfigFile>>;
+/** Where values come from: the files as saved, or with the menu's unsaved changes laid over them. */
+export interface SettingsSource {
+    /** What the file says (undefined: not set there). */
+    written(file: ConfigFile, key: string[]): unknown;
+    /** What is in effect: your file merged with the defaults, or only what a project file says. */
+    effective(file: ConfigFile, key: string[], config: Config): unknown;
+}
+/** The files as they are on disk. */
+export declare const SAVED: SettingsSource;
+/** A value with every secret in it replaced by *** (as the whole settings object would be redacted). */
+export declare function masked(key: readonly string[], value: unknown): unknown;
+/** One setting's row in a scope (`config` and `inProject` can be passed when making many rows). */
+export declare function settingRow(s: Setting, files: SettingsFiles, scope: Scope, source?: SettingsSource, config?: Config, inProject?: ReadonlySet<string>): SettingRow;
+/** Every setting's row in a scope (one read of your settings for all of them). */
+export declare function settingRows(files: SettingsFiles, scope: Scope, source?: SettingsSource): SettingRow[];
+/** The setting a key names in a file's schema; an unknown key says what is close. */
+export declare function findSetting(file: ConfigFile, key: string): {
+    key: string[];
+    node: SchemaNode;
+};

package/dist/app/features/settings/settings-rows.js

@@ -0,0 +1,94 @@
+// Every setting of a file as rows: which settings there are (from the schema, nothing listed by hand), where they are
+// shown (category and heading), their Field, and their values in this file, in your settings and in the project's,
+// with secrets as ***. The settings query sends these rows; the menu lays its unsaved changes over them (`source`).
+import _ from 'lodash';
+import { NEVER_LOOSER } from '../../../core/local-config/index.js';
+import { redactSecrets } from '../../../core/schema/index.js';
+import { fail } from '../../../core/util/index.js';
+import { closest } from '../../../cli/validate.js';
+import { fieldOf } from '../../kernel/index.js';
+import { categoryOf, labelOf, nameOf } from './categories.def.js';
+/** Every editable setting of a file, each in its category (settings covered by another section are left out). */
+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 };
+        });
+    });
+}
+/** The files as they are on disk. */
+export const SAVED = {
+    written: (file, key) => file.valueInFile(key),
+    effective: (file, key, config) => (file.isProject ? file.valueInFile(key) : _.get(config, key)),
+};
+/** A value with every secret in it replaced by *** (as the whole settings object would be redacted). */
+export function masked(key, value) {
+    if (value === undefined)
+        return undefined;
+    return _.get(redactSecrets(_.set({}, key, structuredClone(value))), key);
+}
+/** The keys a project file can set. */
+function projectKeys(files) {
+    return new Set(files.project.schema.leaves().map((l) => l.key.join('.')));
+}
+/** One setting's row in a scope (`config` and `inProject` can be passed when making many rows). */
+export function settingRow(s, files, scope, source = SAVED, config = files.user.userConfig(), inProject = projectKeys(files)) {
+    const file = files[scope];
+    const id = s.key.join('.');
+    return {
+        id,
+        key: s.key,
+        label: labelOf(s.key),
+        category: s.category,
+        ...(s.section ? { section: s.section } : {}),
+        field: fieldOf(s.node, s.key, labelOf(s.key)),
+        value: masked(s.key, source.effective(file, s.key, config)),
+        set: source.written(file, s.key) !== undefined,
+        yours: masked(s.key, source.effective(files.user, s.key, config)),
+        yoursSet: source.written(files.user, s.key) !== undefined,
+        inProject: inProject.has(id) ? masked(s.key, source.written(files.project, s.key)) : undefined,
+        ...(file.isProject ? {} : { default: masked(s.key, file.defaultOf(s.key)) }),
+        locked: NEVER_LOOSER.includes(id),
+    };
+}
+/** Every setting's row in a scope (one read of your settings for all of them). */
+export function settingRows(files, scope, source = SAVED) {
+    const config = files.user.userConfig();
+    const inProject = projectKeys(files);
+    return settingsOf(files[scope]).map((s) => settingRow(s, files, scope, source, config, inProject));
+}
+/** The setting a key names in a file's schema; an unknown key says what is close. */
+export function findSetting(file, key) {
+    const keyPath = key.split('.');
+    let node = file.schema;
+    for (const part of keyPath)
+        node = node?.child(part);
+    if (node)
+        return { key: keyPath, node };
+    const hint = closest(key, file.schema.leaves().map((l) => l.key.join('.')));
+    return fail('There is no setting "' +
+        key +
+        '"' +
+        (file.isProject ? ' a project can set' : '') +
+        '.' +
+        (hint ? ' Did you mean ' + hint + '?' : ''), 'Settings are named like sandbox.memoryMb. See them all with: sandbox config show');
+}