windows-development-sandbox 1.5.0 → 1.7.0

package/dist/cli/menu/pages/sandbox-page.js

@@ -1,5 +1,6 @@
-// Tab 3: the sandbox as a whole. Status (a card, the window, stopping it), Projects (roots and known projects) and
+// Section 3: the sandbox as a whole. Status (a card, the window, stopping it), Projects (roots and known projects) and
 // Databases (start and stop), each a category on the left.
+import fs from 'node:fs';
 import path from 'node:path';
 import { errMsg, safeText } from '../../../core/util/index.js';
 import { RunDir } from '../../../shared/channel/index.js';
@@ -29,9 +30,9 @@ export function sandboxOptions(m) {
         section: 'Sandbox',
         ...extra,
     });
-    const off = running ? {} : { disabled: 'No sandbox is running.' };
     const sessions = m.report.projects.reduce((n, p) => n + p.sessions.length, 0) + m.report.otherSessions.length;
     const status = [
+        ...(running ? [] : startRows(m.defaultAgent, 'status')),
         row('info:state', 'State', running ? Theme.ok(Theme.glyph.on + ' ' + sandbox.phase) : Theme.muted(Theme.glyph.off + ' stopped'), { description: sandbox.message ? safeText(sandbox.message) : undefined }),
         row('info:uptime', 'Up for', sandbox.startedAt && running ? ago(sandbox.startedAt).replace(' ago', '') : '-'),
         row('info:daemon', 'Sandbox agent', running ? safeText(sandbox.daemon) : '-'),
@@ -44,29 +45,37 @@ export function sandboxOptions(m) {
             (repoGuard.findings.length ? ', ' + repoGuard.findings.length + ' change(s) neutralised' : ''), {
             details: repoGuard.findings.slice(-8).map((f) => Theme.warn(safeText(f))),
         }),
-        row('act:show', 'Show the window', '', {
-            section: 'Actions',
-            description: 'Brings the sandbox window to the front.',
-            ...off,
-        }),
-        row('act:hide', 'Hide the window', '', {
-            section: 'Actions',
-            description: 'Hides the window; sbx-show inside the sandbox (or Show the window here) brings it back.',
-            ...off,
-        }),
-        row('act:stop', 'Stop the sandbox…', '', {
-            section: 'Actions',
-            description: 'Shuts the sandbox down; history and claude-mem sync back when it closes.',
-            ...off,
-        }),
+        ...(running
+            ? [
+                row('act:show', 'Show the window', '', {
+                    section: 'Actions',
+                    description: 'Brings the sandbox window to the front.',
+                }),
+                row('act:hide', 'Hide the window', '', {
+                    section: 'Actions',
+                    description: 'Hides the window. Show the window brings it back.',
+                }),
+                row('act:stop', 'Stop the sandbox…', '', {
+                    section: 'Actions',
+                    description: 'Shuts the sandbox down; your history syncs back when it closes.',
+                }),
+            ]
+            : []),
     ];
+    const addRoot = {
+        value: ADD_ROOT,
+        label: '+ Add a project root…',
+        category: 'projects',
+        section: 'Project roots',
+        description: 'Pick a folder that holds your projects: every project in it (also new ones) opens without a restart.',
+    };
     const roots = m.projects.roots.map((r) => ({
         value: 'root:' + r,
         label: Text.middle(r, 60),
         hint: Theme.muted('root'),
         category: 'projects',
         section: 'Project roots',
-        description: 'Every project in this folder (also new ones) opens without a restart.',
+        description: 'Every project in this folder (also new ones) opens without a restart. f removes the root.',
     }));
     const projects = m.projects.projects.map((p) => ({
         value: 'project:' + p.folder,
@@ -80,6 +89,20 @@ export function sandboxOptions(m) {
             Theme.muted('In sandbox ') + (p.running ?? '-'),
         ],
     }));
+    const noDatabases = m.databases
+        ? []
+        : running
+            ? [
+                {
+                    value: 'info:db',
+                    label: 'The sandbox is not ready yet',
+                    category: 'databases',
+                    section: 'Databases',
+                    description: 'Its databases are listed once it is ready. l looks again.',
+                    disabled: 'Not ready yet: l looks again.',
+                },
+            ]
+            : startRows(m.defaultAgent, 'databases');
     const databases = (m.databases ?? []).map((d) => ({
         value: 'db:' + d.name,
         label: d.name,
@@ -90,27 +113,69 @@ export function sandboxOptions(m) {
     }));
     return {
         path: [],
-        items: [...status, ...roots, ...projects, ...databases],
+        items: [...status, addRoot, ...roots, ...projects, ...databases, ...noDatabases],
         categories: CATEGORIES,
-        empty: running ? 'Nothing here yet.' : 'No sandbox is running.',
-        actions: sandboxActions,
-        enterLabel: 'run',
-        escapeLabel: 'quit',
+        empty: 'Nothing here yet.',
+        actions: (category) => sandboxActions(category, running),
+        enterLabel: (_category, id) => enterLabel(id ?? '', m),
     };
 }
-function sandboxActions(category) {
+const ADD_ROOT = '@add-root';
+const REFRESH = { key: 'l', label: 'refresh', importance: 3 };
+/** The rows that start a sandbox, shown where the sandbox has to run for anything to be there. */
+function startRows(agent, category) {
+    return [
+        {
+            value: 'act:start',
+            label: 'Start the sandbox with ' + agent,
+            hint: Theme.muted('default agent'),
+            category,
+            section: 'No sandbox is running',
+            description: 'Starts the sandbox and ' + agent + ' in this folder.',
+        },
+        {
+            value: 'act:start-bare',
+            label: 'Start the sandbox without an agent',
+            category,
+            section: 'No sandbox is running',
+            description: 'Tools and databases only.',
+        },
+    ];
+}
+/** What Enter does on a row ("" = the row only shows information). */
+function enterLabel(id, m) {
+    if (id === 'act:show')
+        return 'show';
+    if (id === 'act:hide')
+        return 'hide';
+    if (id === 'act:stop')
+        return 'stop';
+    if (id.startsWith('act:start'))
+        return 'start';
+    if (id === ADD_ROOT)
+        return 'choose folder';
+    if (id.startsWith('db:'))
+        return m.databases?.find((d) => 'db:' + d.name === id)?.running ? 'stop' : 'start';
+    return '';
+}
+function sandboxActions(category, running) {
     if (category === 'projects')
         return [
-            { key: 'a', label: 'add root' },
-            { key: 'f', label: 'forget / remove' },
-        ];
-    return category === 'databases'
-        ? []
-        : [
-            { key: 'w', label: 'show window' },
-            { key: 'h', label: 'hide window' },
-            { key: 'x', label: 'stop' },
+            { key: 'a', label: 'add root', importance: 1 },
+            { key: 'f', label: 'remove root', importance: 1, applies: (id) => id.startsWith('root:') },
+            { key: 'f', label: 'forget project', importance: 1, applies: (id) => id.startsWith('project:') },
+            REFRESH,
         ];
+    if (category === 'databases')
+        return [REFRESH];
+    return running
+        ? [
+            { key: 'w', label: 'show window', importance: 3 },
+            { key: 'h', label: 'hide window', importance: 3 },
+            { key: 'x', label: 'stop', importance: 1 },
+            REFRESH,
+        ]
+        : [REFRESH];
 }
 export class SandboxPage extends ListPage {
     ctx;
@@ -136,7 +201,7 @@ export class SandboxPage extends ListPage {
                 /* the sandbox did not answer: the list stays empty */
             }
         }
-        this.model = { report, projects: this.projects.list(), databases };
+        this.model = { report, projects: this.projects.list(), databases, defaultAgent: this.defaultAgent() };
     }
     /** The folder `sbx-db` runs in: the sandbox's own workspace. */
     guestWorkspace() {
@@ -151,6 +216,14 @@ export class SandboxPage extends ListPage {
         const id = result.kind === 'pick' || result.kind === 'action' ? result.value : undefined;
         const key = result.kind === 'action' ? result.key : undefined;
         try {
+            if (key === 'l')
+                return { reload: true };
+            if (id === 'act:start' && !key)
+                return { exit: { kind: 'run', argv: ['launch', '--harness', this.defaultAgent()] } };
+            if (id === 'act:start-bare' && !key)
+                return { exit: { kind: 'run', argv: ['start'] } };
+            if (id === ADD_ROOT && !key)
+                return await this.addRoot();
             if (id === 'act:show' || key === 'w')
                 return this.show();
             if (id === 'act:hide' || key === 'h')
@@ -160,7 +233,7 @@ export class SandboxPage extends ListPage {
             if (key === 'a')
                 return await this.addRoot();
             if (key === 'f')
-                return this.forget(id);
+                return await this.forget(id);
             if (id?.startsWith('db:') && result.kind === 'pick')
                 return await this.toggleDatabase(id.slice(3));
         }
@@ -169,6 +242,9 @@ export class SandboxPage extends ListPage {
         }
         return {};
     }
+    defaultAgent() {
+        return this.ctx.loaded.config.defaultHarness;
+    }
     noSandbox() {
         return this.model?.report.sandbox.running ? null : { notice: Theme.warn('No sandbox is running.') };
     }
@@ -186,7 +262,7 @@ export class SandboxPage extends ListPage {
         await this.sandbox.hideWindow();
         return {
             reload: true,
-            notice: Theme.ok(Theme.glyph.ok + ' Window hidden.') + Theme.muted(' sbx-show brings it back.'),
+            notice: Theme.ok(Theme.glyph.ok + ' Window hidden.'),
         };
     }
     async stop() {
@@ -214,17 +290,18 @@ export class SandboxPage extends ListPage {
         return { reload: true, notice: Theme.ok(Theme.glyph.ok + ' The sandbox is shutting down.') };
     }
     async addRoot() {
-        const typed = await this.app.text({
+        const picked = await this.app.pickPath({
             path: ['Sandbox', 'Add a project root'],
-            label: 'Folder that holds your projects',
+            title: 'Choose the folder that holds your projects',
             about: [
                 'Every project inside it (also new ones) opens without a restart. Every agent in the sandbox can see them.',
             ],
-            validate: (v) => (v.trim() ? true : 'Type a folder.'),
+            use: 'add this root',
+            validate: (v) => (fs.existsSync(v) ? true : 'That folder does not exist.'),
         });
-        if (!typed)
+        if (!picked)
             return {};
-        const { dir, added } = this.projects.addRoot(typed.trim());
+        const { dir, added } = this.projects.addRoot(picked);
         return {
             reload: true,
             notice: added
@@ -232,8 +309,20 @@ export class SandboxPage extends ListPage {
                 : Theme.muted(dir + ' is a root already.'),
         };
     }
-    forget(id) {
-        if (id?.startsWith('root:')) {
+    async forget(id) {
+        const root = id?.startsWith('root:');
+        if (!id || (!root && !id.startsWith('project:')))
+            return {};
+        const folder = id.slice(root ? 5 : 8);
+        const ok = await this.app.ask((root ? 'Remove the root ' : 'Forget ') + path.basename(folder) + '?', [
+            root
+                ? 'Its projects are no longer opened without a restart.'
+                : 'The project is dropped from your list of projects.',
+            'Nothing in ' + folder + ' is touched.',
+        ], root ? 'Remove' : 'Forget', true);
+        if (!ok)
+            return {};
+        if (id.startsWith('root:')) {
             const { dir, removed } = this.projects.removeRoot(id.slice(5));
             return {
                 reload: true,

package/dist/cli/menu/pages/sessions-page.d.ts

@@ -6,14 +6,18 @@ export interface SessionsModel {
     readonly sandboxRunning: boolean;
     /** Newest first, this folder's project first. */
     readonly sessions: readonly ListedSession[];
+    /** The agent "Start" offers while there is no session. */
+    readonly defaultAgent: string;
 }
 /** The list for the sessions tab. Pure. */
 export declare function sessionsOptions(m: SessionsModel): ListOptions<string>;
 export declare class SessionsPage extends ListPage<string> {
+    private readonly ctx;
     readonly label = "Sessions";
     private model;
     private readonly service;
     constructor(app: App, ctx: Context);
+    private defaultAgent;
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;
     protected act(result: ListResult<string>): Promise<Outcome<string>>;

package/dist/cli/menu/pages/sessions-page.js

@@ -1,4 +1,4 @@
-// Tab 2: the agent sessions of the running sandbox. Enter shows one in this terminal (the one thing that leaves the
+// Section 2: the agent sessions of the running sandbox. Enter shows one in this terminal (the one thing that leaves the
 // menu), r restarts the agents.
 import { errMsg, safeText } from '../../../core/util/index.js';
 import { isSandboxRunning } from '../../../host/sandbox/index.js';
@@ -6,54 +6,68 @@ import { ago } from '../../output/index.js';
 import { SessionsService, viewerText } from '../../services/index.js';
 import { Theme } from '../../tui/index.js';
 import { ListPage } from './list-page.js';
+const START = '@start';
 /** The list for the sessions tab. Pure. */
 export function sessionsOptions(m) {
     return {
         path: [],
-        intro: m.sandboxRunning
-            ? undefined
-            : 'No sandbox is running. Start one on the Start tab (1); its sessions are listed here.',
-        items: m.sessions.map((s) => ({
-            value: s.id,
-            label: safeText(s.harness) + '  ' + safeText(s.projectName ?? '-'),
-            hint: s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : '') + '  ' + ago(s.startedAt),
-            section: s.here ? "This folder's project" : 'Other sessions',
-            description: s.phase === 'running'
-                ? 'Enter shows this session in this terminal (Ctrl+] detaches; the session keeps running).'
-                : undefined,
-            details: [
-                Theme.muted('Session   ') + s.id,
-                Theme.muted('Folder    ') + safeText(s.cwd),
-                Theme.muted('Attached  ') + viewerText(s.viewers),
+        items: m.sessions.length
+            ? m.sessions.map((s) => ({
+                value: s.id,
+                label: safeText(s.harness) + '  ' + safeText(s.projectName ?? '-'),
+                hint: s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : '') + '  ' + ago(s.startedAt),
+                section: s.here ? "This folder's project" : 'Other sessions',
+                description: s.phase === 'running'
+                    ? 'Enter shows this session in this terminal (Ctrl+] detaches; the session keeps running).'
+                    : undefined,
+                details: [
+                    Theme.muted('Session   ') + s.id,
+                    Theme.muted('Folder    ') + safeText(s.cwd),
+                    Theme.muted('Attached  ') + viewerText(s.viewers),
+                ],
+                ...(s.phase === 'running' ? {} : { disabled: 'This session has ended.' }),
+            }))
+            : [
+                {
+                    value: START,
+                    label: 'Start ' + m.defaultAgent,
+                    hint: Theme.muted('default agent'),
+                    section: m.sandboxRunning ? 'No sessions' : 'No sandbox is running',
+                    description: m.sandboxRunning
+                        ? 'No agent is running. Enter starts ' + m.defaultAgent + ' in this folder.'
+                        : 'Enter starts the sandbox and ' + m.defaultAgent + ' in this folder; its session is listed here.',
+                },
             ],
-            ...(s.phase === 'running' ? {} : { disabled: 'This session has ended.' }),
-        })),
-        empty: 'No sessions yet.',
         actions: [
-            { key: 'r', label: 'restart agents', importance: 1 },
+            { key: 'r', label: 'restart agents', importance: 1, applies: (id) => id !== START },
             { key: 'o', label: 'reopen last sessions', importance: 2 },
             { key: 'l', label: 'refresh', importance: 3 },
         ],
-        enterLabel: 'attach',
-        escapeLabel: 'quit',
+        enterLabel: (_category, id) => (id === START ? 'start' : 'attach'),
     };
 }
 export class SessionsPage extends ListPage {
+    ctx;
     label = 'Sessions';
-    model = { sandboxRunning: false, sessions: [] };
+    model;
     service;
     constructor(app, ctx) {
         super(app);
+        this.ctx = ctx;
         this.service = new SessionsService(ctx);
+        this.model = { sandboxRunning: false, sessions: [], defaultAgent: this.defaultAgent() };
+    }
+    defaultAgent() {
+        return this.ctx.loaded.config.defaultHarness;
     }
     async load() {
         const sandboxRunning = isSandboxRunning();
         try {
             const list = sandboxRunning ? await this.service.list() : [];
-            this.model = { sandboxRunning, sessions: this.service.ordered(list) };
+            this.model = { sandboxRunning, sessions: this.service.ordered(list), defaultAgent: this.defaultAgent() };
         }
         catch (e) {
-            this.model = { sandboxRunning, sessions: [] };
+            this.model = { sandboxRunning, sessions: [], defaultAgent: this.defaultAgent() };
             this.say(Theme.error(Theme.glyph.cross + ' ' + errMsg(e)));
         }
     }
@@ -61,6 +75,8 @@ export class SessionsPage extends ListPage {
         return sessionsOptions(this.model);
     }
     async act(result) {
+        if (result.kind === 'pick' && result.value === START)
+            return { exit: { kind: 'run', argv: ['launch', '--harness', this.model.defaultAgent] } };
         if (result.kind === 'pick')
             return { exit: { kind: 'run', argv: ['attach', result.value] } };
         if (result.kind !== 'action')

package/dist/cli/menu/pages/settings-page.d.ts

@@ -1,4 +1,5 @@
-import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
+import type { Context } from '../../commands/context.js';
+import { type App, type ListItem, type ListOptions, type ListResult } from '../../tui/index.js';
 import type { ConfigFile } from '../settings/config-file.js';
 import type { Draft } from '../settings/draft.js';
 import type { SchemaNode } from '../settings/schema-node.js';
@@ -12,16 +13,19 @@ export interface Setting {
 }
 /** Every editable setting with the category and heading it is shown under. */
 export declare function settingsOf(file: ConfigFile): Setting[];
-/** The list for the settings tab. Pure (reads the files it is given). */
-export declare function settingsOptions(files: Record<Scope, ConfigFile>, scope: Scope, draft: Draft): ListOptions<string>;
+/** The row in General that opens the data folder flow (your own settings only). */
+export declare const DATA_FOLDER = "@data-folder";
+/** The list for the settings section. Pure (reads the files it is given). `extra` are rows that are not settings. */
+export declare function settingsOptions(files: Record<Scope, ConfigFile>, scope: Scope, draft: Draft, extra?: readonly ListItem<string>[]): ListOptions<string>;
 export declare class SettingsPage extends ListPage<string> {
     private readonly files;
     private readonly draft;
+    private readonly ctx;
     readonly label = "Settings";
     readonly stages = true;
     private scope;
     private readonly editor;
-    constructor(app: App, files: Record<Scope, ConfigFile>, draft: Draft);
+    constructor(app: App, files: Record<Scope, ConfigFile>, draft: Draft, ctx: Context);
     private get file();
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;

package/dist/cli/menu/pages/settings-page.js

@@ -1,10 +1,12 @@
-// Tab 5: every setting, for all projects or just this project (two scopes), grouped into categories on the left and
+// Section 5: every setting, for all projects or just this project (two scopes), grouped into categories on the left and
 // searchable, with each value, its default and its description. Changes are staged in the Draft (marked *) and
 // written with Ctrl+S; Enter edits, r resets to the default, z undoes an unsaved change.
 import _ from 'lodash';
 import { NEVER_LOOSER } from '../../../core/local-config/index.js';
 import { errMsg } from '../../../core/util/index.js';
 import { Text, Theme, } from '../../tui/index.js';
+import { dataFolderRow, DataFolderFlow } from '../data-folder.js';
+import { VpnLoginFlow, vpnLoginRow, VPN_LOGIN } from '../vpn-login.js';
 import { CATEGORIES, categoryOf, nameOf } from '../settings/categories.js';
 import { formatValue } from '../settings/format.js';
 import { ValueEditor } from '../settings/value-editor.js';
@@ -106,11 +108,18 @@ function item(s, files, scope, draft, config) {
         flip: s.node.editor === 'boolean',
     };
 }
-/** The list for the settings tab. Pure (reads the files it is given). */
-export function settingsOptions(files, scope, draft) {
+/** The row in General that opens the data folder flow (your own settings only). */
+export const DATA_FOLDER = '@data-folder';
+/** The list for the settings section. Pure (reads the files it is given). `extra` are rows that are not settings. */
+export function settingsOptions(files, scope, draft, extra = []) {
     const file = files[scope];
     const config = file.userConfig();
-    const settings = settingsOf(file);
+    // The Data folder row stands in for the storage folder setting (changing it moves the data, which is asked about).
+    const hideRoot = !file.isProject && extra.some((e) => e.value === DATA_FOLDER);
+    const settings = settingsOf(file).filter((s) => !(hideRoot && s.key.join('.') === 'storage.root'));
+    const ids = (test) => new Set(settings.filter(test).map((s) => s.key.join('.')));
+    const set = ids((s) => written(file, draft, s.key) !== undefined);
+    const unsaved = ids((s) => draft.has(file, s.key));
     const categories = CATEGORIES.filter((c) => settings.some((s) => s.category === c.id)).map((c) => ({
         id: c.id,
         label: c.label,
@@ -120,27 +129,28 @@ export function settingsOptions(files, scope, draft) {
         path: [],
         status: scopeStatus(file),
         tabs: { items: SCOPES.map((x) => x.tab), active: SCOPES.findIndex((x) => x.scope === scope) },
-        items: settings.map((s) => item(s, files, scope, draft, config)),
+        items: [...settings.map((s) => item(s, files, scope, draft, config)), ...(file.isProject ? [] : extra)],
         categories,
         actions: [
-            { key: 'r', label: file.isProject ? 'remove' : 'reset' },
-            { key: 'z', label: 'undo' },
+            { key: 'r', label: file.isProject ? 'remove' : 'reset to default', applies: (id) => set.has(id) },
+            { key: 'z', label: 'undo', applies: (id) => unsaved.has(id) },
         ],
-        enterLabel: 'edit',
-        escapeLabel: 'quit',
+        enterLabel: (_category, id) => (id === DATA_FOLDER || id === VPN_LOGIN ? 'change' : 'edit'),
     };
 }
 export class SettingsPage extends ListPage {
     files;
     draft;
+    ctx;
     label = 'Settings';
     stages = true;
     scope = 'user';
     editor;
-    constructor(app, files, draft) {
+    constructor(app, files, draft, ctx) {
         super(app);
         this.files = files;
         this.draft = draft;
+        this.ctx = ctx;
         this.editor = new ValueEditor(app, {
             suggestions: (key) => ['defaultHarness', 'harness'].includes(key.join('.'))
                 ? Object.keys(this.files.user.userConfig().harnesses)
@@ -154,7 +164,11 @@ export class SettingsPage extends ListPage {
         return Promise.resolve();
     }
     options() {
-        return settingsOptions(this.files, this.scope, this.draft);
+        const row = dataFolderRow(this.ctx);
+        return settingsOptions(this.files, this.scope, this.draft, [
+            { value: DATA_FOLDER, category: 'general', ...row },
+            { value: VPN_LOGIN, category: 'network', ...vpnLoginRow(this.ctx) },
+        ]);
     }
     /** Stages a value; your own file never keeps a line that only repeats the default. */
     stage(key, value) {
@@ -176,6 +190,17 @@ export class SettingsPage extends ListPage {
             return {};
         if (result.value === undefined)
             return {};
+        if (result.value === DATA_FOLDER) {
+            if (result.kind !== 'pick')
+                return {};
+            const exit = await new DataFolderFlow(this.app, this.ctx).run();
+            return exit ? { exit } : { reload: true };
+        }
+        if (result.value === VPN_LOGIN) {
+            if (result.kind !== 'pick')
+                return {};
+            return { reload: true, notice: await new VpnLoginFlow(this.app, this.ctx).run() };
+        }
         const setting = settingsOf(this.file).find((s) => s.key.join('.') === result.value);
         if (!setting)
             return {};
@@ -187,8 +212,6 @@ export class SettingsPage extends ListPage {
             this.stage(setting.key, undefined);
             return {};
         }
-        if (result.value === 'apps.install')
-            return { notice: Theme.muted('Choose apps on the Apps tab (press 4); the list is picked there, not typed.') };
         try {
             const config = this.file.userConfig();
             const current = this.file.isProject

package/dist/cli/menu/settings/categories.d.ts

@@ -5,5 +5,7 @@ export interface SettingsCategory {
     keys: string[];
 }
 export declare const CATEGORIES: SettingsCategory[];
+/** Settings not listed here because their own section covers them (Apps: the catalogue and your own programs). */
+export declare const SETTINGS_ELSEWHERE: readonly string[];
 export declare function nameOf(key: string): string;
 export declare function categoryOf(topKey: string): SettingsCategory | undefined;