windows-development-sandbox 1.10.0 → 1.11.3

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

@@ -0,0 +1,204 @@
+// The health feature's work: the checks (through the repair engine), the repair log, the saved results
+// (<storage>\health\last.json), and turning Windows Sandbox on. The CLI's doctor and repair call healthWith too; the
+// menu and the web run the operations. Talks only through io.
+import fs from 'node:fs';
+import path from 'node:path';
+import { packageVersion } from '../../../core/package-info.js';
+import { assertNoLinks, dirExists, errMsg, fail, safeText } from '../../../core/util/index.js';
+import { assertTestWritable } from '../../../host/test-guard.js';
+import { JsonFile } from '../../../shared/io/index.js';
+import { requireOnPc } from '../../../cli/commands/context.js';
+import { buildEnv } from '../../../cli/commands/repair/env.js';
+import { runHealth } from '../../../cli/commands/repair/health-run.js';
+import { logText, writeRepairLog } from '../../../cli/commands/repair/log.js';
+import { ALL_CHECKS } from '../../../cli/commands/repair/checks/index.js';
+import { ENABLE_COMMAND } from '../../../cli/commands/setup/facts.js';
+import { HealthService } from '../../../cli/services/index.js';
+import { implement } from '../../context.js';
+import { cancelled } from '../../kernel/index.js';
+import { checkHealth, CheckRowSchema, enableSandbox, HealthLastSchema, lastHealth, repairHealth, resultLines, } from './health.def.js';
+/** Where the saved results are: <storage>\health\last.json. */
+function lastFile(storageRoot) {
+    return path.join(storageRoot, 'health', 'last.json');
+}
+function readLast(storageRoot) {
+    return new JsonFile(HealthLastSchema, lastFile(storageRoot)).read();
+}
+/**
+ * Saves the results. A folder that cannot be written must not fail the check or repair (the result is on screen and in
+ * the log), so a failure is not raised.
+ */
+function saveLast(storageRoot, last) {
+    if (!dirExists(storageRoot))
+        return;
+    try {
+        const dir = path.join(storageRoot, 'health');
+        assertNoLinks(storageRoot, dir);
+        assertTestWritable(lastFile(storageRoot));
+        fs.mkdirSync(dir, { recursive: true });
+        new JsonFile(HealthLastSchema, lastFile(storageRoot)).write(last);
+    }
+    catch {
+        // Saving is a convenience: the page then shows the last one saved, or nothing.
+    }
+}
+/** A result as saved: the text cleaned (it can quote what the sandbox wrote), the timing left out. */
+function savedRow(r) {
+    const clean = (t) => (t === undefined ? undefined : safeText(t));
+    return CheckRowSchema.parse({
+        id: r.id,
+        group: r.group,
+        name: safeText(r.name),
+        status: r.status,
+        detail: safeText(r.detail),
+        means: clean(r.means),
+        fix: clean(r.fix),
+        plan: clean(r.plan),
+        lines: r.lines?.map((l) => safeText(l)),
+        fixable: r.fixable,
+        timedOut: r.timedOut,
+        applied: r.applied && {
+            done: safeText(r.applied.done),
+            before: safeText(r.applied.before),
+            after: safeText(r.applied.after),
+        },
+        error: clean(r.error),
+    });
+}
+/** What `sandbox setup` found, as the page keeps it (null when it could not be read). */
+function setupOf(ctx) {
+    const health = new HealthService(ctx);
+    try {
+        health.assertWindows();
+        const report = health.setupReport();
+        return {
+            checks: report.checks.map((c) => ({ name: safeText(c.name), status: c.status, detail: safeText(c.detail) })),
+            canEnable: report.canEnable,
+            error: null,
+        };
+    }
+    catch (e) {
+        return { checks: [], canEnable: false, error: safeText(errMsg(e)) };
+    }
+}
+function quote(n, what) {
+    return n + ' ' + what + (n === 1 ? '' : 's');
+}
+/** Where a run's results go on the surfaces that have no terminal: the shared core's io. */
+export function ioEvents(io) {
+    let group = null;
+    const heading = (g) => {
+        if (g === group)
+            return;
+        group = g;
+        io.log(g, 'accent');
+    };
+    return {
+        hooks: () => ({
+            lookStart: (check) => io.progress('Checking ' + (check.checking ?? check.name.toLowerCase())),
+            lookEnd: (r) => {
+                heading(r.group);
+                for (const l of resultLines(r))
+                    io.log(l.text, l.tone);
+            },
+            fixStart: (r) => io.progress('Fixing: ' + (r.plan ?? r.name)),
+            fixEnd: (r) => {
+                heading(r.group);
+                if (r.status === 'fixed') {
+                    io.log('  [fixed] ' + r.name + ': ' + (r.applied?.done ?? r.detail));
+                    return;
+                }
+                io.log('  [x] ' + r.name + ': the fix did not work' + (r.error ? ' (' + r.error + ')' : ''), 'danger');
+                if (r.fix)
+                    io.log('      Fix: ' + r.fix);
+            },
+        }),
+        plan: (fixable) => {
+            io.log('Repair will change:', 'accent');
+            fixable.forEach((r, i) => {
+                io.log('  ' + (i + 1) + '. ' + r.name + ': ' + (r.plan ?? r.detail));
+                for (const line of (r.lines ?? []).slice(0, 6))
+                    io.log('       ' + line);
+            });
+            io.log('Nothing is deleted except leftovers; your settings, logins and projects are never removed.');
+        },
+        line: (text) => io.log(text),
+    };
+}
+/**
+ * The one run of doctor and repair, for every surface: look, ask (when allowed), fix, write the repair log, and save
+ * the results. The CLI prints what this returns; the menu and the web show the saved results.
+ */
+export async function healthWith(ctx, request, surface) {
+    if (request.mode === 'repair')
+        requireOnPc('repair');
+    const env = buildEnv(ctx, request.configError ?? null);
+    const question = request.mode === 'doctor'
+        ? (n) => quote(n, 'problem') + ' can be fixed. Fix ' + (n === 1 ? 'it' : 'them') + ' now?'
+        : (n) => 'Fix ' + (n === 1 ? 'this problem' : 'these ' + n + ' problems') + '?';
+    const report = await runHealth(env, surface.events, { yes: request.yes, ask: surface.mayAsk, question }, ALL_CHECKS, surface.confirmFix);
+    const details = request.configError ? [] : new HealthService(ctx).doctor(request.harness);
+    let log = null;
+    if (request.mode === 'repair') {
+        const when = new Date();
+        log = writeRepairLog(ctx.storageRoot, logText({
+            when,
+            version: packageVersion(),
+            command: 'sandbox repair' + (request.yes ? ' --yes' : ''),
+            found: report.found,
+            final: report.final,
+            summary: report.summary,
+        }), when);
+    }
+    saveLast(ctx.storageRoot, {
+        at: new Date().toISOString(),
+        mode: request.mode === 'repair' ? 'repair' : 'check',
+        checks: report.final.map(savedRow),
+        summary: report.summary,
+        details: details.map(([name, detail]) => [safeText(name), safeText(detail)]),
+        setup: request.setup ?? null,
+        log: log === null ? null : safeText(log),
+    });
+    return { report, details, log };
+}
+/** Updates the saved results' setup part (after turning the feature on); nothing is saved before the first check. */
+function refreshSetup(ctx) {
+    const last = readLast(ctx.storageRoot);
+    if (last)
+        saveLast(ctx.storageRoot, { ...last, setup: setupOf(ctx) });
+}
+export const checkHealthRun = implement(checkHealth, async (ctx, input, io) => {
+    io.progress('Checking this PC');
+    const { report } = await healthWith(ctx, { mode: 'doctor', yes: false, harness: input.harness, setup: setupOf(ctx) }, { events: ioEvents(io), mayAsk: false, confirmFix: () => Promise.resolve(false) });
+    return { summary: report.summary, changed: report.changed, log: null };
+});
+export const repairHealthRun = implement(repairHealth, async (ctx, _input, io) => {
+    // A "no" is not cancelled(): the run logs "Nothing was changed." and still writes the log, as the command did.
+    const previous = readLast(ctx.storageRoot);
+    const { report, log } = await healthWith(ctx, { mode: 'repair', yes: false, setup: previous?.setup ?? null }, {
+        events: ioEvents(io),
+        mayAsk: true,
+        confirmFix: (question) => io.confirm({ title: question, yes: 'Fix', danger: true }),
+    });
+    return { summary: report.summary, changed: report.changed, log };
+});
+export const enableSandboxRun = implement(enableSandbox, async (ctx, _input, io) => {
+    requireOnPc('setup');
+    const health = new HealthService(ctx);
+    health.assertWindows();
+    const yes = await io.confirm({
+        title: 'Turn on Windows Sandbox?',
+        lines: ['Windows asks for admin permission, then you restart Windows to finish.'],
+        yes: 'Turn on',
+        danger: true,
+    });
+    if (!yes)
+        cancelled();
+    io.progress('Turning on Windows Sandbox');
+    if (!health.enableFeature('ignore'))
+        fail('Windows Sandbox could not be turned on (or the admin prompt was declined).', 'In an admin PowerShell run: ' + ENABLE_COMMAND + ', then restart Windows.');
+    refreshSetup(ctx);
+    return { message: 'Done. Restart Windows to finish.' };
+});
+/** The saved results for the menu and the web (the page reads them; nothing is checked). */
+export const lastHealthRun = implement(lastHealth, (ctx) => ({ last: readLast(ctx.storageRoot) }));

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

@@ -0,0 +1,2 @@
+export * from './health.def.js';
+export * from './health.run.js';

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

@@ -0,0 +1,3 @@
+// The health feature: the checks of this PC and the sandbox, the saved results, and turning Windows Sandbox on.
+export * from './health.def.js';
+export * from './health.run.js';

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

@@ -0,0 +1,2 @@
+export * from './logs.def.js';
+export * from './logs.run.js';

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

@@ -0,0 +1,3 @@
+// The logs feature: the sandbox's own logs (the files, the end of one as it grows, the last crash report).
+export * from './logs.def.js';
+export * from './logs.run.js';

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+/** The name that shows the newest crash report instead of a log (never a log file name: those start with guest-,
+ * daemon- or bootstrap-). */
+export declare const CRASH = "@crash";
+export declare const LogFileSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    bytes: z.ZodNumber;
+    modified: z.ZodNumber;
+}, z.core.$strip>;
+export type LogFileRow = z.output<typeof LogFileSchema>;
+export declare const LogFilesSchema: z.ZodObject<{
+    folder: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        bytes: z.ZodNumber;
+        modified: z.ZodNumber;
+    }, z.core.$strip>>;
+    crash: z.ZodBoolean;
+}, z.core.$strip>;
+export type LogFiles = z.output<typeof LogFilesSchema>;
+export declare const LogTailSchema: z.ZodObject<{
+    name: z.ZodString;
+    file: z.ZodString;
+    text: z.ZodString;
+    next: z.ZodNumber;
+}, z.core.$strip>;
+export type LogTail = z.output<typeof LogTailSchema>;
+export declare const listLogs: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    folder: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        bytes: z.ZodNumber;
+        modified: z.ZodNumber;
+    }, z.core.$strip>>;
+    crash: z.ZodBoolean;
+}, z.core.$strip>, "logs.list">;
+export declare const tailLog: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    from: z.ZodDefault<z.ZodNumber>;
+    lines: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    file: z.ZodString;
+    text: z.ZodString;
+    next: z.ZodNumber;
+}, z.core.$strip>, "logs.tail">;
+/** What the view's address can set: the log shown. */
+export interface LogsParams {
+    readonly name?: string;
+}
+/** The page: one row per log (the one shown marked), the crash report last, and the end of the shown log. Pure. */
+export declare function logsPage(files: LogFiles, tail?: LogTail): Page;
+export declare const logsView: import("../../kernel/define.js").ViewDef<{
+    files: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        folder: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+            bytes: z.ZodNumber;
+            modified: z.ZodNumber;
+        }, z.core.$strip>>;
+        crash: z.ZodBoolean;
+    }, z.core.$strip>, "logs.list">;
+    tail: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        from: z.ZodDefault<z.ZodNumber>;
+        lines: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        file: z.ZodString;
+        text: z.ZodString;
+        next: z.ZodNumber;
+    }, z.core.$strip>, "logs.tail">;
+}, LogsParams, "logs">;

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

@@ -0,0 +1,115 @@
+// The sandbox's own logs: the files (newest first), the end of one (live, so it follows), and the last crash report.
+// Pure: schemas, labels and the view; logs.run.ts reads them through LogsService. `sandbox logs` stays a hand-written
+// command (--follow prints until Ctrl+C), so both queries are CLI-exempt and that command reads them with readQuery.
+import { z } from 'zod';
+import { ago, bytesText, defineQuery, defineView, link, } from '../../kernel/index.js';
+/** The name that shows the newest crash report instead of a log (never a log file name: those start with guest-,
+ * daemon- or bootstrap-). */
+export const CRASH = '@crash';
+/** Most lines the page shows of one log (a query gives at most `lines`; a crash report can be longer). */
+const MAX_SHOWN = 1000;
+const CLI_EXEMPT = 'sandbox logs is hand-written: --follow prints new lines until Ctrl+C; it reads this same query (readQuery)';
+export const LogFileSchema = z.object({
+    name: z.string().describe('The log file'),
+    path: z.string().describe('Where it is on this PC'),
+    bytes: z.number().describe('Its size in bytes'),
+    modified: z.number().describe('When it was last written (ms)'),
+});
+export const LogFilesSchema = z.object({
+    folder: z.string().describe('The folder the logs are in'),
+    files: z.array(LogFileSchema).describe('The log files, newest first'),
+    crash: z.boolean().describe('A crash report exists'),
+});
+export const LogTailSchema = z.object({
+    name: z.string().describe('The log shown, or @crash for the last crash report (empty: there are no logs)'),
+    file: z.string().describe('Its full path (empty: there are no logs)'),
+    text: z.string().describe('The text read, made safe for a terminal'),
+    next: z.number().describe('Where to read on from next time (bytes)'),
+});
+export const listLogs = defineQuery({
+    id: 'logs.list',
+    title: 'Logs',
+    summary: "list the sandbox's own logs",
+    input: z.object({}),
+    output: LogFilesSchema,
+    surfaces: { except: { cli: CLI_EXEMPT } },
+});
+export const tailLog = defineQuery({
+    id: 'logs.tail',
+    title: 'Log',
+    summary: 'the end of one log, followed as it grows',
+    input: z.object({
+        name: z
+            .string()
+            .max(200)
+            .optional()
+            .describe('The log to show (default: the newest), or @crash for the last crash report'),
+        from: z.number().int().min(0).default(0).describe('Read on from this byte (0: the end of the log)'),
+        lines: z.number().int().min(1).max(1000).default(120).describe('How many lines of the end to show'),
+    }),
+    output: LogTailSchema,
+    live: { everyMs: 1000 },
+    surfaces: { except: { cli: CLI_EXEMPT } },
+});
+/** The badge of the log the page shows (a log is not "this folder": marked would say that). */
+const SHOWING = { text: 'showing', tone: 'accent' };
+/** The lines of a text as a page shows them (the last MAX_SHOWN, no trailing empty line). */
+function shownLines(text) {
+    const lines = text.split('\n');
+    if (lines.length && lines[lines.length - 1] === '')
+        lines.pop();
+    return lines.slice(-MAX_SHOWN);
+}
+/** The page: one row per log (the one shown marked), the crash report last, and the end of the shown log. Pure. */
+export function logsPage(files, tail) {
+    const shown = tail?.file ? tail : undefined;
+    const items = files.files.map((f) => ({
+        id: 'log:' + f.name,
+        label: f.name,
+        hint: bytesText(f.bytes) + '  ' + ago(f.modified),
+        keys: 'Enter shows the end of this log in the terminal.',
+        primary: link({ kind: 'view', view: 'logs', params: { name: f.name } }, 'Show', { verb: 'show' }),
+        ...(shown?.name === f.name ? { badges: [SHOWING] } : {}),
+    }));
+    if (files.crash)
+        items.push({
+            id: 'log:' + CRASH,
+            label: 'Last crash report',
+            description: 'What Windows logged, this PC and the sandbox memory when the sandbox last ended in a crash.',
+            primary: link({ kind: 'view', view: 'logs', params: { name: CRASH } }, 'Show', { verb: 'show' }),
+            ...(shown?.name === CRASH ? { badges: [SHOWING] } : {}),
+        });
+    const tailSection = shown
+        ? [
+            {
+                id: 'tail',
+                title: shown.name === CRASH ? 'Last crash report' : shown.name,
+                summary: shown.file,
+                text: shownLines(shown.text),
+            },
+        ]
+        : [];
+    return {
+        title: 'Logs',
+        sections: [{ id: 'files', items }, ...tailSection],
+        actions: [
+            // The web hides command links (it follows live instead); this one stays because `logs` is a hand-written command.
+            link({ kind: 'command', argv: ['logs', '--follow'] }, 'Follow the newest log', {
+                key: 'f',
+                verb: 'follow in the terminal',
+                importance: 2,
+            }),
+        ],
+        empty: { title: 'No logs yet', text: 'Logs appear after the first start.', cliText: 'No sandbox logs yet.' },
+    };
+}
+export const logsView = defineView({
+    id: 'logs',
+    title: 'Logs',
+    summary: "The sandbox's own logs: pick one to see its end as it grows.",
+    queries: { files: listLogs, tail: tailLog },
+    operations: [],
+    params: ['name'],
+    inputs: (p) => ({ tail: p.name ? { name: p.name } : {} }),
+    build: ({ files, tail }) => logsPage(files, tail),
+});

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

@@ -0,0 +1,20 @@
+export declare const listLogsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    folder: import("zod").ZodString;
+    files: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        path: import("zod").ZodString;
+        bytes: import("zod").ZodNumber;
+        modified: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    crash: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, "logs.list">, import("../../../cli/commands/context.js").Context>;
+export declare const tailLogRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    from: import("zod").ZodDefault<import("zod").ZodNumber>;
+    lines: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    file: import("zod").ZodString;
+    text: import("zod").ZodString;
+    next: import("zod").ZodNumber;
+}, import("zod/v4/core").$strip>, "logs.tail">, import("../../../cli/commands/context.js").Context>;

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

@@ -0,0 +1,42 @@
+// The logs feature's work: the sandbox's log files and the end of one, through LogsService. The text is made safe for a
+// terminal there (the sandbox wrote it); a name from outside is only ever an exact name from the folder listing.
+import { fail, safeText } from '../../../core/util/index.js';
+import { newestCrashReport } from '../../../host/life/index.js';
+import { LogsService } from '../../../cli/services/index.js';
+import { implement } from '../../context.js';
+import { CRASH, listLogs, tailLog } from './logs.def.js';
+/** The last `n` lines of a text, joined back the way they were (a trailing newline stays). */
+function lastLines(text, n) {
+    return text.split('\n').slice(-n).join('\n');
+}
+export const listLogsRun = implement(listLogs, (ctx) => {
+    const service = new LogsService(ctx);
+    return {
+        folder: service.folder(),
+        files: service.files().map((f) => ({ name: f.name, path: f.path, bytes: f.bytes, modified: f.modified })),
+        crash: newestCrashReport(ctx.storageRoot) !== null,
+    };
+});
+export const tailLogRun = implement(tailLog, (ctx, input) => {
+    if (input.name === CRASH) {
+        const report = newestCrashReport(ctx.storageRoot);
+        if (!report)
+            return fail('No crash report yet: no sandbox has ended in a crash since this was installed.');
+        return { name: CRASH, file: report.file, text: safeText(report.text), next: 0 };
+    }
+    const service = new LogsService(ctx);
+    // No name and no logs yet: an empty answer (the page says so; the command line fails with the words it always had).
+    const name = input.name ?? service.files()[0]?.name;
+    if (!name)
+        return { name: '', file: '', text: '', next: 0 };
+    const file = service.byName(name);
+    const chunk = service.read(file, input.from);
+    if (!chunk)
+        return { name, file, text: '', next: input.from };
+    return {
+        name,
+        file,
+        text: input.from === 0 ? lastLines(chunk.text, input.lines) : chunk.text,
+        next: chunk.next,
+    };
+});

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

@@ -0,0 +1,2 @@
+export * from './projects.def.js';
+export * from './projects.run.js';

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

@@ -0,0 +1,3 @@
+// The projects feature: which projects a sandbox can open without a restart, roots and the all-projects setting.
+export * from './projects.def.js';
+export * from './projects.run.js';

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

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+export declare const ProjectRowSchema: z.ZodObject<{
+    folder: z.ZodString;
+    here: z.ZodBoolean;
+    known: z.ZodBoolean;
+    root: z.ZodNullable<z.ZodString>;
+    excluded: z.ZodBoolean;
+    mappedAtStart: z.ZodBoolean;
+    running: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ProjectRow = z.output<typeof ProjectRowSchema>;
+export declare const ProjectsListSchema: z.ZodObject<{
+    all: z.ZodBoolean;
+    roots: z.ZodArray<z.ZodString>;
+    exclude: z.ZodArray<z.ZodString>;
+    projects: z.ZodArray<z.ZodObject<{
+        folder: z.ZodString;
+        here: z.ZodBoolean;
+        known: z.ZodBoolean;
+        root: z.ZodNullable<z.ZodString>;
+        excluded: z.ZodBoolean;
+        mappedAtStart: z.ZodBoolean;
+        running: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProjectsList = z.output<typeof ProjectsListSchema>;
+export declare const listProjects: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    all: z.ZodBoolean;
+    roots: z.ZodArray<z.ZodString>;
+    exclude: z.ZodArray<z.ZodString>;
+    projects: z.ZodArray<z.ZodObject<{
+        folder: z.ZodString;
+        here: z.ZodBoolean;
+        known: z.ZodBoolean;
+        root: z.ZodNullable<z.ZodString>;
+        excluded: z.ZodBoolean;
+        mappedAtStart: z.ZodBoolean;
+        running: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "projects.list">;
+export declare const chooseProjects: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "projects.choose">;
+export declare const addProject: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    projectFolder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+    next: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, "projects.add">;
+export declare const removeProject: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    projectFolder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "projects.remove">;
+export declare const includeProject: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    projectFolder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "projects.include">;
+export declare const excludeProject: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    projectFolder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "projects.exclude">;
+export declare const allProjects: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    state: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        on: "on";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "projects.all">;
+export declare const projectRoots: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    change: z.ZodDefault<z.ZodEnum<{
+        list: "list";
+        add: "add";
+        remove: "remove";
+    }>>;
+    rootFolder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "projects.roots">;
+/** The projects page: the settings, the project roots, and the projects (the same rows as the menu's Projects). */
+export declare function projectsPage(o: ProjectsList): Page;
+export declare const projectsView: import("../../kernel/define.js").ViewDef<{
+    projects: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        all: z.ZodBoolean;
+        roots: z.ZodArray<z.ZodString>;
+        exclude: z.ZodArray<z.ZodString>;
+        projects: z.ZodArray<z.ZodObject<{
+            folder: z.ZodString;
+            here: z.ZodBoolean;
+            known: z.ZodBoolean;
+            root: z.ZodNullable<z.ZodString>;
+            excluded: z.ZodBoolean;
+            mappedAtStart: z.ZodBoolean;
+            running: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, "projects.list">;
+}, Record<string, never>, "projects">;