@ours.network/fleet 1.2.0-nightly.24 → 1.2.0-nightly.26

package/README.md

@@ -1820,3 +1820,8 @@ See [predefined Brain models and runtime requirements](presets/README.md) for th
 
 Room layouts describe room composition with shared or fresh participant sessions and independent room closure.
 See [Room layouts](docs/room-layouts.md) for YAML examples and CLI commands.
+
+
+### Dedicated notification service
+
+Configure the web backend with `OURS_NOTIFICATIONS_ORIGIN` and a Fleet-scoped `OURS_NOTIFICATIONS_PRODUCER_TOKEN`. It reads each local supervisor ledger incrementally with persistent checkpoints under web state, correlating owner browser/channel prompts with terminal completion. Monitor/startup turns do not notify. First installation skips existing history; no agent restart or conversation controller is needed. Persist web state across deployment/restarts. Reads are bounded to 256 KiB per role per tick, and oversized model/media records are skipped across chunks. Expose `/notifications` through the generic authenticated prefix gateway with a server-side user token and `stripBrowserContext: true`; producer tokens stay server-side. All browser sessions of this single-owner console map to one stable notification account. See [ours-notifications](https://github.com/adapt-toolkit/ours-notifications) for configuration/API/release details.

package/dist/account-origin.d.ts

@@ -0,0 +1,2 @@
+export declare const accountOrigins: readonly ["https://app.ours.network", "https://app.ours-tunnel.com"];
+export declare function validateAccountOrigin(value: unknown): string;

package/dist/account-origin.js

@@ -0,0 +1,6 @@
+export const accountOrigins = ['https://app.ours.network', 'https://app.ours-tunnel.com'];
+export function validateAccountOrigin(value) {
+    if (typeof value !== 'string' || !accountOrigins.some(origin => origin === value))
+        throw Error('Unsupported account origin');
+    return value;
+}

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.24",
-  "buildId": "80f2457d96f4",
-  "commit": "b9009b9a68c0c11536c33e239eae38144a491233",
+  "version": "1.2.0-nightly.26",
+  "buildId": "7b8a6a05d7bf",
+  "commit": "99c715eed295baa8fff6bff9f42f868d1f7246f5",
   "dirty": true,
-  "builtAt": "2026-09-30T12:55:21.818Z",
+  "builtAt": "2026-10-01T06:37:30.669Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/cli.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import QRCode from 'qrcode';
+import { readWorkspacePayload, enrollWorkspace } from './workspace-enrollment.js';
 import { waitForRoleDaemon } from './startup-readiness.js';
 import { SupervisorOursTools } from './application/supervisor-ours-tools.js';
 import { runTempSupervisor, TEMP_RECYCLE_EXIT } from './temp-supervisor-recovery.js';
@@ -39,7 +41,7 @@ import { controlRequest, controlSocketPath, followControl, livenessNote, } from
 import { SessionControlError } from './session/types.js';
 import { readScheduledLoops, storedLoopHealth } from './loops/state.js';
 import { startWebConsole } from './web/runtime.js';
-import { requestWebControl } from './web/control.js';
+import { requestWebControl, webControlPath } from './web/control.js';
 import { WebServiceManager } from './web/service.js';
 import { WebAccessStore, passwordAccess, validatePublicOrigin } from './web/access.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
@@ -1527,6 +1529,46 @@ webCommand.command('open').description('securely open or re-pair a browser with
         die(e);
     }
 });
+cOpt(program.command('workspace-enroll').description('enroll this host using a private account setup file'))
+    .requiredOption('--file <path>', 'owned private payload file')
+    .option('--migrate-app-origin', 'explicitly migrate the same workspace to its new account origin after verified signed proof')
+    .action(async (opts) => {
+    try {
+        const result = await enrollWorkspace(readWorkspacePayload(opts.file), opts.configuration, { migrateAppOrigin: opts.migrateAppOrigin });
+        if (!existsSync(new WebAccessStore().path))
+            configureWebAccess({ pairing: true });
+        const manager = new WebServiceManager();
+        await manager.install(binPath, 49271, opts.configuration, { bind: '127.0.0.1', publicOrigin: result.origin });
+        await manager.restart();
+        const controlDeadline = Date.now() + 20000;
+        while (!existsSync(webControlPath())) {
+            if (Date.now() >= controlDeadline)
+                throw Error('Workspace console is still starting; run ours-fleet link-device when ready');
+            await new Promise(resolve => setTimeout(resolve, 200));
+        }
+        const link = await requestWebControl('link-device');
+        const code = Buffer.from(JSON.stringify(link)).toString('base64url');
+        process.stdout.write('Root proof submitted; account setup is ready only after tunnel health and binding verification.\nPrivate single-use device code:\n');
+        process.stdout.write(await QRCode.toString(code, { type: 'terminal', small: true }));
+        process.stdout.write('\n' + code + '\n');
+    }
+    catch (error) {
+        die(error);
+    }
+});
+program.command('link-device').description('create a single-use workspace device connection code (expires in five minutes)')
+    .action(async () => {
+    try {
+        const link = await requestWebControl('link-device');
+        process.stdout.write('Private connection code; share only with the intended device.\n');
+        const code = Buffer.from(JSON.stringify(link)).toString('base64url');
+        process.stdout.write(await QRCode.toString(code, { type: 'terminal', small: true }));
+        process.stdout.write('\n' + code + '\n');
+    }
+    catch (e) {
+        die(e);
+    }
+});
 webCommand.command('revoke-all').description('revoke all trusted browsers and active web sessions')
     .action(async () => {
     try {

package/dist/notifications/fleet-producer.d.ts

@@ -0,0 +1,18 @@
+import { type ProducerConfig } from './outbox.js';
+/** Read durable supervisor ledgers without restarting agents or attaching a
+ * conversation controller. Each tick reads at most 256 KiB per role, from its
+ * checkpoint; it never loads a complete transcript or requests model history. */
+export declare class FleetNotificationProducer {
+    private readonly roots;
+    private readonly stateDir;
+    private readonly config;
+    private readonly warn;
+    private readonly queues;
+    private readonly timer;
+    private readonly existing;
+    constructor(roots: string[], stateDir: string, config: ProducerConfig, warn?: (line: string) => void);
+    private names;
+    poll(): void;
+    drain(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/notifications/fleet-producer.js

@@ -0,0 +1,129 @@
+import { closeSync, existsSync, lstatSync, openSync, readSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { NotificationOutbox } from './outbox.js';
+/** Read durable supervisor ledgers without restarting agents or attaching a
+ * conversation controller. Each tick reads at most 256 KiB per role, from its
+ * checkpoint; it never loads a complete transcript or requests model history. */
+export class FleetNotificationProducer {
+    roots;
+    stateDir;
+    config;
+    warn;
+    queues = new Map();
+    timer;
+    existing = new Set();
+    constructor(roots, stateDir, config, warn = () => { }) {
+        this.roots = roots;
+        this.stateDir = stateDir;
+        this.config = config;
+        this.warn = warn;
+        for (const root of roots)
+            for (const name of this.names(root))
+                this.existing.add(join(root, name));
+        this.poll();
+        this.timer = setInterval(() => this.poll(), 1000);
+        this.timer.unref();
+    }
+    names(root) {
+        try {
+            return readdirSync(root, { withFileTypes: true }).filter(d => d.isDirectory() && /^[a-zA-Z0-9_-]+$/.test(d.name)).map(d => d.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    poll() {
+        for (const root of this.roots)
+            for (const roleId of this.names(root)) {
+                const roleDir = join(root, roleId), dir = join(roleDir, '.conversation');
+                try {
+                    if (!existsSync(dir) || lstatSync(dir).isSymbolicLink())
+                        continue;
+                    const segments = readdirSync(dir).filter(n => /^events-\d{6}\.jsonl$/.test(n) && !lstatSync(join(dir, n)).isSymbolicLink()).sort();
+                    if (!segments.length)
+                        continue;
+                    let outbox = this.queues.get(roleDir);
+                    if (!outbox) {
+                        const key = createHash('sha256').update(roleDir).digest('hex');
+                        outbox = new NotificationOutbox(join(this.stateDir, key + '.json'), this.config, async (value, eventId) => ({ eventId, title: `${roleId}: agent completed`, body: 'Your agent finished responding. Open the chat to view the result.',
+                            url: `/fleet/chats?chat=${encodeURIComponent(roleId)}&detail=1`, ...value }), this.warn);
+                        if (!outbox.checkpoint) {
+                            const segment = this.existing.has(roleDir) ? segments.at(-1) : segments[0];
+                            outbox.saveCheckpoint({ segment, offset: this.existing.has(roleDir) ? statSync(join(dir, segment)).size : 0, prompts: [] });
+                        }
+                        this.queues.set(roleDir, outbox);
+                    }
+                    const saved = outbox.checkpoint;
+                    const current = { ...saved, prompts: [...saved.prompts], messages: { ...saved.messages } };
+                    let index = segments.indexOf(current.segment);
+                    if (index < 0) {
+                        this.warn('Notification ledger segment unavailable; checkpoint retained');
+                        continue;
+                    }
+                    const file = join(dir, current.segment), size = statSync(file).size;
+                    if (size < current.offset) {
+                        this.warn('Notification ledger truncated; checkpoint retained');
+                        continue;
+                    }
+                    if (size === current.offset && index < segments.length - 1) {
+                        current.segment = segments[++index];
+                        current.offset = 0;
+                    }
+                    const fd = openSync(join(dir, current.segment), 'r'), buffer = Buffer.alloc(256 * 1024);
+                    let count;
+                    try {
+                        count = readSync(fd, buffer, 0, buffer.length, current.offset);
+                    }
+                    finally {
+                        closeSync(fd);
+                    }
+                    let position = 0;
+                    while (position < count) {
+                        const end = buffer.indexOf(10, position);
+                        if (end < 0 || end >= count) {
+                            // Oversized model/media events are irrelevant to prompt/completion
+                            // correlation. Skip in bounded chunks; retain partial small lines.
+                            if (current.discarding || (position === 0 && count === buffer.length)) {
+                                current.offset += count - position;
+                                current.discarding = true;
+                                this.warn('Notification observer skipping oversized ledger record');
+                            }
+                            break;
+                        }
+                        if (current.discarding) {
+                            current.offset += end - position + 1;
+                            position = end + 1;
+                            current.discarding = false;
+                            continue;
+                        }
+                        const event = JSON.parse(buffer.subarray(position, end).toString('utf8'));
+                        if (event.schemaVersion !== 1 || event.roleId !== roleId)
+                            throw new Error('invalid ledger event');
+                        const prompt = `${event.sessionGeneration}:${event.promptId}`;
+                        if (event.kind === 'prompt.admitted' && event.promptId && ['browser', 'owner_admin_console', 'owner_channel'].includes(event.source ?? '')) {
+                            if (!current.prompts.includes(prompt))
+                                current.prompts.push(prompt);
+                        }
+                        if (['message.chunk', 'message.replace'].includes(event.kind) && event.promptId && event.messageId && current.prompts.includes(prompt))
+                            current.messages[prompt] = event.messageId;
+                        if (event.kind === 'turn.completed' && event.promptId && current.prompts.includes(prompt)) {
+                            if (!outbox.enqueue(`${roleId}:${event.sessionGeneration}:${event.seq}`, { url: `/fleet/chats?chat=${encodeURIComponent(roleId)}&detail=1#fleet-message-${encodeURIComponent(current.messages[prompt] ?? event.promptId)}` }))
+                                break;
+                            current.prompts = current.prompts.filter(p => p !== prompt);
+                            delete current.messages[prompt];
+                        }
+                        current.offset += end - position + 1;
+                        position = end + 1;
+                    }
+                    if (current.segment !== saved.segment || current.offset !== saved.offset)
+                        outbox.saveCheckpoint(current);
+                }
+                catch {
+                    this.warn('Notification ledger admission pending; checkpoint will replay');
+                }
+            }
+    }
+    async drain() { await Promise.all([...this.queues.values()].map(q => q.drain())); }
+    async close() { clearInterval(this.timer); await Promise.all([...this.queues.values()].map(q => q.close())); }
+}

package/dist/notifications/outbox.d.ts

@@ -0,0 +1,31 @@
+export interface NotificationInput {
+    eventId: string;
+    title: string;
+    body: string;
+    url: string;
+}
+export interface ProducerConfig {
+    origin: string;
+    token: string;
+}
+export declare function producerConfig(env?: NodeJS.ProcessEnv): ProducerConfig | undefined;
+/** Durable producer queue. Service dedupe makes crash-after-acceptance replay safe. */
+export declare class NotificationOutbox {
+    private readonly file;
+    private readonly config;
+    private readonly project;
+    private readonly warn;
+    private entries;
+    cursor?: number;
+    checkpoint?: unknown;
+    private running?;
+    private timer;
+    constructor(file: string, config: ProducerConfig, project: (value: unknown, id: string) => Promise<NotificationInput>, warn?: (message: string) => void);
+    private persist;
+    advance(cursor: number): void;
+    saveCheckpoint(checkpoint: unknown): void;
+    enqueue(id: string, value: unknown, cursor?: number | undefined): boolean;
+    drain(): Promise<void>;
+    private drainOnce;
+    close(): Promise<void>;
+}

package/dist/notifications/outbox.js

@@ -0,0 +1,104 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function producerConfig(env = process.env) {
+    const origin = env.OURS_NOTIFICATIONS_ORIGIN, token = env.OURS_NOTIFICATIONS_PRODUCER_TOKEN;
+    if (!origin && !token)
+        return;
+    if (!origin || !token || token.length < 32)
+        throw new Error('notifications producer requires origin and scoped token');
+    const url = new URL(origin);
+    if (!['http:', 'https:'].includes(url.protocol) || url.origin !== origin || url.username || url.password)
+        throw new Error('invalid notification service origin');
+    if (url.protocol === 'http:' && !['127.0.0.1', '[::1]', 'localhost'].includes(url.hostname))
+        throw new Error('notification credentials require HTTPS or loopback');
+    return { origin, token };
+}
+/** Durable producer queue. Service dedupe makes crash-after-acceptance replay safe. */
+export class NotificationOutbox {
+    file;
+    config;
+    project;
+    warn;
+    entries;
+    cursor;
+    checkpoint;
+    running;
+    timer;
+    constructor(file, config, project, warn = () => { }) {
+        this.file = file;
+        this.config = config;
+        this.project = project;
+        this.warn = warn;
+        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+        const saved = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : { entries: [] };
+        this.entries = Array.isArray(saved) ? saved : saved.entries;
+        this.cursor = saved.cursor;
+        this.checkpoint = saved.checkpoint;
+        if (!Array.isArray(this.entries))
+            throw new Error('invalid notification outbox');
+        this.timer = setInterval(() => { void this.drain(); }, 3000);
+        this.timer.unref();
+    }
+    persist(entries, cursor = this.cursor, checkpoint = this.checkpoint) {
+        const tmp = this.file + '.tmp', fd = openSync(tmp, 'w', 0o600);
+        try {
+            writeFileSync(fd, JSON.stringify({ entries, cursor, checkpoint }));
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(tmp, this.file);
+        const dir = openSync(dirname(this.file), 'r');
+        try {
+            fsyncSync(dir);
+        }
+        finally {
+            closeSync(dir);
+        }
+        this.entries = entries;
+        this.cursor = cursor;
+        this.checkpoint = checkpoint;
+    }
+    advance(cursor) { this.persist(this.entries, cursor); }
+    saveCheckpoint(checkpoint) { this.persist(this.entries, this.cursor, checkpoint); }
+    enqueue(id, value, cursor = this.cursor) {
+        if (this.entries.some(e => e.id === id)) {
+            if (cursor !== this.cursor)
+                this.advance(cursor);
+            return true;
+        }
+        if (this.entries.length >= 2000)
+            return false;
+        this.persist([...this.entries, { id, value }], cursor);
+        return true;
+    }
+    drain() {
+        return this.running ??= this.drainOnce().finally(() => { this.running = undefined; });
+    }
+    async drainOnce() {
+        for (const entry of [...this.entries].slice(0, 32)) {
+            try {
+                const value = entry.payload ?? await this.project(entry.value, entry.id);
+                // Freeze the canonical projection before any network attempt. A crash
+                // after service acceptance must replay the identical dedupe payload.
+                if (!entry.payload)
+                    this.persist(this.entries.map(e => e.id === entry.id ? { ...e, payload: value } : e));
+                const response = await fetch(this.config.origin + '/api/v1/send', {
+                    method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
+                    headers: { Authorization: `Bearer ${this.config.token}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify(value),
+                });
+                await response.body?.cancel();
+                if (!response.ok)
+                    throw new Error('notification service rejected event');
+                this.persist(this.entries.filter(e => e.id !== entry.id));
+            }
+            catch {
+                this.warn('Notification producer delivery pending; retrying from durable outbox');
+                break;
+            }
+        }
+    }
+    async close() { clearInterval(this.timer); await this.running; }
+}

package/dist/rooms-tasks/live-readiness.js

@@ -27,7 +27,7 @@ export async function taskLiveReadiness(task, room, cowork, deps = {}) {
     if (!remote || remote.room_id !== room.room_id || remote.identity_cid !== room.room_identity_cid
         || remote.state !== 'active')
         return degraded('room_identity_or_state_mismatch');
-    if (room.owner_seat_cid && remote.seats.filter(seat => seat.identity_cid === room.owner_seat_cid && seat.seat_state === 'active').length !== 1)
+    if (room.owner_seat_cid && remote.seats.filter(seat => seat.identity_cid.toLowerCase() === room.owner_seat_cid.toLowerCase() && seat.seat_state === 'active').length !== 1)
         return degraded('owner_seat_missing');
     for (const seat of room.member_seats) {
         const member = seat.role_name;
@@ -80,6 +80,6 @@ export async function taskLiveReadiness(task, room, cowork, deps = {}) {
     const memberCids = new Set(room.member_seats.map(seat => seat.identity_cid));
     const memberRoles = new Set(room.member_seats.map(seat => seat.cowork_role));
     if (remote.seats.some(seat => seat.seat_state === 'active' && memberRoles.has(seat.role)
-        && !memberCids.has(seat.identity_cid) && seat.identity_cid !== room.owner_seat_cid))
+        && !memberCids.has(seat.identity_cid) && seat.identity_cid.toLowerCase() !== room.owner_seat_cid?.toLowerCase()))
         return degraded('untracked_member_seats');
 }

package/dist/rooms-tasks/provision.js

@@ -619,7 +619,7 @@ export async function reconcileExistingTaskMembers(input) {
                 || remote.state !== 'active')
                 throw new Error('Cowork room is not the exact active room');
             assertCoworkRoomPolicy(remote, storedRoomLaunchPolicy(current.room_policy).anonymous);
-            if (current.owner_seat_cid && !remote.seats.some(seat => seat.identity_cid === current.owner_seat_cid && seat.seat_state === 'active'))
+            if (current.owner_seat_cid && !remote.seats.some(seat => seat.identity_cid.toLowerCase() === current.owner_seat_cid.toLowerCase() && seat.seat_state === 'active'))
                 throw new Error('expected Owner seat is not active');
             const seats = [];
             for (const seat of current.member_seats) {

package/dist/web/auth.d.ts

@@ -1,3 +1,4 @@
+import { WorkspaceDeviceStore } from './workspace-devices.js';
 import type { FastifyRequest } from 'fastify';
 import type { WebSocket } from 'ws';
 import { TrustedDeviceStore, type TrustedDeviceIssue } from './device-store.js';
@@ -26,6 +27,8 @@ export declare class WebAuth {
     private readonly now;
     private readonly devices;
     private readonly access;
+    private readonly workspaceDevices?;
+    readonly appOrigin: string;
     private _bootstrapSecret;
     private bootstrapExpiresAt;
     private bootstrapUsed;
@@ -35,7 +38,7 @@ export declare class WebAuth {
     private readonly rates;
     private readonly transports;
     private readonly sockets;
-    constructor(_origin: string, _host: string, now?: () => number, devices?: TrustedDeviceStore, access?: WebAccessConfig);
+    constructor(_origin: string, _host: string, now?: () => number, devices?: TrustedDeviceStore, access?: WebAccessConfig, workspaceDevices?: WorkspaceDeviceStore | undefined, appOrigin?: string);
     get bootstrapSecret(): string;
     get origin(): string;
     get host(): string;
@@ -66,6 +69,26 @@ export declare class WebAuth {
     bindTransport(sessionId: string, close: () => void): () => void;
     clearSessions(): void;
     revokeAllTrustedDevices(): number;
+    workspaceIdentity(): {
+        workspaceId: string;
+    };
+    workspaceEnrollment(issuer?: string | null): {
+        enrollment: string;
+        workspaceId: string;
+        expiresAt: number;
+    };
+    enrollWorkspace(request: FastifyRequest, input: {
+        enrollment: string;
+        workspaceId: string;
+        label: string;
+    }): {
+        token: string;
+        device: import("./workspace-devices.js").WorkspaceDevice;
+        workspaceId: string;
+    };
+    listWorkspaceDevices(): import("./workspace-devices.js").WorkspaceDevice[];
+    revokeWorkspaceDevice(id: string): void;
+    private requireWorkspaceDevices;
     shutdown(): void;
     private createSession;
     private removeSession;

package/dist/web/auth.js

@@ -14,6 +14,8 @@ export class WebAuth {
     now;
     devices;
     access;
+    workspaceDevices;
+    appOrigin;
     _bootstrapSecret = token(32);
     bootstrapExpiresAt = Date.now() + 5 * 60_000;
     bootstrapUsed = false;
@@ -23,12 +25,14 @@ export class WebAuth {
     rates = new Map();
     transports = new Map();
     sockets = new Map();
-    constructor(_origin, _host, now = Date.now, devices = new TrustedDeviceStore(), access = { version: 1, mode: 'pairing' }) {
+    constructor(_origin, _host, now = Date.now, devices = new TrustedDeviceStore(), access = { version: 1, mode: 'pairing' }, workspaceDevices, appOrigin = 'https://app.ours.network') {
         this._origin = _origin;
         this._host = _host;
         this.now = now;
         this.devices = devices;
         this.access = access;
+        this.workspaceDevices = workspaceDevices;
+        this.appOrigin = appOrigin;
     }
     get bootstrapSecret() { return this._bootstrapSecret; }
     get origin() { return this._origin; }
@@ -56,12 +60,17 @@ export class WebAuth {
         const origins = this.allowedOrigins.size ? this.allowedOrigins : new Set([this.origin]);
         if (!host || !hosts.has(host))
             throw new FleetError('forbidden', `This address is not configured for the fleet console. Open ${this.origin} or set --public-origin.`);
-        if (requireOrigin && (!request.headers.origin || !origins.has(request.headers.origin)))
+        if (this.workspaceDevices && String(request.headers.authorization ?? '').startsWith('Bearer ') && request.headers.origin && request.headers.origin !== this.appOrigin && !origins.has(request.headers.origin))
+            throw new FleetError('forbidden', 'workspace request Origin does not match configured account origin');
+        const workspaceRequest = Boolean(this.workspaceDevices) && request.headers.origin === this.appOrigin
+            && (String(request.headers.authorization ?? '').startsWith('Bearer ') || (request.url ?? '').split('?')[0] === '/api/v1/devices/enroll' || request.method === 'OPTIONS');
+        if (requireOrigin && !workspaceRequest && (!request.headers.origin || !origins.has(request.headers.origin)))
             throw new FleetError('forbidden', 'request Origin does not match the configured control-panel origin');
         const fetchSite = request.headers['sec-fetch-site'];
         const pageNavigation = allowPageNavigation && !requireOrigin && request.method === 'GET'
-            && request.headers['sec-fetch-mode'] === 'navigate' && request.headers['sec-fetch-dest'] === 'document';
-        if (!pageNavigation && fetchSite && !['same-origin', 'none'].includes(String(fetchSite)))
+            && request.headers['sec-fetch-mode'] === 'navigate'
+            && (request.headers['sec-fetch-dest'] === 'document' || (Boolean(this.workspaceDevices) && request.headers['sec-fetch-dest'] === 'iframe' && new URL(request.url || '/', this.origin).searchParams.get('workspace-frame') === '1'));
+        if (!workspaceRequest && !pageNavigation && fetchSite && !['same-origin', 'none'].includes(String(fetchSite)))
             throw new FleetError('forbidden', 'cross-site request rejected');
     }
     exchange(request) {
@@ -103,7 +112,23 @@ export class WebAuth {
         return { session: this.createSession(device.id), device };
     }
     authenticate(request, mutation = false) {
+        const authorization = String(request.headers.authorization ?? '');
+        if (authorization.startsWith('Bearer ')) {
+            this.validateBoundary(request, mutation);
+            if (!this.workspaceDevices)
+                throw new FleetError('unauthorized', 'workspace bearer credential is invalid');
+            const device = this.requireWorkspaceDevices().authenticate(authorization.slice(7));
+            const id = `workspace:${device.id}`;
+            const session = { id, csrf: '', createdAt: device.createdAt, lastSeenAt: this.now(), absoluteExpiresAt: device.expiresAt };
+            this.sessions.set(id, session);
+            this.sessionDevices.set(id, id);
+            if (mutation)
+                this.consumeRate(`mutation:${id}`, 120, 60000);
+            return session;
+        }
         this.validateBoundary(request, mutation);
+        if (request.headers.origin === this.appOrigin && !this.allowedOrigins.has(this.appOrigin))
+            throw new FleetError('unauthorized', 'workspace bearer credential required');
         const id = parseCookies(request.headers.cookie ?? '').ofs_session;
         const session = id ? this.sessions.get(id) : undefined;
         const now = this.now();
@@ -124,7 +149,9 @@ export class WebAuth {
     logout(request) {
         const session = this.authenticate(request, true);
         const deviceId = this.sessionDevices.get(session.id);
-        if (deviceId && deviceId !== 'unprotected')
+        if (session.id.startsWith('workspace:'))
+            this.workspaceDevices?.revoke(session.id.slice(10));
+        else if (deviceId && deviceId !== 'unprotected')
             this.devices.revokeId(deviceId);
         this.removeSession(session.id);
     }
@@ -146,7 +173,7 @@ export class WebAuth {
             || ticket.roleId !== roleId)
             throw new FleetError('unauthorized', 'WebSocket ticket is invalid, expired, or already used');
         const session = this.sessions.get(ticket.sessionId);
-        if (!session)
+        if (!session || (session.id.startsWith('workspace:') && !this.workspaceDevices?.valid(session.id.slice(10))))
             throw new FleetError('unauthorized', 'browser session expired');
         return session;
     }
@@ -157,7 +184,10 @@ export class WebAuth {
             this.sockets.set(sessionId, sockets);
         }
         sockets.add(socket);
-        socket.once('close', () => sockets?.delete(socket));
+        const expiry = setInterval(() => { const session = this.sessions.get(sessionId); if (!session || session.absoluteExpiresAt <= this.now() || (sessionId.startsWith('workspace:') && !this.workspaceDevices?.valid(sessionId.slice(10))))
+            this.removeSession(sessionId); }, 1000);
+        expiry.unref();
+        socket.once('close', () => { clearInterval(expiry); sockets?.delete(socket); });
     }
     /** Raw service streams share the same logout/revocation boundary as native sockets. */
     bindTransport(sessionId, close) {
@@ -167,7 +197,10 @@ export class WebAuth {
             this.transports.set(sessionId, transports);
         }
         transports.add(close);
-        return () => { transports.delete(close); if (!transports.size)
+        const expiry = setInterval(() => { const session = this.sessions.get(sessionId); if (!session || session.absoluteExpiresAt <= this.now() || (sessionId.startsWith('workspace:') && !this.workspaceDevices?.valid(sessionId.slice(10))))
+            this.removeSession(sessionId); }, 1000);
+        expiry.unref();
+        return () => { clearInterval(expiry); transports.delete(close); if (!transports.size)
             this.transports.delete(sessionId); };
     }
     clearSessions() {
@@ -185,10 +218,29 @@ export class WebAuth {
     }
     revokeAllTrustedDevices() {
         const count = this.devices.revokeAll();
+        for (const device of this.workspaceDevices?.list() ?? [])
+            this.workspaceDevices?.revoke(device.id);
         this.clearSessions();
         return count;
     }
-    shutdown() { this.clearSessions(); }
+    workspaceIdentity() { return { workspaceId: this.requireWorkspaceDevices().workspaceId }; }
+    workspaceEnrollment(issuer = null) { return this.requireWorkspaceDevices().mint(issuer?.startsWith('workspace:') ? issuer.slice(10) : null); }
+    enrollWorkspace(request, input) {
+        this.validateBoundary(request, true);
+        this.consumeRate('workspace-enrollment', 30, 60000);
+        return this.requireWorkspaceDevices().enroll(input.enrollment, input.workspaceId, input.label);
+    }
+    listWorkspaceDevices() { return this.requireWorkspaceDevices().list(); }
+    revokeWorkspaceDevice(id) {
+        this.requireWorkspaceDevices().revoke(id);
+        this.removeSession(`workspace:${id}`);
+    }
+    requireWorkspaceDevices() {
+        if (!this.workspaceDevices)
+            throw new FleetError('capability_unavailable', 'workspace device access is not configured');
+        return this.workspaceDevices;
+    }
+    shutdown() { this.clearSessions(); this.workspaceDevices?.close(); }
     createSession(deviceId) {
         const now = this.now();
         const session = {

package/dist/web/control.d.ts

@@ -1,4 +1,4 @@
-export type WebControlCommand = 'open' | 'revoke-all';
+export type WebControlCommand = 'open' | 'revoke-all' | 'link-device';
 export declare const webControlPath: (dir?: string) => string;
 export interface WebControlServer {
     path: string;
@@ -7,8 +7,9 @@ export interface WebControlServer {
 export declare function startWebControlServer(options: {
     dir?: string;
     onOpen(): void | Promise<void>;
+    onLinkDevice?(): Record<string, unknown> | Promise<Record<string, unknown>>;
     onRevokeAll(): void | Promise<void>;
     now?: () => number;
     rateLimit?: number;
 }): Promise<WebControlServer>;
-export declare function requestWebControl(command: WebControlCommand, path?: string, timeoutMs?: number): Promise<void>;
+export declare function requestWebControl(command: WebControlCommand, path?: string, timeoutMs?: number): Promise<Record<string, unknown> | void>;