windows-development-sandbox 1.18.4 → 1.23.0

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

@@ -4,7 +4,7 @@
 // are on.
 import fs from 'node:fs';
 import path from 'node:path';
-import { agentsPage, listAgents } from '../../../app/features/agents/index.js';
+import { agentEnv, agentEnvPage, agentsPage, listAgents, } from '../../../app/features/agents/index.js';
 import { readQuery } from '../../../app/registry.js';
 import { commandLine, readHistory } from '../../history.js';
 import { AgentCommandsService } from '../../services/index.js';
@@ -16,6 +16,10 @@ import { menuView } from '../render-view.js';
 import { askPath } from '../settings/ask-path.js';
 import { SeveralAgents } from '../several.js';
 import { ListPage } from './list-page.js';
+/** What the agent commands section shows (before the status is read: off, nothing found). Pure. */
+function commandsOf(m) {
+    return m.agentCommands ?? { enabled: m.hostAgents.length > 0, dir: '', found: [] };
+}
 /** The agents page's data as the agents view takes it. Pure. */
 export function agentsList(m) {
     const removable = m.removable ?? [];
@@ -32,7 +36,13 @@ export function agentsList(m) {
 }
 /** The Start category: the agents view's rows and keys, as the menu draws them. Pure. */
 function startView(m) {
-    return menuView(agentsPage(agentsList(m)), { category: 'start', refresh: false });
+    const page = agentsPage(agentsList(m), commandsOf(m));
+    return menuView({ ...page, sections: page.sections.slice(0, 1) }, { category: 'start', refresh: false });
+}
+/** The On this PC category: the agent commands switch and the agents it covers (the view's second section). Pure. */
+function commandsView(m) {
+    const page = agentsPage(agentsList(m), commandsOf(m));
+    return menuView({ ...page, sections: page.sections.slice(1) }, { category: 'host', refresh: false });
 }
 /**
  * The "not sandboxed" entries: only while agent commands are on (typing the agent then starts the sandbox, so a way to
@@ -65,16 +75,21 @@ export function agentCategories(m) {
             label: 'Start',
             description: 'Agents you can start in ' + m.folder + '. Add an agent at the end of the list.',
         },
-        { id: 'options', label: 'Options', description: 'How a start goes, and the other ways to start.' },
-        ...(m.hostAgents.length
+        ...(m.claudeEnv
             ? [
                 {
-                    id: 'host',
-                    label: 'On this PC',
-                    description: 'The real agents on this PC, with no sandbox around them.',
+                    id: 'env',
+                    label: 'Claude environment',
+                    description: 'Models, limits, how many subagents run at once, and other variables of Claude.',
                 },
             ]
             : []),
+        { id: 'options', label: 'Options', description: 'How a start goes, and the other ways to start.' },
+        {
+            id: 'host',
+            label: 'On this PC',
+            description: 'Agent commands: typing claude, codex ... here starts them in a sandbox. The real agents are listed too.',
+        },
     ];
 }
 /** A Start row of the view with the menu's own lines: the default's accent and the command a start runs. Pure. */
@@ -88,9 +103,21 @@ function startRow(item, m, cwd) {
         details: [Theme.muted('Command  ') + commandLine(startArgv(m, name, cwd))],
     };
 }
+/** The Claude environment tab: the environment view's rows and keys, as the menu draws them. Pure. */
+function envView(m) {
+    return m.claudeEnv ? menuView(agentEnvPage(m.claudeEnv), { category: 'env', refresh: false }) : undefined;
+}
+/** What the last start was, in words: the agent and the folder it was for (never the command line). */
+function lastStart(argv) {
+    const at = argv.indexOf('--harness');
+    const agent = at >= 0 ? argv[at + 1] : argv[0];
+    return agent ?? 'last start';
+}
 /** The list for the agents section. Pure. */
 export function agentsOptions(m, cwd = process.cwd()) {
     const view = startView(m);
+    const env = envView(m);
+    const commands = commandsView(m);
     return {
         path: [],
         categories: agentCategories(m),
@@ -102,12 +129,14 @@ export function agentsOptions(m, cwd = process.cwd()) {
                         label: 'Repeat last',
                         category: 'start',
                         section: 'Quick start',
-                        hint: Theme.muted(Text.truncate(commandLine(m.last), 50)),
-                        description: 'Runs the last command again.',
+                        hint: Theme.muted(Text.truncate(lastStart(m.last), 50)),
+                        description: 'Starts the same agent again with the same options.',
                     },
                 ]
                 : []),
             ...view.items.map((item) => startRow(item, m, cwd)),
+            ...(env?.items ?? []),
+            ...commands.items,
             {
                 value: 'opt:attach',
                 label: 'Attach this terminal',
@@ -161,8 +190,21 @@ export function agentsOptions(m, cwd = process.cwd()) {
                 description: 'Runs the real ' + agent + ' on this PC, with no sandbox around it.',
             })),
         ],
-        enterLabel: (_category, id) => ENTER[id ?? ''] ?? (id?.startsWith('agent:') ? 'start' : id?.startsWith('host:') ? 'run' : 'open'),
-        actions: (category) => (category === 'start' ? view.actions : []),
+        enterLabel: (category, id) => ENTER[id ?? ''] ??
+            (id?.startsWith('agent:')
+                ? 'start'
+                : id?.startsWith('host:')
+                    ? 'run'
+                    : category === 'host'
+                        ? commands.enterLabel(category, id)
+                        : 'open'),
+        actions: (category) => category === 'start'
+            ? view.actions
+            : category === 'env'
+                ? (env?.actions ?? [])
+                : category === 'host'
+                    ? commands.actions
+                    : [],
     };
 }
 /** What Enter does on the rows that are not an agent. */
@@ -199,7 +241,7 @@ export class AgentsPage extends ListPage {
     current() {
         if (!this.facts)
             throw new Error('The agents tab was not loaded');
-        const { agents, commands, last } = this.facts;
+        const { agents, commands, last, env } = this.facts;
         return {
             folder: this.folder,
             defaultAgent: agents.defaultAgent,
@@ -208,7 +250,13 @@ export class AgentsPage extends ListPage {
             attach: this.attach,
             window: this.window,
             hostAgents: hostAgentsToShow(commands.enabled, commands.found),
+            agentCommands: {
+                enabled: commands.enabled,
+                dir: commands.dir,
+                found: commands.found.map((a) => ({ command: a.command, harness: a.harness, real: a.real })),
+            },
             removable: agents.agents.filter((a) => a.removable).map((a) => a.name),
+            ...(env ? { claudeEnv: env } : {}),
         };
     }
     /** The cursor starts on the default agent. */
@@ -220,6 +268,9 @@ export class AgentsPage extends ListPage {
             agents: await readQuery(listAgents, this.ctx),
             commands: await new AgentCommandsService(this.ctx).statusAsync(),
             last: readHistory()[0]?.argv,
+            env: 'claude' in this.ctx.loaded.config.harnesses
+                ? await readQuery(agentEnv, this.ctx, { agent: 'claude' })
+                : undefined,
         };
         this.model = this.current();
     }
@@ -229,9 +280,20 @@ export class AgentsPage extends ListPage {
     }
     async act(result) {
         const model = this.current();
-        const chosen = startView(model).resolve(result);
+        const env = this.category === 'env' ? envView(model) : undefined;
+        if (env) {
+            const picked = env.resolve(result);
+            if (picked?.kind === 'action')
+                return this.operate(picked.action);
+            return {};
+        }
+        const chosen = startView(model).resolve(result) ?? commandsView(model).resolve(result);
         if (chosen?.kind === 'action') {
             const { action } = chosen;
+            if (action.kind === 'link' && action.target.kind === 'view') {
+                await this.selectCategory('env');
+                return {};
+            }
             // A start keeps the options of this page (attach, window, folder), which the plain link does not know.
             if (action.kind === 'link' && action.target.kind === 'start-agent')
                 return { exit: { kind: 'run', argv: startArgv(model, action.target.agent, process.cwd()) } };

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

@@ -8,6 +8,7 @@ import { type UpdatesStatus } from '../../../app/features/updates/updates.def.js
 import { type WebStatus } from '../../../app/features/web/index.js';
 import type { Context } from '../../commands/context.js';
 import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
+import { type MenuView } from '../render-view.js';
 import { ListPage, type Outcome } from './list-page.js';
 export interface MaintenanceModel {
     /** The Data & storage category's storage rows: the data folder and contained storage (null until read). */
@@ -42,6 +43,11 @@ export interface MaintenanceModel {
         summary: string;
     }[];
 }
+/**
+ * The logs view's rows and keys for the Logs category (its own empty row is left out: the category shows the page's
+ * "Nothing here yet.").
+ */
+export declare function logsMenu(files: LogFiles): MenuView;
 /** The list for the maintenance tab. Pure. */
 export declare function maintenanceOptions(m: MaintenanceModel): ListOptions<string>;
 export declare class MaintenancePage extends ListPage<string> {

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

@@ -2,6 +2,7 @@
 // what is stored, clean-up), Health (doctor, repair and this PC's setup together), Activity (the audit log), the logs,
 // and the less common commands. Each is a category on the left and loads when you open it.
 import { dataPage, showData } from '../../../app/features/data/index.js';
+import { link } from '../../../app/kernel/index.js';
 import { readQuery } from '../../../app/registry.js';
 import { errMsg } from '../../../core/util/index.js';
 import { enginePage, engineLeftovers, engineStatus, } from '../../../app/features/engine/index.js';
@@ -51,7 +52,7 @@ const CATEGORIES = [
     },
     { id: 'more', label: 'More commands', description: 'Less common commands.' },
 ];
-const MORE_COMMANDS = ['sync', 'config', 'generate', 'exec', 'agent-commands'];
+const MORE_COMMANDS = ['sync', 'config', 'generate', 'exec'];
 const NO_LOGS = { folder: '', files: [], crash: false };
 /** Until the status is read: the server counts as not running. */
 const NO_WEB = { running: false, port: null, address: null };
@@ -61,7 +62,6 @@ const MORE_LABELS = {
     config: 'Your settings file',
     generate: 'Preview a start',
     exec: 'Run a command in the sandbox',
-    'agent-commands': 'Agent commands (Beta)',
 };
 /** The Data & storage category's rows and keys once measured: the data view (src/app/features/data) as menu rows. */
 function dataMenuView(data) {
@@ -109,8 +109,14 @@ const NO_UPDATES = {
  * The logs view's rows and keys for the Logs category (its own empty row is left out: the category shows the page's
  * "Nothing here yet.").
  */
-function logsMenu(files) {
-    return menuView({ ...logsPage(files), empty: undefined }, { category: 'logs', refresh: false });
+export function logsMenu(files) {
+    // Following a log runs the hand-written `logs --follow` on the normal screen: a menu key, not a page link.
+    const follow = link({ kind: 'command', argv: ['logs', '--follow'] }, 'Follow the newest log', {
+        key: 'f',
+        verb: 'follow in the terminal',
+        importance: 2,
+    });
+    return menuView({ ...logsPage(files), empty: undefined, actions: [follow] }, { category: 'logs', refresh: false });
 }
 /** The audit view (src/app/features/audit) as the Activity category's rows and keys (none until it was read). */
 function auditMenu(m) {

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

@@ -1,9 +1,11 @@
 import { type SessionsList } from '../../../app/features/sessions/index.js';
 import type { Context } from '../../commands/context.js';
 import type { App, ListOptions, ListResult } from '../../tui/index.js';
+import { type MenuView } from '../render-view.js';
 import { ListPage, type Outcome } from './list-page.js';
 /** What the page shows: the sessions query's result (the folder column is never shown here). */
 export type SessionsModel = Omit<SessionsList, 'wide'>;
+export declare function sessionsMenu(m: SessionsModel): MenuView;
 /** The list for the sessions tab. Pure. */
 export declare function sessionsOptions(m: SessionsModel): ListOptions<string>;
 export declare class SessionsPage extends ListPage<string> {

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

@@ -1,16 +1,24 @@
 // Section 2: the agent sessions of the running sandbox, as the sessions view shows them (src/app/features/sessions).
 // Enter shows one in this terminal (the one thing that leaves the menu), r restarts the agents.
+import { link } from '../../../app/kernel/index.js';
 import { listSessions, sessionsPage } from '../../../app/features/sessions/index.js';
 import { readQuery } from '../../../app/registry.js';
 import { MenuOperations } from '../io-menu.js';
 import { menuView } from '../render-view.js';
 import { ListPage } from './list-page.js';
-function view(m) {
-    return menuView(sessionsPage({ ...m, wide: false }));
+export function sessionsMenu(m) {
+    // Reopening the last sessions runs the hand-written `resume` on the normal screen: a key of the menu, not a link.
+    const resume = link({ kind: 'command', argv: ['resume'] }, 'Reopen last sessions', {
+        key: 'o',
+        verb: 'reopen last sessions',
+        importance: 2,
+    });
+    const page = sessionsPage({ ...m, wide: false });
+    return menuView({ ...page, actions: [...(page.actions ?? []), resume] });
 }
 /** The list for the sessions tab. Pure. */
 export function sessionsOptions(m) {
-    const v = view(m);
+    const v = sessionsMenu(m);
     return { path: [], items: v.items, actions: v.actions, enterLabel: v.enterLabel };
 }
 export class SessionsPage extends ListPage {
@@ -31,7 +39,7 @@ export class SessionsPage extends ListPage {
         return sessionsOptions(this.model);
     }
     async act(result) {
-        const chosen = view(this.model).resolve(result);
+        const chosen = sessionsMenu(this.model).resolve(result);
         if (!chosen)
             return {};
         if (chosen.kind === 'refresh')

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

@@ -158,9 +158,21 @@ export class SettingsPage extends ListPage {
         login: 'none',
         loginSavedAt: null,
         running: null,
+        lastFailure: null,
     };
     /** Whether a GitHub token is saved (never the token): the token row needs only its state. */
-    github = { shareToken: false, gitAccess: 'full', token: 'none', kind: null, savedAt: null };
+    github = {
+        shareToken: false,
+        gitAccess: 'full',
+        token: 'none',
+        kind: null,
+        savedAt: null,
+        login: null,
+        expiresAt: null,
+        repoCount: null,
+        checkedAt: null,
+        tokenUrl: '',
+    };
     constructor(app, files, draft, ctx) {
         super(app);
         this.files = files;

package/dist/cli/menu/remote-menu.js

@@ -94,7 +94,7 @@ export class RemoteMenu {
             if (action.kind === 'link') {
                 notice =
                     action.target.kind === 'terminal'
-                        ? Theme.muted('Attach to it from your own terminal: sandbox attach ' + safeText(action.target.session))
+                        ? Theme.muted('Attach to it from your own terminal (session ' + safeText(action.target.session) + ').')
                         : Theme.muted('That opens on ' + safeText(this.owner) + "'s side only.");
                 continue;
             }

package/dist/cli/menu/shell.d.ts

@@ -82,6 +82,11 @@ export declare class Shell implements Screen<ShellExit> {
     restore(view: MenuView): Promise<void>;
     /** Opens a section by index (loads its data); the first time, it goes back to the category and search it had. */
     openTab(index: number): Promise<void>;
+    /** Opens a section by name, on a category and/or with a search typed (a link from another page). */
+    goTo(section: string, where?: {
+        category?: string;
+        search?: string;
+    }): Promise<void>;
     /** Puts the keyboard in the navigation or in the list. */
     setFocus(focus: 'nav' | 'list'): void;
     /** Loads the open section again (after a command ran). */

package/dist/cli/menu/shell.js

@@ -27,6 +27,7 @@ export class Shell {
         this.draft = draft;
         this.afterSave = afterSave;
         app.nav = () => this.nav();
+        app.goTo = (section, where) => this.goTo(section, where);
     }
     get page() {
         return this.pages[this.active];
@@ -86,6 +87,18 @@ export class Shell {
         if (wanted?.search)
             this.page.restoreSearch?.(wanted.search);
     }
+    /** Opens a section by name, on a category and/or with a search typed (a link from another page). */
+    async goTo(section, where = {}) {
+        const index = this.pages.findIndex((p) => p.label === section);
+        if (index < 0)
+            return;
+        await this.openTab(index);
+        if (where.category)
+            await this.page.selectCategory(where.category);
+        if (where.search)
+            this.page.restoreSearch?.(where.search);
+        this.setFocus('list');
+    }
     /** Puts the keyboard in the navigation or in the list. */
     setFocus(focus) {
         this.focus = focus;

package/dist/cli/menu/views.js

@@ -1,7 +1,7 @@
 // The shared core's views the menu shows, and in which section (the parity self-test reads this list: an operation or
 // query is reachable in the menu when a view here offers it). Settings is drawn by its own page over the same rows,
 // because the menu stages changes until Ctrl+S.
-import { agentsView } from '../../app/features/agents/index.js';
+import { agentEnvView, agentsView } from '../../app/features/agents/index.js';
 import { dataView } from '../../app/features/data/index.js';
 import { accountsView } from '../../app/features/accounts/index.js';
 import { appsView } from '../../app/features/apps/index.js';
@@ -21,6 +21,7 @@ import { githubView } from '../../app/features/github/index.js';
 import { accessView } from '../../app/features/access/index.js';
 export const MENU_VIEWS = [
     { view: agentsView, section: 'Agents' },
+    { view: agentEnvView, section: 'Agents' },
     { view: sessionsView, section: 'Sessions' },
     { view: sandboxView, section: 'Sandbox' },
     { view: settingsView, section: 'Settings' },

package/dist/cli/report.js

@@ -41,6 +41,8 @@ export function report(e) {
         console.error(c.red('Error: ') + plainText(e.message));
         if (e.fix)
             console.error('  Fix:  ' + plainText(e.fix));
+        if (e.action?.cli)
+            console.error('  Run:  ' + plainText(e.action.cli));
         return 1;
     }
     console.error(c.red('Unexpected error: ') + errMsg(e));

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

@@ -14,6 +14,8 @@ export declare class AgentCommandsService {
     constructor(ctx: Context);
     /** Agent commands change this PC's PATH, so they are set up from the PC, not inside the sandbox. */
     assertOnPc(): void;
+    /** Your settings as they are on disk now (a switch made a moment ago, here or in Settings, counts). */
+    private config;
     status(): AgentCommandsStatus;
     /** status() that does not block the program (the menu asks while it stays responsive). */
     statusAsync(): Promise<AgentCommandsStatus>;

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

@@ -1,12 +1,12 @@
-// "Agent commands" (Beta): typing claude, codex ... on this PC starts them in a hidden sandbox. Never prints.
+// "Agent commands": typing claude, codex ... on this PC starts them in a hidden sandbox. Never prints.
 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, agentCommandsAsync, commandsDir, reconcileAgentCommands, } from '../../host/agent-commands/index.js';
+import { agentCommands, agentCommandsAsync, commandsDir, forwardTarget, reconcileAgentCommands, } from '../../host/agent-commands/index.js';
+import { InstallLayout } from '../../host/install/layout.js';
 import { insideSandbox } from '../../host/sandbox/index.js';
 import { writeFileAtomic } from '../../shared/io/index.js';
-import { editConfigText } from '../../app/features/settings/index.js';
+import { editConfigText } from '../../app/features/settings/settings-file.js';
 export class AgentCommandsService {
     ctx;
     constructor(ctx) {
@@ -17,8 +17,12 @@ export class AgentCommandsService {
         if (insideSandbox())
             fail("Agent commands change your PC's PATH, so they are set up from your PC, not inside the sandbox.", 'Run sandbox agent-commands on in a terminal on your PC.');
     }
+    /** Your settings as they are on disk now (a switch made a moment ago, here or in Settings, counts). */
+    config() {
+        return loadConfig(this.ctx.loaded.configPath ?? undefined).config;
+    }
     status() {
-        const { config } = this.ctx.loaded;
+        const config = this.config();
         return {
             enabled: config.agentCommands.enabled,
             dir: commandsDir(this.ctx.storageRoot),
@@ -27,7 +31,7 @@ export class AgentCommandsService {
     }
     /** status() that does not block the program (the menu asks while it stays responsive). */
     async statusAsync() {
-        const { config } = this.ctx.loaded;
+        const config = this.config();
         return {
             enabled: config.agentCommands.enabled,
             dir: commandsDir(this.ctx.storageRoot),
@@ -48,6 +52,8 @@ export class AgentCommandsService {
     reconcile(config) {
         if (insideSandbox())
             return null;
-        return reconcileAgentCommands(config, this.ctx.storageRoot, process.execPath, path.join(this.ctx.packageRoot, 'dist', 'bin', 'sandbox.js'));
+        // Under a managed install the forwarding files call its launcher, which keeps working after an update.
+        const installRoot = InstallLayout.detect(this.ctx.packageRoot)?.root ?? null;
+        return reconcileAgentCommands(config, this.ctx.storageRoot, forwardTarget(this.ctx.packageRoot, installRoot, process.execPath));
     }
 }

package/dist/cli/services/vpn-service.d.ts

@@ -1,7 +1,7 @@
 import type { Config } from '../../core/types.js';
 import type { VpnProvider } from '../../core/schema/index.js';
 import type { SecretStore } from '../../host/secrets/index.js';
-import { type LoginState, type VpnCredentials, type VpnLine } from '../../host/vpn/index.js';
+import { type VpnFailureInfo, type LoginState, type VpnCredentials, type VpnLine } from '../../host/vpn/index.js';
 import type { Context } from '../commands/context.js';
 export interface VpnReport {
     readonly enabled: boolean;
@@ -13,6 +13,8 @@ export interface VpnReport {
     readonly loginSavedAt: string | null;
     /** The running sandbox's tunnel, when one runs with the VPN on. */
     readonly running: VpnLine | null;
+    /** The last sandbox's VPN attempt, when it failed (kept after it closed). */
+    readonly lastFailure: VpnFailureInfo | null;
 }
 export declare class VpnService {
     private readonly ctx;
@@ -26,5 +28,7 @@ export declare class VpnService {
     }): Promise<VpnReport>;
     loginState(): LoginState;
     save(credentials: VpnCredentials): void;
+    /** A hint when the login does not look like it belongs to the provider (null when it looks right). */
+    warning(credentials: VpnCredentials): string | null;
     remove(): boolean;
 }

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

@@ -1,5 +1,5 @@
 import { isSandboxRunning } from '../../host/sandbox/index.js';
-import { hostPublicIp, readVpnLine, VpnLogin, } from '../../host/vpn/index.js';
+import { hostPublicIp, loginWarning, readLastFailure, readVpnLine, VpnLogin, } from '../../host/vpn/index.js';
 export class VpnService {
     ctx;
     login;
@@ -25,6 +25,7 @@ export class VpnService {
             killSwitch: c.killSwitch,
             login: this.login.state(c.provider),
             loginSavedAt: this.login.savedAt(c.provider),
+            lastFailure: readLastFailure(this.ctx.storageRoot),
             running: running ? readVpnLine(this.ctx.dataPath, await hostPublicIp()) : null,
         };
     }
@@ -34,6 +35,10 @@ export class VpnService {
     save(credentials) {
         this.login.save(this.provider, credentials);
     }
+    /** A hint when the login does not look like it belongs to the provider (null when it looks right). */
+    warning(credentials) {
+        return loginWarning(credentials, this.provider);
+    }
     remove() {
         return this.login.remove(this.provider);
     }

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

@@ -19,6 +19,11 @@ export declare class App {
     onKey: () => void;
     /** The navigation on the left of every screen (none: no navigation column). */
     nav: () => NavState | undefined;
+    /** Opens another section of the menu (the shell sets it): what a link to a setting or a view does. */
+    goTo: (section: string, where?: {
+        category?: string;
+        search?: string;
+    }) => Promise<void>;
     /** The screens being shown, innermost last: a dialog is drawn over the one below it. */
     private readonly shown;
     private redrawNow;

package/dist/cli/tui/app.js

@@ -25,6 +25,8 @@ export class App {
     onKey = () => undefined;
     /** The navigation on the left of every screen (none: no navigation column). */
     nav = () => undefined;
+    /** Opens another section of the menu (the shell sets it): what a link to a setting or a view does. */
+    goTo = () => Promise.resolve();
     /** The screens being shown, innermost last: a dialog is drawn over the one below it. */
     shown = [];
     redrawNow = null;

package/dist/cli/tui/dialogs/text-screen.js

@@ -100,7 +100,8 @@ export class TextScreen {
         }
         if (key.text) {
             const accept = this.o.accept;
-            const add = [...key.text.replace(/[\r\n]/g, '')].filter((c) => !accept || accept.test(c));
+            // Line breaks and the bracketed-paste markers a terminal wraps around pasted text are not part of the text.
+            const add = [...key.text.replace(/\x1b?\[20[01]~/g, '').replace(/[\r\n]/g, '')].filter((c) => !accept || accept.test(c));
             if (!add.length)
                 return;
             set([...chars.slice(0, this.cursor), ...add, ...chars.slice(this.cursor)], this.cursor + add.length);

package/dist/cli/tui/terminal.js

@@ -119,9 +119,11 @@ export class Terminal {
         });
     }
     push(str, key) {
+        // The markers around a paste (readline names them paste-start / paste-end) carry no text.
+        const marker = key?.name === 'paste-start' || key?.name === 'paste-end';
         const event = {
             name: key?.name ?? '',
-            text: str && !key?.ctrl && !key?.meta && str.length >= 1 && str >= ' ' && str !== '\x7f' ? str : '',
+            text: str && !marker && !key?.ctrl && !key?.meta && str.length >= 1 && str >= ' ' && str !== '\x7f' ? str : '',
             ctrl: Boolean(key?.ctrl),
             meta: Boolean(key?.meta),
             shift: Boolean(key?.shift),

package/dist/core/config/defaults.js

@@ -38,6 +38,14 @@ export const DEFAULTS = {
     network: { blockPrivateRanges: true, allowOnly: [], blockHosts: [], forwardPorts: [], dns: [], proxy: '' },
     vpn: { enabled: false, provider: 'nordvpn', protocol: 'udp', country: '', configFile: '', killSwitch: true },
     github: { shareToken: false },
+    codex: {
+        sandboxMode: 'danger-full-access',
+        approvalPolicy: 'never',
+        model: '',
+        reasoningEffort: 'default',
+        windowsSandbox: 'off',
+        mcpLoginsInFile: true,
+    },
     accounts: {
         epic: { share: false },
         steam: { share: false },
@@ -47,6 +55,8 @@ export const DEFAULTS = {
         play: { share: false },
         expo: { share: false },
         appstore: { share: false },
+        perplexity: { share: false },
+        comet: { share: false },
     },
     pcInstalls: { steamGames: false, epicGames: false, unrealEngines: false, unityEditors: false },
     provisioning: {
@@ -78,6 +88,7 @@ export const DEFAULTS = {
             acceptLicense: false,
             components: [],
             keepInstallFiles: true,
+            visualStudio: 'full',
             persistEngines: true,
             derivedDataCache: 'persisted',
         },
@@ -183,7 +194,7 @@ export const DEFAULTS = {
             npmBin: 'codex',
             arguments: [],
             environment: {},
-            home: { env: { CODEX_HOME: 'codex' }, loginFiles: ['auth.json'], hostDir: '~/.codex' },
+            home: { env: { CODEX_HOME: 'codex' }, loginFiles: ['auth.json', '.credentials.json'], hostDir: '~/.codex' },
             localState: { CODEX_SQLITE_HOME: 'sqlite' },
             // Its own command sandbox keeps local users' passwords sealed with DPAPI: unreadable in the next sandbox
             // ("CryptUnprotectData" on every command), so it sets that sandbox up again at each boot. tmp\arg0: folders

package/dist/core/detect/toolchains.js

@@ -1,3 +1,4 @@
+import { isToolchainReady } from '../../shared/readiness.js';
 import { projectUses } from './versions.js';
 /** Files that show a project uses a language (looked for in the workspace and one folder down). */
 export const MARKERS = {
@@ -84,6 +85,8 @@ export function decideToolchains(settings, entries, pcHas, hints = {}) {
         const setting = settings[name].enabled;
         if (setting !== 'auto')
             return { on: setting, reason: setting ? 'enabled in config' : 'disabled in config' };
+        if (!isToolchainReady(name))
+            return { on: false, reason: 'coming in a later version' };
         const marker = MARKERS[name].map((m) => entries.find((e) => projectUses([e], [m]))).find(Boolean);
         if (marker)
             return { on: true, reason: marker };
@@ -124,9 +127,15 @@ function applyImplications(settings, result) {
         imply(settings, result, 'android', 'React Native builds for Android');
     if (result.godot.on && settings.godot.dotnet === true)
         imply(settings, result, 'dotnet', "Godot's .NET build");
+    if (result.unreal.on && settings.unreal.visualStudio === 'autosdk')
+        imply(settings, result, 'msvc', 'Unreal builds from the portable MSVC (AutoSDK)');
+    // Unreal's licence acceptance covers the MSVC it builds from (the same Visual Studio terms).
+    const autosdkLicence = settings.unreal.visualStudio === 'autosdk' && settings.unreal.acceptLicense;
     for (const name of LICENSED_TOOLCHAINS) {
         if (settings[name].enabled !== 'auto' || !result[name].on || settings[name].acceptLicense)
             continue;
+        if (name === 'msvc' && autosdkLicence)
+            continue;
         result[name] = {
             on: false,
             reason: 'would be used (' + result[name].reason + '); set toolchains.' + name + '.acceptLicense to install it',

package/dist/core/disk.d.ts

@@ -8,11 +8,7 @@ export declare function humanBytes(bytes: number): string;
 export declare function sizeOf(p: string): number;
 /** sizeOf with a time budget: null when measuring would take longer than `ms` (a big data folder can take minutes). */
 export declare function sizeWithin(p: string, ms: number): number | null;
-/**
- * Free bytes on the drive that holds `dir` (which may not exist yet: the nearest existing parent is asked); null if
- * unknown.
- */
-export declare function freeBytesAt(dir: string): number | null;
+export { freeBytesAt } from '../shared/io/disk.js';
 export interface DiskUsage {
     drive: string;
     totalBytes: number;