windows-development-sandbox 1.7.0 → 1.9.0

package/dist/cli/menu/vpn-login.js

@@ -6,6 +6,12 @@ export const VPN_LOGIN = '@vpn-login';
 export function vpnLoginRow(ctx) {
     const service = new VpnService(ctx);
     const nord = service.provider === 'nordvpn';
+    if (service.provider === 'wireguard-file')
+        return {
+            label: 'VPN login',
+            hint: 'not needed',
+            description: 'A WireGuard file carries its own keys (vpn.configFile): there is no login to set.',
+        };
     const state = service.loginState();
     return {
         label: nord ? 'Set NordVPN login…' : 'Set VPN login…',
@@ -25,6 +31,8 @@ export class VpnLoginFlow {
     async run() {
         const service = new VpnService(this.ctx);
         const nord = service.provider === 'nordvpn';
+        if (service.provider === 'wireguard-file')
+            return 'A WireGuard file carries its own keys: no login is needed.';
         const path = ['Settings', 'Network', 'VPN login'];
         await this.app.message({
             path,

package/dist/cli/operations/handler.d.ts

@@ -0,0 +1,6 @@
+import { type AnyDefinition } from '../../app/kernel/index.js';
+import type { Handler } from '../commands/registry.js';
+/** The command for a definition. */
+export declare function definitionHandler(def: AnyDefinition): Handler;
+/** The command a parsed command line runs when it is one of the shared core's, else undefined. */
+export declare function operationHandler(command: string, positionals: readonly string[]): Handler | undefined;

package/dist/cli/operations/handler.js

@@ -0,0 +1,61 @@
+// Runs a definition as a command: its input from the command line, its questions on the terminal, and its output as
+// --json, as the definition's one-line text, or as the page of the view that shows it. A declined question prints
+// "Nothing changed." and exits 1, as the commands always have.
+import { VIEWS } from '../../app/features/defs.js';
+import { runDefinition } from '../../app/registry.js';
+import { Cancelled } from '../../app/kernel/index.js';
+import { printJson, printPage } from '../output/index.js';
+import { cliInput, definitionFor } from './input.js';
+import { cliIO } from './io-cli.js';
+/** The view that shows only this query (its page is the command's text output). */
+function viewOf(def) {
+    for (const view of VIEWS) {
+        const entries = Object.entries(view.queries);
+        if (entries.length === 1 && entries[0][1] === def)
+            return { view, name: entries[0][0] };
+    }
+    return undefined;
+}
+/** Prints what a definition returned, the way its command shows it. */
+function printOutput(def, output, input) {
+    if (def.text) {
+        const text = def.text(output);
+        if (text)
+            console.log(text);
+        return;
+    }
+    const shown = viewOf(def);
+    if (shown)
+        printPage(shown.view.build({ [shown.name]: output }, input));
+    else
+        console.log(JSON.stringify(output, null, 2));
+}
+/** The command for a definition. */
+export function definitionHandler(def) {
+    return async (ctx) => {
+        const input = cliInput(def, ctx.options);
+        const { io, close } = cliIO(ctx.options);
+        try {
+            const output = await runDefinition(def.id, ctx, input, io);
+            close();
+            if (def.cli?.json && ctx.options.json) {
+                printJson(ctx, def.cli.shapeJson ? def.cli.shapeJson(output) : output);
+                return 0;
+            }
+            printOutput(def, output, def.input.parse(input));
+            return 0;
+        }
+        catch (e) {
+            close();
+            if (!(e instanceof Cancelled))
+                throw e;
+            console.log(e.message);
+            return 1;
+        }
+    };
+}
+/** The command a parsed command line runs when it is one of the shared core's, else undefined. */
+export function operationHandler(command, positionals) {
+    const def = definitionFor(command, positionals);
+    return def ? definitionHandler(def) : undefined;
+}

package/dist/cli/operations/index.d.ts

@@ -0,0 +1,4 @@
+export { definitionHandler, operationHandler } from './handler.js';
+export { cliInput, definitionFor } from './input.js';
+export { cliIO } from './io-cli.js';
+export { actionDefinitions, commandDefinitions, commandSpecOf, inputField, withActions, withOperationCommands, } from './spec.js';

package/dist/cli/operations/index.js

@@ -0,0 +1,5 @@
+// The command line of the shared core: commands from definitions, their input, their terminal IO and their output.
+export { definitionHandler, operationHandler } from './handler.js';
+export { cliInput, definitionFor } from './input.js';
+export { cliIO } from './io-cli.js';
+export { actionDefinitions, commandDefinitions, commandSpecOf, inputField, withActions, withOperationCommands, } from './spec.js';

package/dist/cli/operations/input.d.ts

@@ -0,0 +1,6 @@
+import type { AnyDefinition } from '../../app/kernel/index.js';
+import type { CliOptions } from '../args.js';
+/** The definition a command runs: its own command, or an action of a hand-written one (`config get`). */
+export declare function definitionFor(command: string, positionals: readonly string[]): AnyDefinition | undefined;
+/** The input a command line gives a definition (fields not on the line are left to the schema's defaults). */
+export declare function cliInput(def: AnyDefinition, options: CliOptions): Record<string, unknown>;

package/dist/cli/operations/input.js

@@ -0,0 +1,37 @@
+// Which definition a parsed command line runs, and its input: positional arguments and flags mapped to input fields by
+// the definition's CLI hint (zod then checks them like any other input).
+import { DEFINITIONS } from '../../app/features/defs.js';
+import { fail } from '../../core/util/index.js';
+import { inputField } from './spec.js';
+/** The definition a command runs: its own command, or an action of a hand-written one (`config get`). */
+export function definitionFor(command, positionals) {
+    return DEFINITIONS.find((d) => d.cli?.name === command && (d.cli.action === undefined || d.cli.action === positionals[0]));
+}
+/** commander's attribute name for a long flag: --keep-old -> keepOld. */
+function attribute(flag) {
+    return flag.replace(/^--/, '').replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
+}
+/** The input a command line gives a definition (fields not on the line are left to the schema's defaults). */
+export function cliInput(def, options) {
+    const hint = def.cli;
+    if (!hint)
+        return {};
+    const positionals = hint.action ? options.positionals.slice(1) : options.positionals;
+    const names = hint.positional ?? [];
+    const missing = names.slice(positionals.length).filter((name) => !inputField(def, name).optional);
+    if (missing.length)
+        fail('Missing ' + missing.join(' and ') + '.', 'Usage: sandbox ' + [hint.name, hint.action, ...names.map((n) => '<' + n + '>')].filter(Boolean).join(' '));
+    const input = {};
+    names.forEach((name, i) => {
+        if (positionals[i] !== undefined)
+            input[name] = positionals[i];
+    });
+    for (const [name, flag] of Object.entries(hint.flags ?? {})) {
+        if (!flag)
+            continue;
+        const value = (flag.shownAs ? options.raw[attribute(flag.shownAs)] : undefined) ?? options.raw[attribute(flag.flag)];
+        if (value !== undefined)
+            input[name] = value;
+    }
+    return input;
+}

package/dist/cli/operations/io-cli.d.ts

@@ -0,0 +1,7 @@
+import type { OperationIO } from '../../app/kernel/index.js';
+import type { CliOptions } from '../args.js';
+/** An OperationIO for one command; close() removes a progress line still shown. */
+export declare function cliIO(options: CliOptions): {
+    io: OperationIO;
+    close: () => void;
+};

package/dist/cli/operations/io-cli.js

@@ -0,0 +1,62 @@
+import { ioFromAsker } from '../../app/kernel/index.js';
+import { askChoice, askChoices, askName, askRequired, askSecret, askTyped } from '../../core/prompt.js';
+import { fail } from '../../core/util/index.js';
+import { c, ProgressLine } from '../output/index.js';
+/** What to do instead when there is no terminal to ask in. */
+const NO_TERMINAL_FIX = 'Run it in a terminal, or give the value on the command line.';
+const PAINT = {
+    ok: c.green,
+    warn: c.yellow,
+    danger: c.red,
+    muted: c.dim,
+    accent: c.bold,
+};
+/** The question in one line, as a prompt says it: its lines, then the question itself. */
+function promptText(q) {
+    return [...(q.lines ?? []), q.title].join(' ');
+}
+function interactive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function ask(q, options) {
+    if ('problem' in q && q.problem)
+        console.log(c.yellow(q.problem));
+    switch (q.kind) {
+        case 'confirm': {
+            if (q.implied || options.yes)
+                return true;
+            if (!interactive())
+                fail(q.noTerminal?.message ?? 'Cannot ask here (no terminal).', q.noTerminal?.fix ?? 'Add --yes to answer yes.');
+            if (q.typed)
+                return askTyped(promptText(q), q.typed);
+            return askRequired(promptText(q), q.noTerminal?.fix);
+        }
+        case 'choose':
+            return askChoice(promptText(q), q.choices.map((ch) => ({ name: ch.label, value: ch.value, description: ch.description })), NO_TERMINAL_FIX);
+        case 'checklist':
+            return askChoices(promptText(q), q.choices.map((ch) => ({ name: ch.label, value: ch.value, description: ch.description })), NO_TERMINAL_FIX);
+        case 'secret':
+            return askSecret(promptText(q), NO_TERMINAL_FIX);
+        case 'text':
+        case 'path': {
+            const answer = await askName(promptText(q), NO_TERMINAL_FIX);
+            return answer === '' && q.kind === 'text' && !q.allowEmpty ? undefined : answer;
+        }
+    }
+}
+/** An OperationIO for one command; close() removes a progress line still shown. */
+export function cliIO(options) {
+    const progress = new ProgressLine();
+    const asker = async (q) => {
+        progress.stop();
+        return (await ask(q, options));
+    };
+    const io = ioFromAsker(asker, {
+        progress: (text) => progress.show(text),
+        log: (text, tone) => {
+            progress.stop();
+            console.log(tone ? PAINT[tone](text) : text);
+        },
+    });
+    return { io, close: () => progress.stop() };
+}

package/dist/cli/operations/spec.d.ts

@@ -0,0 +1,18 @@
+import { type AnyDefinition, type Field } from '../../app/kernel/index.js';
+import type { CommandSpec } from '../manifest.js';
+/** The definitions that are a command of their own. */
+export declare function commandDefinitions(): AnyDefinition[];
+/** The definitions that are an action of a hand-written command. */
+export declare function actionDefinitions(): AnyDefinition[];
+/** The Field of one input field of a definition. */
+export declare function inputField(def: AnyDefinition, name: string): Field;
+/** The manifest command of a definition that is a command of its own. */
+export declare function commandSpecOf(def: AnyDefinition): CommandSpec;
+/**
+ * A hand-written command with the actions the definitions add (`config reset`): the action is one of the first
+ * argument's choices, each later argument is asked for it in the menu's command form, and --json is offered when an
+ * action prints JSON.
+ */
+export declare function withActions(spec: CommandSpec, defs?: readonly AnyDefinition[]): CommandSpec;
+/** Every command the definitions add, and the hand-written ones with their added actions. */
+export declare function withOperationCommands(handWritten: readonly CommandSpec[]): CommandSpec[];

package/dist/cli/operations/spec.js

@@ -0,0 +1,108 @@
+// The command line of the shared core's definitions: each definition with a CLI hint becomes a manifest command (its
+// options and arguments read from the input schema, their help from .describe()), or an action of an existing command
+// (`config get`). manifest.ts adds these to the hand-written commands, so --help, the parser and the menu's command
+// list treat them like any other command.
+import { DEFINITIONS } from '../../app/features/defs.js';
+import { fieldOf, SchemaNode } from '../../app/kernel/index.js';
+/** The definitions that are a command of their own. */
+export function commandDefinitions() {
+    return DEFINITIONS.filter((d) => d.cli && !d.cli.action);
+}
+/** The definitions that are an action of a hand-written command. */
+export function actionDefinitions() {
+    return DEFINITIONS.filter((d) => d.cli?.action);
+}
+/** The Field of one input field of a definition. */
+export function inputField(def, name) {
+    const node = new SchemaNode(def.input).child(name);
+    if (!node)
+        throw new Error(def.id + ': the CLI hint names "' + name + '", which is not in its input');
+    return fieldOf(node, [name]);
+}
+const OPTION_TYPES = {
+    boolean: 'boolean',
+    number: 'number',
+    list: 'list',
+};
+function stringChoices(field) {
+    const values = field.choices?.map((c) => c.value).filter((v) => typeof v === 'string');
+    return values?.length ? values : undefined;
+}
+function optionSpec(def, name, flag) {
+    const field = inputField(def, name);
+    const type = OPTION_TYPES[field.kind] ?? 'string';
+    const choices = flag.choices ? (typeof flag.choices === 'string' ? flag.choices : [...flag.choices]) : undefined;
+    const fixed = choices ?? stringChoices(field);
+    const fallback = field.default;
+    return {
+        flag: flag.flag,
+        type,
+        description: field.help ?? '',
+        ...(flag.short ? { short: flag.short } : {}),
+        ...(flag.shownAs ? { shownAs: flag.shownAs } : {}),
+        ...(type === 'boolean' ? {} : { value: flag.value ?? name }),
+        ...(flag.label ? { label: flag.label } : {}),
+        ...(fixed ? { choices: fixed } : {}),
+        ...(type !== 'boolean' && (typeof fallback === 'string' || typeof fallback === 'number')
+            ? { default: fallback }
+            : {}),
+        ...(flag.noMenu ? { noMenu: true } : {}),
+        ...(flag.advanced ? { advanced: true } : {}),
+    };
+}
+function argSpec(def, name) {
+    const field = inputField(def, name);
+    const choices = stringChoices(field);
+    return {
+        name,
+        description: field.help ?? '',
+        required: !field.optional,
+        ...(choices ? { choices } : {}),
+    };
+}
+/** The manifest command of a definition that is a command of its own. */
+export function commandSpecOf(def) {
+    const hint = def.cli;
+    if (!hint?.group)
+        throw new Error(def.id + ': a CLI command of its own needs a group');
+    return {
+        name: hint.name,
+        summary: hint.summary ?? def.summary,
+        group: hint.group,
+        args: (hint.positional ?? []).map((name) => argSpec(def, name)),
+        options: [
+            ...Object.entries(hint.flags ?? {}).flatMap(([name, flag]) => (flag ? [optionSpec(def, name, flag)] : [])),
+            ...(hint.yes
+                ? [{ flag: '--yes', short: '-y', type: 'boolean', description: hint.yes, noMenu: true }]
+                : []),
+        ],
+        ...(hint.json ? { json: true } : {}),
+        ...(hint.examples ? { examples: [...hint.examples] } : {}),
+    };
+}
+/**
+ * A hand-written command with the actions the definitions add (`config reset`): the action is one of the first
+ * argument's choices, each later argument is asked for it in the menu's command form, and --json is offered when an
+ * action prints JSON.
+ */
+export function withActions(spec, defs = actionDefinitions()) {
+    const mine = defs.filter((d) => d.cli?.name === spec.name);
+    if (!mine.length || !spec.args.length)
+        return spec;
+    const [first, ...rest] = spec.args;
+    const actions = mine.map((d) => d.cli.action);
+    const choices = Array.isArray(first.choices) ? [...new Set([...first.choices, ...actions])] : first.choices;
+    const asked = (arg, position) => {
+        const users = mine.filter((d) => (d.cli?.positional?.length ?? 0) > position).map((d) => d.cli.action);
+        if (!users.length || arg.when === undefined)
+            return arg;
+        const when = Array.isArray(arg.when) ? arg.when : [arg.when];
+        return { ...arg, when: [...new Set([...when, ...users])] };
+    };
+    const json = spec.json || mine.some((d) => d.cli?.json) ? { json: true } : {};
+    return { ...spec, ...json, args: [{ ...first, choices }, ...rest.map(asked)] };
+}
+/** Every command the definitions add, and the hand-written ones with their added actions. */
+export function withOperationCommands(handWritten) {
+    return [...handWritten.map((spec) => withActions(spec)), ...commandDefinitions().map(commandSpecOf)];
+}

package/dist/cli/output/colors.d.ts

@@ -14,8 +14,8 @@ export declare function stripAnsi(text: string): string;
 export declare function shorten(text: string, max: number): string;
 /** Cuts the middle out of a long path or id so both ends stay readable. */
 export declare function shortenMiddle(text: string, max: number): string;
-/** 1536 -> "1.5 KB" is in the data command; this is "3 min ago" for the tables. */
-export declare function ago(then: number | string | Date, now?: number): string;
+/** "3 min ago" for the tables (the kernel's, so every surface says it the same way). */
+export { ago } from '../../app/kernel/index.js';
 /** Width to lay text out in (terminal columns, 80 when unknown, never absurdly small). */
 export declare function termWidth(): number;
 /** Each menu page starts on a clean screen (answered prompts would otherwise pile up above it). */

package/dist/cli/output/colors.js

@@ -34,17 +34,8 @@ export function shortenMiddle(text, max) {
     const head = Math.ceil(keep / 2);
     return text.slice(0, head) + '…' + text.slice(text.length - (keep - head));
 }
-/** 1536 -> "1.5 KB" is in the data command; this is "3 min ago" for the tables. */
-export function ago(then, now = Date.now()) {
-    const secs = Math.max(0, Math.round((now - new Date(then).getTime()) / 1000));
-    if (secs < 45)
-        return 'just now';
-    if (secs < 3600)
-        return Math.round(secs / 60) + ' min ago';
-    if (secs < 86400)
-        return Math.round(secs / 3600) + ' h ago';
-    return Math.round(secs / 86400) + ' d ago';
-}
+/** "3 min ago" for the tables (the kernel's, so every surface says it the same way). */
+export { ago } from '../../app/kernel/index.js';
 /** Width to lay text out in (terminal columns, 80 when unknown, never absurdly small). */
 export function termWidth() {
     return Math.max(40, process.stdout.columns ?? 80);

package/dist/cli/output/index.d.ts

@@ -1,3 +1,4 @@
 export * from './colors.js';
 export * from './progress.js';
 export * from './print.js';
+export * from './render-view.js';

package/dist/cli/output/index.js

@@ -1,3 +1,4 @@
 export * from './colors.js';
 export * from './progress.js';
 export * from './print.js';
+export * from './render-view.js';

package/dist/cli/output/print.d.ts

@@ -1,6 +1,8 @@
 import type { Context } from '../commands/context.js';
+/** Rows as aligned columns (the last column is not padded). */
+export declare function tableLines(rows: readonly (readonly string[])[]): string[];
 /** Prints rows as aligned columns (the last column is not padded). */
-export declare function table(rows: string[][]): void;
+export declare function table(rows: readonly (readonly string[])[]): void;
 /** Prints `value` as JSON when --json was given; returns whether it did. */
 export declare function printJson(ctx: Context, value: unknown): boolean;
 /** A dim "Next: ..." line after a command: the usual thing to do now. */

package/dist/cli/output/print.js

@@ -1,11 +1,15 @@
 import _ from 'lodash';
 import { scrubSecrets } from '../../core/schema/index.js';
 import { c } from './colors.js';
+/** Rows as aligned columns (the last column is not padded). */
+export function tableLines(rows) {
+    const widths = _.range(_.max(rows.map((r) => r.length)) ?? 0).map((i) => _.max(rows.map((r) => (r[i] ?? '').length)) ?? 0);
+    return rows.map((row) => row.map((cell, i) => (i === row.length - 1 ? cell : _.padEnd(cell, widths[i] + 2))).join(''));
+}
 /** Prints rows as aligned columns (the last column is not padded). */
 export function table(rows) {
-    const widths = _.range(_.max(rows.map((r) => r.length)) ?? 0).map((i) => _.max(rows.map((r) => (r[i] ?? '').length)) ?? 0);
-    for (const row of rows)
-        console.log(row.map((cell, i) => (i === row.length - 1 ? cell : _.padEnd(cell, widths[i] + 2))).join(''));
+    for (const line of tableLines(rows))
+        console.log(line);
 }
 /** Prints `value` as JSON when --json was given; returns whether it did. */
 export function printJson(ctx, value) {

package/dist/cli/output/progress.d.ts

@@ -22,3 +22,18 @@ export declare function follow<T>(show: () => Progressing, work: () => Promise<T
  * (waiting on the sandbox); for long synchronous work (measuring folders) the static line is what you see.
  */
 export declare function working<T>(message: string | (() => string), work: () => Promise<T> | T, enabled?: boolean): Promise<T>;
+/**
+ * A progress line that follows an operation (its io.progress): on a terminal one line redrawn in place until stop();
+ * without one, each new text once as "text...". Prompts and log lines call stop() first.
+ */
+export declare class ProgressLine {
+    private text;
+    private timer;
+    private frame;
+    private start;
+    private readonly animate;
+    show(text: string): void;
+    private draw;
+    /** Removes the line (the next show() starts it again). */
+    stop(): void;
+}

package/dist/cli/output/progress.js

@@ -122,3 +122,47 @@ export async function working(message, work, enabled = true) {
         err.write('\r\x1b[2K');
     }
 }
+/**
+ * A progress line that follows an operation (its io.progress): on a terminal one line redrawn in place until stop();
+ * without one, each new text once as "text...". Prompts and log lines call stop() first.
+ */
+export class ProgressLine {
+    text = '';
+    timer;
+    frame = 0;
+    start = 0;
+    animate = canAnimate(process.env, Boolean(process.stderr.isTTY));
+    show(text) {
+        if (text === this.text && (this.timer || !this.animate))
+            return;
+        this.text = text;
+        if (!this.animate) {
+            process.stderr.write(text + '...\n');
+            return;
+        }
+        if (!this.timer) {
+            this.start = Date.now();
+            this.timer = setInterval(() => this.draw(), 120);
+        }
+        this.draw();
+    }
+    draw() {
+        const colour = colorEnabled(process.env, true);
+        process.stderr.write('\r\x1b[2K' +
+            (colour ? '\x1b[36m' : '') +
+            FRAMES[this.frame++ % FRAMES.length] +
+            (colour ? '\x1b[0m' : '') +
+            ' ' +
+            shorten(this.text, termWidth() - 14) +
+            (Date.now() - this.start > 3000 ? ' (' + elapsed(Date.now() - this.start) + ')' : ''));
+    }
+    /** Removes the line (the next show() starts it again). */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+            process.stderr.write('\r\x1b[2K');
+        }
+        this.text = '';
+    }
+}

package/dist/cli/output/render-view.d.ts

@@ -0,0 +1,4 @@
+import type { Page } from '../../app/kernel/index.js';
+/** The page as lines of text (text that came from the sandbox was made safe by the feature; this makes sure). */
+export declare function pageLines(page: Page): string[];
+export declare function printPage(page: Page): void;

package/dist/cli/output/render-view.js

@@ -0,0 +1,63 @@
+import { pageHasContent } from '../../app/kernel/index.js';
+import { safeText } from '../../core/util/index.js';
+import { c } from './colors.js';
+import { tableLines } from './print.js';
+const PAINT = {
+    ok: (t) => t,
+    warn: c.yellow,
+    danger: c.red,
+    muted: c.dim,
+    accent: (t) => t,
+};
+const forCli = (n) => n.only === undefined || n.only === 'cli';
+function itemLine(item) {
+    const label = item.tone ? PAINT[item.tone](item.label) : item.details?.length ? c.bold(item.label) : item.label;
+    return (item.marked ? '* ' : '  ') + label + (item.hint ? '  ' + item.hint : '');
+}
+function sectionLines(section) {
+    const items = section.items ?? [];
+    const lines = [];
+    if (section.title)
+        lines.push(c.bold(section.title) + (section.summary ? '  ' + section.summary : ''));
+    if (section.facts?.length)
+        lines.push(...tableLines(section.facts.map((f) => [f.label, f.value])));
+    if (section.columns && items.length) {
+        const columns = section.columns;
+        lines.push(...tableLines([
+            columns.map((col) => col.label),
+            ...items.map((i) => columns.map((col) => i.cells?.[col.key] ?? '')),
+        ]));
+    }
+    else
+        for (const item of items) {
+            lines.push(itemLine(item));
+            for (const detail of item.details ?? [])
+                lines.push('      ' + detail);
+        }
+    for (const note of (section.notes ?? []).filter(forCli))
+        lines.push(note.tone ? PAINT[note.tone](note.text) : note.text);
+    return lines;
+}
+/** The page as lines of text (text that came from the sandbox was made safe by the feature; this makes sure). */
+export function pageLines(page) {
+    const out = [];
+    if (page.notice)
+        out.push(c.bold(page.notice.text));
+    if (!pageHasContent(page) && page.empty) {
+        out.push(page.empty.cliText ?? page.empty.text);
+        return out.map(safeText);
+    }
+    for (const section of page.sections) {
+        const lines = sectionLines(section);
+        if (!lines.length)
+            continue;
+        if (section.title && out.length)
+            out.push('');
+        out.push(...lines);
+    }
+    return out.map(safeText);
+}
+export function printPage(page) {
+    for (const line of pageLines(page))
+        console.log(line);
+}

package/dist/cli/services/agent-commands-service.d.ts

@@ -15,6 +15,8 @@ export declare class AgentCommandsService {
     /** Agent commands change this PC's PATH, so they are set up from the PC, not inside the sandbox. */
     assertOnPc(): void;
     status(): AgentCommandsStatus;
+    /** status() that does not block the program (the menu asks while it stays responsive). */
+    statusAsync(): Promise<AgentCommandsStatus>;
     /** Writes agentCommands.enabled to your config file, then brings this PC in line with it. */
     setEnabled(on: boolean): Reconciled | null;
     /** Brings this PC in line with agentCommands. Null inside a sandbox (nothing to change there). */

package/dist/cli/services/agent-commands-service.js

@@ -3,10 +3,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { loadConfig, userConfigPath } from '../../core/config/index.js';
 import { fail } from '../../core/util/index.js';
-import { agentCommands, commandsDir, reconcileAgentCommands, } from '../../host/agent-commands/index.js';
+import { agentCommands, agentCommandsAsync, commandsDir, reconcileAgentCommands, } from '../../host/agent-commands/index.js';
 import { insideSandbox } from '../../host/sandbox/index.js';
 import { writeFileAtomic } from '../../shared/io/index.js';
-import { editConfigText } from '../menu/settings/index.js';
+import { editConfigText } from '../../app/features/settings/index.js';
 export class AgentCommandsService {
     ctx;
     constructor(ctx) {
@@ -25,6 +25,15 @@ export class AgentCommandsService {
             found: agentCommands(config, this.ctx.storageRoot),
         };
     }
+    /** status() that does not block the program (the menu asks while it stays responsive). */
+    async statusAsync() {
+        const { config } = this.ctx.loaded;
+        return {
+            enabled: config.agentCommands.enabled,
+            dir: commandsDir(this.ctx.storageRoot),
+            found: await agentCommandsAsync(config, this.ctx.storageRoot),
+        };
+    }
     /** Writes agentCommands.enabled to your config file, then brings this PC in line with it. */
     setEnabled(on) {
         const file = this.ctx.loaded.configPath ?? userConfigPath();

package/dist/cli/services/logs-service.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import _ from 'lodash';
 import { assertNoLinks, fail, safeText } from '../../core/util/index.js';
+import { hostDataFolder, hostDataRoot } from '../../host/storage/index.js';
 const LOG_NAME = /^(guest|daemon|bootstrap)-.*\.log$/;
 /** Only the end of a log is read: the sandbox writes it. */
 const FIRST_READ_BYTES = 64 * 1024;
@@ -13,8 +14,8 @@ export class LogsService {
         this.ctx = ctx;
     }
     dir() {
-        const dir = path.join(this.ctx.dataPath, 'logs');
-        assertNoLinks(this.ctx.dataPath, dir);
+        const dir = hostDataFolder(this.ctx.dataPath, 'logs');
+        assertNoLinks(hostDataRoot(this.ctx.dataPath), dir);
         return dir;
     }
     /** Log files, newest first. */
@@ -34,7 +35,7 @@ export class LogsService {
     /** The newest log, or a UserError when there is none yet. */
     newest() {
         return (this.files()[0]?.path ??
-            fail('No sandbox logs yet in ' + path.join(this.ctx.dataPath, 'logs') + '.', 'Logs appear after the first start (sandbox claude).'));
+            fail('No sandbox logs yet in ' + hostDataFolder(this.ctx.dataPath, 'logs') + '.', 'Logs appear after the first start (sandbox claude).'));
     }
     /**
      * What was written to `file` since offset `from` (0 = the end of the log), as text safe for a terminal, and where