@ours.network/fleet 1.2.0-nightly.7 → 1.2.0-nightly.70

package/dist/web/prefix-gateway.js

@@ -0,0 +1,238 @@
+import { randomUUID } from 'node:crypto';
+import { WorkspaceDeviceAuthError } from './workspace-devices.js';
+import { createServer, request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+/** The App offers exactly these two subprotocols; only the marker is ever answered or forwarded. */
+const DEVICE_SOCKET_PROTOCOL = 'ours.workspace.v1';
+const DEVICE_SOCKET_BEARER = 'ours.workspace.bearer.';
+/** The device credential a WebSocket offered as a subprotocol; undefined when it offered none of ours. */
+function deviceSocketCredential(req) {
+    const offered = String(req.headers['sec-websocket-protocol'] ?? '').split(',').map(value => value.trim()).filter(Boolean);
+    if (!offered.some(value => value === DEVICE_SOCKET_PROTOCOL || value.startsWith(DEVICE_SOCKET_BEARER)))
+        return undefined;
+    const credentials = offered.filter(value => value.startsWith(DEVICE_SOCKET_BEARER));
+    const token = credentials[0]?.slice(DEVICE_SOCKET_BEARER.length) ?? '';
+    if (offered.length !== 2 || credentials.length !== 1 || !offered.includes(DEVICE_SOCKET_PROTOCOL) || !/^[A-Za-z0-9_.-]{16,256}$/.test(token))
+        throw new Error('invalid workspace socket subprotocol');
+    return token;
+}
+const hopHeaders = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade']);
+function headersFor(message) {
+    const denied = new Set([...hopHeaders, ...(message.headers.connection ?? '').split(',').map(x => x.trim().toLowerCase())]);
+    return Object.fromEntries(Object.entries(message.headers).filter(([key]) => !denied.has(key)));
+}
+/** Raw transport deliberately runs outside Fastify's JSON parser and body limits. */
+export function createPrefixGateway(options) {
+    const auth = options.auth === 'backend' ? undefined : options.auth;
+    let auditWindow = Date.now(), auditCount = 0;
+    const rejected = (requestId, prefix, result) => {
+        if (Date.now() - auditWindow >= 60_000) {
+            auditWindow = Date.now();
+            auditCount = 0;
+        }
+        if (auditCount++ >= 60)
+            return;
+        void options.audit?.record({ requestId, action: 'gateway' + prefix.replaceAll('/', '.'), result, errorCode: 'unauthorized' }).catch(() => { });
+    };
+    const services = options.services.map(target => {
+        if (!/^\/[a-z][a-z0-9-]*$/.test(target.prefix) || target.prefix === '/fleet')
+            throw new Error('invalid service prefix');
+        const origin = new URL(target.origin);
+        if (target.upstreamPrefix && !/^\/(?:[A-Za-z0-9_-]+\/)*[A-Za-z0-9_-]*$/.test(target.upstreamPrefix))
+            throw new Error('invalid upstream service prefix');
+        if (!['http:', 'https:'].includes(origin.protocol) || origin.pathname !== '/' || origin.search || origin.hash || origin.username || origin.password)
+            throw new Error('service target must be an HTTP origin');
+        return { ...target, origin: origin.origin };
+    });
+    if (new Set(services.map(x => x.prefix)).size !== services.length)
+        throw new Error('duplicate service prefix');
+    const select = (req) => {
+        const raw = req.url ?? '/';
+        if (!raw.startsWith('/') || raw.startsWith('//'))
+            throw new Error('invalid request target');
+        const path = raw.split('?')[0];
+        const service = services.find(x => path === x.prefix || path.startsWith(x.prefix + '/'));
+        const fleet = path === '/fleet/api' || path.startsWith('/fleet/api/');
+        return { service, origin: service?.origin ?? options.fleetOrigin,
+            path: service ? (service.upstreamPrefix || '') + (raw.slice(service.prefix.length) || '/').replace(/^\?/, '/?') : fleet ? raw.slice('/fleet'.length) : raw };
+    };
+    const prepare = (req, upgrade = false) => {
+        const route = select(req);
+        // The device credential of an App WebSocket: accepted only on an upgrade, from the exact
+        // account origin, on a path the service declares, and never beside another credential.
+        const socketCredential = upgrade && auth ? deviceSocketCredential(req) : undefined;
+        if (socketCredential !== undefined) {
+            const path = route.service ? (req.url ?? '/').split('?')[0].slice(route.service.prefix.length) : undefined;
+            if (!route.service?.deviceSocketPaths?.includes(path ?? '') || req.headers.authorization !== undefined || req.headers.cookie !== undefined
+                || !req.headers.origin || auth.accountOrigin(req) !== req.headers.origin)
+                throw new Error('workspace socket credential is not accepted here');
+        }
+        // Authentication sees the credential as the bearer it is; the request's own headers are untouched.
+        const authHeaders = socketCredential !== undefined ? { ...req.headers, authorization: `Bearer ${socketCredential}` } : req.headers;
+        const request = { headers: authHeaders, method: req.method, url: route.path };
+        if (!auth && (req.headers.origin || req.headers['sec-fetch-site'] || !route.service))
+            throw new Error('machine-client listener rejects browser requests');
+        auth?.validateBoundary(request, upgrade);
+        const session = route.service && auth ? auth.authenticate(request, !upgrade && !['GET', 'HEAD', 'OPTIONS'].includes(req.method ?? 'GET')) : undefined;
+        const headers = headersFor(req);
+        // Forward only the explicit browser context, never an attacker-selected forwarding chain.
+        for (const key of Object.keys(headers))
+            if (key.startsWith('x-forwarded-') || key === 'forwarded')
+                delete headers[key];
+        delete headers['x-ours-workspace-auth'];
+        delete headers['x-ours-request-id'];
+        if (route.service) {
+            if (auth)
+                for (const name of ['cookie', 'authorization', 'x-csrf-token', 'x-ours-api-token'])
+                    delete headers[name];
+            // The server gateway lets this header choose a producer credential; only machine producers send it directly there.
+            delete headers['x-ours-notifications-producer'];
+            if (route.service.stripBrowserContext) {
+                for (const name of ['origin', 'sec-fetch-site', 'sec-fetch-mode', 'sec-fetch-dest', 'sec-fetch-user'])
+                    delete headers[name];
+            }
+            Object.assign(headers, route.service.headers);
+            headers.host = new URL(route.origin).host;
+        }
+        if (upgrade) {
+            headers.connection = 'Upgrade';
+            headers.upgrade = 'websocket';
+        }
+        // The credential subprotocol ends here: the service is not offered it, on any request.
+        if (socketCredential !== undefined || String(headers['sec-websocket-protocol'] ?? '').includes(DEVICE_SOCKET_BEARER))
+            delete headers['sec-websocket-protocol'];
+        return { ...route, headers, session, authHeaders, deviceSocket: socketCredential !== undefined };
+    };
+    const track = (authHeaders, session, close) => {
+        if (!session)
+            return () => { };
+        // The session authenticated for this request, with its own deadline, not whatever is current later.
+        const unbind = auth.bindTransport(session, close);
+        const timer = setInterval(() => { try {
+            auth.authenticate({ headers: authHeaders });
+        }
+        catch {
+            close();
+        } }, 30_000);
+        timer.unref();
+        return () => { clearInterval(timer); unbind(); };
+    };
+    // The account App calls workspace services directly from its own origin with a device
+    // credential. Only that exact configured origin is answered; the reply grants nothing by
+    // itself, every request is still authenticated below.
+    const accountCors = (req) => {
+        const origin = auth?.accountOrigin(req);
+        return origin ? { 'access-control-allow-origin': origin, vary: 'Origin',
+            'access-control-expose-headers': 'Accept-Ranges, Content-Disposition, Content-Length, Content-Range, Content-Type, ETag, X-Ours-Workspace-Auth, X-Ours-Request-Id' } : {};
+    };
+    const server = createServer((req, res) => {
+        const cors = accountCors(req);
+        const requestId = randomUUID();
+        let route;
+        try {
+            if (req.method === 'OPTIONS' && cors.vary && req.headers['access-control-request-method'] && select(req).service) {
+                auth.validateBoundary({ headers: req.headers, method: req.method, url: req.url }, false);
+                res.writeHead(204, { ...cors, 'cache-control': 'no-store', 'access-control-max-age': '600',
+                    'access-control-allow-methods': 'GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS',
+                    'access-control-allow-headers': 'Authorization, Content-Type, Idempotency-Key, If-None-Match, Range, X-CSRF-Token, X-Ours-Messenger-CSRF, X-Voice-Duration' });
+                res.end();
+                return;
+            }
+            route = prepare(req);
+        }
+        catch (error) {
+            const code = error.code;
+            const deviceRejected = error instanceof WorkspaceDeviceAuthError;
+            if (code === 'unauthorized')
+                rejected(requestId, '/auth', deviceRejected ? 'device_rejected' : 'gateway_rejected');
+            res.writeHead(code === 'unauthorized' ? 401 : 403, { ...cors, 'content-type': 'application/json', 'cache-control': 'no-store',
+                ...(code === 'unauthorized' ? { 'x-ours-request-id': requestId } : {}),
+                ...(deviceRejected ? { 'x-ours-workspace-auth': 'rejected' } : {}) });
+            res.end(JSON.stringify({ error: { code: code ?? 'forbidden', message: error.message } }));
+            return;
+        }
+        const upstream = (route.origin.startsWith('https:') ? httpsRequest : httpRequest)(route.origin, {
+            method: req.method, path: route.path, headers: route.headers,
+        }, response => {
+            const headers = headersFor(response);
+            if (route.service) {
+                delete headers['set-cookie'];
+                // Only Fleet may assert device rejection; never trust a service's marker or correlation id.
+                delete headers['x-ours-workspace-auth'];
+                delete headers['x-ours-request-id'];
+                if (response.statusCode === 401) {
+                    headers['x-ours-request-id'] = requestId;
+                    headers['x-ours-workspace-auth'] = 'service';
+                    rejected(requestId, route.service.prefix, 'upstream_401');
+                }
+                for (const key of Object.keys(headers))
+                    if (key.startsWith('access-control-'))
+                        delete headers[key];
+                Object.assign(headers, cors);
+            }
+            res.writeHead(response.statusCode ?? 502, headers);
+            // Streaming headers, including exact-origin CORS and upstream errors,
+            // must reach the client before the first event or body byte arrives.
+            res.flushHeaders();
+            response.on('error', () => res.destroy());
+            response.on('aborted', () => res.destroy());
+            response.on('close', () => { if (!response.complete)
+                res.destroy(); });
+            response.pipe(res);
+            res.on('close', () => response.destroy());
+        });
+        upstream.on('error', () => {
+            if (!res.headersSent)
+                res.writeHead(502, { ...(route.service ? cors : {}), 'content-type': 'application/json' });
+            res.end(JSON.stringify({ error: { code: 'upstream_unavailable', message: 'Service is unavailable' } }));
+        });
+        const untrack = track(route.authHeaders, route.session, () => { upstream.destroy(); res.destroy(); });
+        res.on('close', untrack);
+        req.on('aborted', () => upstream.destroy());
+        res.on('close', () => upstream.destroy());
+        req.pipe(upstream);
+    });
+    const sockets = new Set();
+    server.on('connection', socket => { sockets.add(socket); socket.on('close', () => sockets.delete(socket)); });
+    server.on('upgrade', (req, socket, head) => {
+        let route;
+        try {
+            route = prepare(req, true);
+        }
+        catch {
+            socket.end('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
+            return;
+        }
+        const upstream = (route.origin.startsWith('https:') ? httpsRequest : httpRequest)(route.origin, {
+            method: req.method, path: route.path, headers: route.headers,
+        });
+        upstream.on('upgrade', (response, peer, upstreamHead) => {
+            const headers = headersFor(response);
+            headers.connection = 'Upgrade';
+            headers.upgrade = 'websocket';
+            delete headers['set-cookie'];
+            // A browser that offered subprotocols needs one answered; only the marker, never the credential.
+            if (route.deviceSocket)
+                headers['sec-websocket-protocol'] = DEVICE_SOCKET_PROTOCOL;
+            socket.write(`HTTP/1.1 101 Switching Protocols\r\n${Object.entries(headers).flatMap(([k, v]) => (Array.isArray(v) ? v : [v]).map(value => `${k}: ${value}\r\n`)).join('')}\r\n`);
+            if (head.length)
+                peer.write(head);
+            if (upstreamHead.length)
+                socket.write(upstreamHead);
+            const untrack = track(route.authHeaders, route.session, () => { peer.destroy(); socket.destroy(); });
+            socket.on('close', untrack);
+            peer.pipe(socket);
+            socket.pipe(peer);
+            peer.on('error', () => socket.destroy());
+            socket.on('error', () => peer.destroy());
+            socket.on('close', () => peer.destroy());
+            peer.on('close', () => socket.destroy());
+        });
+        upstream.on('response', response => { socket.end(`HTTP/1.1 ${response.statusCode ?? 502} Rejected\r\nConnection: close\r\n\r\n`); response.destroy(); });
+        upstream.on('error', () => socket.destroy());
+        socket.on('close', () => upstream.destroy());
+        upstream.end();
+    });
+    return { server, async close() { for (const socket of sockets)
+            socket.destroy(); await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve())); } };
+}

package/dist/web/runtime.d.ts

@@ -2,8 +2,10 @@ import { type WebServer } from './server.js';
 import { type WebAccessConfig } from './access.js';
 export interface StartWebOptions {
     configPath?: string;
+    /** Separate console state for an independently launched gateway. */
+    webStateDir?: string;
+    control?: boolean;
     port?: number;
-    open?: boolean;
     binPath: string;
     log?(line: string): void;
     bind?: string;

package/dist/web/runtime.js

@@ -1,5 +1,17 @@
-import { spawn } from 'node:child_process';
-import { existsSync, realpathSync } from 'node:fs';
+import { ConversationRoleObserver } from '../application/conversation-role-observer.js';
+import { replaceFileAtomically } from '../atomic-file.js';
+import { validateAccountOrigin } from '../account-origin.js';
+import { startWorkspaceTunnel } from './workspace-tunnel.js';
+import { createPrefixGateway } from './prefix-gateway.js';
+import { readClientProfile } from '../client-profile.js';
+import { readPrivateFile } from '@ours.network/sdk/connector';
+import { LayoutBindingGrants } from '../rooms-tasks/layout-binding-grants.js';
+import { RoomLayoutService } from '../rooms-tasks/layout-service.js';
+import { FleetNotificationProducer } from '../notifications/fleet-producer.js';
+import { producerConfig } from '../notifications/outbox.js';
+import { SubscriptionService } from '../subscriptions/service.js';
+import { createCodexModelDiscovery } from '../application/codex-models.js';
+import { existsSync, mkdirSync, realpathSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { loadConfig } from '../config.js';
 import { RoleRepository } from '../application/role-repository.js';
@@ -13,7 +25,8 @@ import { FleetError } from '../application/errors.js';
 import { controlRequest, controlSocketPath } from '../session/control.js';
 import { pickBackend } from '../supervisor/index.js';
 import { realExec } from '../exec.js';
-import { home, stateRoot } from '../paths.js';
+import { home, stateRoot, agentsRoot, tmpRoot, logsRoot } from '../paths.js';
+import { executeInitAnswers, publishSetup } from '../init-wizard.js';
 import { AuditSink } from './audit.js';
 import { FleetEventBus } from './events.js';
 import { buildWebServer } from './server.js';
@@ -21,8 +34,11 @@ import { FleetConfigService } from './fleet-config-service.js';
 import { mergeTopology } from './topology-model.js';
 import { TopologyDraftStore } from './topology-draft-store.js';
 import { TopologyPromoteService } from './topology-promote.js';
+import { RoomLayoutDefinitions } from '../application/room-layout-definitions.js';
+import { PresetProvenance } from '../application/preset-provenance.js';
 import { doctor } from '../doctor.js';
 import { acquireWebServerLock } from './lock.js';
+import { WorkspaceDeviceStore } from './workspace-devices.js';
 import { TrustedDeviceStore } from './device-store.js';
 import { WebAuth } from './auth.js';
 import { startWebControlServer } from './control.js';
@@ -47,19 +63,31 @@ function cachedConfigProvider(configPath) {
     };
 }
 export async function startWebConsole(options) {
-    const requestedPort = options.port ?? 49_271;
+    const notificationConfig = producerConfig(process.env, undefined, options.log);
+    let requestedPort = options.port ?? 49_271;
     if (!Number.isInteger(requestedPort) || requestedPort < 0 || requestedPort > 65_535)
         throw new FleetError('invalid_request', 'port must be between 0 and 65535');
-    const lock = acquireWebServerLock();
-    const webDir = resolve(stateRoot(), 'web');
+    const webDir = options.webStateDir ?? resolve(stateRoot(), 'web');
+    const lock = acquireWebServerLock(webDir);
     const bind = options.bind ?? '127.0.0.1';
     const publicOrigin = options.publicOrigin ? validatePublicOrigin(options.publicOrigin) : undefined;
+    const workspaceGateway = Boolean(publicOrigin && existsSync(resolve(stateRoot(), 'workspace', 'binding.json')));
     if (!isLoopback(bind) && !publicOrigin) {
         lock.release();
         throw new FleetError('forbidden', 'a non-loopback bind requires an explicit --public-origin');
     }
     const access = options.access ?? new WebAccessStore(webDir).read();
-    const auth = new WebAuth(publicOrigin?.origin ?? `http://127.0.0.1:${requestedPort}`, publicOrigin?.host ?? `127.0.0.1:${requestedPort}`, Date.now, new TrustedDeviceStore(webDir), access);
+    const bindingFile = resolve(stateRoot(), 'workspace', 'binding.json');
+    let appOrigin = 'https://app.ours.network';
+    try {
+        if (existsSync(bindingFile))
+            appOrigin = validateAccountOrigin(JSON.parse(readFileSync(bindingFile, 'utf8')).appOrigin ?? appOrigin);
+    }
+    catch (error) {
+        lock.release();
+        throw error;
+    }
+    const auth = new WebAuth(publicOrigin?.origin ?? `http://127.0.0.1:${requestedPort}`, publicOrigin?.host ?? `127.0.0.1:${requestedPort}`, Date.now, new TrustedDeviceStore(webDir), access, new WorkspaceDeviceStore(webDir), appOrigin);
     const backend = pickBackend();
     const repository = new RoleRepository({
         configPath: options.configPath,
@@ -83,6 +111,13 @@ export async function startWebConsole(options) {
         },
     });
     const events = new FleetEventBus();
+    const roleMutations = new Set();
+    const signalRoleMutation = () => { for (const listener of roleMutations)
+        listener(); };
+    const observeRole = (roleId, listener) => new ConversationRoleObserver({
+        roleId, configPath: options.configPath,
+        subscribeMutations: changed => { roleMutations.add(changed); return () => { roleMutations.delete(changed); }; },
+    }, listener);
     const audit = new AuditSink();
     const watchdogConfigProvider = cachedConfigProvider(options.configPath);
     const log = options.log ?? (() => { });
@@ -122,6 +157,7 @@ export async function startWebConsole(options) {
                 ? 'ready' : detail?.status.overall === 'attention' ? 'attention' : 'unknown';
         },
         onProgress: action => {
+            signalRoleMutation();
             events.publish('creation.changed', action, action.roleId);
             void audit.record({
                 roleId: action.roleId, action: `creation.${action.state}`,
@@ -137,6 +173,7 @@ export async function startWebConsole(options) {
         repository, ops, configPath: options.configPath,
         status: async (roleId) => (await query.detail(roleId)).status,
         onProgress: receipt => {
+            signalRoleMutation();
             events.publish('action.changed', receipt, receipt.roleId);
             void audit.record({
                 roleId: receipt.roleId, action: `lifecycle.${receipt.action}`,
@@ -158,9 +195,30 @@ export async function startWebConsole(options) {
     let server;
     try {
         server = await buildWebServer({
-            query, repository, logs, commands, creation, removal, audit, events, watchdogs, configuration,
-            taskRooms: new TaskRoomApplicationService(options.configPath),
+            query, repository, logs, commands, creation, removal, audit, events, watchdogs, configuration, observeRole,
+            taskRooms: new TaskRoomApplicationService(options.configPath, { binPath: () => options.binPath }),
+            roomLayouts: new RoomLayoutDefinitions(options.configPath),
+            layoutBindings: new LayoutBindingGrants(new RoomLayoutService(options.configPath).supervisor()),
+            presetProvenance: new PresetProvenance(options.configPath),
             topology: readTopology, topologyDrafts, topologyPromote,
+            // Same boundary as `ours-fleet init --settings`: existing files are preserved, missing defaults are added.
+            onboardingSetup: async (answers) => {
+                await executeInitAnswers(answers, configuration.path, {
+                    async hostSetup() {
+                        for (const directory of [agentsRoot(), tmpRoot(), logsRoot()])
+                            mkdirSync(directory, { recursive: true });
+                        await pickBackend().init(options.binPath);
+                    },
+                    publish: publishSetup,
+                });
+            },
+            codexModels: createCodexModelDiscovery(),
+            subscriptions: new SubscriptionService({
+                agents: async () => (await query.list(true)).map(({ role, status }) => ({
+                    roleId: role.id, stateDir: repository.stateDir(role), running: status.supervisor.liveness === 'running',
+                })),
+                onChange: () => events.publish('subscription.changed', {}),
+            }),
             async session(roleId) {
                 const role = await repository.get(roleId);
                 if (!role)
@@ -170,7 +228,7 @@ export async function startWebConsole(options) {
                     const dir = repository.stateDir(role);
                     if (!dir)
                         throw new FleetError('control_unavailable', 'role state directory is unavailable');
-                    return new RoleSessionControlAdapter(dir);
+                    return new RoleSessionControlAdapter(dir, undefined, undefined, listener => observeRole(roleId, listener));
                 }
                 throw new FleetError('capability_unavailable', 'role session backend is unavailable');
             },
@@ -182,7 +240,7 @@ export async function startWebConsole(options) {
     }
     let address;
     try {
-        address = await server.app.listen({ host: bind, port: requestedPort });
+        address = await server.app.listen({ host: workspaceGateway ? '127.0.0.1' : bind, port: workspaceGateway ? 0 : requestedPort });
     }
     catch (error) {
         await server.close();
@@ -193,39 +251,84 @@ export async function startWebConsole(options) {
     const localHost = `127.0.0.1:${actual.port}`;
     const browserOrigin = publicOrigin?.origin ?? `http://${localHost}`;
     const browserHost = publicOrigin?.host ?? localHost;
+    let gateway;
+    if (workspaceGateway)
+        try {
+            const profile = readClientProfile(), provider = new URL(profile.serverUrl), credential = readPrivateFile(profile.credentialPath, 4096).toString('utf8').trim();
+            const basePath = provider.pathname.replace(/\/$/, '');
+            const services = ['daemon', 'cowork', 'messenger', 'notifications'].map(name => ({ prefix: '/' + name, origin: provider.origin, upstreamPrefix: basePath + '/' + name, stripBrowserContext: true, headers: { 'X-Ours-Api-Token': credential, ...(name === 'messenger' ? { Origin: provider.origin, 'X-Ours-Messenger-CSRF': '1' } : name === 'cowork' ? { Origin: provider.origin } : {}) },
+                // The App reports a visible page to the notification service, so an open app is not sent a push.
+                ...(name === 'notifications' ? { deviceSocketPaths: ['/api/v1/presence'] } : {}) }));
+            gateway = createPrefixGateway({ auth: server.auth, fleetOrigin: address, services, audit });
+            const listen = (port) => new Promise((resolve, reject) => { gateway.server.once('error', reject); gateway.server.listen(port, bind, () => { gateway.server.off('error', reject); resolve(); }); });
+            try {
+                await listen(requestedPort);
+            }
+            catch (error) {
+                const selection = resolve(webDir, 'port-selection.json');
+                if (error.code !== 'EADDRINUSE' || !existsSync(selection) || JSON.parse(readPrivateFile(selection, 4096).toString()).expiresAt <= Date.now())
+                    throw error;
+                await listen(0);
+            }
+            const bound = gateway.server.address();
+            if (!bound || typeof bound === 'string')
+                throw Error('Workspace listener did not bind');
+            requestedPort = bound.port;
+            replaceFileAtomically(resolve(webDir, 'workspace-port.json'), JSON.stringify({ port: requestedPort }) + '\n', 0o600);
+        }
+        catch (error) {
+            await gateway?.close().catch(() => { });
+            await server.close();
+            lock.release();
+            throw error;
+        }
     server.auth.setBoundary(browserOrigin, browserHost, publicOrigin ? {
         // nginx's safe default uses the loopback upstream as Host. The declared
         // browser Origin remains mandatory for auth/mutations and WebSocket hello,
         // so operators do not need a fragile Host-rewrite incantation.
-        hosts: [localHost, `localhost:${actual.port}`],
+        hosts: [localHost, `localhost:${actual.port}`, ...(workspaceGateway ? [`127.0.0.1:${requestedPort}`, `localhost:${requestedPort}`] : [])],
     } : {
         hosts: [`localhost:${actual.port}`], origins: [`http://localhost:${actual.port}`],
     });
     let control;
     try {
-        control = await startWebControlServer({
-            dir: webDir,
-            onOpen() {
-                const url = access.mode === 'pairing'
-                    ? `${browserOrigin}/#bootstrap=${server.auth.mintBootstrap()}` : `${browserOrigin}/`;
-                openBrowser(url);
-            },
-            onRevokeAll() { server.auth.revokeAllTrustedDevices(); },
-        });
+        if (options.control !== false)
+            control = await startWebControlServer({
+                dir: webDir,
+                onLinkDevice() { return { version: 1, origin: browserOrigin, ...server.auth.workspaceEnrollment() }; },
+                onRevokeAll() { server.auth.revokeAllTrustedDevices(); },
+            });
     }
     catch (error) {
+        await gateway?.close();
         await server.close();
         lock.release();
         throw error;
     }
-    if (options.open !== false)
-        openBrowser(access.mode === 'pairing'
-            ? `${browserOrigin}/#bootstrap=${server.auth.bootstrapSecret}` : `${browserOrigin}/`);
+    let stopTunnel;
+    try {
+        stopTunnel = startWorkspaceTunnel(browserOrigin);
+    }
+    catch (error) {
+        try {
+            await control?.close();
+            await gateway?.close();
+            await server.close();
+        }
+        finally {
+            lock.release();
+        }
+        throw error;
+    }
+    const notifications = notificationConfig ? new FleetNotificationProducer([agentsRoot(), tmpRoot()], resolve(webDir, 'notification-outboxes'), notificationConfig, options.log) : undefined;
     return {
         ...server, address: browserOrigin,
         async close() {
             try {
-                await control.close();
+                await stopTunnel();
+                await notifications?.close();
+                await control?.close();
+                await gateway?.close();
                 await server.close();
             }
             finally {
@@ -237,11 +340,3 @@ export async function startWebConsole(options) {
 function isLoopback(host) {
     return ['127.0.0.1', 'localhost', '::1'].includes(host);
 }
-function openBrowser(url) {
-    const command = process.platform === 'darwin' ? 'open'
-        : process.platform === 'win32' ? 'cmd' : 'xdg-open';
-    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
-    const child = spawn(command, args, { stdio: 'ignore', detached: true, shell: false });
-    child.on('error', () => undefined);
-    child.unref();
-}

package/dist/web/server.d.ts

@@ -1,3 +1,5 @@
+import type { ConversationRoleObservation, ConversationRoleState } from '../application/conversation-role-observer.js';
+import { type InitAnswers } from '../init-wizard.js';
 import { SupervisorOursTools } from '../application/supervisor-ours-tools.js';
 import { type FastifyInstance } from 'fastify';
 import type { FleetQueryService } from '../application/fleet-query-service.js';
@@ -16,7 +18,14 @@ import type { TopologyDraftStore } from './topology-draft-store.js';
 import type { TopologyPromoteService } from './topology-promote.js';
 import type { RoleRemovalService } from '../application/role-removal-service.js';
 import type { TaskRoomApplicationService } from '../application/task-room-service.js';
+import type { RoomLayoutDefinitions } from '../application/room-layout-definitions.js';
+import type { PresetProvenance } from '../application/preset-provenance.js';
+import type { OfferedModels } from '../subscriptions/cli.js';
+import type { SubscriptionService } from '../subscriptions/service.js';
+import type { LayoutBindingGrants } from '../rooms-tasks/layout-binding-grants.js';
 export interface WebServices {
+    observeRole?(roleId: string, listener: (state: ConversationRoleState) => void): ConversationRoleObservation;
+    layoutBindings?: Pick<LayoutBindingGrants, 'control'>;
     query: FleetQueryService;
     repository: RoleRepository;
     session(roleId: string): Promise<RoleSessionControl>;
@@ -32,7 +41,14 @@ export interface WebServices {
     topologyPromote?: TopologyPromoteService;
     removal?: RoleRemovalService;
     taskRooms?: TaskRoomApplicationService;
+    roomLayouts?: RoomLayoutDefinitions;
+    presetProvenance?: PresetProvenance;
     oursTools?: Pick<SupervisorOursTools, 'list' | 'call'>;
+    subscriptions?: SubscriptionService;
+    /** First-time setup from the packaged presets; the account App supplies only the model choices. */
+    onboardingSetup?(answers: InitAnswers): Promise<void>;
+    /** The Codex models the runtime that sessions will use offers the active account. Absent: this server cannot tell, and filters nothing. */
+    codexModels?(): Promise<OfferedModels>;
 }
 export interface WebServer {
     app: FastifyInstance;