windows-development-sandbox 1.12.0 → 1.13.0

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

@@ -1,6 +1,7 @@
 import type { z } from 'zod';
+import type { AccessRule } from './access.js';
 import type { OperationIO } from './io.js';
-import type { Page } from './view.js';
+import type { Page, Target } from './view.js';
 export type SurfaceName = 'cli' | 'menu' | 'web';
 export declare const SURFACE_NAMES: readonly SurfaceName[];
 /** Where a definition is offered: everywhere, or everywhere but these surfaces (each with the reason). */
@@ -63,6 +64,11 @@ interface Definition<Id extends string, I extends z.ZodType, O extends z.ZodType
     readonly output: O;
     /** Default: every surface. */
     readonly surfaces?: Surfaces;
+    /**
+     * What a caller other than the owner needs (docs/design/remote-access.md). Default (fails closed): view for a query,
+     * owner for an operation; an operation says 'control' to be open to someone the owner gave control.
+     */
+    readonly access?: AccessRule;
     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;
@@ -77,6 +83,13 @@ export interface OperationDef<I extends z.ZodType = z.ZodType, O extends z.ZodTy
     readonly kind: 'operation';
     /** Shown as dangerous (red); it asks for its own confirmation through io.confirm. */
     readonly danger?: boolean;
+    /** Its result must stay on screen until dismissed (a one-time code to type elsewhere): the web keeps it open. */
+    readonly keepResult?: boolean;
+    /**
+     * Where every surface goes once it succeeded: a new session's terminal is attached on the command line and in the
+     * menu, and opened in the web UI.
+     */
+    opens?(output: z.output<O>): Target | undefined;
 }
 export interface QueryDef<I extends z.ZodType = z.ZodType, O extends z.ZodType = z.ZodType, Id extends string = string> extends Definition<Id, I, O> {
     readonly kind: 'query';

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

@@ -1,3 +1,4 @@
+export * from './access.js';
 export * from './define.js';
 export * from './errors.js';
 export * from './fields.js';

package/dist/app/kernel/index.js

@@ -1,5 +1,6 @@
 // The kernel of the shared core: pure (zod and nothing of Node, the terminal or the DOM), so the CLI, the menu, the
 // web server and the browser all import the same definitions, view model, form fields, questions and RPC messages.
+export * from './access.js';
 export * from './define.js';
 export * from './errors.js';
 export * from './fields.js';

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import type { Access, Caller } from './access.js';
 import { type OperationIO } from './io.js';
 /** One call or subscription on the socket (chosen by the browser, unique while it runs). */
 export declare const RpcIdSchema: z.ZodString;
@@ -168,6 +169,8 @@ export interface RpcHost {
     kind(id: string): 'operation' | 'query' | undefined;
     /** How often a query is read again while subscribed (undefined: once). */
     liveMs(id: string): number | undefined;
-    /** Runs an allowed definition (input and output checked). */
-    run(id: string, input: unknown, io: OperationIO): Promise<unknown>;
+    /** What a caller other than the owner needs to run it with this input (undefined: not here). */
+    need(id: string, input: unknown): Access | undefined;
+    /** Runs an allowed definition (input and output checked); refused when `caller` (default: the owner) may not. */
+    run(id: string, input: unknown, io: OperationIO, caller?: Caller): Promise<unknown>;
 }

package/dist/app/registry.d.ts

@@ -6,5 +6,8 @@ export declare function implementationOf(id: string): Implementation<AnyDefiniti
 export declare function runDefinition(id: string, ctx: AppContext, input: unknown, io: OperationIO): Promise<unknown>;
 /** Reads a query in-process (the menu): typed output, and no questions. */
 export declare function readQuery<D extends QueryDef>(def: D, ctx: AppContext, input?: unknown): Promise<OutputOf<D>>;
-/** What the web server may run: the registered definitions whose surfaces include the web. */
+/**
+ * What the web server may run: the registered definitions whose surfaces include the web, each refused to a caller
+ * whose role does not reach what it needs (docs/design/remote-access.md).
+ */
 export declare function createRpcHost(ctx: AppContext): RpcHost;

package/dist/app/registry.js

@@ -1,4 +1,5 @@
-import { invoke, NO_QUESTIONS, onSurface, } from './kernel/index.js';
+import { fail } from '../core/util/errors.js';
+import { accessNeeded, allows, invoke, OWNER, refusalText, 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';
@@ -10,13 +11,14 @@ import { checkHealthRun, enableSandboxRun, lastHealthRun, repairHealthRun } from
 import { hideWindowRun, sandboxStatusRun, showWindowRun, stopSandboxRun } from './features/sandbox/index.js';
 import { listLogsRun, tailLogRun } from './features/logs/index.js';
 import { listAuditRun } from './features/audit/index.js';
-import { listSessionsRun, restartSessionsRun } from './features/sessions/index.js';
+import { closeSessionRun, listSessionsRun, restartSessionsRun, startShellRun } from './features/sessions/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';
+import { accessStatusRun, allowDeviceRun, lanOffRun, lanOnRun, revokeAccessRun, revokeAllAccessRun, } from './features/access/index.js';
 export const IMPLEMENTATIONS = [
     sandboxStatusRun,
     showWindowRun,
@@ -24,6 +26,8 @@ export const IMPLEMENTATIONS = [
     stopSandboxRun,
     listSessionsRun,
     restartSessionsRun,
+    startShellRun,
+    closeSessionRun,
     startAgentRun,
     addAgentRun,
     makeDefaultAgentRun,
@@ -88,6 +92,12 @@ export const IMPLEMENTATIONS = [
     githubLoginRun,
     githubLogoutRun,
     webStatusRun,
+    accessStatusRun,
+    allowDeviceRun,
+    revokeAccessRun,
+    revokeAllAccessRun,
+    lanOnRun,
+    lanOffRun,
 ];
 export function implementationOf(id) {
     return IMPLEMENTATIONS.find((i) => i.def.id === id);
@@ -103,7 +113,10 @@ export function runDefinition(id, ctx, input, io) {
 export async function readQuery(def, ctx, input = {}) {
     return (await runDefinition(def.id, ctx, input, NO_QUESTIONS));
 }
-/** What the web server may run: the registered definitions whose surfaces include the web. */
+/**
+ * What the web server may run: the registered definitions whose surfaces include the web, each refused to a caller
+ * whose role does not reach what it needs (docs/design/remote-access.md).
+ */
 export function createRpcHost(ctx) {
     const allowed = (id) => {
         const impl = implementationOf(id);
@@ -115,10 +128,17 @@ export function createRpcHost(ctx) {
             const def = allowed(id)?.def;
             return def?.kind === 'query' ? def.live?.everyMs : undefined;
         },
-        run: (id, input, io) => {
+        need: (id, input) => {
+            const impl = allowed(id);
+            return impl ? accessNeeded(impl.def, input) : undefined;
+        },
+        run: async (id, input, io, caller = OWNER) => {
             const impl = allowed(id);
             if (!impl)
                 throw new Error('Not allowed on the web: ' + id);
+            const need = accessNeeded(impl.def, input);
+            if (!allows(caller, need))
+                fail(refusalText(caller, need));
             return invoke(impl, ctx, input, io);
         },
     };

package/dist/cli/commands/registry.js

@@ -15,6 +15,7 @@ import { agentCommandsCommand } from './agent-commands.js';
 import { vpn } from './vpn.js';
 import { github } from './github.js';
 import { web, webServer } from './web.js';
+import { remote } from './remote.js';
 export const HANDLERS = {
     launch: (ctx) => launch(ctx),
     generate: (ctx) => launch(ctx, true),
@@ -54,5 +55,6 @@ export const HANDLERS = {
     vpn: vpn,
     github: github,
     web: web,
+    remote: remote,
     _web: webServer,
 };

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

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

package/dist/cli/commands/remote.js

@@ -0,0 +1,49 @@
+// `sandbox remote [user] [--browser]`: another Windows user's program, used from here (docs/design/remote-access.md).
+// Windows sign-in through the owner's pipe gives a one-time token; the menu then runs over the owner's web UI (every
+// action checked against the role the owner gave, and written to their audit log), or --browser opens it signed in.
+import { allows } from '../../app/kernel/index.js';
+import { fail, safeText } from '../../core/util/index.js';
+import { knockOnDoor } from '../../host/remote/index.js';
+import { currentUserName, runningOwner } from '../../host/sharing/index.js';
+import { openBrowser } from '../../host/web/index.js';
+import { RemoteMenu } from '../menu/remote-menu.js';
+import { remoteClient } from '../services/remote-client.js';
+import { App } from '../tui/index.js';
+import { requireOnPc } from './context.js';
+/** Whose program: the user named, else the owner of the running sandbox when it is someone else's. */
+function ownerOf(ctx) {
+    const named = ctx.options.positionals[0];
+    if (named)
+        return { name: named, id: named };
+    const owner = runningOwner();
+    if (owner.kind === 'other')
+        return { name: owner.user, id: owner.record.sid };
+    return fail('Whose web UI? No sandbox of another user is running.', 'Name them: sandbox remote <their Windows user name>');
+}
+export async function remote(ctx) {
+    requireOnPc('remote');
+    const owner = ownerOf(ctx);
+    const answer = await knockOnDoor(ctx.storageRoot, owner.id);
+    if (!answer.ok)
+        return fail(safeText(answer.reason), 'Ask ' +
+            safeText(owner.name) +
+            ' to turn on web.remote.windowsSignIn, add you to web.remote.users and start the web UI.');
+    if (ctx.options.raw.browser === true) {
+        openBrowser('http://127.0.0.1:' + answer.port + '/#w=' + answer.token);
+        console.log('Opened ' + safeText(owner.name) + "'s web UI in your browser (" + answer.role + '). It runs as them, not you.');
+        return 0;
+    }
+    const client = await remoteClient(answer.port, answer.token);
+    const caller = { kind: 'windows', user: currentUserName(), role: answer.role };
+    const app = new App();
+    try {
+        await new RemoteMenu(app, ctx, client, owner.name, caller).start();
+    }
+    finally {
+        app.close();
+        client.close();
+    }
+    if (!allows(caller, 'control'))
+        console.log('You had view access: nothing was changed.');
+    return 0;
+}

package/dist/cli/commands/sessions/reopen.js

@@ -8,6 +8,9 @@ import { c } from '../../output/index.js';
 /** Where each running session is on this PC, so it can be reopened after a restart. */
 export function sessionsToReopen(registry, sessions) {
     return sessions.flatMap((s) => {
+        // Shells are not reopened: a new one would not be the one that ended.
+        if (s.kind === 'shell')
+            return [];
         const project = projectForGuestDir([...registry.projects, ...registry.roots.map((r) => ({ ...r }))], s.cwd);
         return project
             ? [

package/dist/cli/commands/web.js

@@ -3,10 +3,16 @@
 // running when no sandbox does. startWebOnLaunch is the sandbox start's hook.
 import fs from 'node:fs';
 import path from 'node:path';
+import { accessStoreOf } from '../../app/features/access/index.js';
 import { currentServer, START_WAIT_MS, webStatus } from '../../app/features/web/index.js';
 import { createRpcHost } from '../../app/registry.js';
+import { loadConfig } from '../../core/config/index.js';
 import { packageVersion } from '../../core/package-info.js';
 import { sleep, fail } from '../../core/util/index.js';
+import { AuditLog } from '../../host/audit/index.js';
+import { doorPipeName, HostToolsHelper, networkProfile, RemoteGate, TlsStore, } from '../../host/remote/index.js';
+import { SecretStore } from '../../host/secrets/index.js';
+import { currentUserSid } from '../../host/sharing/index.js';
 import { IDLE_EXIT_MS, openBrowser, WebControl, WebRunner, WebStore } from '../../host/web/index.js';
 import { spawnDetached } from '../../host/sandbox/index.js';
 import { WebService } from '../services/index.js';
@@ -53,6 +59,65 @@ export async function startWebOnLaunch(ctx) {
 export async function web(ctx) {
     return (await definitionHandler(webStatus)(ctx)) ?? 0;
 }
+/** The remote settings as in the file now (read again at most every 3 seconds; a broken file keeps the last). */
+function remoteSettings(ctx) {
+    let last = ctx.loaded.config.web.remote;
+    let readAt = Date.now();
+    return () => {
+        if (Date.now() - readAt < 3000)
+            return last;
+        readAt = Date.now();
+        try {
+            last = loadConfig(ctx.options.config).config.web.remote;
+        }
+        catch {
+            // A settings file being edited or broken: keep what was read last.
+        }
+        return last;
+    };
+}
+/** Remote actions go to the audit log of this data set (k: remote), so the Activity page shows who did what. */
+function remoteAudit(ctx) {
+    const { days, maxMb } = ctx.loaded.config.audit;
+    const log = new AuditLog(AuditLog.dirFor(ctx.storageRoot, ctx.dataPath), { days, maxMb });
+    return (entry) => {
+        try {
+            log.append([{ t: new Date().toISOString(), k: 'remote', p: entry.what, a: entry.outcome, au: entry.who }]);
+        }
+        catch {
+            // The audit log is a record, never a reason for a request to fail.
+        }
+    };
+}
+/**
+ * The gate for other Windows users and devices (docs/design/remote-access.md). The Windows helper is started when it
+ * can be built here: then the owner's own cookie is bound to the owner's connections too, and the sign-in pipe is
+ * served (it refuses everyone while web.remote.windowsSignIn is off).
+ */
+function remoteGate(ctx) {
+    const secrets = SecretStore.standard();
+    let ownerSid = '';
+    try {
+        ownerSid = currentUserSid();
+    }
+    catch {
+        // Unknown: Windows sign-in stays off, the owner signs in with the token as before.
+    }
+    const helper = ownerSid ? HostToolsHelper.start(ctx.storageRoot, doorPipeName(ownerSid)) : null;
+    const audit = remoteAudit(ctx);
+    helper?.onProblem((text) => audit({ who: 'the web UI', what: 'Windows sign-in: ' + text, outcome: 'failed' }));
+    const store = new WebStore(ctx.storageRoot);
+    return new RemoteGate({
+        store: accessStoreOf(ctx),
+        settings: remoteSettings(ctx),
+        ownerSid,
+        helper,
+        audit,
+        tls: new TlsStore(store.dir, secrets),
+        profile: (address) => networkProfile(address),
+        port: () => ctx.loaded.config.web.port,
+    });
+}
 /** Body of the background process (`sandbox _web`): runs until stopped. */
 export async function webServer(ctx) {
     const staticRoot = path.join(ctx.packageRoot, 'dist', 'web');
@@ -66,6 +131,7 @@ export async function webServer(ctx) {
         staticRoot,
         version: packageVersion(),
         idleExitMs: IDLE_EXIT_MS,
+        gate: remoteGate(ctx),
     }).run();
     process.exit(0);
 }

package/dist/cli/manifest.d.ts

@@ -769,17 +769,76 @@ declare const COMMAND_LIST: readonly [{
     readonly interactive: true;
 }, {
     readonly name: "web";
-    readonly summary: "(beta) your sandbox sessions in a browser on this PC: start, stop, status or open";
+    readonly summary: "(beta) your sandbox sessions in a browser on this PC (and, if you allow it, on your network)";
     readonly group: "Web";
-    readonly examples: readonly ["sandbox web open               start the web UI and open it in your browser"];
+    readonly examples: readonly ["sandbox web open               start the web UI and open it in your browser", "sandbox web lan-on             let devices you allow use it on your network", "sandbox web allow-device       show a one-time code for a phone", "sandbox web devices            who may use it; sandbox web revoke <id> signs one out"];
     readonly args: readonly [{
         readonly name: "action";
-        readonly description: "start the server, stop it, show whether it runs, or open it in your browser";
+        readonly description: "start, stop, status, open; devices, allow-device, revoke, revoke-all, lan-on, lan-off (remote access)";
         readonly required: false;
         readonly choices: readonly ["start", "stop", "status", "open"];
+    }, {
+        readonly name: "id";
+        readonly description: "(revoke) the device or sign-in id from sandbox web devices";
+        readonly required: false;
+        readonly when: "revoke";
+    }];
+    readonly options: readonly [{
+        flag: string;
+        type: "string" | "number" | "boolean" | "list";
+        description: string;
+        short?: string | undefined;
+        value?: string | undefined;
+        label?: string | undefined;
+        default?: string | number | undefined;
+        choices?: string[] | "harnesses" | "sessions" | "accounts" | undefined;
+        advanced?: boolean | undefined;
+        when?: string | undefined;
+        noMenu?: boolean | undefined;
+        group?: string | undefined;
+        shownAs?: string | undefined;
+    }, {
+        flag: string;
+        type: "string" | "number" | "boolean" | "list";
+        description: string;
+        short?: string | undefined;
+        value?: string | undefined;
+        label?: string | undefined;
+        default?: string | number | undefined;
+        choices?: string[] | "harnesses" | "sessions" | "accounts" | undefined;
+        advanced?: boolean | undefined;
+        when?: string | undefined;
+        noMenu?: boolean | undefined;
+        group?: string | undefined;
+        shownAs?: string | undefined;
     }];
-    readonly options: readonly [];
     readonly json: true;
+}, {
+    readonly name: "remote";
+    readonly summary: "(beta) use another Windows user's web UI from here, signed in with your Windows account";
+    readonly group: "Web";
+    readonly examples: readonly ["sandbox remote                 the menu over the owner of the running sandbox (their program, your role)", "sandbox remote alice --browser open alice's web UI in your browser, signed in"];
+    readonly args: readonly [{
+        readonly name: "user";
+        readonly description: "whose web UI (default: the owner of the running sandbox)";
+        readonly required: false;
+    }];
+    readonly options: readonly [{
+        flag: string;
+        type: "string" | "number" | "boolean" | "list";
+        description: string;
+        short?: string | undefined;
+        value?: string | undefined;
+        label?: string | undefined;
+        default?: string | number | undefined;
+        choices?: string[] | "harnesses" | "sessions" | "accounts" | undefined;
+        advanced?: boolean | undefined;
+        when?: string | undefined;
+        noMenu?: boolean | undefined;
+        group?: string | undefined;
+        shownAs?: string | undefined;
+    }];
+    readonly interactive: true;
 }, {
     readonly name: "_watch";
     readonly summary: "background history sync";

package/dist/cli/manifest.js

@@ -540,20 +540,49 @@ const COMMAND_LIST = [
     },
     {
         name: 'web',
-        summary: '(beta) your sandbox sessions in a browser on this PC: start, stop, status or open',
+        summary: '(beta) your sandbox sessions in a browser on this PC (and, if you allow it, on your network)',
         group: 'Web',
-        examples: ['sandbox web open               start the web UI and open it in your browser'],
+        examples: [
+            'sandbox web open               start the web UI and open it in your browser',
+            'sandbox web lan-on             let devices you allow use it on your network',
+            'sandbox web allow-device       show a one-time code for a phone',
+            'sandbox web devices            who may use it; sandbox web revoke <id> signs one out',
+        ],
         args: [
             {
                 name: 'action',
-                description: 'start the server, stop it, show whether it runs, or open it in your browser',
+                description: 'start, stop, status, open; devices, allow-device, revoke, revoke-all, lan-on, lan-off (remote access)',
                 required: false,
                 choices: ['start', 'stop', 'status', 'open'],
             },
+            {
+                name: 'id',
+                description: '(revoke) the device or sign-in id from sandbox web devices',
+                required: false,
+                when: 'revoke',
+            },
+        ],
+        options: [
+            text('--role', 'view|control', '(allow-device) what the device may do (default view)', {
+                when: 'allow-device',
+                choices: ['view', 'control'],
+            }),
+            bool('--yes', '(revoke-all, lan-off) do not ask first', { short: '-y', noMenu: true }),
         ],
-        options: [],
         json,
     },
+    {
+        name: 'remote',
+        summary: "(beta) use another Windows user's web UI from here, signed in with your Windows account",
+        group: 'Web',
+        examples: [
+            'sandbox remote                 the menu over the owner of the running sandbox (their program, your role)',
+            "sandbox remote alice --browser open alice's web UI in your browser, signed in",
+        ],
+        args: [{ name: 'user', description: 'whose web UI (default: the owner of the running sandbox)', required: false }],
+        options: [bool('--browser', 'open it in your browser instead of the menu')],
+        interactive: true,
+    },
     { name: '_watch', summary: 'background history sync', group: 'Data', args: [], options: [], hidden: true },
     {
         name: '_web',

package/dist/cli/menu/io-menu.d.ts

@@ -1,4 +1,4 @@
-import { type Action, type AnyDefinition } from '../../app/kernel/index.js';
+import { type Action, type AnyDefinition, type OperationIO } from '../../app/kernel/index.js';
 import type { Context } from '../commands/context.js';
 import { type App } from '../tui/index.js';
 import type { ShellExit } from './shell.js';
@@ -12,10 +12,12 @@ export interface Performed {
     readonly notice?: string;
     readonly reload?: boolean;
 }
+/** How a definition is run: in this process (the menu), or on the owner's web UI (sandbox remote). */
+export type DefinitionRunner = (id: string, input: unknown, io: OperationIO) => Promise<unknown>;
 export declare class MenuOperations {
     private readonly app;
-    private readonly ctx;
-    constructor(app: App, ctx: Context);
+    private readonly runner;
+    constructor(app: App, ctx: Context, runner?: DefinitionRunner);
     /** Does what an action of a page says: follows a link, or asks for its fields and runs its operation. */
     perform(action: Action, where: Where, busy?: ShowBusy, onOutput?: (output: unknown) => void): Promise<Performed>;
     /** The values of an action's fields, from the editors that fit them (undefined: one was backed out of). */

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

@@ -66,10 +66,10 @@ function follow(target) {
 }
 export class MenuOperations {
     app;
-    ctx;
-    constructor(app, ctx) {
+    runner;
+    constructor(app, ctx, runner = (id, input, io) => runDefinition(id, ctx, input, io)) {
         this.app = app;
-        this.ctx = ctx;
+        this.runner = runner;
     }
     /** Does what an action of a page says: follows a link, or asks for its fields and runs its operation. */
     async perform(action, where, busy, onOutput) {
@@ -81,7 +81,14 @@ export class MenuOperations {
         const answers = await this.fields(action, def, where);
         if (!answers)
             return {};
-        return { reload: true, notice: await this.run(def, { ...action.input, ...answers }, where, busy, onOutput) };
+        // An operation that opens a session's terminal (a new shell) leaves the menu to attach to it.
+        let opened;
+        const notice = await this.run(def, { ...action.input, ...answers }, where, busy, (output) => {
+            onOutput?.(output);
+            opened = def.kind === 'operation' ? def.opens?.(output) : undefined;
+        });
+        const exit = opened ? follow(opened).exit : undefined;
+        return { reload: true, notice, ...(exit ? { exit } : {}) };
     }
     /** The values of an action's fields, from the editors that fit them (undefined: one was backed out of). */
     async fields(action, def, where) {
@@ -110,7 +117,7 @@ export class MenuOperations {
             log: (text, tone) => said.push(tone === 'warn' || tone === 'danger' ? Theme.warn(text) : text),
         });
         try {
-            const output = await runDefinition(def.id, this.ctx, input, io);
+            const output = await this.runner(def.id, input, io);
             onOutput?.(output);
             // The notice is one line: an operation that says several lines (accounts use) runs them together.
             const text = def.text?.(output)?.replace(/\n+/g, ' ');

package/dist/cli/menu/remote-menu.d.ts

@@ -0,0 +1,19 @@
+import { type AnyView, type Caller } from '../../app/kernel/index.js';
+import type { Context } from '../commands/context.js';
+import type { RemoteClient } from '../services/remote-client.js';
+import { type App } from '../tui/index.js';
+/** The views of the owner's program this role may open (remote access itself is the owner's). */
+export declare function remoteViews(role: Caller): AnyView[];
+export declare class RemoteMenu {
+    private readonly app;
+    private readonly client;
+    private readonly owner;
+    private readonly caller;
+    private readonly operations;
+    constructor(app: App, ctx: Context, client: RemoteClient, owner: string, caller: Caller);
+    private title;
+    /** The list of areas, until Esc. */
+    start(): Promise<void>;
+    private page;
+    private showView;
+}

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

@@ -0,0 +1,108 @@
+// `sandbox remote`: the menu drawn over another Windows user's program (docs/design/remote-access.md). Every view the
+// web UI has is drawn by the menu's own renderer (menuView) from the shared core's pure definitions; its queries and
+// operations run on the owner's web UI over the RPC socket, which checks the role this user was given and writes each
+// action to the owner's audit log. Nothing here runs on this user's own settings or data.
+import { NAV, navViews, viewById } from '../../app/features/defs.js';
+import { NO_QUESTIONS, allows, viewInputs, } from '../../app/kernel/index.js';
+import { errMsg, safeText } from '../../core/util/index.js';
+import { Theme } from '../tui/index.js';
+import { MenuOperations } from './io-menu.js';
+import { menuView } from './render-view.js';
+/** The views of the owner's program this role may open (remote access itself is the owner's). */
+export function remoteViews(role) {
+    return navViews(NAV)
+        .map((id) => viewById(id))
+        .filter((v) => v !== undefined)
+        .filter((v) => Object.values(v.queries).every((q) => allows(role, q.access ?? 'view')));
+}
+export class RemoteMenu {
+    app;
+    client;
+    owner;
+    caller;
+    operations;
+    constructor(app, ctx, client, owner, caller) {
+        this.app = app;
+        this.client = client;
+        this.owner = owner;
+        this.caller = caller;
+        this.operations = new MenuOperations(app, ctx, (id, input, io) => client.run(id, input, io));
+    }
+    title() {
+        return safeText(this.owner) + "'s sandbox";
+    }
+    /** The list of areas, until Esc. */
+    async start() {
+        const views = remoteViews(this.caller);
+        const role = this.caller.kind === 'owner' ? 'owner' : this.caller.role;
+        let at;
+        for (;;) {
+            const picked = await this.app.list({
+                path: [this.title()],
+                intro: [
+                    'You are using ' + safeText(this.owner) + "'s program with the role " + role + '.',
+                    'What you do runs as ' + safeText(this.owner) + ' and is written to their audit log.',
+                ],
+                items: views.map((v) => ({ value: v.id, label: v.title, description: v.summary })),
+                startAt: at,
+                escapeLabel: 'quit',
+                enterLabel: 'open',
+            });
+            if (picked.kind !== 'pick')
+                return;
+            at = picked.value;
+            const view = views.find((v) => v.id === picked.value);
+            if (view)
+                await this.showView(view);
+        }
+    }
+    async page(view) {
+        const inputs = viewInputs(view, {});
+        const data = {};
+        for (const [name, query] of Object.entries(view.queries))
+            data[name] = await this.client.run(query.id, inputs[name], NO_QUESTIONS);
+        return view.build(data, {});
+    }
+    async showView(view) {
+        let notice;
+        for (;;) {
+            let page;
+            try {
+                page = await this.page(view);
+            }
+            catch (e) {
+                await this.app.message({ path: [this.title(), view.title], lines: [safeText(errMsg(e))], tone: 'error' });
+                return;
+            }
+            const mv = menuView(page);
+            const result = await this.app.list({
+                path: [this.title(), view.title],
+                intro: page.notice ? [safeText(page.notice.text)] : undefined,
+                items: mv.items,
+                actions: mv.actions,
+                enterLabel: mv.enterLabel,
+                notice,
+                empty: page.empty?.text,
+            });
+            if (result.kind === 'back')
+                return;
+            const chosen = mv.resolve(result);
+            notice = undefined;
+            if (!chosen || chosen.kind === 'refresh')
+                continue;
+            const action = chosen.action;
+            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('That opens on ' + safeText(this.owner) + "'s side only.");
+                continue;
+            }
+            const done = await this.operations.perform(action, [this.title(), view.title], (text) => {
+                notice = text;
+                this.app.redraw();
+            });
+            notice = done.notice;
+        }
+    }
+}