windows-development-sandbox 1.9.0 → 1.11.3

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

@@ -0,0 +1,208 @@
+// The projects a sandbox can open without a restart: the list, roots, include/exclude, the all-projects setting, and
+// choosing the ticked ones. Pure: schemas, labels and the view; projects.run.ts does the work.
+import { z } from 'zod';
+import { action, defineOperation, defineQuery, defineView, fieldsOf, } from '../../kernel/index.js';
+export const ProjectRowSchema = z.object({
+    folder: z.string().describe('The project folder on this PC'),
+    here: z.boolean().describe('The folder you are in is inside it'),
+    known: z.boolean().describe('Started with this tool before'),
+    root: z.string().nullable().describe('The project root it is in, if any'),
+    excluded: z.boolean().describe('Excluded from the projects mapped at every start'),
+    mappedAtStart: z.boolean().describe('Mapped at every start'),
+    running: z.string().nullable().describe('Its name and how it got into the running sandbox, if it is there'),
+});
+export const ProjectsListSchema = z.object({
+    all: z.boolean().describe('Every project is mapped at every start (except excluded ones)'),
+    roots: z.array(z.string()).describe('Folders of projects, each opened without a restart'),
+    exclude: z.array(z.string()).describe('Folders left out of the projects mapped at every start'),
+    projects: z.array(ProjectRowSchema).describe('Every project worth listing'),
+});
+const Message = z.object({ message: z.string().describe('What happened') });
+const FolderText = (what) => z
+    .string()
+    .optional()
+    .describe(what + ' (. = this folder; asked when left out)');
+export const listProjects = defineQuery({
+    id: 'projects.list',
+    title: 'Projects',
+    summary: 'list your projects, roots and the all-projects setting',
+    input: z.object({}),
+    output: ProjectsListSchema,
+    cli: { name: 'projects', action: 'list', json: true },
+});
+export const chooseProjects = defineOperation({
+    id: 'projects.choose',
+    title: 'Choose the projects mapped at every start…',
+    summary: 'tick the projects mapped at every start; the rest are excluded',
+    input: z.object({}),
+    output: Message,
+    text: (o) => o.message,
+    cli: { name: 'projects', action: 'choose' },
+});
+export const addProject = defineOperation({
+    id: 'projects.add',
+    title: 'Add a project…',
+    summary: 'remember a project folder',
+    input: z.object({ projectFolder: FolderText('The project folder') }),
+    output: z.object({
+        message: z.string().describe('What happened'),
+        next: z.string().optional().describe('What to do next, when mapping all projects is off'),
+    }),
+    text: (o) => (o.next ? o.message + '\n' + o.next : o.message),
+    cli: { name: 'projects', action: 'add', positional: ['projectFolder'] },
+});
+export const removeProject = defineOperation({
+    id: 'projects.remove',
+    title: 'Forget project',
+    summary: 'forget a project (nothing in the folder is touched)',
+    input: z.object({ projectFolder: FolderText('The project folder') }),
+    output: Message,
+    danger: true,
+    text: (o) => o.message,
+    cli: { name: 'projects', action: 'remove', positional: ['projectFolder'] },
+});
+export const includeProject = defineOperation({
+    id: 'projects.include',
+    title: 'Include',
+    summary: 'map a project at every start again',
+    input: z.object({ projectFolder: FolderText('The project folder') }),
+    output: Message,
+    text: (o) => o.message,
+    cli: { name: 'projects', action: 'include', positional: ['projectFolder'] },
+});
+export const excludeProject = defineOperation({
+    id: 'projects.exclude',
+    title: 'Exclude',
+    summary: 'leave a project out of the projects mapped at every start',
+    input: z.object({ projectFolder: FolderText('The project folder') }),
+    output: Message,
+    text: (o) => o.message,
+    cli: { name: 'projects', action: 'exclude', positional: ['projectFolder'] },
+});
+export const allProjects = defineOperation({
+    id: 'projects.all',
+    title: 'Map all projects at every start',
+    summary: 'map every project at every start, or not',
+    input: z.object({ state: z.enum(['on', 'off']).optional().describe('on or off (left out: say which it is)') }),
+    output: Message,
+    text: (o) => o.message,
+    cli: { name: 'projects', action: 'all', positional: ['state'] },
+});
+export const projectRoots = defineOperation({
+    id: 'projects.roots',
+    title: 'Project roots',
+    summary: 'list, add or remove project roots',
+    input: z.object({
+        change: z.enum(['list', 'add', 'remove']).default('list').describe('list, add or remove'),
+        rootFolder: z.string().optional().describe('(add, remove) the folder that holds your projects'),
+    }),
+    output: Message,
+    text: (o) => o.message,
+    cli: { name: 'projects', action: 'roots', positional: ['change', 'rootFolder'] },
+});
+/** The folder fields: their names end in Folder, so the menu and the web give them the folder picker. */
+const rootField = fieldsOf(projectRoots.input).find((f) => f.name === 'rootFolder');
+const projectField = fieldsOf(addProject.input).find((f) => f.name === 'projectFolder');
+const ROOT_DESCRIPTION = 'Every project in this folder (also new ones) opens without a restart.';
+function atStart(p) {
+    return p.root ? 'root' : p.excluded ? 'excluded' : p.mappedAtStart ? 'mapped' : '-';
+}
+function projectItem(p) {
+    return {
+        id: 'project:' + p.folder,
+        label: p.folder,
+        marked: p.here,
+        icon: 'project',
+        hint: p.running ?? (p.root ? 'in a root' : p.excluded ? 'excluded' : p.mappedAtStart ? 'mapped' : '-'),
+        description: p.here ? 'This is the folder you started the menu in.' : undefined,
+        details: ['At start   ' + atStart(p), 'In sandbox ' + (p.running ?? '-')],
+        cells: { here: p.here ? '*' : '', folder: p.folder, atStart: atStart(p), running: p.running ?? '-' },
+        actions: [
+            action(removeProject, { projectFolder: p.folder }, { key: 'f', verb: 'forget project', importance: 1 }),
+            p.excluded
+                ? action(includeProject, { projectFolder: p.folder })
+                : action(excludeProject, { projectFolder: p.folder }),
+        ],
+    };
+}
+function rootItem(r) {
+    return {
+        id: 'root:' + r,
+        label: r,
+        hint: 'root',
+        icon: 'folder',
+        description: ROOT_DESCRIPTION,
+        keys: 'f removes the root.',
+        actions: [
+            action(projectRoots, { change: 'remove', rootFolder: r }, { label: 'Remove the root', key: 'f', verb: 'remove root', importance: 1 }),
+        ],
+    };
+}
+/** The projects page: the settings, the project roots, and the projects (the same rows as the menu's Projects). */
+export function projectsPage(o) {
+    const settings = {
+        id: 'settings',
+        facts: [
+            {
+                id: 'all',
+                label: 'All projects',
+                value: o.all ? 'on (every project below is mapped at every start, except excluded ones)' : 'off',
+            },
+            {
+                id: 'roots',
+                label: 'Roots',
+                value: o.roots.length ? o.roots.join(', ') : 'none (sandbox projects roots add <folder>)',
+            },
+        ],
+        actions: [
+            action(allProjects, { state: o.all ? 'off' : 'on' }, { label: o.all ? 'Stop mapping all projects' : 'Map all projects at every start' }),
+        ],
+        notes: [{ text: 'sandbox projects all on|off', tone: 'muted', only: 'cli' }],
+    };
+    const roots = {
+        id: 'roots',
+        title: 'Project roots',
+        items: [
+            {
+                id: '@add-root',
+                label: '+ Add a project root…',
+                description: 'Pick a folder that holds your projects: every project in it (also new ones) opens without a restart.',
+                primary: action(projectRoots, { change: 'add' }, { label: 'Choose the folder…', verb: 'choose folder', fields: [rootField] }),
+            },
+            ...o.roots.map(rootItem),
+        ],
+    };
+    const projects = {
+        id: 'projects',
+        title: 'Projects',
+        columns: [
+            { key: 'here', label: '' },
+            { key: 'folder', label: 'FOLDER' },
+            { key: 'atStart', label: 'AT START' },
+            { key: 'running', label: 'RUNNING SANDBOX' },
+        ],
+        // The web lists the rows in full (its table cannot carry the row actions: forget, include, exclude).
+        columnsOn: 'cli',
+        items: o.projects.map(projectItem),
+        notes: o.projects.length === 0
+            ? [{ text: 'No projects yet: start one with sandbox claude in its folder.', tone: 'muted' }]
+            : [{ text: '* = this folder.  Choose with: sandbox projects choose', tone: 'muted', only: 'cli' }],
+    };
+    return {
+        title: 'Projects',
+        sections: [settings, roots, projects],
+        actions: [
+            action(chooseProjects, {}, { label: 'Choose…' }),
+            action(addProject, {}, { fields: [projectField] }),
+            action(projectRoots, { change: 'add' }, { label: 'Add a project root…', key: 'a', verb: 'add root', importance: 1, fields: [rootField] }),
+        ],
+    };
+}
+export const projectsView = defineView({
+    id: 'projects',
+    title: 'Projects',
+    summary: 'The projects a sandbox opens without a restart: roots, your projects, all or chosen.',
+    queries: { projects: listProjects },
+    operations: [chooseProjects, addProject, removeProject, includeProject, excludeProject, allProjects, projectRoots],
+    build: ({ projects }) => projectsPage(projects),
+});

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

@@ -0,0 +1,56 @@
+export declare const listProjectsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    all: import("zod").ZodBoolean;
+    roots: import("zod").ZodArray<import("zod").ZodString>;
+    exclude: import("zod").ZodArray<import("zod").ZodString>;
+    projects: import("zod").ZodArray<import("zod").ZodObject<{
+        folder: import("zod").ZodString;
+        here: import("zod").ZodBoolean;
+        known: import("zod").ZodBoolean;
+        root: import("zod").ZodNullable<import("zod").ZodString>;
+        excluded: import("zod").ZodBoolean;
+        mappedAtStart: import("zod").ZodBoolean;
+        running: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, "projects.list">, import("../../../cli/commands/context.js").Context>;
+export declare const chooseProjectsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "projects.choose">, import("../../../cli/commands/context.js").Context>;
+export declare const addProjectRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    projectFolder: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+    next: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, "projects.add">, import("../../../cli/commands/context.js").Context>;
+export declare const removeProjectRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    projectFolder: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "projects.remove">, import("../../../cli/commands/context.js").Context>;
+export declare const includeProjectRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    projectFolder: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "projects.include">, import("../../../cli/commands/context.js").Context>;
+export declare const excludeProjectRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    projectFolder: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "projects.exclude">, import("../../../cli/commands/context.js").Context>;
+export declare const allProjectsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    state: import("zod").ZodOptional<import("zod").ZodEnum<{
+        off: "off";
+        on: "on";
+    }>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "projects.all">, import("../../../cli/commands/context.js").Context>;
+export declare const projectRootsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    change: import("zod").ZodDefault<import("zod").ZodEnum<{
+        list: "list";
+        add: "add";
+        remove: "remove";
+    }>>;
+    rootFolder: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "projects.roots">, import("../../../cli/commands/context.js").Context>;

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

@@ -0,0 +1,155 @@
+// The projects feature's work: your project list, roots and the all-projects setting, through ProjectsService. Talks
+// only through io. Changes what is mapped from the next start; a running sandbox keeps what it has.
+import path from 'node:path';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { fail } from '../../../core/util/index.js';
+import { hereDir } from '../../../cli/commands/projects/here.js';
+import { ProjectsService } from '../../../cli/services/index.js';
+import { implement } from '../../context.js';
+import { cancelled } from '../../kernel/index.js';
+import { addProject, allProjects, chooseProjects, excludeProject, includeProject, listProjects, projectRoots, removeProject, } from './projects.def.js';
+const NEXT_START = 'This changes what is mapped from the next start.';
+function runningNote() {
+    return isSandboxRunning()
+        ? ' The running sandbox keeps what it has; start a project in it (sandbox claude there) and it joins without a restart when it can, or you are offered one.'
+        : '';
+}
+/** The folder given, or one picked from the known projects (or this folder) when it was left out. */
+async function pickFolder(ctx, io, given) {
+    if (given)
+        return path.resolve(given);
+    const here = hereDir(ctx);
+    const chosen = await io.choose({
+        title: 'Which folder?',
+        choices: [
+            { value: here, label: 'This folder (' + here + ')' },
+            ...new ProjectsService(ctx)
+                .rows()
+                .filter((r) => !r.here)
+                .map((r) => ({ value: r.folder, label: r.folder })),
+        ],
+    });
+    if (chosen === undefined)
+        cancelled();
+    return chosen;
+}
+export const listProjectsRun = implement(listProjects, async (ctx) => new ProjectsService(ctx).list());
+export const chooseProjectsRun = implement(chooseProjects, async (ctx, _input, io) => {
+    const service = new ProjectsService(ctx);
+    const rows = service.rows().filter((r) => !r.root);
+    if (!rows.length)
+        return {
+            message: 'No projects to choose from yet (projects in a root are always mapped with it). Start one with sandbox claude in its folder.',
+        };
+    const all = service.settings().all;
+    const picked = await io.checklist({
+        title: 'Projects mapped at every start, so they open without a restart (every agent in the sandbox can see them):',
+        choices: rows.map((r) => ({ value: r.folder, label: r.folder + (r.here ? '  (this folder)' : '') })),
+        checked: rows.filter((r) => all && !r.excluded).map((r) => r.folder),
+    });
+    if (picked === undefined)
+        cancelled();
+    const { mapped, excluded } = service.choose(rows, picked);
+    return {
+        message: mapped + ' project(s) mapped at every start, ' + excluded + ' excluded. ' + NEXT_START + runningNote(),
+    };
+});
+export const addProjectRun = implement(addProject, async (ctx, input, io) => {
+    const folder = await pickFolder(ctx, io, input.projectFolder);
+    const service = new ProjectsService(ctx);
+    const dir = service.add(folder);
+    const all = service.settings().all;
+    return {
+        message: 'Added ' + dir + ' to your projects.' + (all ? ' ' + NEXT_START : ''),
+        ...(all ? {} : { next: 'Next: sandbox projects all on   (map every project at every start)' }),
+    };
+});
+export const removeProjectRun = implement(removeProject, async (ctx, input, io) => {
+    const dir = await pickFolder(ctx, io, input.projectFolder);
+    const yes = await io.confirm({
+        title: 'Forget ' + path.basename(dir) + '?',
+        lines: ['The project is dropped from your list of projects.', 'Nothing in ' + dir + ' is touched.'],
+        yes: 'Forget',
+        danger: true,
+        implied: true,
+    });
+    if (!yes)
+        cancelled();
+    const { dir: forgotten, removed } = new ProjectsService(ctx).forget(dir);
+    return {
+        message: removed
+            ? 'Removed ' + forgotten + ' from your projects (nothing in the folder was touched).'
+            : forgotten + ' was not in your projects.',
+    };
+});
+export const includeProjectRun = implement(includeProject, async (ctx, input, io) => {
+    const dir = await pickFolder(ctx, io, input.projectFolder);
+    const service = new ProjectsService(ctx);
+    const changed = service.include(dir);
+    return { message: includeOrExcludeText(service, 'include', dir, changed) };
+});
+export const excludeProjectRun = implement(excludeProject, async (ctx, input, io) => {
+    const dir = await pickFolder(ctx, io, input.projectFolder);
+    const service = new ProjectsService(ctx);
+    const changed = service.exclude(dir);
+    return { message: includeOrExcludeText(service, 'exclude', dir, changed) };
+});
+/** The sentence include and exclude print. */
+function includeOrExcludeText(service, action, dir, changed) {
+    return ((changed
+        ? (action === 'exclude' ? 'Excluded ' : 'Included ') + path.resolve(dir) + '. ' + NEXT_START
+        : 'Nothing changed.') +
+        (action === 'include' && !service.settings().all
+            ? ' Mapping all projects is off: sandbox projects all on maps your projects at every start.'
+            : '') +
+        (changed ? runningNote() : ''));
+}
+export const allProjectsRun = implement(allProjects, async (ctx, input) => {
+    const service = new ProjectsService(ctx);
+    if (input.state === undefined)
+        return { message: 'Mapping all projects at every start is ' + (service.settings().all ? 'on' : 'off') + '.' };
+    service.setAll(input.state === 'on');
+    return {
+        message: 'Mapping all projects at every start is ' +
+            input.state +
+            '. ' +
+            NEXT_START +
+            (input.state === 'on' ? ' Every agent in the sandbox can then see all of those projects.' : '') +
+            runningNote(),
+    };
+});
+export const projectRootsRun = implement(projectRoots, async (ctx, input, io) => {
+    const service = new ProjectsService(ctx);
+    if (input.change === 'list') {
+        const list = service.settings().roots;
+        return {
+            message: list.length ? list.join('\n') : 'No project roots. Add one: sandbox projects roots add <folder>',
+        };
+    }
+    if (!input.rootFolder)
+        fail('Which folder?', 'Usage: sandbox projects roots ' + input.change + ' <folder>');
+    if (input.change === 'add') {
+        const { dir, added } = service.addRoot(input.rootFolder);
+        return {
+            message: added
+                ? 'Added the project root ' +
+                    dir +
+                    ': every project in it (also new ones) opens without a restart. Every agent in the sandbox can see all of them. ' +
+                    NEXT_START +
+                    runningNote()
+                : dir + ' is a root already.',
+        };
+    }
+    const dir = path.resolve(input.rootFolder);
+    const yes = await io.confirm({
+        title: 'Remove the root ' + path.basename(dir) + '?',
+        lines: ['Its projects are no longer opened without a restart.', 'Nothing in ' + dir + ' is touched.'],
+        yes: 'Remove',
+        danger: true,
+        implied: true,
+    });
+    if (!yes)
+        cancelled();
+    const { removed } = service.removeRoot(dir);
+    return { message: removed ? 'Removed the project root ' + dir + '. ' + NEXT_START : dir + ' was not a root.' };
+});

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

@@ -126,6 +126,7 @@ function projectItem(p) {
     return {
         id: 'project:' + p.name,
         label: p.name,
+        icon: 'project',
         hint: p.host + '  ->  ' + p.guest + '  (' + (MECHANISM_TEXT[p.mechanism] ?? 'wsb share') + ')',
         marked: p.here,
         details: [
@@ -149,11 +150,12 @@ function facts(o) {
     });
     return [
         ...(o.shared?.startedBy ? [fact('owner', 'Started by', o.shared.startedBy)] : []),
-        fact('running', 'Running', s.running ? 'yes' : 'no', { tone: s.running ? 'ok' : 'muted' }),
+        // One line for what it is doing: "Ready", "Installing Rust ...", or "not running".
+        fact('state', 'State', s.running ? s.message || s.phase : 'not running', {
+            tone: !s.running ? 'muted' : s.phase === 'ready' ? 'ok' : 'warn',
+        }),
         ...(s.running
             ? [
-                fact('phase', 'Phase', s.phase, { tone: s.phase === 'ready' ? 'ok' : 'warn' }),
-                fact('message', 'Message', s.message || '-'),
                 fact('window', 'Window', s.headless ? 'hidden (sandbox show opens it)' : 'shown'),
                 fact('uptime', 'Uptime', uptime(s) ?? '-'),
                 fact('helper', 'Helper', s.daemon === '-' ? '-' : helperText(s.daemon)),
@@ -168,6 +170,7 @@ function projectsSection(o) {
     const roots = o.roots.map((r) => ({
         id: 'root:' + r.host,
         label: 'root',
+        icon: 'folder',
         hint: r.host + '  ->  ' + r.guest + '  (every project in it opens without a restart)',
     }));
     const here = o.projects.some((p) => p.here);
@@ -206,11 +209,14 @@ export function sandboxPage(o) {
     const running = o.sandbox.running;
     const status = {
         id: 'status',
+        title: 'Status',
         facts: facts(o),
+        // Only the window action that changes something: show a hidden window, hide a shown one.
         actions: running
             ? [
-                action(showWindow, {}, { key: 'w', verb: 'show', importance: 3 }),
-                action(hideWindow, {}, { key: 'h', verb: 'hide', importance: 3 }),
+                o.sandbox.headless
+                    ? action(showWindow, {}, { key: 'w', verb: 'show', importance: 3 })
+                    : action(hideWindow, {}, { key: 'h', verb: 'hide', importance: 3 }),
                 action(stopSandbox, {}, { key: 'x', verb: 'stop', importance: 1 }),
             ]
             : [],

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

@@ -92,6 +92,7 @@ function sessionItem(s, wide) {
         badges: [{ text: s.phase, tone: running ? 'ok' : s.phase === 'failed' ? 'danger' : 'muted' }],
         group: s.here ? "This folder's project" : 'Other sessions',
         marked: s.here,
+        icon: s.harness,
         description: running
             ? "Opens this session's terminal (in a terminal, Ctrl+] detaches; the session keeps running)."
             : undefined,
@@ -126,6 +127,7 @@ export function sessionsPage(o) {
         sections: [
             {
                 id: 'sessions',
+                cards: true,
                 columns: [
                     { key: 'here', label: '' },
                     { key: 'id', label: 'ID' },
@@ -147,6 +149,7 @@ export function sessionsPage(o) {
             ...startSection,
         ],
         actions: [
+            ...(o.sandboxRunning ? [{ ...start, label: 'New session', key: 'n', verb: 'new session', importance: 1 }] : []),
             ...(sessions.length
                 ? [action(restartSessions, { all: false }, { key: 'r', verb: 'restart agents', importance: 1 })]
                 : []),

package/dist/app/features/settings/categories.def.js

@@ -42,8 +42,8 @@ export const CATEGORIES = [
     {
         id: 'security',
         label: 'Security & privacy',
-        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'],
+        description: 'Git-ignored files kept out, secrets kept out of the sandbox, a GitHub token for sandboxes (with its login set here), download checks, what is kept on this PC, and sharing your sandbox with other Windows users.',
+        keys: ['workspaceFilter', 'audit', 'secrets', 'github', 'downloads', 'storage', 'sharing'],
     },
     {
         id: 'projects',
@@ -67,6 +67,7 @@ const NAMES = {
     storage: 'Storage on this PC',
     network: 'Network',
     vpn: 'VPN',
+    github: 'GitHub',
     hooks: 'Hooks',
     personalization: 'Desktop look',
     projects: 'Projects',

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

@@ -1,5 +1,5 @@
 import type { Config } from '../../../core/types.js';
-import type { SettingChange } from '../../../app/features/settings/index.js';
+import type { SettingChange } from './settings-file.js';
 /** Why something was left out. */
 export interface Skipped {
     readonly key: string;

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

@@ -1,11 +1,12 @@
 // Sharing your settings: the part of them that differs from the defaults, as a .json a team can pass around, and the
 // reverse (read a file, show what it would change, apply the rest). Secrets (anything the schema marks), the data
-// folder and folders or files of this PC never go into a file and are never taken from one.
+// folder and folders or files of this PC never go into a file and are never taken from one. Node side (lodash,
+// core/schema): the settings run functions use these; the menu and the web only see the operations.
 import { parse } from 'jsonc-parser';
 import _ from 'lodash';
 import { DEFAULTS, mergeConfig } from '../../../core/config/index.js';
 import { ConfigSchema, describeIssues, secretPaths } from '../../../core/schema/index.js';
-import { pathKindOf } from '../../../app/kernel/index.js';
+import { pathKindOf } from '../../kernel/index.js';
 /** Settings that are about this PC and never travel (the data folder). */
 const MACHINE_ONLY = ['storage.root'];
 /** A folder or file of this PC: a drive path, a network path, a rooted path or a %VARIABLE% path. */

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { type Page } from '../../kernel/index.js';
+import { type Field, type Page } from '../../kernel/index.js';
 export declare const ScopeSchema: z.ZodEnum<{
     project: "project";
     user: "user";
@@ -12,7 +12,7 @@ export declare const SettingRowSchema: z.ZodObject<{
     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>>;
+    field: z.ZodType<Field, unknown, z.core.$ZodTypeInternals<Field, unknown>>;
     value: z.ZodUnknown;
     set: z.ZodBoolean;
     yours: z.ZodUnknown;
@@ -30,6 +30,7 @@ export declare const SettingsListSchema: z.ZodObject<{
     file: z.ZodString;
     exists: z.ZodBoolean;
     dataFolder: z.ZodOptional<z.ZodString>;
+    exportFile: z.ZodOptional<z.ZodString>;
     categories: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
@@ -41,7 +42,7 @@ export declare const SettingsListSchema: z.ZodObject<{
         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>>;
+        field: z.ZodType<Field, unknown, z.core.$ZodTypeInternals<Field, unknown>>;
         value: z.ZodUnknown;
         set: z.ZodBoolean;
         yours: z.ZodUnknown;
@@ -65,6 +66,7 @@ export declare const listSettings: import("../../kernel/define.js").QueryDef<z.Z
     file: z.ZodString;
     exists: z.ZodBoolean;
     dataFolder: z.ZodOptional<z.ZodString>;
+    exportFile: z.ZodOptional<z.ZodString>;
     categories: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
@@ -76,7 +78,7 @@ export declare const listSettings: import("../../kernel/define.js").QueryDef<z.Z
         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>>;
+        field: z.ZodType<Field, unknown, z.core.$ZodTypeInternals<Field, unknown>>;
         value: z.ZodUnknown;
         set: z.ZodBoolean;
         yours: z.ZodUnknown;
@@ -115,6 +117,20 @@ export declare const resetSetting: import("../../kernel/define.js").OperationDef
     changed: z.ZodBoolean;
     message: z.ZodString;
 }, z.core.$strip>, "settings.reset">;
+export declare const exportConfig: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    settingsFile: z.ZodOptional<z.ZodString>;
+    withPaths: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    file: z.ZodString;
+    leftOut: z.ZodArray<z.ZodString>;
+    pathsLeftOut: z.ZodBoolean;
+}, z.core.$strip>, "settings.export">;
+export declare const importConfig: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    settingsFile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    changed: z.ZodNumber;
+    message: z.ZodString;
+}, z.core.$strip>, "settings.import">;
 /** 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<{
@@ -131,6 +147,7 @@ export declare const settingsView: import("../../kernel/define.js").ViewDef<{
         file: z.ZodString;
         exists: z.ZodBoolean;
         dataFolder: z.ZodOptional<z.ZodString>;
+        exportFile: z.ZodOptional<z.ZodString>;
         categories: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             label: z.ZodString;
@@ -142,7 +159,7 @@ export declare const settingsView: import("../../kernel/define.js").ViewDef<{
             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>>;
+            field: z.ZodType<Field, unknown, z.core.$ZodTypeInternals<Field, unknown>>;
             value: z.ZodUnknown;
             set: z.ZodBoolean;
             yours: z.ZodUnknown;