windows-development-sandbox 1.5.0 → 1.7.0

package/dist/cli/tui/list/list-screen.js

@@ -1,9 +1,13 @@
 import { Text } from '../text.js';
 import { Theme } from '../theme.js';
+/** Lists longer than this say how to search. */
+const LONG_LIST = 12;
 export class ListScreen {
     o;
     category = 0;
     focus = 'list';
+    /** The list has the keyboard (false while the menu's navigation has it): the highlight is drawn softer. */
+    active = true;
     cursor = 0;
     offset = 0;
     query = '';
@@ -57,7 +61,7 @@ export class ListScreen {
     render(size) {
         const visible = this.visible();
         this.cursor = Math.min(this.cursor, Math.max(0, visible.length - 1));
-        const sideWidth = this.o.categories
+        const sideWidth = this.o.categories && !this.external
             ? Math.min(32, Math.max(...this.o.categories.map((c) => Text.width(c.label))) + 7)
             : 0;
         const rest = size.width - 1 - (sideWidth ? sideWidth + 3 : 0);
@@ -65,14 +69,16 @@ export class ListScreen {
         const detailsWidth = detailsRight ? Math.min(52, Math.floor(rest * 0.38)) : rest;
         const listWidth = detailsRight ? rest - detailsWidth - 3 : rest;
         const top = [];
-        if (this.o.tabs)
-            top.push(' ' +
+        if (this.o.tabs) {
+            const row = ' ' +
                 this.o.tabs.items
                     .map((tab, i) => i === this.o.tabs.active
                     ? tab.paint(' ' + tab.badge + ' ' + tab.label + ' ')
                     : Theme.muted('  ' + tab.label + '  '))
                     .join(' ') +
-                Theme.muted('   tab switches'), '');
+                Theme.muted('   tab switches');
+            top.push(Text.truncate(row, size.width - 1), '');
+        }
         const intro = typeof this.o.intro === 'string' ? [this.o.intro] : (this.o.intro ?? []);
         for (const line of intro)
             top.push(...Text.wrap(line, size.width - 3).map((l) => ' ' + Theme.muted(l)));
@@ -113,9 +119,10 @@ export class ListScreen {
             listLines.push(Theme.muted('   ' +
                 (above > 0 ? '▲ ' + above + ' above' : '') +
                 (above > 0 && below > 0 ? '   ' : '') +
-                (below > 0 ? '▼ ' + below + ' more' : '')));
+                (below > 0 ? '▼ ' + below + ' more' : '') +
+                (this.searching || this.query ? '' : '   / search')));
         }
-        const sideLines = this.sideLines(sideWidth);
+        const sideLines = sideWidth ? this.sideLines(sideWidth) : [];
         const body = [...top];
         const height = Math.max(listLines.length, detailsRight ? details.length : 0, sideLines.length);
         for (let i = 0; i < Math.min(height, size.height - top.length); i++) {
@@ -156,7 +163,9 @@ export class ListScreen {
             ' ';
         if (!selected)
             return ' ' + line;
-        return this.focus === 'list' ? ' ' + Theme.selected(Text.strip(line)) : ' ' + Theme.accent(Text.strip(line));
+        return this.focus === 'list' && this.active
+            ? ' ' + Theme.selected(Text.strip(line))
+            : ' ' + Theme.accent(Text.strip(line));
     }
     sideLines(width) {
         if (!this.o.categories)
@@ -199,12 +208,14 @@ export class ListScreen {
         if (this.searching)
             return [
                 ['type', 'to search', 1],
-                ['↵', this.o.multi ? 'done' : (this.o.enterLabel ?? 'open'), 1],
+                ['↵', this.o.multi ? 'done' : this.enterLabel(this.valueAt(this.visible()[this.cursor])), 1],
                 ['esc', 'clear search', 0],
                 ['↑↓', 'move', 4],
             ];
         const current = this.visible()[this.cursor];
+        const value = current === undefined ? undefined : this.o.items[current].value;
         const flips = current !== undefined && this.o.items[current].flip;
+        const long = this.o.items.length > LONG_LIST;
         return [
             ...(this.o.multi
                 ? [
@@ -212,16 +223,19 @@ export class ListScreen {
                     ...(this.o.enterTicks ? [] : [['↵', 'done', 1]]),
                     ['a', 'tick all shown', 6],
                 ]
-                : [['↵', this.o.enterLabel ?? 'open', 1], ...(flips ? [['space', 'flip', 1]] : [])]),
-            ...this.actionsNow().map((a) => [
+                : [
+                    ...(this.enterLabel(value) ? [['↵', this.enterLabel(value), 1]] : []),
+                    ...(flips ? [['space', 'flip', 1]] : []),
+                ]),
+            ...this.actionsNow(value).map((a) => [
                 a.ctrl ? 'ctrl+' + a.key : a.key,
                 a.label,
                 a.ctrl ? 0 : (a.importance ?? 2),
             ]),
             ...(this.o.tabs ? [['tab', 'scope', 3]] : []),
-            ...(this.o.categories ? [['←→', 'categories', 3]] : []),
+            ...(this.o.categories && !this.external ? [['←→', 'categories', 3]] : []),
             ['↑↓', 'move', 5],
-            ['/', 'search', 6],
+            ['/', 'search', long ? 3 : 6],
             ['esc', this.o.escapeLabel ?? 'back', 0],
         ];
     }
@@ -229,14 +243,45 @@ export class ListScreen {
     setNotice(text) {
         this.notice = text;
     }
+    /** The categories are shown by the menu's navigation, which drives them (no sidebar of its own). */
+    get external() {
+        return this.o.categoryNav === 'external';
+    }
+    enterLabel(value) {
+        const label = this.o.enterLabel;
+        return (typeof label === 'function' ? label(this.currentCategory, value) : label) ?? 'open';
+    }
+    valueAt(index) {
+        return index === undefined ? undefined : this.o.items[index].value;
+    }
+    /** The categories of the list (empty without any). */
+    get categories() {
+        return this.o.categories ?? [];
+    }
+    /** Opens a category (the menu's navigation does this); a search in progress ends. */
+    setCategory(id) {
+        const index = this.categories.findIndex((c) => c.id === id);
+        if (index < 0 || index === this.category)
+            return;
+        this.category = index;
+        this.query = '';
+        this.searching = false;
+        this.cursor = 0;
+        this.offset = 0;
+    }
+    /** Whether the list has the keyboard (the highlight is drawn softer when it has not). */
+    setActive(on) {
+        this.active = on;
+    }
     /** The id of the category open in the sidebar (undefined without a sidebar). */
     get currentCategory() {
         return this.o.categories?.[this.category]?.id;
     }
-    /** The extra keys that work now (they may depend on the category). */
-    actionsNow() {
+    /** The extra keys that work now (they may depend on the category and on the highlighted entry). */
+    actionsNow(value) {
         const actions = this.o.actions;
-        return typeof actions === 'function' ? actions(this.currentCategory) : (actions ?? []);
+        const all = typeof actions === 'function' ? actions(this.currentCategory) : (actions ?? []);
+        return all.filter((a) => !a.applies || (value !== undefined && a.applies(value)));
     }
     /** Keys are going into the search box (digits and letters are text, not shortcuts). */
     get isSearching() {
@@ -250,15 +295,10 @@ export class ListScreen {
         const visible = this.visible();
         const current = visible[this.cursor];
         this.notice = undefined;
-        const ctrlAction = key.ctrl ? this.actionsNow().find((a) => a.ctrl && a.key === key.name) : undefined;
+        const value = this.valueAt(current);
+        const ctrlAction = key.ctrl ? this.actionsNow(value).find((a) => a.ctrl && a.key === key.name) : undefined;
         if (ctrlAction)
-            return {
-                done: {
-                    kind: 'action',
-                    key: 'ctrl+' + ctrlAction.key,
-                    value: current === undefined ? undefined : this.o.items[current].value,
-                },
-            };
+            return { done: { kind: 'action', key: 'ctrl+' + ctrlAction.key, value } };
         const move = (by) => {
             this.cursor = Math.max(0, Math.min(visible.length - 1, this.cursor + by));
         };
@@ -318,7 +358,9 @@ export class ListScreen {
             const n = this.o.tabs.items.length;
             return { done: { kind: 'tab', index: (this.o.tabs.active + (key.shift ? n - 1 : 1)) % n } };
         }
-        if (this.o.categories && !this.query) {
+        if (this.external && !this.query && !this.searching && key.name === 'left')
+            return { done: { kind: 'back' } };
+        if (this.o.categories && !this.external && !this.query) {
             if (key.name === 'left' && this.focus === 'list') {
                 this.focus = 'side';
                 return;
@@ -370,15 +412,9 @@ export class ListScreen {
             }
             return { done: { kind: 'pick', value: it.value } };
         }
-        const action = !this.searching && key.text ? this.actionsNow().find((a) => !a.ctrl && a.key === key.text) : undefined;
+        const action = !this.searching && key.text ? this.actionsNow(value).find((a) => !a.ctrl && a.key === key.text) : undefined;
         if (action)
-            return {
-                done: {
-                    kind: 'action',
-                    key: action.key,
-                    value: current === undefined ? undefined : this.o.items[current].value,
-                },
-            };
+            return { done: { kind: 'action', key: action.key, value } };
         return;
     }
     toggle(index) {

package/dist/cli/tui/list/list-types.d.ts

@@ -26,9 +26,11 @@ export interface Category {
     label: string;
     description?: string;
 }
-export interface ListAction {
+export interface ListAction<T = unknown> {
     key: string;
     label: string;
+    /** Only while an entry this accepts is highlighted: the key bar and the key itself ignore it otherwise. */
+    applies?: (value: T) => boolean;
     /** Pressed with Ctrl (ctrl+s ...); works while searching too. */
     ctrl?: boolean;
     /** How long it survives in a narrow footer: 0 never goes, bigger goes earlier (default 2). */
@@ -70,7 +72,7 @@ export interface ListOptions<T> {
     startAt?: T;
     startCategory?: string;
     /** Extra keys; a function picks them by the open category. */
-    actions?: ListAction[] | ((category: string | undefined) => ListAction[]);
+    actions?: ListAction<T>[] | ((category: string | undefined) => ListAction<T>[]);
     notice?: string;
     empty?: string;
     tabs?: {
@@ -79,6 +81,8 @@ export interface ListOptions<T> {
     };
     /** What Esc does, for the footer ("back", "quit"). */
     escapeLabel?: string;
-    /** What Enter does, for the footer ("open", "edit", "start"). */
-    enterLabel?: string;
+    /** What Enter does, for the footer ("open", "edit", "start"); a function picks it by entry ("": none). */
+    enterLabel?: string | ((category: string | undefined, value: T | undefined) => string);
+    /** Where the categories are listed: in a sidebar of the list itself (default) or in the menu's own navigation. */
+    categoryNav?: 'own' | 'external';
 }

package/dist/cli/tui/nav.d.ts

@@ -0,0 +1,29 @@
+export interface NavCategory {
+    readonly label: string;
+    /** The category open in the list. */
+    readonly current: boolean;
+}
+export interface NavSection {
+    readonly label: string;
+    /** Something is waiting in this section (unsaved changes). */
+    readonly marked?: boolean;
+    /** The categories of the open section (other sections are drawn without theirs). */
+    readonly categories: readonly NavCategory[];
+}
+export interface NavState {
+    readonly sections: readonly NavSection[];
+    /** Index of the open section. */
+    readonly active: number;
+    /** The navigation has the keyboard (else the list has it). */
+    readonly focused: boolean;
+    /** A dialog or sub-screen is shown over the menu: everything is drawn grey. */
+    readonly dimmed?: boolean;
+}
+export declare class SideNav {
+    /** Columns the navigation takes on a terminal `termWidth` columns wide (without the divider). */
+    static width(termWidth: number): number;
+    /** Exactly `height` lines, each `SideNav.width(termWidth)` columns wide. */
+    static render(nav: NavState, termWidth: number, height: number): string[];
+    private static section;
+    private static category;
+}

package/dist/cli/tui/nav.js

@@ -0,0 +1,67 @@
+// The navigation on the left of every menu screen: the sections as a tree (the open one shows its categories), with
+// the way you are standing marked. Narrow terminals get a slim column of numbers instead of names. Pure (tested).
+import { Text } from './text.js';
+import { Theme } from './theme.js';
+/** Terminals narrower than this get the slim column. */
+const SLIM_BELOW = 80;
+const SLIM_WIDTH = 5;
+export class SideNav {
+    /** Columns the navigation takes on a terminal `termWidth` columns wide (without the divider). */
+    static width(termWidth) {
+        if (termWidth < SLIM_BELOW)
+            return SLIM_WIDTH;
+        return termWidth >= 130 ? 28 : 24;
+    }
+    /** Exactly `height` lines, each `SideNav.width(termWidth)` columns wide. */
+    static render(nav, termWidth, height) {
+        const width = SideNav.width(termWidth);
+        const slim = width === SLIM_WIDTH;
+        const lines = [];
+        nav.sections.forEach((section, i) => {
+            const open = i === nav.active;
+            const hasCategories = open && section.categories.length > 0;
+            const standing = open && !hasCategories;
+            lines.push({ text: SideNav.section(nav, section, i, width, slim, standing), stop: standing });
+            if (!hasCategories)
+                return;
+            section.categories.forEach((cat, c) => {
+                const last = c === section.categories.length - 1;
+                lines.push({ text: SideNav.category(nav, cat, last, width, slim), stop: cat.current });
+            });
+        });
+        const at = Math.max(0, lines.findIndex((l) => l.stop));
+        const start = lines.length > height ? Math.min(Math.max(0, at - Math.floor(height / 2)), lines.length - height) : 0;
+        const shown = lines.slice(start, start + height).map((l) => l.text);
+        while (shown.length < height)
+            shown.push(' '.repeat(width));
+        return shown;
+    }
+    static section(nav, section, index, width, slim, standing) {
+        const open = index === nav.active;
+        const live = !nav.dimmed;
+        // The open section has a marker, so it shows without colour.
+        const lead = open ? (section.categories.length ? '▾' : Theme.glyph.pointer) : ' ';
+        const mark = section.marked ? Theme.changed(Theme.glyph.changed) : ' ';
+        const inner = slim
+            ? lead + (index + 1) + mark + '  '
+            : Text.fit(lead + (index + 1) + ' ' + (open && live ? Theme.bold(section.label) : section.label), width - 3) +
+                ' ' +
+                mark +
+                ' ';
+        if (standing && live && nav.focused)
+            return Theme.selected(Text.fit(inner, width));
+        if (!live || !open)
+            return Theme.muted(Text.fit(inner, width));
+        return nav.focused ? Text.fit(inner, width) : Theme.accent(Text.fit(inner, width));
+    }
+    static category(nav, cat, last, width, slim) {
+        const live = !nav.dimmed;
+        const plain = slim
+            ? '  ' + (cat.current ? Theme.glyph.on : Theme.glyph.dot) + '  '
+            : '  ' + (cat.current ? Theme.glyph.pointer : last ? '└' : '├') + ' ' + cat.label;
+        const line = Text.fit(plain, width);
+        if (!cat.current || !live)
+            return Theme.muted(line);
+        return nav.focused ? Theme.selected(line) : Theme.accentBold(line);
+    }
+}

package/dist/cli/validate.d.ts

@@ -12,6 +12,6 @@ export declare function validPythonSpec(spec: string): boolean;
 export declare function checkHarness(name: string | undefined, harnesses: string[]): void;
 export declare const PROJECT_ACTIONS: readonly ["list", "choose", "add", "remove", "include", "exclude", "all", "roots"];
 /** `sandbox projects <action> [value] [folder]`: the action, then what it needs. Pure (no file checks). */
-export declare function validateProjectsArgs(args: string[]): void;
+export declare function validateProjectsArgs(args: string[], canAsk?: boolean): void;
 /** Fails with what is wrong and what is valid, before anything is started. */
 export declare function validateOptions(ctx: Context): void;

package/dist/cli/validate.js

@@ -44,11 +44,11 @@ export function checkHarness(name, harnesses) {
 const LAUNCHING = new Set(['launch', 'generate', 'host-claude']);
 export const PROJECT_ACTIONS = ['list', 'choose', 'add', 'remove', 'include', 'exclude', 'all', 'roots'];
 /** `sandbox projects <action> [value] [folder]`: the action, then what it needs. Pure (no file checks). */
-export function validateProjectsArgs(args) {
+export function validateProjectsArgs(args, canAsk = false) {
     const [action = 'list', value, folder] = args;
     if (!PROJECT_ACTIONS.includes(action))
         unknownValue('projects action', action, PROJECT_ACTIONS, 'sandbox projects with no action lists your projects.');
-    if (['add', 'remove', 'include', 'exclude'].includes(action) && !value)
+    if (['add', 'remove', 'include', 'exclude'].includes(action) && !value && !canAsk)
         fail('Which folder?', 'Usage: sandbox projects ' + action + ' <folder>   (. = this folder)');
     if (action === 'all' && value !== undefined && !['on', 'off'].includes(value))
         unknownValue('value for projects all', value, ['on', 'off'], 'sandbox projects all on|off');
@@ -64,7 +64,7 @@ export function validateOptions(ctx) {
     if (['launch', 'generate', 'restart', 'doctor'].includes(o.command))
         checkHarness(o.harness, harnesses);
     if (o.command === 'projects')
-        validateProjectsArgs(o.positionals);
+        validateProjectsArgs(o.positionals, Boolean(process.stdin.isTTY));
     if (!LAUNCHING.has(o.command))
         return;
     if (o.node !== undefined && !validNodeSpec(o.node))

package/dist/cli/version.d.ts

@@ -0,0 +1,2 @@
+/** The text for a version-only command line (`--version`, `-v`, with or without `--short`), or null for any other. */
+export declare function versionText(argv: readonly string[], packageRoot: string): string | null;

package/dist/cli/version.js

@@ -0,0 +1,11 @@
+// `sandbox --version`: the version and where it runs from; `--version --short` is the plain number (the updater and the
+// installer compare it to the version they just installed).
+import { packageVersion } from '../core/package-info.js';
+import { describeCopy } from '../host/install/index.js';
+/** The text for a version-only command line (`--version`, `-v`, with or without `--short`), or null for any other. */
+export function versionText(argv, packageRoot) {
+    const flags = argv.filter((a) => a !== '--short');
+    if (flags.length === 0 || flags.some((a) => a !== '--version' && a !== '-v'))
+        return null;
+    return argv.includes('--short') ? packageVersion() : packageVersion() + ' (' + describeCopy(packageRoot) + ')';
+}

package/dist/core/config/defaults.js

@@ -24,13 +24,14 @@ export const DEFAULTS = {
     },
     sharing: { otherUsers: false },
     storage: {
-        root: '%LOCALAPPDATA%\\AgentSandbox',
+        root: '%ProgramData%\\AgentSandbox\\users\\%USERNAME%',
         persistAgentState: true,
         dataName: 'default',
         markSandboxFiles: true,
         warnDataGb: 50,
     },
     network: { blockPrivateRanges: true, allowOnly: [], blockHosts: [], forwardPorts: [], dns: [], proxy: '' },
+    vpn: { enabled: false, provider: 'nordvpn', protocol: 'udp', country: '', configFile: '', killSwitch: true },
     provisioning: {
         copyFromHost: true,
         fallbackToInstall: true,
@@ -88,6 +89,7 @@ export const DEFAULTS = {
         sqlserver: { enabled: 'auto' },
     },
     attach: { enabled: true, reuseSession: true, auto: false, autoHide: false },
+    web: { enabled: false, port: 47800 },
     agentCommands: { enabled: false, agents: 'auto' },
     secrets: { strip: true, allow: [], patterns: [], warnFiles: true },
     personalization: { enabled: true },
@@ -99,6 +101,7 @@ export const DEFAULTS = {
         globalStateFile: 'auto',
         copyCredentials: false,
         overwrite: true,
+        sharePluginsAcrossAccounts: false,
         syncHistory: true,
         historyScope: 'project',
         syncClaudeMem: true,
@@ -122,6 +125,7 @@ export const DEFAULTS = {
             arguments: [],
             environment: {},
             home: { env: { CODEX_HOME: 'codex' }, loginFiles: ['auth.json'], hostDir: '~/.codex' },
+            localState: { CODEX_SQLITE_HOME: 'sqlite' },
             resumeArguments: ['resume', '--last'],
         },
         gemini: {

package/dist/core/config/loader.js

@@ -23,8 +23,18 @@ export function machineConfigPath(env = process.env) {
  * folders in it must be full paths (after %VARIABLES% expand), never relative to someone's folder.
  */
 function readMachineConfig(file) {
-    if (!fs.existsSync(file))
-        return null;
+    // existsSync says false on "access denied": a user not yet in the group would silently get the defaults.
+    try {
+        fs.accessSync(file, fs.constants.R_OK);
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR')
+            return null;
+        if (code === 'EACCES' || code === 'EPERM')
+            fail('Cannot read the settings for this PC in ' + file + '.', 'Sign out of Windows and in again after being added to the Agent Sandbox Users group.');
+        throw e;
+    }
     const raw = readJsonc(file);
     const config = validateConfig(mergeConfig(DEFAULTS, raw), file);
     const folders = config.mappings.map((m, i) => ['mappings[' + i + '].host', m.host]);

package/dist/core/local-config/overrides.js

@@ -49,6 +49,7 @@ export const ON_IS_SAFER = [
     'network.blockPrivateRanges',
     'sandbox.protectedClient',
     'downloads.requireChecksum',
+    'vpn.killSwitch',
 ];
 export const OFF_IS_SAFER = [
     'sandbox.networking',

package/dist/core/prompt.d.ts

@@ -1,4 +1,23 @@
+/** One entry of a list question; `description` is shown under the highlighted entry. */
+export interface PromptChoice<T> {
+    readonly name: string;
+    readonly value: T;
+    readonly description?: string;
+}
 /** A yes/no question (default no). */
 export declare function askYesNo(question: string, defaultYes?: boolean): Promise<boolean>;
+/** A yes/no question the command needs answered: no terminal fails (`--yes` answers yes on the command line). */
+export declare function askRequired(question: string, fix?: string, defaultYes?: boolean): Promise<boolean>;
 /** Asks the user to type `expected` (a stronger confirmation than yes/no). */
 export declare function askTyped(question: string, expected: string): Promise<boolean>;
+/** Pick one entry from a list (for an argument that was left out); `fix` says what to type instead. */
+export declare function askChoice<T>(message: string, choices: readonly PromptChoice<T>[], fix: string): Promise<T>;
+/** Tick any number of entries from a list; `fix` says what to type instead. */
+export declare function askChoices<T>(message: string, choices: readonly PromptChoice<T>[], fix: string): Promise<T[]>;
+/** Type a name or a path. `validate` returns true, or the problem to show. */
+export declare function askName(message: string, fix: string, validate?: (value: string) => true | string): Promise<string>;
+/**
+ * Type a secret (a password, an API key) with each character shown as *. Never echoed, never kept; `fix` says what to
+ * do without a terminal.
+ */
+export declare function askSecret(message: string, fix: string): Promise<string>;

package/dist/core/prompt.js

@@ -1,12 +1,24 @@
-// Questions asked on the terminal, all through @inquirer/prompts. Without an interactive terminal the answer is always
-// "no".
-import { confirm, input } from '@inquirer/prompts';
+// Questions asked on the terminal, all through @inquirer/prompts. askYesNo is for optional offers: without an
+// interactive terminal the answer is "no". askRequired, askChoice and askName are for questions a command cannot go on
+// without: with no terminal they fail and say how to answer on the command line.
+import { checkbox, confirm, input, password, select } from '@inquirer/prompts';
+import { fail } from './util/errors.js';
+/** The terminal check every required question starts with. */
+function requireTerminal(fix) {
+    if (!process.stdin.isTTY)
+        fail('Cannot ask here (no terminal).', fix);
+}
 /** A yes/no question (default no). */
 export async function askYesNo(question, defaultYes = false) {
     if (!process.stdin.isTTY)
         return false;
     return confirm({ message: question, default: defaultYes });
 }
+/** A yes/no question the command needs answered: no terminal fails (`--yes` answers yes on the command line). */
+export async function askRequired(question, fix = 'Add --yes to answer yes.', defaultYes = false) {
+    requireTerminal(fix);
+    return confirm({ message: question, default: defaultYes });
+}
 /** Asks the user to type `expected` (a stronger confirmation than yes/no). */
 export async function askTyped(question, expected) {
     if (!process.stdin.isTTY)
@@ -14,3 +26,31 @@ export async function askTyped(question, expected) {
     const answer = await input({ message: question + ' Type "' + expected + '" to confirm:' });
     return answer.trim().toLowerCase() === expected;
 }
+/** Pick one entry from a list (for an argument that was left out); `fix` says what to type instead. */
+export async function askChoice(message, choices, fix) {
+    requireTerminal(fix);
+    return select({ message, choices: [...choices] });
+}
+/** Tick any number of entries from a list; `fix` says what to type instead. */
+export async function askChoices(message, choices, fix) {
+    requireTerminal(fix);
+    return checkbox({ message, choices: [...choices] });
+}
+/** Type a name or a path. `validate` returns true, or the problem to show. */
+export async function askName(message, fix, validate) {
+    requireTerminal(fix);
+    const answer = await input({ message, validate: validate ? (v) => validate(v.trim()) : undefined });
+    return answer.trim();
+}
+/**
+ * Type a secret (a password, an API key) with each character shown as *. Never echoed, never kept; `fix` says what to
+ * do without a terminal.
+ */
+export async function askSecret(message, fix) {
+    requireTerminal(fix);
+    return password({
+        message,
+        mask: '*',
+        validate: (v) => (v.length > 0 ? true : 'Type it, or press Ctrl+C to cancel.'),
+    });
+}

package/dist/core/schema/common.d.ts

@@ -18,3 +18,9 @@ export declare const GitAccessSchema: z.ZodEnum<{
 export declare const EnabledSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
 export declare function enabled(what: string, markers: string): typeof EnabledSchema;
 export declare function Packages(what: string, example: string): typeof StringsSchema;
+/**
+ * Marks a setting whose value is a secret (an API key in an agent's environment): config show / get, the menu, doctor
+ * and every --json print *** for it (core/schema/redact.ts), and it is never written to session.json or the launch
+ * folder (it travels in a one-shot file, see shared/channel/secrets.ts).
+ */
+export declare function secret<T extends z.ZodType>(schema: T): T;

package/dist/core/schema/common.js

@@ -25,3 +25,11 @@ export function enabled(what, markers) {
 export function Packages(what, example) {
     return StringsSchema.describe(what + ', installed once and kept (e.g. ' + example + ').');
 }
+/**
+ * Marks a setting whose value is a secret (an API key in an agent's environment): config show / get, the menu, doctor
+ * and every --json print *** for it (core/schema/redact.ts), and it is never written to session.json or the launch
+ * folder (it travels in a one-shot file, see shared/channel/secrets.ts).
+ */
+export function secret(schema) {
+    return schema.meta({ secret: true });
+}

package/dist/core/schema/config.d.ts

@@ -60,6 +60,20 @@ export declare const ConfigSchema: z.ZodObject<{
         dns: z.ZodArray<z.ZodString>;
         proxy: z.ZodString;
     }, z.core.$strict>;
+    vpn: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        provider: z.ZodEnum<{
+            nordvpn: "nordvpn";
+            "openvpn-file": "openvpn-file";
+        }>;
+        protocol: z.ZodEnum<{
+            udp: "udp";
+            tcp: "tcp";
+        }>;
+        country: z.ZodString;
+        configFile: z.ZodString;
+        killSwitch: z.ZodBoolean;
+    }, z.core.$strict>;
     provisioning: z.ZodObject<{
         copyFromHost: z.ZodBoolean;
         fallbackToInstall: z.ZodBoolean;
@@ -218,6 +232,10 @@ export declare const ConfigSchema: z.ZodObject<{
         auto: z.ZodBoolean;
         autoHide: z.ZodBoolean;
     }, z.core.$strict>;
+    web: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        port: z.ZodNumber;
+    }, z.core.$strict>;
     agentCommands: z.ZodObject<{
         enabled: z.ZodBoolean;
         agents: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodArray<z.ZodString>]>;
@@ -258,6 +276,7 @@ export declare const ConfigSchema: z.ZodObject<{
         globalStateFile: z.ZodString;
         copyCredentials: z.ZodBoolean;
         overwrite: z.ZodBoolean;
+        sharePluginsAcrossAccounts: z.ZodBoolean;
         syncHistory: z.ZodBoolean;
         historyScope: z.ZodEnum<{
             project: "project";
@@ -281,6 +300,7 @@ export declare const ConfigSchema: z.ZodObject<{
             loginFiles: z.ZodArray<z.ZodString>;
             hostDir: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        localState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         resumeArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
         resumeOneArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
@@ -345,6 +365,9 @@ export declare const LocalOverridesSchema: z.ZodObject<{
         blockPrivateRanges: z.ZodOptional<z.ZodBoolean>;
         blockHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
+    vpn: z.ZodOptional<z.ZodObject<{
+        killSwitch: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
     provisioning: z.ZodOptional<z.ZodObject<{
         copyFromHost: z.ZodOptional<z.ZodBoolean>;
         fallbackToInstall: z.ZodOptional<z.ZodBoolean>;