windows-development-sandbox 1.9.0 → 1.11.3

package/dist/app/kernel/define.d.ts

@@ -41,15 +41,18 @@ export interface CliHint {
     readonly json?: boolean;
     /** Shapes what --json prints (kept as the command printed it before the core); default: the output. */
     shapeJson?(output: unknown): unknown;
+    /** The command's exit code for this output (default 0). */
+    exitCode?(output: unknown): number;
     readonly examples?: readonly string[];
 }
 /** A CliHint as written in a definition: field names checked against the input, the output typed. */
-export interface TypedCliHint<I, O> extends Omit<CliHint, 'positional' | 'flags' | 'shapeJson'> {
+export interface TypedCliHint<I, O> extends Omit<CliHint, 'positional' | 'flags' | 'shapeJson' | 'exitCode'> {
     readonly positional?: readonly (keyof I & string)[];
     readonly flags?: {
         readonly [K in keyof I]?: CliFlag;
     };
     shapeJson?(output: O): unknown;
+    exitCode?(output: O): number;
 }
 interface Definition<Id extends string, I extends z.ZodType, O extends z.ZodType> {
     readonly id: Id;
@@ -63,6 +66,8 @@ interface Definition<Id extends string, I extends z.ZodType, O extends z.ZodType
     readonly cli?: CliHint;
     /** The output in one text: what an operation did, or a value a query read (CLI output, menu notice, web note). */
     text?(output: z.output<O>): string;
+    /** The next step to suggest after the text, CLI only (a dimmed "Next:" line); menu and web ignore it. */
+    next?(output: z.output<O>): string | undefined;
 }
 /** What a definition is written as: its CLI hint typed against its own schemas. */
 type Written<D extends Definition<string, z.ZodType, z.ZodType>> = Omit<D, 'kind' | 'cli'> & {
@@ -106,8 +111,12 @@ export interface ViewDef<Q extends QueryMap = QueryMap, P = Record<string, never
     readonly queries: Q;
     /** Every operation the page may offer (the parity check reads this). */
     readonly operations: readonly OperationDef[];
+    /** Queries its inputs read while you fill them in (the web's folder picker reads files.browse). */
+    readonly pickers?: readonly QueryDef[];
     /** A parameter switched with tabs above the page (Settings: all projects or this project), first choice default. */
     readonly tabs?: ViewTabs<P>;
+    /** Parameters taken from the address as they are (the log shown), besides the tabs' one. */
+    readonly params?: readonly (keyof P & string)[];
     /** The input of each query for these view parameters (default: each query's defaults). */
     inputs?(params: P): ViewInputs<Q>;
     /** Pure: query results in, a Page out. */

package/dist/app/kernel/io.d.ts

@@ -14,6 +14,7 @@ export declare const ConfirmQuestionSchema: z.ZodObject<{
     danger: z.ZodOptional<z.ZodBoolean>;
     typed: z.ZodOptional<z.ZodString>;
     implied: z.ZodOptional<z.ZodBoolean>;
+    skipWithYes: z.ZodOptional<z.ZodBoolean>;
     noTerminal: z.ZodOptional<z.ZodObject<{
         message: z.ZodString;
         fix: z.ZodString;
@@ -29,6 +30,10 @@ export declare const ChooseQuestionSchema: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     initial: z.ZodOptional<z.ZodString>;
+    noTerminal: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        fix: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const TextQuestionSchema: z.ZodObject<{
     kind: z.ZodLiteral<"text">;
@@ -37,6 +42,10 @@ export declare const TextQuestionSchema: z.ZodObject<{
     initial: z.ZodOptional<z.ZodString>;
     allowEmpty: z.ZodOptional<z.ZodBoolean>;
     problem: z.ZodOptional<z.ZodString>;
+    noTerminal: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        fix: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const SecretQuestionSchema: z.ZodObject<{
     kind: z.ZodLiteral<"secret">;
@@ -55,6 +64,10 @@ export declare const PathQuestionSchema: z.ZodObject<{
     initial: z.ZodOptional<z.ZodString>;
     literals: z.ZodOptional<z.ZodArray<z.ZodString>>;
     problem: z.ZodOptional<z.ZodString>;
+    noTerminal: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        fix: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const ChecklistQuestionSchema: z.ZodObject<{
     kind: z.ZodLiteral<"checklist">;
@@ -66,6 +79,10 @@ export declare const ChecklistQuestionSchema: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     checked: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    noTerminal: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        fix: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const QuestionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"confirm">;
@@ -75,6 +92,7 @@ export declare const QuestionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     danger: z.ZodOptional<z.ZodBoolean>;
     typed: z.ZodOptional<z.ZodString>;
     implied: z.ZodOptional<z.ZodBoolean>;
+    skipWithYes: z.ZodOptional<z.ZodBoolean>;
     noTerminal: z.ZodOptional<z.ZodObject<{
         message: z.ZodString;
         fix: z.ZodString;
@@ -89,6 +107,10 @@ export declare const QuestionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     initial: z.ZodOptional<z.ZodString>;
+    noTerminal: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        fix: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"text">;
     title: z.ZodString;
@@ -96,6 +118,10 @@ export declare const QuestionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     initial: z.ZodOptional<z.ZodString>;
     allowEmpty: z.ZodOptional<z.ZodBoolean>;
     problem: z.ZodOptional<z.ZodString>;
+    noTerminal: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        fix: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"secret">;
     title: z.ZodString;
@@ -112,6 +138,10 @@ export declare const QuestionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     initial: z.ZodOptional<z.ZodString>;
     literals: z.ZodOptional<z.ZodArray<z.ZodString>>;
     problem: z.ZodOptional<z.ZodString>;
+    noTerminal: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        fix: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"checklist">;
     title: z.ZodString;
@@ -122,6 +152,10 @@ export declare const QuestionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     checked: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    noTerminal: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        fix: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>], "kind">;
 export type Question = z.output<typeof QuestionSchema>;
 export type ConfirmQuestion = z.output<typeof ConfirmQuestionSchema>;

package/dist/app/kernel/io.js

@@ -5,6 +5,8 @@
 import { z } from 'zod';
 const Lines = z.array(z.string()).optional();
 const ChoiceSchema = z.strictObject({ value: z.string(), label: z.string(), description: z.string().optional() });
+/** What the CLI says and fixes when a question needs a terminal and there is none. */
+const NoTerminalSchema = z.strictObject({ message: z.string(), fix: z.string() });
 export const ConfirmQuestionSchema = z.strictObject({
     kind: z.literal('confirm'),
     title: z.string(),
@@ -19,6 +21,8 @@ export const ConfirmQuestionSchema = z.strictObject({
      * asks on a terminal, takes --yes, and fails without a terminal (with `noTerminal`, or "Add --yes").
      */
     implied: z.boolean().optional(),
+    /** On the command line --yes answers no without asking: an extra step a script did not ask for (delete the image). */
+    skipWithYes: z.boolean().optional(),
     noTerminal: z.strictObject({ message: z.string(), fix: z.string() }).optional(),
 });
 export const ChooseQuestionSchema = z.strictObject({
@@ -27,6 +31,8 @@ export const ChooseQuestionSchema = z.strictObject({
     lines: Lines,
     choices: z.array(ChoiceSchema).min(1),
     initial: z.string().optional(),
+    /** Without a terminal the CLI fails with this message and fix instead of its own (see confirm). */
+    noTerminal: NoTerminalSchema.optional(),
 });
 export const TextQuestionSchema = z.strictObject({
     kind: z.literal('text'),
@@ -36,6 +42,7 @@ export const TextQuestionSchema = z.strictObject({
     allowEmpty: z.boolean().optional(),
     /** What was wrong with the last answer (asked again). */
     problem: z.string().optional(),
+    noTerminal: NoTerminalSchema.optional(),
 });
 export const SecretQuestionSchema = z.strictObject({
     kind: z.literal('secret'),
@@ -52,6 +59,7 @@ export const PathQuestionSchema = z.strictObject({
     /** Words allowed instead of a path ("auto"). */
     literals: z.array(z.string()).optional(),
     problem: z.string().optional(),
+    noTerminal: NoTerminalSchema.optional(),
 });
 export const ChecklistQuestionSchema = z.strictObject({
     kind: z.literal('checklist'),
@@ -59,6 +67,7 @@ export const ChecklistQuestionSchema = z.strictObject({
     lines: Lines,
     choices: z.array(ChoiceSchema),
     checked: z.array(z.string()).optional(),
+    noTerminal: NoTerminalSchema.optional(),
 });
 export const QuestionSchema = z.discriminatedUnion('kind', [
     ConfirmQuestionSchema,

package/dist/app/kernel/rpc.d.ts

@@ -72,6 +72,7 @@ export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         danger: z.ZodOptional<z.ZodBoolean>;
         typed: z.ZodOptional<z.ZodString>;
         implied: z.ZodOptional<z.ZodBoolean>;
+        skipWithYes: z.ZodOptional<z.ZodBoolean>;
         noTerminal: z.ZodOptional<z.ZodObject<{
             message: z.ZodString;
             fix: z.ZodString;
@@ -86,6 +87,10 @@ export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         initial: z.ZodOptional<z.ZodString>;
+        noTerminal: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            fix: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"text">;
         title: z.ZodString;
@@ -93,6 +98,10 @@ export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         initial: z.ZodOptional<z.ZodString>;
         allowEmpty: z.ZodOptional<z.ZodBoolean>;
         problem: z.ZodOptional<z.ZodString>;
+        noTerminal: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            fix: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"secret">;
         title: z.ZodString;
@@ -109,6 +118,10 @@ export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         initial: z.ZodOptional<z.ZodString>;
         literals: z.ZodOptional<z.ZodArray<z.ZodString>>;
         problem: z.ZodOptional<z.ZodString>;
+        noTerminal: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            fix: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"checklist">;
         title: z.ZodString;
@@ -119,6 +132,10 @@ export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         checked: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        noTerminal: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            fix: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>], "kind">;
 }, z.core.$strict>, z.ZodObject<{
     t: z.ZodLiteral<"result">;

package/dist/app/kernel/text.d.ts

@@ -2,5 +2,7 @@
 export declare function ago(then: number | string | Date, now?: number): string;
 /** "1 session", "2 sessions". */
 export declare function plural(n: number, noun: string, many?: string): string;
+/** 1536 -> "1.5 KB" (the same words as core/disk.ts humanBytes, which the CLI prints). */
+export declare function bytesText(bytes: number): string;
 /** "memoryMb" -> "Memory MB", "vGpu" -> "V GPU": a readable label from a setting's key. */
 export declare function humanize(key: string): string;

package/dist/app/kernel/text.js

@@ -38,6 +38,13 @@ const UPPER = new Set([
 ]);
 /** "harness" is the code's word for an agent; screens say agent. */
 const PLAIN = { harness: 'agent', harnesses: 'agents' };
+/** 1536 -> "1.5 KB" (the same words as core/disk.ts humanBytes, which the CLI prints). */
+export function bytesText(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = bytes <= 0 ? 0 : Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+    const value = bytes / 1024 ** i;
+    return (i === 0 ? String(bytes) : value.toFixed(value < 10 ? 1 : 0)) + ' ' + units[i];
+}
 /** "memoryMb" -> "Memory MB", "vGpu" -> "V GPU": a readable label from a setting's key. */
 export function humanize(key) {
     const words = key

package/dist/app/kernel/view.d.ts

@@ -15,7 +15,7 @@ export type Target =
     readonly kind: 'terminal';
     readonly session: string;
 }
-/** Start an agent: the menu runs `launch`, the web opens its new-session dialog. */
+/** Start an agent: the menu runs `launch`, the web runs agents.start and opens the session's terminal. */
  | {
     readonly kind: 'start-agent';
     readonly agent: string;
@@ -29,6 +29,7 @@ export type Target =
  | {
     readonly kind: 'view';
     readonly view: string;
+    readonly params?: Readonly<Record<string, string>>;
 };
 interface ActionBase {
     /** The words on a button or a row ("Stop the sandbox…"). */
@@ -52,6 +53,8 @@ export interface OperationAction extends ActionBase {
     readonly fields?: readonly Field[];
     /** What `fields` start as (the current value of a setting), by field name. */
     readonly initial?: Readonly<Record<string, unknown>>;
+    /** Its one field can be changed in place (the web shows the control in the row; the menu opens its editor). */
+    readonly inline?: boolean;
 }
 export interface LinkAction extends ActionBase {
     readonly kind: 'link';
@@ -66,6 +69,11 @@ export interface Fact {
     readonly tone?: Tone;
     readonly description?: string;
     readonly details?: readonly string[];
+    /** How full something is (memory used of total): a bar on the web, the value text elsewhere. */
+    readonly meter?: {
+        readonly value: number;
+        readonly max: number;
+    };
 }
 /** A column of a section shown as a table (CLI table, web table); items fill it through `cells`. */
 export interface Column {
@@ -78,9 +86,13 @@ export interface Item {
     readonly label: string;
     /** The right-hand text (a state, a value). */
     readonly hint?: string;
+    /** Its name in files and commands (a setting's key), shown small in monospace on the web. */
+    readonly code?: string;
     readonly tone?: Tone;
     readonly badges?: readonly Badge[];
     readonly description?: string;
+    /** Words about the menu's keys ("x deletes it."): the menu shows them after the description; the web does not. */
+    readonly keys?: string;
     /** Extra lines (the menu's details pane, the CLI's indented lines, the web's card body). */
     readonly details?: readonly string[];
     /** A heading inside the section ("This folder's project"). */
@@ -94,6 +106,8 @@ export interface Item {
     readonly actions?: readonly Action[];
     /** Why it cannot be used now. */
     readonly disabled?: string;
+    /** What picture fits it: an agent's name (claude), or project, folder, database, session. Only the web shows it. */
+    readonly icon?: string;
     /** More words a search finds it by. */
     readonly keywords?: string;
 }
@@ -115,8 +129,12 @@ export interface Section {
     readonly columns?: readonly Column[];
     /** Where `columns` is used: everywhere (default), or only on the command line (the web lists the items in full). */
     readonly columnsOn?: 'all' | 'cli';
+    /** The items are things to pick from (sessions, agents): the web shows them as cards rather than rows. */
+    readonly cards?: boolean;
     readonly actions?: readonly Action[];
     readonly notes?: readonly Note[];
+    /** Preformatted lines (a log): monospace, shown as they are. */
+    readonly text?: readonly string[];
 }
 /** What a page shows when it has nothing: the text and the next step (the CLI prints `cliText`, naming a command). */
 export interface Empty {
@@ -134,6 +152,11 @@ export interface Page {
     readonly actions?: readonly Action[];
     /** Shown instead of the sections when they have no facts and no items. */
     readonly empty?: Empty;
+    /**
+     * The sections are categories of one long list (settings): the web shows one at a time beside a list of them, with
+     * a search over all; the menu and the CLI show them as they always do.
+     */
+    readonly categories?: boolean;
 }
 /** An action that runs `def` with `input` (typed from its input schema; `fields` may ask for the rest). */
 export declare function action<I extends z.ZodType, O extends z.ZodType>(def: OperationDef<I, O>, input: Partial<z.input<I>>, extra?: Partial<Omit<OperationAction, 'kind' | 'op' | 'input'>>): OperationAction;

package/dist/app/kernel/view.js

@@ -15,7 +15,7 @@ export function link(target, label, extra = {}) {
 }
 /** Does the page show anything besides its empty state? */
 export function pageHasContent(page) {
-    return page.sections.some((s) => (s.facts?.length ?? 0) > 0 || (s.items?.length ?? 0) > 0);
+    return page.sections.some((s) => (s.facts?.length ?? 0) > 0 || (s.items?.length ?? 0) > 0 || (s.text?.length ?? 0) > 0);
 }
 /** Every action a page offers, wherever it sits (for parity checks and key bars). */
 export function pageActions(page) {

package/dist/app/registry.js

@@ -1,7 +1,21 @@
 import { invoke, NO_QUESTIONS, onSurface, } from './kernel/index.js';
+import { addAgentRun, listAgentsRun, makeDefaultAgentRun, removeAgentRun, startAgentRun, } from './features/agents/index.js';
+import { defaultAccountRun, listAccountsRun, removeAccountRun, renameAccountRun, saveAccountRun, useAccountRun, } from './features/accounts/index.js';
+import { listAppsRun, requestAppRun, setCustomAppsRun, toggleAppRun } from './features/apps/index.js';
+import { browseFolderRun } from './features/files/index.js';
+import { cleanDataRun, pruneStorageRun, showDataRun } from './features/data/index.js';
+import { changeDataFolderRun, containedOffRun, containedOnRun, containedStatusRun, moveStorageRun, showStorageRun, useStorageRun, } from './features/storage/index.js';
+import { addProjectRun, allProjectsRun, chooseProjectsRun, excludeProjectRun, includeProjectRun, listProjectsRun, projectRootsRun, removeProjectRun, } from './features/projects/index.js';
+import { checkHealthRun, enableSandboxRun, lastHealthRun, repairHealthRun } from './features/health/index.js';
 import { hideWindowRun, sandboxStatusRun, showWindowRun, stopSandboxRun } from './features/sandbox/index.js';
+import { listLogsRun, tailLogRun } from './features/logs/index.js';
 import { listSessionsRun, restartSessionsRun } from './features/sessions/index.js';
-import { getSettingRun, listSettingsRun, resetSettingRun, setSettingRun } from './features/settings/index.js';
+import { exportConfigRun, getSettingRun, importConfigRun, listSettingsRun, resetSettingRun, setSettingRun, } from './features/settings/index.js';
+import { migrateSettingsRun, runUpdateRun, updatesStatusRun } from './features/updates/index.js';
+import { checkEngineRun, cleanEngineRun, engineLeftoversRun, engineStatusRun } from './features/engine/index.js';
+import { openWebRun, startWebRun, stopWebRun, webStatusRun } from './features/web/index.js';
+import { vpnLoginRun, vpnLogoutRun, vpnStatusRun } from './features/vpn/index.js';
+import { githubLoginRun, githubLogoutRun, githubStatusRun } from './features/github/index.js';
 export const IMPLEMENTATIONS = [
     sandboxStatusRun,
     showWindowRun,
@@ -9,10 +23,69 @@ export const IMPLEMENTATIONS = [
     stopSandboxRun,
     listSessionsRun,
     restartSessionsRun,
+    startAgentRun,
+    addAgentRun,
+    makeDefaultAgentRun,
+    removeAgentRun,
+    listAgentsRun,
     listSettingsRun,
     getSettingRun,
     setSettingRun,
     resetSettingRun,
+    exportConfigRun,
+    importConfigRun,
+    browseFolderRun,
+    listAccountsRun,
+    saveAccountRun,
+    useAccountRun,
+    defaultAccountRun,
+    renameAccountRun,
+    removeAccountRun,
+    listAppsRun,
+    toggleAppRun,
+    setCustomAppsRun,
+    requestAppRun,
+    listProjectsRun,
+    chooseProjectsRun,
+    addProjectRun,
+    removeProjectRun,
+    includeProjectRun,
+    excludeProjectRun,
+    allProjectsRun,
+    projectRootsRun,
+    lastHealthRun,
+    checkHealthRun,
+    repairHealthRun,
+    enableSandboxRun,
+    showDataRun,
+    cleanDataRun,
+    pruneStorageRun,
+    showStorageRun,
+    moveStorageRun,
+    useStorageRun,
+    changeDataFolderRun,
+    containedStatusRun,
+    containedOnRun,
+    containedOffRun,
+    listLogsRun,
+    tailLogRun,
+    runUpdateRun,
+    migrateSettingsRun,
+    updatesStatusRun,
+    engineStatusRun,
+    checkEngineRun,
+    engineLeftoversRun,
+    cleanEngineRun,
+    startWebRun,
+    openWebRun,
+    stopWebRun,
+    vpnStatusRun,
+    vpnLoginRun,
+    vpnLogoutRun,
+    githubStatusRun,
+    githubLoginRun,
+    githubLogoutRun,
+    webStatusRun,
 ];
 export function implementationOf(id) {
     return IMPLEMENTATIONS.find((i) => i.def.id === id);

package/dist/cli/args.js

@@ -47,7 +47,7 @@ const HELP_ORDER = [
     ['Data', ['data', 'storage', 'clean', 'sync']],
     ['Web', ['web']],
     ['Health', ['setup', 'doctor', 'repair', 'logs', 'audit', 'update', 'migrate', 'config']],
-    ['Advanced', ['generate', 'agent-commands', 'vpn']],
+    ['Advanced', ['generate', 'agent-commands', 'vpn', 'github']],
 ];
 /** The commands in the order --help lists them. */
 function helpOrdered() {

package/dist/cli/commands/context.d.ts

@@ -15,6 +15,13 @@ export interface Context {
     borrowed?: Borrowed;
 }
 export declare function createContext(packageRoot: string, entry: string, options: CliOptions): Context;
+/**
+ * The built-in defaults as a context, for a command that must run even when the settings file is broken (the
+ * settings problem is then the command's own to report).
+ */
+export declare function defaultsContext(packageRoot: string, entry: string, options: CliOptions): Context;
+/** The context of a command that must not stop on a broken settings file: the defaults when createContext refuses. */
+export declare function contextOrDefaults(packageRoot: string, entry: string, options: CliOptions): Context;
 /** Reads the config again and takes the storage folder from it (after a migration or a move changed it). */
 export declare function refreshStorage(ctx: Context): void;
 /** For commands that control the sandbox from your PC: inside the sandbox they make no sense. */

package/dist/cli/commands/context.js

@@ -1,8 +1,8 @@
 // What every command receives, plus the small helpers they share.
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadConfig, userDir } from '../../core/config/index.js';
-import { expandPath, fail, isInsideOrEqual } from '../../core/util/index.js';
+import { DEFAULTS, loadConfig, userDir } from '../../core/config/index.js';
+import { expandPath, fail, isInsideOrEqual, UserError } from '../../core/util/index.js';
 import { GUEST_DATA_DIR, insideSandbox, isSandboxRunning } from '../../host/sandbox/index.js';
 /** Keeps ~/.agent-sandbox/*.schema.json in step with the installed version (local schema paths editors trust). */
 function refreshSchemas(packageRoot) {
@@ -36,6 +36,33 @@ export function createContext(packageRoot, entry, options) {
         dataPath: insideSandbox() ? GUEST_DATA_DIR : path.join(storageRoot, 'data', loaded.config.storage.dataName),
     };
 }
+/**
+ * The built-in defaults as a context, for a command that must run even when the settings file is broken (the
+ * settings problem is then the command's own to report).
+ */
+export function defaultsContext(packageRoot, entry, options) {
+    const loaded = { config: structuredClone(DEFAULTS), configPath: null, base: userDir() };
+    const storageRoot = expandPath(loaded.config.storage.root, loaded.base);
+    return {
+        packageRoot,
+        entry,
+        options,
+        loaded,
+        storageRoot,
+        dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName),
+    };
+}
+/** The context of a command that must not stop on a broken settings file: the defaults when createContext refuses. */
+export function contextOrDefaults(packageRoot, entry, options) {
+    try {
+        return createContext(packageRoot, entry, options);
+    }
+    catch (e) {
+        if (!(e instanceof UserError))
+            throw e;
+        return defaultsContext(packageRoot, entry, options);
+    }
+}
 /** Reads the config again and takes the storage folder from it (after a migration or a move changed it). */
 export function refreshStorage(ctx) {
     ctx.loaded = loadConfig(ctx.options.config);

package/dist/cli/commands/engine.js

@@ -1,60 +1,7 @@
-// `sandbox engine`: the engine in use and, for each engine, what it can do and whether this PC can run it.
-import { fail } from '../../core/util/index.js';
-import { engineReports } from '../../host/engines/index.js';
-import { c, printJson, table } from '../output/index.js';
-const CAPABILITY_NAMES = {
-    desktop: 'desktop window',
-    gpu: 'GPU',
-    clipboard: 'clipboard',
-    audio: 'audio',
-    video: 'camera',
-    printers: 'printers',
-    liveFolderAdd: 'add folders while running',
-    attachedDisks: 'attached disks',
-    multipleInstances: 'several at once',
-    hvsocket: 'Hyper-V sockets',
-};
-/** sandbox engine check <engine>: the reasons and the exact commands, in plain words. Nothing is run or changed. */
-async function checkEngine(ctx, name) {
-    const report = (await engineReports(ctx.loaded.config)).find((r) => r.id === name);
-    if (!report)
-        return fail('Unknown engine: ' + name, 'Use windows-sandbox or hcs.');
-    if (printJson(ctx, report))
-        return report.check.available ? 0 : 1;
-    if (report.check.available) {
-        console.log(c.green(name + ' can be used on this PC.'));
-        if (name === 'hcs')
-            console.log('HCS is in alpha: starting it is not enabled yet (docs/design/engines.md).');
-        return 0;
-    }
-    console.log(c.yellow(name + ' cannot be used on this PC yet:'));
-    report.check.reasons.forEach((reason, i) => {
-        console.log('\n  ' + (i + 1) + '. ' + reason);
-        console.log('     To fix: ' + (report.check.fixes[i] ?? 'see docs/design/engines.md'));
-    });
-    console.log('\nNothing was changed. These commands change Windows, so they are yours to run (or not).');
-    return 1;
-}
+// `sandbox engine`: the engine in use and what each engine can do. The bare command is `sandbox engine show`; `check`
+// is the other action. Both are definitions of the shared core (src/app/features/engine).
+import { engineStatus } from '../../app/features/engine/index.js';
+import { definitionHandler } from '../operations/index.js';
 export async function engine(ctx) {
-    const [action = 'show', name = 'hcs'] = ctx.options.positionals;
-    if (action === 'check')
-        return checkEngine(ctx, name);
-    const reports = await engineReports(ctx.loaded.config);
-    const using = reports.find((r) => r.inUse);
-    if (printJson(ctx, { engine: using?.id, engines: reports }))
-        return 0;
-    console.log('Engine in use: ' + (using?.id ?? ctx.loaded.config.sandbox.engine) + '  (setting: sandbox.engine)');
-    for (const report of reports) {
-        console.log('\n' + report.id + (report.inUse ? '  (in use)' : ''));
-        console.log('  ' + (report.check.available ? c.green('can be used on this PC') : c.yellow('cannot be used yet')));
-        for (const reason of report.check.reasons)
-            console.log('  ' + reason);
-        for (const fix of report.check.fixes)
-            console.log('  Fix: ' + fix);
-        table(Object.entries(CAPABILITY_NAMES).map(([key, name]) => [
-            '  ' + name,
-            report.capabilities[key] ? 'yes' : 'no',
-        ]));
-    }
-    return 0;
+    return (await definitionHandler(engineStatus)(ctx)) ?? 0;
 }

package/dist/cli/commands/github.d.ts

@@ -0,0 +1,2 @@
+import { type Context } from './context.js';
+export declare function github(ctx: Context): number | Promise<number | void>;

package/dist/cli/commands/github.js

@@ -0,0 +1,11 @@
+// `sandbox github [status|login|logout]`: the actions are the GitHub feature's operations (src/app/features/github);
+// with no action the command shows the status page.
+import { fail } from '../../core/util/index.js';
+import { githubStatus } from '../../app/features/github/index.js';
+import { definitionHandler } from '../operations/index.js';
+export function github(ctx) {
+    const action = ctx.options.positionals[0];
+    if (action === undefined)
+        return definitionHandler(githubStatus)(ctx);
+    return fail('Unknown GitHub action "' + action + '".', 'Use: sandbox github status | login | logout');
+}

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

@@ -1,13 +1,11 @@
 export { createContext, type Context } from './context.js';
 export { launch } from './launch/index.js';
 export { setup } from './setup/index.js';
-export { data } from './data/index.js';
-export { storage, storageBeforeCommand } from './storage/index.js';
+export { storageBeforeCommand } from './storage/index.js';
 export { repairCommand } from './repair/index.js';
+export { contextOrDefaults } from './context.js';
 export { attach, db, exec } from './sessions/index.js';
-export { account } from './accounts.js';
 export { resume } from './resume.js';
-export { projects } from './projects/index.js';
-export { audit, claudeHost, clean, config, doctor, hostCommand, logs, migrate, migrateBeforeCommand, runMigrate, runUpdate, sync, update, updatesBeforeCommand, watcher, } from './maintenance/index.js';
+export { audit, claudeHost, config, doctor, hostCommand, logs, migrateBeforeCommand, sync, updatesBeforeCommand, watcher, } from './maintenance/index.js';
 export { agentCommandsCommand, syncAgentCommands } from './agent-commands.js';
 export { HANDLERS, type Handler } from './registry.js';

package/dist/cli/commands/index.js

@@ -1,13 +1,11 @@
 export { createContext } from './context.js';
 export { launch } from './launch/index.js';
 export { setup } from './setup/index.js';
-export { data } from './data/index.js';
-export { storage, storageBeforeCommand } from './storage/index.js';
+export { storageBeforeCommand } from './storage/index.js';
 export { repairCommand } from './repair/index.js';
+export { contextOrDefaults } from './context.js';
 export { attach, db, exec } from './sessions/index.js';
-export { account } from './accounts.js';
 export { resume } from './resume.js';
-export { projects } from './projects/index.js';
-export { audit, claudeHost, clean, config, doctor, hostCommand, logs, migrate, migrateBeforeCommand, runMigrate, runUpdate, sync, update, updatesBeforeCommand, watcher, } from './maintenance/index.js';
+export { audit, claudeHost, config, doctor, hostCommand, logs, migrateBeforeCommand, sync, updatesBeforeCommand, watcher, } from './maintenance/index.js';
 export { agentCommandsCommand, syncAgentCommands } from './agent-commands.js';
 export { HANDLERS } from './registry.js';