windows-development-sandbox 1.7.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}

@@ -9,3 +9,5 @@ export declare const CATEGORIES: SettingsCategory[];
 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,7 +1,7 @@
-// How the settings are grouped on screen: categories in the navigation, readable names for sections and toolchains.
-// 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.
-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',
@@ -106,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');
+}

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

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+export declare const ScopeSchema: z.ZodEnum<{
+    project: "project";
+    user: "user";
+}>;
+export type Scope = z.output<typeof ScopeSchema>;
+/** One setting as every surface shows it. Values are what the file or the merged settings say, secrets as ***. */
+export declare const SettingRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodArray<z.ZodString>;
+    label: z.ZodString;
+    category: z.ZodString;
+    section: z.ZodOptional<z.ZodString>;
+    field: z.ZodType<import("../../kernel/fields.js").Field, unknown, z.core.$ZodTypeInternals<import("../../kernel/fields.js").Field, unknown>>;
+    value: z.ZodUnknown;
+    set: z.ZodBoolean;
+    yours: z.ZodUnknown;
+    yoursSet: z.ZodBoolean;
+    inProject: z.ZodOptional<z.ZodUnknown>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    locked: z.ZodBoolean;
+}, z.core.$strip>;
+export type SettingRow = z.output<typeof SettingRowSchema>;
+export declare const SettingsListSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        project: "project";
+        user: "user";
+    }>;
+    file: z.ZodString;
+    exists: z.ZodBoolean;
+    dataFolder: z.ZodOptional<z.ZodString>;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodArray<z.ZodString>;
+        label: z.ZodString;
+        category: z.ZodString;
+        section: z.ZodOptional<z.ZodString>;
+        field: z.ZodType<import("../../kernel/fields.js").Field, unknown, z.core.$ZodTypeInternals<import("../../kernel/fields.js").Field, unknown>>;
+        value: z.ZodUnknown;
+        set: z.ZodBoolean;
+        yours: z.ZodUnknown;
+        yoursSet: z.ZodBoolean;
+        inProject: z.ZodOptional<z.ZodUnknown>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        locked: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SettingsList = z.output<typeof SettingsListSchema>;
+export declare const listSettings: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+    scope: z.ZodDefault<z.ZodEnum<{
+        project: "project";
+        user: "user";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    scope: z.ZodEnum<{
+        project: "project";
+        user: "user";
+    }>;
+    file: z.ZodString;
+    exists: z.ZodBoolean;
+    dataFolder: z.ZodOptional<z.ZodString>;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodArray<z.ZodString>;
+        label: z.ZodString;
+        category: z.ZodString;
+        section: z.ZodOptional<z.ZodString>;
+        field: z.ZodType<import("../../kernel/fields.js").Field, unknown, z.core.$ZodTypeInternals<import("../../kernel/fields.js").Field, unknown>>;
+        value: z.ZodUnknown;
+        set: z.ZodBoolean;
+        yours: z.ZodUnknown;
+        yoursSet: z.ZodBoolean;
+        inProject: z.ZodOptional<z.ZodUnknown>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        locked: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "settings.list">;
+export declare const getSetting: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodUnknown;
+}, z.core.$strip>, "settings.get">;
+export declare const setSetting: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    scope: z.ZodDefault<z.ZodEnum<{
+        project: "project";
+        user: "user";
+    }>>;
+    key: z.ZodString;
+    value: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    key: z.ZodString;
+    changed: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>, "settings.set">;
+export declare const resetSetting: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    scope: z.ZodDefault<z.ZodEnum<{
+        project: "project";
+        user: "user";
+    }>>;
+    key: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    key: z.ZodString;
+    changed: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>, "settings.reset">;
+/** The settings page of one scope: a section per category, each setting with its value and an edit action. */
+export declare function settingsPage(o: SettingsList): Page;
+export declare const settingsView: import("../../kernel/define.js").ViewDef<{
+    settings: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+        scope: z.ZodDefault<z.ZodEnum<{
+            project: "project";
+            user: "user";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        scope: z.ZodEnum<{
+            project: "project";
+            user: "user";
+        }>;
+        file: z.ZodString;
+        exists: z.ZodBoolean;
+        dataFolder: z.ZodOptional<z.ZodString>;
+        categories: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        rows: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            key: z.ZodArray<z.ZodString>;
+            label: z.ZodString;
+            category: z.ZodString;
+            section: z.ZodOptional<z.ZodString>;
+            field: z.ZodType<import("../../kernel/fields.js").Field, unknown, z.core.$ZodTypeInternals<import("../../kernel/fields.js").Field, unknown>>;
+            value: z.ZodUnknown;
+            set: z.ZodBoolean;
+            yours: z.ZodUnknown;
+            yoursSet: z.ZodBoolean;
+            inProject: z.ZodOptional<z.ZodUnknown>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            locked: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, "settings.list">;
+}, {
+    scope: Scope;
+}, "settings">;