@ours.network/fleet 1.2.0-nightly.2 → 1.2.0-nightly.21

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,20 @@
+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;
+    /** Server-side service credentials; never taken from browser headers. */
+    headers?: Record<string, 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>;
+};

package/dist/web/prefix-gateway.js

@@ -0,0 +1,150 @@
+import { createServer, request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+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;
+    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 (!['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, page: !service && !fleet && !path.startsWith('/api/'), origin: service?.origin ?? options.fleetOrigin,
+            path: service ? (raw.slice(service.prefix.length) || '/').replace(/^\?/, '/?') : fleet ? raw.slice('/fleet'.length) : raw };
+    };
+    const prepare = (req, upgrade = false) => {
+        const route = select(req);
+        const request = { headers: req.headers, method: req.method };
+        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, route.page);
+        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];
+        if (route.service) {
+            if (auth)
+                for (const name of ['cookie', 'authorization', 'x-csrf-token', 'x-ours-api-token'])
+                    delete headers[name];
+            Object.assign(headers, route.service.headers);
+            headers.host = new URL(route.origin).host;
+        }
+        if (upgrade) {
+            headers.connection = 'Upgrade';
+            headers.upgrade = 'websocket';
+        }
+        return { ...route, headers, session };
+    };
+    const track = (req, session, close) => {
+        if (!session)
+            return () => { };
+        const unbind = auth.bindTransport(session.id, close);
+        const timer = setInterval(() => { try {
+            auth.authenticate({ headers: req.headers });
+        }
+        catch {
+            close();
+        } }, 30_000);
+        timer.unref();
+        return () => { clearInterval(timer); unbind(); };
+    };
+    const server = createServer((req, res) => {
+        let route;
+        try {
+            route = prepare(req);
+        }
+        catch (error) {
+            const code = error.code;
+            res.writeHead(code === 'unauthorized' ? 401 : 403, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            res.end(JSON.stringify({ error: { code: code ?? 'forbidden', message: error.message } }));
+            return;
+        }
+        if (req.url === '/') {
+            res.writeHead(302, { location: '/fleet' });
+            res.end();
+            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'];
+            res.writeHead(response.statusCode ?? 502, headers);
+            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, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ error: { code: 'upstream_unavailable', message: 'Service is unavailable' } }));
+        });
+        const untrack = track(req, 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'];
+            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(req, 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,6 +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;
+    staticRoot?: string;
     port?: number;
     open?: boolean;
     binPath: string;

package/dist/web/runtime.js

@@ -21,6 +21,8 @@ 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 { TrustedDeviceStore } from './device-store.js';
@@ -50,8 +52,8 @@ export async function startWebConsole(options) {
     const 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;
     if (!isLoopback(bind) && !publicOrigin) {
@@ -159,7 +161,9 @@ export async function startWebConsole(options) {
     try {
         server = await buildWebServer({
             query, repository, logs, commands, creation, removal, audit, events, watchdogs, configuration,
-            taskRooms: new TaskRoomApplicationService(options.configPath),
+            taskRooms: new TaskRoomApplicationService(options.configPath, { binPath: () => options.binPath }),
+            roomLayouts: new RoomLayoutDefinitions(options.configPath),
+            presetProvenance: new PresetProvenance(options.configPath),
             topology: readTopology, topologyDrafts, topologyPromote,
             async session(roleId) {
                 const role = await repository.get(roleId);
@@ -174,7 +178,7 @@ export async function startWebConsole(options) {
                 }
                 throw new FleetError('capability_unavailable', 'role session backend is unavailable');
             },
-        }, { origin: `http://127.0.0.1:${requestedPort}`, host: `127.0.0.1:${requestedPort}` }, { auth });
+        }, { origin: `http://127.0.0.1:${requestedPort}`, host: `127.0.0.1:${requestedPort}` }, { auth, staticRoot: options.staticRoot });
     }
     catch (error) {
         lock.release();
@@ -203,15 +207,16 @@ export async function startWebConsole(options) {
     });
     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,
+                onOpen() {
+                    const url = access.mode === 'pairing'
+                        ? `${browserOrigin}/#bootstrap=${server.auth.mintBootstrap()}` : `${browserOrigin}/`;
+                    openBrowser(url);
+                },
+                onRevokeAll() { server.auth.revokeAllTrustedDevices(); },
+            });
     }
     catch (error) {
         await server.close();
@@ -225,7 +230,7 @@ export async function startWebConsole(options) {
         ...server, address: browserOrigin,
         async close() {
             try {
-                await control.close();
+                await control?.close();
                 await server.close();
             }
             finally {

package/dist/web/server.d.ts

@@ -1,3 +1,4 @@
+import { SupervisorOursTools } from '../application/supervisor-ours-tools.js';
 import { type FastifyInstance } from 'fastify';
 import type { FleetQueryService } from '../application/fleet-query-service.js';
 import type { RoleRepository } from '../application/role-repository.js';
@@ -15,6 +16,8 @@ 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';
 export interface WebServices {
     query: FleetQueryService;
     repository: RoleRepository;
@@ -31,6 +34,9 @@ export interface WebServices {
     topologyPromote?: TopologyPromoteService;
     removal?: RoleRemovalService;
     taskRooms?: TaskRoomApplicationService;
+    roomLayouts?: RoomLayoutDefinitions;
+    presetProvenance?: PresetProvenance;
+    oursTools?: Pick<SupervisorOursTools, 'list' | 'call'>;
 }
 export interface WebServer {
     app: FastifyInstance;
@@ -44,4 +50,5 @@ export declare function buildWebServer(services: WebServices, boundary: {
     host: string;
 }, options?: {
     auth?: WebAuth;
+    staticRoot?: string;
 }): Promise<WebServer>;