windows-development-sandbox 1.5.0 → 1.9.0

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,5 +1,9 @@
 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. */
+export declare function nextStep(text: string): void;

package/dist/cli/output/print.js

@@ -1,14 +1,25 @@
 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) {
     // JSON.stringify leaves C1 controls (U+0080-U+009F) as they are; text from the sandbox must not reach a terminal raw.
+    // Secret values of your settings (agent API keys) never appear, whatever built the value.
     if (ctx.options.json)
-        console.log(JSON.stringify(value, null, 2).replace(/[\u0080-\u009f]/g, (ch) => '\\u' + ch.charCodeAt(0).toString(16).padStart(4, '0')));
+        console.log(scrubSecrets(JSON.stringify(value, null, 2), ctx.loaded.config).replace(/[\u0080-\u009f]/g, (ch) => '\\u' + ch.charCodeAt(0).toString(16).padStart(4, '0')));
     return ctx.options.json;
 }
+/** A dim "Next: ..." line after a command: the usual thing to do now. */
+export function nextStep(text) {
+    console.log(c.dim('Next: ' + text));
+}

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/accounts-service.d.ts

@@ -13,6 +13,8 @@ export interface AgentAccounts {
 export interface AccountRef {
     readonly name: string;
     readonly email: string | null;
+    /** Something worth telling after a switch (e.g. plugins were copied, or could not be). */
+    readonly note?: string;
 }
 export declare class AccountsService {
     private readonly ctx;

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

@@ -12,7 +12,7 @@ export class AccountsService {
     claude;
     constructor(ctx) {
         this.ctx = ctx;
-        this.claude = new AccountStore(ctx.storageRoot);
+        this.claude = new AccountStore(ctx.storageRoot, ctx.loaded.config.claudeProfile.sharePluginsAcrossAccounts);
     }
     /** Claude first, then the other agents that keep a login, then the ones that cannot. */
     agents() {
@@ -68,7 +68,7 @@ export class AccountsService {
     activate(name, agent = CLAUDE) {
         if (agent === CLAUDE) {
             const a = this.claude.activate(this.ctx.dataPath, name);
-            return { name: a.name, email: a.email };
+            return { name: a.name, email: a.email, note: this.claude.pluginNote ?? undefined };
         }
         const { store, stateDir } = this.other(agent);
         store.activate(this.ctx.dataPath, name, stateDir);

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/health-service.d.ts

@@ -1,10 +1,6 @@
-import { UserError } from '../../core/util/index.js';
 import type { Context } from '../commands/context.js';
-import type { RepairCheck, RepairEnv, RepairResult } from '../commands/repair/types.js';
 import { type Check } from '../commands/setup/checks.js';
 import { type MachineFacts } from '../commands/setup/facts.js';
-/** Runs every check in order; a check that throws is reported, never stops the rest. */
-export declare function runChecks(env: RepairEnv, checks?: RepairCheck[]): RepairResult[];
 /** What `sandbox setup` found out about this PC. */
 export interface SetupReport {
     readonly facts: MachineFacts;
@@ -17,8 +13,6 @@ export declare class HealthService {
     constructor(ctx: Context);
     /** The table `doctor` shows: [name, detail] rows. */
     doctor(): string[][];
-    /** Runs the repair checks (and the fixes they make). A config file that does not load is the first problem. */
-    repair(configError?: UserError | null): RepairResult[];
     /** Fails unless this is Windows: Windows Sandbox runs nowhere else. */
     assertWindows(): void;
     /** The setup checklist for this PC. */

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

@@ -1,28 +1,15 @@
-// Is this PC (and the sandbox) in good shape: doctor rows, repair checks, the setup checklist. Never prints.
-import path from 'node:path';
+// Is this PC (and the sandbox) in good shape: the doctor details, the setup checklist. The checks themselves are in
+// commands/repair (one engine for doctor and repair). Never prints.
 import { spawnSync } from 'node:child_process';
-import { loadConfig } from '../../core/config/index.js';
-import { errMsg, expandPath, fail, isWin, UserError } from '../../core/util/index.js';
+import { expandPath, fail, isWin } from '../../core/util/index.js';
 import { detectWsb, doctorRows, insideSandbox, isSandboxRunning } from '../../host/sandbox/index.js';
+import { machineDoctorRows } from '../../host/sharing/index.js';
 import { KnownProjects, ProjectRegistry } from '../../host/projects/index.js';
 import { nativeScript } from '../../host/native.js';
 import { refuseInSelfTest } from '../../host/test-guard.js';
 import { SYSTEM } from '../../shared/system.js';
-import { CHECKS } from '../commands/repair/checks.js';
 import { buildChecks, canEnableFeature } from '../commands/setup/checks.js';
 import { ENABLE_COMMAND, gatherFacts } from '../commands/setup/facts.js';
-/** Runs every check in order; a check that throws is reported, never stops the rest. */
-export function runChecks(env, checks = CHECKS) {
-    return checks.map((check) => {
-        try {
-            return { name: check.name, ...check.run(env) };
-        }
-        catch (e) {
-            const fix = e instanceof UserError && e.fix ? ' ' + e.fix : '';
-            return { name: check.name, status: 'needs-you', detail: 'check failed: ' + errMsg(e) + fix };
-        }
-    });
-}
 export class HealthService {
     ctx;
     constructor(ctx) {
@@ -45,6 +32,7 @@ export class HealthService {
         const wsb = p.wsbShare ? detectWsb() : null;
         return [
             ...rows,
+            ...machineDoctorRows(ctx.packageRoot, ctx.dataPath),
             [
                 'Project roots',
                 p.roots.length
@@ -75,31 +63,6 @@ export class HealthService {
             ],
         ];
     }
-    /** Runs the repair checks (and the fixes they make). A config file that does not load is the first problem. */
-    repair(configError = null) {
-        const { ctx } = this;
-        const env = {
-            ctx,
-            running: isSandboxRunning(),
-            dataPath: ctx.dataPath,
-            storageRoot: ctx.storageRoot,
-            toolsDir: path.join(ctx.dataPath, 'tools'),
-            configError,
-        };
-        // Re-check the config file even when the context loaded (it may have been edited since, or come from --config).
-        if (!env.configError) {
-            try {
-                loadConfig(ctx.options.config);
-            }
-            catch (e) {
-                if (e instanceof UserError)
-                    env.configError = e;
-                else
-                    throw e;
-            }
-        }
-        return runChecks(env);
-    }
     /** Fails unless this is Windows: Windows Sandbox runs nowhere else. */
     assertWindows() {
         if (!isWin)

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

@@ -5,8 +5,10 @@ export { resolveCleanTargets, type CleanTarget } from './data-targets.js';
 export { DatabasesService, parseDatabaseList, type DatabaseAction, type DatabaseRow } from './databases-service.js';
 export { autoMigrates, continuesAfterFailedMigration, MigrateService, type MigrateContext, type MigrateResult, } from './migrate-service.js';
 export { NPM_UPDATE_COMMAND, UpdateService, runsAsSystem, type CheckResult, type UpdateServiceOptions, type UpdateStatus, type UpdateTaskPort, } from './update-service.js';
+export { NORD_STEPS, VpnService, type VpnReport } from './vpn-service.js';
 export { LogsService, type LogFile } from './logs-service.js';
-export { HealthService, runChecks, type SetupReport } from './health-service.js';
+export { WebService, webSession } from './web-service.js';
+export { HealthService, type SetupReport } from './health-service.js';
 export { ProjectsService, type ProjectRow, type ProjectSettings, type ProjectsListing } from './projects-service.js';
 export { SandboxService, type OtherSession, type ProjectInfo, type SandboxReport, type SandboxState, type StopPlan, } from './sandbox-service.js';
 export { SessionsService, projectOf, viewerText, type ListedSession, type RestartScope } from './sessions-service.js';

package/dist/cli/services/index.js

@@ -5,8 +5,10 @@ export { resolveCleanTargets } from './data-targets.js';
 export { DatabasesService, parseDatabaseList } from './databases-service.js';
 export { autoMigrates, continuesAfterFailedMigration, MigrateService, } from './migrate-service.js';
 export { NPM_UPDATE_COMMAND, UpdateService, runsAsSystem, } from './update-service.js';
+export { NORD_STEPS, VpnService } from './vpn-service.js';
 export { LogsService } from './logs-service.js';
-export { HealthService, runChecks } from './health-service.js';
+export { WebService, webSession } from './web-service.js';
+export { HealthService } from './health-service.js';
 export { ProjectsService } from './projects-service.js';
 export { SandboxService, } from './sandbox-service.js';
 export { SessionsService, projectOf, viewerText } from './sessions-service.js';

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

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

@@ -32,7 +32,7 @@ export class MigrateService {
     }
 }
 /** Commands that never update the settings first: they must work whatever state the settings are in. */
-const NO_AUTO_MIGRATION = ['self-test', 'migrate', 'update', '_watch'];
+const NO_AUTO_MIGRATION = ['self-test', 'migrate', 'update', '_watch', '_web'];
 /** Does this command update the saved settings before it runs (when the version changed)? Never inside a sandbox. */
 export function autoMigrates(command, inSandbox) {
     return !inSandbox && !NO_AUTO_MIGRATION.includes(command);