@ours.network/fleet 1.2.0-nightly.4 → 1.2.0-nightly.41

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;
@@ -21,13 +23,16 @@ export class WebAuth {
     sessionDevices = new Map();
     tickets = new Map();
     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; }
@@ -49,16 +54,24 @@ export class WebAuth {
         this.bootstrapUsed = false;
         return this._bootstrapSecret;
     }
+    /** The configured account origin, when this request comes from it and workspace devices are enabled. */
+    accountOrigin(request) {
+        return this.workspaceDevices && request.headers.origin === this.appOrigin ? this.appOrigin : undefined;
+    }
     validateBoundary(request, requireOrigin) {
         const host = request.headers.host;
         const hosts = this.allowedHosts.size ? this.allowedHosts : new Set([this.host]);
         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'];
-        if (fetchSite && !['same-origin', 'none'].includes(String(fetchSite)))
+        if (!workspaceRequest && fetchSite && !['same-origin', 'none'].includes(String(fetchSite)))
             throw new FleetError('forbidden', 'cross-site request rejected');
     }
     exchange(request) {
@@ -100,7 +113,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();
@@ -121,7 +150,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);
     }
@@ -143,7 +174,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;
     }
@@ -154,9 +185,30 @@ 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) {
+        let transports = this.transports.get(sessionId);
+        if (!transports) {
+            transports = new Set();
+            this.transports.set(sessionId, transports);
+        }
+        transports.add(close);
+        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() {
+        for (const transports of this.transports.values())
+            for (const close of transports)
+                close();
+        this.transports.clear();
         for (const sockets of this.sockets.values())
             for (const socket of sockets)
                 socket.close(4401, 'authentication revoked');
@@ -167,10 +219,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 = {
@@ -182,6 +253,9 @@ export class WebAuth {
         return session;
     }
     removeSession(id) {
+        for (const close of this.transports.get(id) ?? [])
+            close();
+        this.transports.delete(id);
         this.sessions.delete(id);
         this.sessionDevices.delete(id);
         for (const [ticket, value] of this.tickets)

package/dist/web/available-port.d.ts

@@ -0,0 +1,2 @@
+/** Bind the preferred loopback port; only EADDRINUSE permits an OS-selected replacement. */
+export declare function availableWebPort(preferred: number): Promise<number>;

package/dist/web/available-port.js

@@ -0,0 +1,23 @@
+import { createServer } from 'node:net';
+/** Bind the preferred loopback port; only EADDRINUSE permits an OS-selected replacement. */
+export async function availableWebPort(preferred) {
+    const server = createServer();
+    const listen = (port) => new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', () => { server.removeListener('error', reject); resolve(); });
+    });
+    try {
+        await listen(preferred);
+    }
+    catch (error) {
+        if (error.code !== 'EADDRINUSE')
+            throw error;
+        await listen(0);
+    }
+    const address = server.address();
+    if (!address || typeof address === 'string')
+        throw Error('No loopback port selected');
+    const port = address.port;
+    await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
+    return port;
+}

package/dist/web/control.d.ts

@@ -1,4 +1,4 @@
-export type WebControlCommand = 'open' | 'revoke-all';
+export type WebControlCommand = 'revoke-all' | 'link-device';
 export declare const webControlPath: (dir?: string) => string;
 export interface WebControlServer {
     path: string;
@@ -6,9 +6,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>;

package/dist/web/control.js

@@ -1,9 +1,10 @@
+import { socketPath as privateSocketPath } from '../socket-path.js';
 import { chmodSync, mkdirSync, rmSync } from 'node:fs';
 import { createConnection, createServer } from 'node:net';
 import { join } from 'node:path';
 import { FleetError, safeLine } from '../application/errors.js';
 import { stateRoot } from '../paths.js';
-export const webControlPath = (dir = join(stateRoot(), 'web')) => join(dir, 'control.sock');
+export const webControlPath = (dir = join(stateRoot(), 'web')) => privateSocketPath(join(dir, 'control.sock'));
 export async function startWebControlServer(options) {
     const dir = options.dir ?? join(stateRoot(), 'web');
     const path = webControlPath(dir);
@@ -34,13 +35,14 @@ export async function startWebControlServer(options) {
                     if (used > rateLimit)
                         throw new FleetError('rate_limited', 'local web control rate limit exceeded');
                     const parsed = JSON.parse(body.slice(0, body.indexOf('\n')));
-                    if (parsed.command === 'open')
-                        await options.onOpen();
+                    let result;
+                    if (parsed.command === 'link-device' && options.onLinkDevice)
+                        result = await options.onLinkDevice();
                     else if (parsed.command === 'revoke-all')
                         await options.onRevokeAll();
                     else
                         throw new FleetError('invalid_request', 'unknown local web control command');
-                    socket.end(JSON.stringify({ ok: true }) + '\n');
+                    socket.end(JSON.stringify({ ok: true, result }) + '\n');
                 }
                 catch (error) {
                     const code = error instanceof FleetError ? error.code : 'internal';
@@ -65,7 +67,7 @@ export async function startWebControlServer(options) {
     };
 }
 export async function requestWebControl(command, path = webControlPath(), timeoutMs = 5_000) {
-    await new Promise((resolve, reject) => {
+    return await new Promise((resolve, reject) => {
         const socket = createConnection(path);
         let response = '';
         let settled = false;
@@ -73,7 +75,7 @@ export async function requestWebControl(command, path = webControlPath(), timeou
             socket.destroy();
             reject(new FleetError('timeout', 'local web control request timed out'));
         }, timeoutMs);
-        const finish = (error) => {
+        const finish = (error, result) => {
             if (settled)
                 return;
             settled = true;
@@ -81,7 +83,7 @@ export async function requestWebControl(command, path = webControlPath(), timeou
             if (error)
                 reject(error);
             else
-                resolve();
+                resolve(result);
         };
         socket.once('connect', () => socket.write(JSON.stringify({ command }) + '\n'));
         socket.on('data', chunk => { response += chunk.toString('utf8'); });
@@ -91,7 +93,7 @@ export async function requestWebControl(command, path = webControlPath(), timeou
                 const parsed = JSON.parse(response);
                 if (!parsed.ok)
                     throw new FleetError(parsed.error?.code === 'rate_limited' ? 'rate_limited' : 'rejected', parsed.error?.message ?? 'local web control request was rejected');
-                finish();
+                finish(undefined, parsed.result);
             }
             catch (error) {
                 finish(error);

package/dist/web/fleet-config-service.d.ts

@@ -4,6 +4,9 @@ export interface EditableFleetModel {
     manifest: Record<string, unknown>;
     agents: Record<string, Record<string, unknown>>;
     agent_templates: Record<string, Record<string, unknown>>;
+    roles?: Record<string, Record<string, unknown>>;
+    brains?: Record<string, Record<string, unknown>>;
+    room_templates?: Record<string, Record<string, unknown>>;
 }
 export interface ConfigReadResult {
     path: string;
@@ -45,7 +48,7 @@ export declare class FleetConfigService {
     private readonly preflight;
     private readonly beforeMutation?;
     constructor(options?: FleetConfigServiceOptions);
-    read(): ConfigReadResult;
+    read(includeDefinitions?: boolean): ConfigReadResult;
     preview(baseRevision: string, input: unknown): Promise<ConfigPreviewResult>;
     write(baseRevision: string, input: unknown): Promise<ConfigWriteResult>;
 }

package/dist/web/fleet-config-service.js

@@ -23,7 +23,7 @@ export class FleetConfigService {
         this.preflight = options.preflight ?? (async () => emptyReport());
         this.beforeMutation = options.beforeMutation;
     }
-    read() {
+    read(includeDefinitions = false) {
         const sources = readSources(this.path);
         try {
             loadConfig(this.path, { yamlMode: 'strict' });
@@ -31,7 +31,7 @@ export class FleetConfigService {
         catch (error) {
             throw safeError(error, sourceSensitiveValues(sources));
         }
-        const raw = modelFrom(sources);
+        const raw = modelFrom(sources, includeDefinitions);
         const redacted = redactModel(raw);
         return {
             path: basename(this.path), exists: true, firstRun: false,
@@ -41,7 +41,7 @@ export class FleetConfigService {
     async preview(baseRevision, input) {
         const current = readSources(this.path);
         assertRevision(baseRevision, current);
-        const currentModel = modelFrom(current);
+        const currentModel = modelFrom(current, !!input && typeof input === 'object' && 'roles' in input);
         const next = restoreRedactions(assertModel(input), currentModel, new Set(redactModel(currentModel).paths));
         const proposal = renderProposal(current, next);
         const staged = stageProposal(this.path, current, proposal);
@@ -63,7 +63,7 @@ export class FleetConfigService {
         return withFileLock(`${splitRootFor(this.path)}.web-edit.lock`, async () => {
             const current = readSources(this.path);
             assertRevision(baseRevision, current);
-            const currentModel = modelFrom(current);
+            const currentModel = modelFrom(current, !!input && typeof input === 'object' && 'roles' in input);
             const next = restoreRedactions(assertModel(input), currentModel, new Set(redactModel(currentModel).paths));
             const proposal = renderProposal(current, next);
             const changed = changedDocuments(current, proposal);
@@ -105,6 +105,8 @@ export class FleetConfigService {
                         rmSync(target, { force: true });
                     else {
                         assertWritableTarget(target, current.documents.has(rel));
+                        mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+                        trustedDirectory(dirname(target));
                         replaceFileAtomically(target, contents, 0o600);
                         chmodSync(target, 0o600);
                     }
@@ -184,7 +186,7 @@ function readSources(manifest) {
     }
     return { manifest, root, documents };
 }
-function modelFrom(sources) {
+function modelFrom(sources, includeDefinitions = false) {
     const manifestKey = basename(sources.manifest);
     const manifest = parseFleetDocument(sources.manifest, sources.documents.get(manifestKey), 'strict').value;
     const agents = {};
@@ -199,15 +201,24 @@ function modelFrom(sources) {
             const id = basename(rel, extname(rel));
             agent_templates[id] = parseFleetDocument(absoluteFor(sources.manifest, rel), source, 'strict').value;
         }
-    return { manifest, agents, agent_templates };
+    const model = { manifest, agents, agent_templates };
+    if (includeDefinitions)
+        for (const kind of ['roles', 'brains', 'room_templates']) {
+            model[kind] = {};
+            for (const [rel, source] of sources.documents)
+                if (rel.startsWith(kind + '/') && ['.yaml', '.yml'].includes(extname(rel))) {
+                    model[kind][basename(rel, extname(rel))] = parseFleetDocument(absoluteFor(sources.manifest, rel), source, 'strict').value;
+                }
+        }
+    return model;
 }
 function assertModel(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new FleetError('invalid_request', 'model must be an object');
     const input = value;
-    if (Object.keys(input).sort().join(',') !== 'agent_templates,agents,manifest')
-        throw new FleetError('invalid_request', 'model allows exactly manifest, agents, and agent_templates');
-    for (const key of ['manifest', 'agents', 'agent_templates'])
+    if (!['agent_templates,agents,manifest', 'agent_templates,agents,brains,manifest,roles,room_templates'].includes(Object.keys(input).sort().join(',')))
+        throw new FleetError('invalid_request', 'model requires manifest, agents, agent_templates and optionally all definition collections');
+    for (const key of Object.keys(input))
         if (!input[key] || typeof input[key] !== 'object' || Array.isArray(input[key]))
             throw new FleetError('invalid_request', `${key} must be an object`);
     for (const [id, doc] of Object.entries(input.agents)) {
@@ -222,6 +233,14 @@ function assertModel(value) {
         if (!doc || typeof doc !== 'object' || Array.isArray(doc))
             throw new FleetError('invalid_request', `Agent Template '${id}' must be an object`);
     }
+    for (const kind of ['roles', 'brains', 'room_templates']) {
+        for (const [id, doc] of Object.entries((input[kind] ?? {}))) {
+            if (!ROLE_NAME_RE.test(id))
+                throw new FleetError('invalid_request', `invalid definition ID '${id}'`);
+            if (!doc || typeof doc !== 'object' || Array.isArray(doc))
+                throw new FleetError('invalid_request', `definition '${id}' must be an object`);
+        }
+    }
     return structuredClone(input);
 }
 function renderProposal(current, model) {
@@ -240,9 +259,21 @@ function renderProposal(current, model) {
         next.set(oldRel ?? join('agent_templates', `${id}.yaml`), oldRel
             ? render(current.documents.get(oldRel), doc) : stringify(doc));
     }
-    for (const [rel, source] of current.documents)
-        if (rel.startsWith('roles/') || rel.startsWith('brains/') || rel.startsWith('room_templates/'))
-            next.set(rel, source);
+    for (const kind of ['roles', 'brains', 'room_templates']) {
+        if (model[kind] === undefined) {
+            for (const [rel, source] of current.documents)
+                if (rel.startsWith(kind + '/'))
+                    next.set(rel, source);
+            continue;
+        }
+        for (const [rel, source] of current.documents)
+            if (rel.startsWith(kind + '/') && !['.yaml', '.yml'].includes(extname(rel)))
+                next.set(rel, source);
+        for (const [id, doc] of Object.entries(model[kind])) {
+            const oldRel = [...current.documents.keys()].find(rel => rel.startsWith(kind + '/') && ['.yaml', '.yml'].includes(extname(rel)) && basename(rel, extname(rel)) === id);
+            next.set(oldRel ?? join(kind, `${id}.yaml`), oldRel ? render(current.documents.get(oldRel), doc) : stringify(doc));
+        }
+    }
     return next;
 }
 function render(source, model) {
@@ -395,9 +426,9 @@ function sourceDiff(before, after, label, secrets) {
         ...left.slice(left.length - tail, left.length - tail + trailing).map(x => ` ${x}`), ''].join('\n');
 }
 function proposalDiff(current, proposal) {
-    const secrets = sensitiveValues(modelFrom(current));
+    const secrets = sensitiveValues(modelFrom(current, true));
     try {
-        secrets.push(...sensitiveValues(modelFrom({ ...current, documents: proposal })));
+        secrets.push(...sensitiveValues(modelFrom({ ...current, documents: proposal }, true)));
     }
     catch { /* validation reports later */ }
     return [...new Set([...current.documents.keys(), ...proposal.keys()])].sort().map(rel => sourceDiff(current.documents.get(rel) ?? '', proposal.get(rel) ?? '', rel, secrets)).filter(Boolean).join('\n');
@@ -405,7 +436,7 @@ function proposalDiff(current, proposal) {
 function splitLines(source) { return source.replace(/\n$/, '').split('\n'); }
 function restartImpact(before, after) {
     const roles = [...new Set([...Object.keys(before.agents), ...Object.keys(after.agents)])]
-        .filter(id => JSON.stringify(before.agents[id]) !== JSON.stringify(after.agents[id])).sort();
+        .filter(id => JSON.stringify(before.agents[id]) !== JSON.stringify(after.agents[id]) || JSON.stringify(before.roles) !== JSON.stringify(after.roles) || JSON.stringify(before.brains) !== JSON.stringify(after.brains)).sort();
     const watchdogScheduler = JSON.stringify(before.manifest.watchdogs) !== JSON.stringify(after.manifest.watchdogs);
     const scheduledLoops = JSON.stringify(before.manifest.loops) !== JSON.stringify(after.manifest.loops);
     const required = roles.length > 0 || watchdogScheduler || scheduledLoops;

package/dist/web/prefix-gateway.d.ts

@@ -0,0 +1,29 @@
+import { type IncomingMessage } from 'node:http';
+import type { WebAuth } from './auth.js';
+/** Each entry exposes one dedicated backend listener. Endpoint dispatch stays upstream. */
+export interface ServiceTarget {
+    prefix: string;
+    origin: string;
+    upstreamPrefix?: string;
+    /** Server-side service credentials; never taken from browser headers. */
+    headers?: Record<string, string>;
+    /** Dedicated credential-authenticated services reject direct browser context. */
+    stripBrowserContext?: boolean;
+    /**
+     * Service paths (below the prefix) where the account App may open a WebSocket with its device
+     * credential. A browser cannot set Authorization on a WebSocket, so only there it is accepted
+     * as a subprotocol.
+     */
+    deviceSocketPaths?: string[];
+}
+export interface GatewayOptions {
+    /** Backend mode is for a separate loopback machine-client listener; browsers are rejected. */
+    auth: WebAuth | 'backend';
+    fleetOrigin: string;
+    services: ServiceTarget[];
+}
+/** Raw transport deliberately runs outside Fastify's JSON parser and body limits. */
+export declare function createPrefixGateway(options: GatewayOptions): {
+    server: import("http").Server<typeof IncomingMessage, typeof import("http").ServerResponse>;
+    close(): Promise<void>;
+};