@ours.network/fleet 0.15.3 → 0.15.4

package/dist/session/types.d.ts

@@ -1,4 +1,5 @@
 import type { SessionBackendId } from '../config.js';
+import type { ConversationEventV1, ConversationSnapshot, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 export type SessionReadiness = 'starting' | 'idle' | 'running' | 'awaiting_permission' | 'failed';
 export type TurnOutcome = 'completed' | 'refused' | 'cancelled' | 'failed' | 'inconclusive';
 export type TurnCancellationSource = 'owner' | 'local-console' | 'fleet-monitor' | 'scheduled-loop' | 'shutdown';
@@ -9,13 +10,23 @@ export type PromptOrigin = {
 } | {
     kind: 'owner';
     requestId: string;
+    displayText?: string;
 } | {
     kind: 'fleet-monitor';
 } | {
     kind: 'scheduled-loop';
     loop: string;
     runId: string;
+} | {
+    kind: 'owner-admin-console';
+    commandId: string;
 };
+export interface RuntimeSelectorMetadata {
+    /** Exact provider/model identifier reported by the live ACP session. */
+    value: string;
+    /** Complete provider-supplied label for that exact value, when available. */
+    label?: string;
+}
 /**
  * Two independent facts about one turn, deliberately kept apart:
  *
@@ -105,6 +116,10 @@ export interface SubmitPromptOptions {
     origin?: PromptOrigin;
     /** Use the ACP steering extension when available; ignored by other backends. */
     steer?: boolean;
+    /** Audit-grade actor detail persisted with the conversation admission record. */
+    actor?: {
+        browserSession?: string;
+    };
 }
 export interface SessionSnapshot {
     backend: SessionBackendId;
@@ -113,6 +128,14 @@ export interface SessionSnapshot {
     sessionId?: string;
     lastError?: string;
     pendingPermissionId?: string;
+    runtimeModel?: RuntimeSelectorMetadata;
+    reasoningEffort?: RuntimeSelectorMetadata;
+    permissionMode?: {
+        /** Effective harness-neutral policy after native overrides. */
+        fleetMode: import('../config.js').FleetPermissionMode;
+        /** Exact harness-native approval/permission mode used by this runner. */
+        nativeMode: string;
+    };
 }
 export type SessionEventKind = 'state' | 'agent_text' | 'thought' | 'tool_call' | 'tool_update' | 'permission' | 'turn_stop' | 'error';
 /** What a settled permission request resolved to. */
@@ -147,11 +170,26 @@ export interface SessionEvent {
     /** The option actually selected, when one was. */
     optionId?: string;
 }
+export interface ConversationHandlePage {
+    events: ConversationEventV1[];
+    firstAvailableCursor?: string;
+    nextCursor?: string;
+    hasMore: boolean;
+    snapshot: ConversationSnapshot;
+}
 export interface SessionHandle {
     readonly backend: SessionBackendId;
     readonly pid: number;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
+    conversationPage?(request: {
+        after?: string;
+        limit?: number;
+    }): ConversationHandlePage;
+    conversationSnapshot?(): ConversationSnapshot;
+    subscribeConversation?(listener: (event: ConversationEventV1) => void): () => void;
+    /** Durably admit an idempotent browser prompt; resolves on admission. */
+    submitPromptBrowser?(command: SubmitPromptCommand): Promise<PromptReceipt>;
     /**
      * Hand the session a prompt and return as soon as it has accepted
      * responsibility for it. Throws `SessionControlError` if it cannot.
@@ -161,6 +199,8 @@ export interface SessionHandle {
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
     interrupt(source?: TurnCancellationSource): Promise<void>;
     respondPermission(permissionId: string, optionId: string): boolean;
+    /** Generation-bound browser decision; stale/settled/invalid all fail closed. */
+    respondPermissionV2?(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';
     eventsSince(seq: number): SessionEvent[];
     subscribe(listener: (event: SessionEvent) => void): () => void;
     setControllerAttached(attached: boolean): void;

package/dist/spawn.d.ts

@@ -30,6 +30,7 @@ export interface SpawnOpts {
     launcher?: string;
     search?: boolean;
     codexConfig?: Record<string, string | number | boolean>;
+    reasoningEffort?: string | null;
     addDirs?: string[];
     monitor?: boolean;
     /** Typed external monitor configuration used by trusted creation surfaces. */

package/dist/spawn.js

@@ -62,8 +62,13 @@ export function buildRoleConfig(o, defaultHarness) {
         harnessOptions.launcher = o.launcher;
     if (o.search === true)
         harnessOptions.search = true;
-    if (o.codexConfig && Object.keys(o.codexConfig).length)
-        harnessOptions.config = o.codexConfig;
+    const codexConfig = { ...(o.codexConfig ?? {}) };
+    if (o.reasoningEffort && harness === 'codex')
+        codexConfig.model_reasoning_effort = o.reasoningEffort;
+    if (Object.keys(codexConfig).length)
+        harnessOptions.config = codexConfig;
+    if (o.reasoningEffort && harness === 'claude-code')
+        harnessOptions.effort = o.reasoningEffort;
     if (o.addDirs?.length)
         harnessOptions.add_dirs = o.addDirs;
     if (o.monitor === true)
@@ -118,8 +123,8 @@ export function validateSpawnOpts(o) {
         throw new Error('--mission and --mission-file are mutually exclusive');
     if (o.session && !['tmux', 'acp'].includes(o.session))
         throw new Error(`invalid --session '${o.session}'; allowed: tmux, acp`);
-    if (o.approval && !['ask', 'allow', 'deny'].includes(o.approval))
-        throw new Error(`invalid --approval '${o.approval}'; allowed: ask, allow, deny`);
+    if (o.approval && !['ask', 'auto', 'allow', 'deny'].includes(o.approval))
+        throw new Error(`invalid --approval '${o.approval}'; allowed: ask, auto, allow (deprecated alias: deny)`);
     if (o.filesystem && !['read-only', 'workspace', 'unrestricted'].includes(o.filesystem))
         throw new Error(`invalid --filesystem '${o.filesystem}'; allowed: read-only, workspace, unrestricted`);
     if (o.unattended && !['deny', 'wait'].includes(o.unattended))

package/dist/web/auth.d.ts

@@ -16,7 +16,7 @@ export interface AuthResult {
 interface Ticket {
     value: string;
     sessionId: string;
-    purpose: 'events' | 'terminal';
+    purpose: 'events' | 'terminal' | 'conversation';
     roleId?: string;
     expiresAt: number;
 }

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

@@ -0,0 +1,47 @@
+import type { PrereqReport } from '../harness/types.js';
+export declare const REDACTED_ENV_VALUE = "__OURS_FLEET_SECRET_REDACTED__";
+export type EditableFleetModel = Record<string, unknown>;
+export interface ConfigReadResult {
+    path: string;
+    exists: boolean;
+    firstRun: boolean;
+    revision: string;
+    model: EditableFleetModel;
+    redactions: string[];
+}
+export interface RestartImpact {
+    required: boolean;
+    roles: string[];
+    watchdogScheduler: boolean;
+    scheduledLoops: boolean;
+    summary: string;
+}
+export interface ConfigPreviewResult {
+    valid: true;
+    revision: string;
+    normalizedModel: EditableFleetModel;
+    diff: string;
+    redactions: string[];
+    impact: RestartImpact;
+    preflight: PrereqReport;
+}
+export interface ConfigWriteResult extends ConfigPreviewResult {
+    saved: true;
+    newRevision: string;
+    backup?: string;
+}
+export interface FleetConfigServiceOptions {
+    configPath?: string;
+    preflight?(configPath: string): Promise<PrereqReport>;
+}
+export declare class FleetConfigService {
+    readonly path: string;
+    private readonly preflight;
+    constructor(options?: FleetConfigServiceOptions);
+    read(): ConfigReadResult;
+    preview(baseRevision: string, model: unknown): Promise<ConfigPreviewResult>;
+    write(baseRevision: string, model: unknown): Promise<ConfigWriteResult>;
+    private readSource;
+    private assertRevision;
+    private validateCandidate;
+}

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

@@ -0,0 +1,204 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { chmodSync, existsSync, lstatSync, readFileSync, rmSync, } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { stringify } from 'yaml';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { loadConfig } from '../config.js';
+import { parseFleetDocument } from '../config-yaml.js';
+import { defaultConfigPath } from '../paths.js';
+import { FleetError } from '../application/errors.js';
+export const REDACTED_ENV_VALUE = '__OURS_FLEET_SECRET_REDACTED__';
+const MAX_CONFIG_BYTES = 256 * 1024;
+const emptyReport = () => ({ ok: true, checks: [] });
+export class FleetConfigService {
+    path;
+    preflight;
+    constructor(options = {}) {
+        this.path = options.configPath ?? defaultConfigPath();
+        this.preflight = options.preflight ?? (async () => emptyReport());
+    }
+    read() {
+        const source = this.readSource();
+        const parsed = parseFleetDocument(this.path, source, 'strict').value;
+        const redacted = redactModel(parsed);
+        return {
+            path: basename(this.path), exists: existsSync(this.path),
+            firstRun: !existsSync(this.path), revision: digest(source),
+            model: redacted.model, redactions: redacted.paths,
+        };
+    }
+    async preview(baseRevision, model) {
+        const currentSource = this.readSource();
+        this.assertRevision(baseRevision, currentSource);
+        const current = parseFleetDocument(this.path, currentSource, 'strict').value;
+        const restored = restoreRedactions(assertModel(model), current);
+        const source = serialize(restored);
+        const candidate = this.validateCandidate(source);
+        const [redactedCurrent, redactedNext] = [redactModel(current), redactModel(restored)];
+        const preflight = await this.preflight(candidate.path).finally(candidate.remove);
+        return {
+            valid: true, revision: digest(currentSource), normalizedModel: redactedNext.model,
+            diff: exactDiff(serialize(redactedCurrent.model), serialize(redactedNext.model)),
+            redactions: redactedNext.paths,
+            impact: restartImpact(current, restored), preflight,
+        };
+    }
+    async write(baseRevision, model) {
+        return withFileLock(`${this.path}.web-edit.lock`, async () => {
+            const currentSource = this.readSource();
+            this.assertRevision(baseRevision, currentSource);
+            const current = parseFleetDocument(this.path, currentSource, 'strict').value;
+            const restored = restoreRedactions(assertModel(model), current);
+            const nextSource = serialize(restored);
+            const candidate = this.validateCandidate(nextSource);
+            const preflight = await this.preflight(candidate.path).finally(candidate.remove);
+            // The lock coordinates trusted web/agent writers. An operator's editor does
+            // not take it, so re-check immediately before replacement as well.
+            this.assertRevision(baseRevision, this.readSource());
+            const redactedCurrent = redactModel(current);
+            const redactedNext = redactModel(restored);
+            let backup;
+            if (existsSync(this.path)) {
+                backup = `${basename(this.path)}.backup-${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`;
+                replaceFileAtomically(join(dirname(this.path), backup), currentSource, 0o600);
+            }
+            replaceFileAtomically(this.path, nextSource, 0o600);
+            chmodSync(this.path, 0o600);
+            return {
+                saved: true, valid: true, revision: digest(currentSource), newRevision: digest(nextSource),
+                normalizedModel: redactedNext.model,
+                diff: exactDiff(serialize(redactedCurrent.model), serialize(redactedNext.model)),
+                redactions: redactedNext.paths, impact: restartImpact(current, restored), preflight,
+                backup,
+            };
+        });
+    }
+    readSource() {
+        if (!existsSync(this.path))
+            return 'roles: {}\n';
+        const stat = lstatSync(this.path);
+        const uid = process.getuid?.();
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new FleetError('invalid_request', 'fleet configuration must be a regular non-symlink file');
+        if (stat.size > MAX_CONFIG_BYTES)
+            throw new FleetError('invalid_request', `fleet configuration exceeds ${MAX_CONFIG_BYTES} bytes`);
+        if (uid !== undefined && stat.uid !== uid)
+            throw new FleetError('forbidden', 'fleet configuration is not owned by the current user');
+        return readFileSync(this.path, 'utf8');
+    }
+    assertRevision(expected, source) {
+        if (!expected || expected !== digest(source))
+            throw new FleetError('stale_state', 'fleet.yaml changed since it was opened; reload before saving');
+    }
+    validateCandidate(source) {
+        if (Buffer.byteLength(source) > MAX_CONFIG_BYTES)
+            throw new FleetError('invalid_request', `fleet configuration exceeds ${MAX_CONFIG_BYTES} bytes`);
+        const candidate = join(dirname(this.path), `.${basename(this.path)}.preview-${process.pid}-${randomUUID()}.yaml`);
+        replaceFileAtomically(candidate, source, 0o600);
+        try {
+            loadConfig(candidate, { yamlMode: 'strict' });
+        }
+        catch (error) {
+            rmSync(candidate, { force: true });
+            throw new FleetError('invalid_request', error.message);
+        }
+        return { path: candidate, remove: () => rmSync(candidate, { force: true }) };
+    }
+}
+function assertModel(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new FleetError('invalid_request', 'model must be a JSON object');
+    return structuredClone(value);
+}
+function serialize(model) {
+    return stringify(model, { lineWidth: 0, sortMapEntries: false });
+}
+function digest(source) {
+    return createHash('sha256').update(source).digest('hex');
+}
+function envMaps(model) {
+    const maps = [];
+    const add = (value, path) => {
+        if (value && typeof value === 'object' && !Array.isArray(value))
+            maps.push({ path, map: value });
+    };
+    add(model.defaults?.env, 'defaults.env');
+    const roles = model.roles;
+    if (roles && typeof roles === 'object' && !Array.isArray(roles))
+        for (const [name, raw] of Object.entries(roles))
+            add(raw?.env, `roles.${name}.env`);
+    return maps;
+}
+function redactModel(input) {
+    const model = structuredClone(input);
+    const paths = [];
+    const secretVars = new Set();
+    for (const item of envMaps(model))
+        for (const [key, value] of Object.entries(item.map)) {
+            if (typeof value === 'string')
+                for (const match of value.matchAll(/\$\{(\w+)\}/g))
+                    secretVars.add(match[1]);
+            item.map[key] = REDACTED_ENV_VALUE;
+            paths.push(`${item.path}.${key}`);
+        }
+    const vars = model.vars;
+    if (vars && typeof vars === 'object' && !Array.isArray(vars))
+        for (const key of secretVars)
+            if (key in vars) {
+                vars[key] = REDACTED_ENV_VALUE;
+                paths.push(`vars.${key}`);
+            }
+    return { model, paths: paths.sort() };
+}
+function restoreRedactions(next, current) {
+    const oldByPath = new Map(envMaps(current).map(item => [item.path, item.map]));
+    for (const item of envMaps(next))
+        for (const [key, value] of Object.entries(item.map)) {
+            if (value !== REDACTED_ENV_VALUE)
+                continue;
+            const previous = oldByPath.get(item.path)?.[key];
+            if (previous === undefined)
+                throw new FleetError('invalid_request', `${item.path}.${key} uses a redaction marker with no prior value`);
+            item.map[key] = previous;
+        }
+    const nextVars = next.vars;
+    const oldVars = current.vars;
+    if (nextVars)
+        for (const [key, value] of Object.entries(nextVars)) {
+            if (value !== REDACTED_ENV_VALUE)
+                continue;
+            if (!oldVars || oldVars[key] === undefined)
+                throw new FleetError('invalid_request', `vars.${key} uses a redaction marker with no prior value`);
+            nextVars[key] = oldVars[key];
+        }
+    return next;
+}
+function exactDiff(before, after) {
+    if (before === after)
+        return '';
+    return ['--- fleet.yaml (current)', '+++ fleet.yaml (proposed)',
+        ...before.trimEnd().split('\n').map(line => `-${line}`),
+        ...after.trimEnd().split('\n').map(line => `+${line}`), ''].join('\n');
+}
+function objectKeys(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? Object.keys(value) : [];
+}
+function restartImpact(before, after) {
+    const changed = (key) => JSON.stringify(before[key]) !== JSON.stringify(after[key]);
+    const beforeRoles = (before.roles ?? {});
+    const afterRoles = (after.roles ?? {});
+    const roles = [...new Set([...objectKeys(beforeRoles), ...objectKeys(afterRoles)])]
+        .filter(name => JSON.stringify(beforeRoles[name]) !== JSON.stringify(afterRoles[name])).sort();
+    if (changed('defaults'))
+        roles.splice(0, roles.length, ...objectKeys(afterRoles).sort());
+    const watchdogScheduler = changed('watchdogs');
+    const scheduledLoops = changed('loops');
+    const required = roles.length > 0 || watchdogScheduler || scheduledLoops || changed('vars');
+    const parts = [roles.length ? `${roles.length} role${roles.length === 1 ? '' : 's'}` : '',
+        watchdogScheduler ? 'watchdog scheduler' : '', scheduledLoops ? 'scheduled loops' : ''].filter(Boolean);
+    return {
+        required, roles, watchdogScheduler, scheduledLoops,
+        summary: required ? `Save only writes configuration; apply/restart ${parts.join(', ') || 'affected roles'} separately.`
+            : 'No running process needs a restart.',
+    };
+}

package/dist/web/runtime.js

@@ -8,6 +8,7 @@ import { AcpRoleSessionAdapter, TmuxRoleSessionAdapter } from '../application/se
 import { StructuredLogService } from '../application/log-service.js';
 import { RoleCommandService } from '../application/role-command-service.js';
 import { RoleCreationService } from '../application/role-creation-service.js';
+import { RoleRemovalService } from '../application/role-removal-service.js';
 import { FleetError } from '../application/errors.js';
 import { controlRequest, controlSocketPath } from '../session/control.js';
 import { Tmux } from '../tmux.js';
@@ -17,6 +18,9 @@ import { home, stateRoot } from '../paths.js';
 import { AuditSink } from './audit.js';
 import { FleetEventBus } from './events.js';
 import { buildWebServer } from './server.js';
+import { FleetConfigService } from './fleet-config-service.js';
+import { deriveTopology } from './topology.js';
+import { doctor } from '../doctor.js';
 import { TerminalBridgeManager } from './terminal/bridge.js';
 import { acquireWebServerLock } from './lock.js';
 import { TrustedDeviceStore } from './device-store.js';
@@ -123,6 +127,10 @@ export async function startWebConsole(options) {
             });
         },
     });
+    const removal = new RoleRemovalService({
+        configPath: options.configPath, ops,
+        currentControlRole: process.env.OURS_FLEET_PROXY_CALLER,
+    });
     const commands = new RoleCommandService({
         repository, ops, configPath: options.configPath,
         status: async (roleId) => (await query.detail(roleId)).status,
@@ -136,10 +144,15 @@ export async function startWebConsole(options) {
     });
     const logs = new StructuredLogService(backend, realExec);
     const watchdogs = new WatchdogQueryService(watchdogConfigProvider);
+    const configuration = new FleetConfigService({
+        configPath: options.configPath,
+        preflight: path => doctor({ configPath: path, yamlMode: 'strict' }),
+    });
     let server;
     try {
         server = await buildWebServer({
-            query, repository, logs, commands, creation, audit, events, watchdogs,
+            query, repository, logs, commands, creation, removal, audit, events, watchdogs, configuration,
+            topology: async () => deriveTopology(loadConfig(options.configPath), await query.list()),
             terminalUpgrade: terminalAvailable
                 ? async (socket, _request, roleId, _ticket, hello) => terminals.connect(socket, roleId, hello)
                 : undefined,

package/dist/web/server.d.ts

@@ -10,6 +10,9 @@ import type { WatchdogQueryService } from '../watchdog/query.js';
 import { AuditSink } from './audit.js';
 import { WebAuth } from './auth.js';
 import { FleetEventBus } from './events.js';
+import type { FleetConfigService } from './fleet-config-service.js';
+import type { TopologySnapshot } from './topology.js';
+import type { RoleRemovalService } from '../application/role-removal-service.js';
 export interface WebServices {
     query: FleetQueryService;
     repository: RoleRepository;
@@ -20,6 +23,9 @@ export interface WebServices {
     audit?: AuditSink;
     events?: FleetEventBus;
     watchdogs?: WatchdogQueryService;
+    configuration?: FleetConfigService;
+    topology?: () => Promise<TopologySnapshot>;
+    removal?: RoleRemovalService;
     terminalUpgrade?: (socket: WebSocket, request: FastifyRequest, roleId: string, ticket: string, hello: Record<string, unknown>) => Promise<void>;
 }
 export interface WebServer {