windows-development-sandbox 1.11.7 → 1.13.0

package/dist/app/features/web/web.run.d.ts

@@ -10,6 +10,9 @@ export declare const webStatusRun: import("../../kernel/define.js").Implementati
     running: import("zod").ZodBoolean;
     port: import("zod").ZodNullable<import("zod").ZodNumber>;
     address: import("zod").ZodNullable<import("zod").ZodString>;
+    lanAddress: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    lanFingerprint: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    lanProblem: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
 }, import("zod/v4/core").$strip>, "web.status">, import("../../../cli/commands/context.js").Context>;
 export declare const startWebRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     port: import("zod").ZodNumber;

package/dist/app/features/web/web.run.js

@@ -60,7 +60,15 @@ export const webStatusRun = implement(webStatus, async (ctx) => {
     requireOnPc('web');
     const { running, state } = await controlOf(ctx).status();
     const port = running && state ? state.port : null;
-    return { running, port, address: port ? 'http://127.0.0.1:' + port + '/' : null };
+    const lan = running ? (state?.lan ?? null) : null;
+    return {
+        running,
+        port,
+        address: port ? 'http://127.0.0.1:' + port + '/' : null,
+        lanAddress: lan?.url ?? null,
+        lanFingerprint: lan?.fingerprint ?? null,
+        lanProblem: lan?.problem ?? null,
+    };
 });
 export const startWebRun = implement(startWeb, async (ctx, _input, io) => {
     requireOnPc('web');
@@ -73,8 +81,8 @@ export const openWebRun = implement(openWeb, async (ctx, _input, io) => {
     const started = await startServer(ctx, io, control);
     if (started.wasRunning)
         io.log(started.message);
-    const { state } = await control.status();
-    if (!state)
+    const { running, state } = await control.status();
+    if (!running || !state)
         return fail('The web UI stopped right away.', 'Run sandbox web start again.');
     openBrowser(control.url(state));
     return { message: 'Opened in your browser.' };

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

@@ -0,0 +1,33 @@
+/** What a definition needs. Default (fails closed): a query needs view, an operation owner. */
+export type Access = 'view' | 'control' | 'owner';
+/** A role the owner can give: view only, or full control (everything but the owner's own things). */
+export type RemoteRole = 'view' | 'control';
+/** Who runs a definition: the owner, or someone the owner let in. */
+export type Caller = {
+    readonly kind: 'owner';
+} | {
+    readonly kind: 'windows';
+    readonly user: string;
+    readonly role: RemoteRole;
+} | {
+    readonly kind: 'device';
+    readonly id: string;
+    readonly name: string;
+    readonly role: RemoteRole;
+};
+export declare const OWNER: Caller;
+/** A definition's need, as written: fixed, or from its input (settings.set on a web.* key needs owner). */
+export type AccessRule = Access | ((input: unknown) => Access);
+/** The most a caller may do. */
+export declare function callerAccess(caller: Caller): Access;
+/** The caller may run something that needs `need`. */
+export declare function allows(caller: Caller, need: Access): boolean;
+/** What a definition needs for this input. A rule that throws on a strange input needs owner. */
+export declare function accessNeeded(def: {
+    readonly kind: 'operation' | 'query';
+    readonly access?: AccessRule;
+}, input: unknown): Access;
+/** Who the caller is, in a few words (the audit log, the page's header). */
+export declare function callerLabel(caller: Caller): string;
+/** The refusal text for a caller that may not. */
+export declare function refusalText(caller: Caller, need: Access): string;

package/dist/app/kernel/access.js

@@ -0,0 +1,44 @@
+// Who may run what (docs/design/remote-access.md): every definition needs view, control or owner; the caller of a run
+// has a role. The owner (at the PC, or through the token link) may do everything; another Windows user of this PC or a
+// paired device has the role the owner gave them, never owner. Pure (the web bundle shows what the role allows).
+export const OWNER = { kind: 'owner' };
+const RANK = { view: 0, control: 1, owner: 2 };
+/** The most a caller may do. */
+export function callerAccess(caller) {
+    return caller.kind === 'owner' ? 'owner' : caller.role;
+}
+/** The caller may run something that needs `need`. */
+export function allows(caller, need) {
+    return RANK[callerAccess(caller)] >= RANK[need];
+}
+/** What a definition needs for this input. A rule that throws on a strange input needs owner. */
+export function accessNeeded(def, input) {
+    const rule = def.access;
+    if (rule === undefined)
+        return def.kind === 'query' ? 'view' : 'owner';
+    if (typeof rule === 'string')
+        return rule;
+    try {
+        return rule(input);
+    }
+    catch {
+        return 'owner';
+    }
+}
+/** Who the caller is, in a few words (the audit log, the page's header). */
+export function callerLabel(caller) {
+    switch (caller.kind) {
+        case 'owner':
+            return 'you';
+        case 'windows':
+            return 'Windows user ' + caller.user;
+        case 'device':
+            return 'device ' + caller.name;
+    }
+}
+/** The refusal text for a caller that may not. */
+export function refusalText(caller, need) {
+    if (need === 'owner')
+        return 'Only the owner of this PC can do that, at the PC.';
+    return callerAccess(caller) === 'view' ? 'Your access is view only.' : 'You may not do that.';
+}

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';
@@ -103,6 +116,15 @@ export interface ViewTabs<P> {
         readonly label: string;
     }[];
 }
+/**
+ * A filter of a view: one parameter picked from fixed values (the audit's kind and period). The web shows a small
+ * choice per filter above the page (changing one keeps the view's other parameters); the command line has the query's
+ * flags for the same thing, and the menu shows the first value. The first value is the default.
+ */
+export interface ViewFilter<P> extends ViewTabs<P> {
+    /** What the choice is about ("Period"), for its label. */
+    readonly label: string;
+}
 export interface ViewDef<Q extends QueryMap = QueryMap, P = Record<string, never>, Id extends string = string> {
     readonly kind: 'view';
     readonly id: Id;
@@ -115,7 +137,9 @@ export interface ViewDef<Q extends QueryMap = QueryMap, P = Record<string, never
     readonly pickers?: readonly QueryDef[];
     /** A parameter switched with tabs above the page (Settings: all projects or this project), first choice default. */
     readonly tabs?: ViewTabs<P>;
-    /** Parameters taken from the address as they are (the log shown), besides the tabs' one. */
+    /** Parameters picked from fixed values above the page (the audit's kind and period), first value default. */
+    readonly filters?: readonly ViewFilter<P>[];
+    /** Parameters taken from the address as they are (the log shown), besides the tabs' and filters' ones. */
     readonly params?: readonly (keyof P & string)[];
     /** The input of each query for these view parameters (default: each query's defaults). */
     inputs?(params: P): ViewInputs<Q>;

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';
@@ -9,13 +10,15 @@ import { addProjectRun, allProjectsRun, chooseProjectsRun, excludeProjectRun, in
 import { checkHealthRun, enableSandboxRun, lastHealthRun, repairHealthRun } from './features/health/index.js';
 import { hideWindowRun, sandboxStatusRun, showWindowRun, stopSandboxRun } from './features/sandbox/index.js';
 import { listLogsRun, tailLogRun } from './features/logs/index.js';
-import { listSessionsRun, restartSessionsRun } from './features/sessions/index.js';
+import { listAuditRun } from './features/audit/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,
@@ -23,6 +26,8 @@ export const IMPLEMENTATIONS = [
     stopSandboxRun,
     listSessionsRun,
     restartSessionsRun,
+    startShellRun,
+    closeSessionRun,
     startAgentRun,
     addAgentRun,
     makeDefaultAgentRun,
@@ -69,6 +74,7 @@ export const IMPLEMENTATIONS = [
     containedOffRun,
     listLogsRun,
     tailLogRun,
+    listAuditRun,
     runUpdateRun,
     migrateSettingsRun,
     updatesStatusRun,
@@ -86,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);
@@ -101,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);
@@ -113,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/args.d.ts

@@ -42,9 +42,6 @@ export interface CliOptions {
     all: boolean;
     /** launch --session <agent>@<folder> (repeatable): several sessions at once, folders made absolute. */
     sessions: SessionWant[];
-    /** audit: only events of this kind, and containing this text. */
-    kind?: string;
-    grep?: string;
     /** migrate --dry-run, and --restore <backup folder>. */
     dryRun: boolean;
     /** doctor --fix: repair what it finds without asking. */

package/dist/cli/args.js

@@ -217,11 +217,10 @@ export function parseCli(argv, wrapper = false) {
         keepOld: Boolean(o.keepOld),
         withPaths: Boolean(o.withPaths),
         all: Boolean(o.all),
-        sessions: (o.session ?? []).map((s) => parseSessionWant(s)),
+        // launch --session is repeatable (a list); `audit --session <id>` is one id, which its definition reads.
+        sessions: (Array.isArray(o.session) ? o.session : []).map((s) => parseSessionWant(s)),
         timeout: o.timeout ?? 600,
-        days: o.days ?? (name === 'audit' ? 1 : 7),
-        kind: o.kind,
-        grep: o.grep,
+        days: o.days ?? 7,
         dryRun: Boolean(o.dryRun),
         fix: Boolean(o.fix),
         auto: o.auto === true,

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

@@ -6,6 +6,6 @@ export { repairCommand } from './repair/index.js';
 export { contextOrDefaults } from './context.js';
 export { attach, db, exec } from './sessions/index.js';
 export { resume } from './resume.js';
-export { audit, claudeHost, config, doctor, hostCommand, logs, migrateBeforeCommand, sync, updatesBeforeCommand, watcher, } from './maintenance/index.js';
+export { claudeHost, config, doctor, hostCommand, logs, migrateBeforeCommand, sync, updatesBeforeCommand, watcher, } from './maintenance/index.js';
 export { agentCommandsCommand, syncAgentCommands } from './agent-commands.js';
 export { HANDLERS, type Handler } from './registry.js';

package/dist/cli/commands/index.js

@@ -6,6 +6,6 @@ export { repairCommand } from './repair/index.js';
 export { contextOrDefaults } from './context.js';
 export { attach, db, exec } from './sessions/index.js';
 export { resume } from './resume.js';
-export { audit, claudeHost, config, doctor, hostCommand, logs, migrateBeforeCommand, sync, updatesBeforeCommand, watcher, } from './maintenance/index.js';
+export { claudeHost, config, doctor, hostCommand, logs, migrateBeforeCommand, sync, updatesBeforeCommand, watcher, } from './maintenance/index.js';
 export { agentCommandsCommand, syncAgentCommands } from './agent-commands.js';
 export { HANDLERS } from './registry.js';

package/dist/cli/commands/launch/prepare.js

@@ -7,7 +7,7 @@ import { RepoGuardStore, readDataSize, saveMarkedProjects } from '../../../host/
 import { ensureConpty, ensureTerminal } from '../../../host/tools/index.js';
 import { planView, viewSkipped, saveActiveViews, WorkspaceView } from '../../../host/workspace-view/index.js';
 import { saveForwards } from '../../../host/network/index.js';
-import { saveAuditSettings } from '../../../host/audit/collect.js';
+import { saveAuditSettings } from '../../../host/audit/index.js';
 import { humanBytes } from '../../../core/disk.js';
 import { syncBeforeLaunch, watcherRunning } from '../../../sync/index.js';
 import { errMsg } from '../../../core/util/index.js';

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

@@ -4,6 +4,5 @@ export * from './config.js';
 export * from './doctor.js';
 export * from './host-claude.js';
 export * from './watch.js';
-export * from './audit.js';
 export * from './migrate.js';
 export * from './update.js';

package/dist/cli/commands/maintenance/index.js

@@ -5,6 +5,5 @@ export * from './config.js';
 export * from './doctor.js';
 export * from './host-claude.js';
 export * from './watch.js';
-export * from './audit.js';
 export * from './migrate.js';
 export * from './update.js';

package/dist/cli/commands/registry.js

@@ -8,13 +8,14 @@ import { containedStatus, showStorage } from '../../app/features/storage/index.j
 import { listProjects } from '../../app/features/projects/index.js';
 import { definitionHandler } from '../operations/index.js';
 import { fail } from '../../core/util/index.js';
-import { audit, claudeHost, config, doctor, hostCommand, logs, sync, watcher } from './maintenance/index.js';
+import { claudeHost, config, doctor, hostCommand, logs, sync, watcher } from './maintenance/index.js';
 import { engine } from './engine.js';
 import { resume } from './resume.js';
 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),
@@ -29,7 +30,6 @@ export const HANDLERS = {
     projects: definitionHandler(listProjects),
     sync: sync,
     logs: logs,
-    audit: audit,
     config: config,
     doctor: doctor,
     setup: setup,
@@ -55,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);
 }