@ours.network/fleet 1.2.0-nightly.9 → 2.0.0

package/dist/application/conversation-role-observer.js

@@ -0,0 +1,206 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lstatSync, readFileSync, realpathSync, watch } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { parse } from 'yaml';
+import { loadConfig, ROLE_NAME_RE, splitRootFor } from '../config.js';
+import { agentsRoot, defaultConfigPath, tmpRoot } from '../paths.js';
+import { controlSocketPath } from '../session/control.js';
+function identity(path) {
+    try {
+        const s = lstatSync(path);
+        return `${s.dev}:${s.ino}:${s.birthtimeMs}`;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+}
+/** Native directory notifications are assumed reliable on qualified host/mount setups.
+ * No periodic reads or claim of detecting every silently dropped filesystem event.
+ */
+export class ConversationRoleObserver {
+    options;
+    listener;
+    state;
+    watchers = new Map();
+    detach;
+    disposed = false;
+    listeners = new Set();
+    queued = false;
+    fingerprint;
+    configPath;
+    permanent;
+    temporary;
+    constructor(options, listener) {
+        this.options = options;
+        this.listener = listener;
+        if (!ROLE_NAME_RE.test(options.roleId))
+            throw new Error('invalid role id');
+        this.configPath = resolve(options.configPath ?? defaultConfigPath());
+        this.permanent = resolve(options.permanentRoot ?? agentsRoot(), options.roleId);
+        this.temporary = resolve(options.temporaryRoot ?? tmpRoot(), options.roleId);
+        this.state = { roleId: options.roleId, roleRevision: 0, roleLifetime: randomUUID(), availability: 'missing', health: 'healthy' };
+        this.refresh();
+        if (this.state.health === 'healthy')
+            this.detach = options.subscribeMutations?.(() => this.schedule());
+    }
+    snapshot() {
+        return this.disposed ? { ...this.state, health: 'failed', failure: 'observer-disposed' } : { ...this.state };
+    }
+    subscribe(listener) {
+        if (!this.disposed)
+            this.listeners.add(listener);
+        return { snapshot: this.snapshot(), unsubscribe: () => { this.listeners.delete(listener); } };
+    }
+    publish() {
+        this.listener(this.snapshot());
+        for (const listener of this.listeners)
+            listener(this.snapshot());
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.release();
+        this.listeners.clear();
+    }
+    release() {
+        const retired = [...this.watchers.values()];
+        // Retire before close: native close events may arrive synchronously or later.
+        this.watchers.clear();
+        for (const watcher of retired)
+            watcher.handle.close();
+        this.detach?.();
+        this.detach = undefined;
+    }
+    fail(failure) {
+        if (this.disposed || this.state.health !== 'healthy')
+            return;
+        this.state = { ...this.state, roleRevision: this.state.roleRevision + 1, health: failure === 'watch-unsupported' ? 'unsupported' : 'failed', failure };
+        this.release();
+        this.publish();
+    }
+    schedule() {
+        if (this.queued || this.disposed || this.state.health !== 'healthy')
+            return;
+        this.queued = true;
+        queueMicrotask(() => { this.queued = false; if (!this.disposed && this.state.health === 'healthy')
+            this.refresh(); });
+    }
+    refresh() {
+        try {
+            // Install parents before reading, including absent children, so atomic rename
+            // and recreation cannot strand us watching an unlinked inode.
+            this.install();
+            if (this.state.health !== 'healthy')
+                return;
+            let configured;
+            const split = splitRootFor(this.configPath);
+            if (identity(this.configPath) && identity(split) && identity(join(split, 'agents')))
+                configured = loadConfig(this.configPath).roles.find(role => role.name === this.options.roleId);
+            const permanentId = identity(this.permanent), temporaryId = identity(this.temporary);
+            const stateDir = temporaryId ? realpathSync(this.temporary) : permanentId ? realpathSync(this.permanent) : undefined;
+            let temporary;
+            if (!configured && temporaryId && identity(join(this.temporary, 'role.yaml'))) {
+                const raw = parse(readFileSync(join(this.temporary, 'role.yaml'), 'utf8'));
+                if (!raw || typeof raw !== 'object' || Array.isArray(raw)
+                    || (raw.session !== undefined && raw.session !== 'acp' && raw.session !== 'codex-app-server'))
+                    throw new Error('invalid temporary role snapshot');
+                temporary = { session: raw.session ?? 'acp', harness: typeof raw.harness === 'string' ? raw.harness : 'claude-code' };
+            }
+            const backend = configured?.session ?? temporary?.session;
+            const fallbackHarness = configured?.harness ?? temporary?.harness;
+            const socket = stateDir ? identity(controlSocketPath(stateDir)) : undefined;
+            const tokenPath = stateDir && join(stateDir, '.control-token');
+            const token = tokenPath && identity(tokenPath) ? createHash('sha256').update(readFileSync(tokenPath)).digest('hex') : undefined;
+            const exists = Boolean(configured || permanentId || temporaryId);
+            const availability = !exists ? 'missing' : stateDir && socket && token && backend ? 'available' : 'unavailable';
+            const fingerprint = JSON.stringify([Boolean(configured), permanentId, temporaryId, backend, socket, token]);
+            const lifetime = this.fingerprint === fingerprint ? this.state.roleLifetime : randomUUID();
+            this.fingerprint = fingerprint;
+            const next = { roleId: this.options.roleId, roleRevision: this.state.roleRevision, roleLifetime: lifetime,
+                availability, fallbackHarness, backend, stateDir, health: 'healthy' };
+            if (JSON.stringify(next) !== JSON.stringify(this.state)) {
+                this.state = { ...next, roleRevision: this.state.roleRevision + 1 };
+                this.publish();
+            }
+        }
+        catch {
+            this.fail('role-read-failed');
+        }
+    }
+    install() {
+        const wanted = new Map();
+        const add = (dir, child) => {
+            if (child === undefined)
+                wanted.set(dir, null);
+            else if (wanted.get(dir) !== null) {
+                const names = wanted.get(dir) ?? new Set();
+                names.add(child);
+                wanted.set(dir, names);
+            }
+        };
+        const parents = (path, boundary) => {
+            while (path !== boundary && dirname(path) !== path) {
+                add(dirname(path), basename(path));
+                path = dirname(path);
+            }
+        };
+        const configRoot = splitRootFor(this.configPath);
+        const configBoundary = dirname(dirname(this.configPath));
+        parents(this.configPath, configBoundary);
+        for (const dir of [configRoot, ...['agents', 'brains', 'roles', 'agent_templates'].map(kind => join(configRoot, kind))]) {
+            parents(dir, configBoundary);
+            add(dir);
+        }
+        for (const dir of [this.permanent, this.temporary]) {
+            parents(dir, dirname(dirname(dirname(dir))));
+            for (const name of ['role.yaml', '.control-token', '.control.sock'])
+                add(dir, name);
+            const socket = controlSocketPath(dir);
+            parents(socket, dirname(dirname(socket)));
+        }
+        for (const [dir, current] of this.watchers) {
+            if (!wanted.has(dir) || identity(dir) !== current.identity) {
+                this.watchers.delete(dir);
+                current.handle.close();
+            }
+        }
+        for (const [dir, names] of wanted) {
+            const id = identity(dir);
+            if (!id)
+                continue;
+            const existing = this.watchers.get(dir);
+            if (existing) {
+                existing.names = names;
+                continue;
+            }
+            try {
+                const handle = (this.options.watch ?? ((path, listener) => watch(path, { persistent: false }, listener)))(dir, (_event, filename) => {
+                    const entry = this.watchers.get(dir);
+                    if (filename === null || !entry?.names || entry.names.has(String(filename)) || String(filename) === basename(dir))
+                        this.schedule();
+                });
+                this.watchers.set(dir, { identity: id, names, handle });
+                handle.on('error', (error) => {
+                    if (this.watchers.get(dir)?.handle === handle)
+                        this.watchFailure(error);
+                });
+                handle.on('close', () => {
+                    if (this.watchers.get(dir)?.handle !== handle)
+                        return;
+                    this.watchers.delete(dir);
+                    this.fail('watch-closed');
+                });
+            }
+            catch (error) {
+                this.watchFailure(error);
+                return;
+            }
+        }
+    }
+    watchFailure(error) {
+        this.fail(['ENOSYS', 'ENOTSUP', 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM'].includes(error.code ?? '') ? 'watch-unsupported' : 'watch-error');
+    }
+}

package/dist/application/fleet-query-service.d.ts

@@ -24,7 +24,7 @@ export declare class FleetQueryService {
     private readonly options;
     private readonly control;
     constructor(options: FleetQueryOptions);
-    list(): Promise<Array<{
+    list(includeTemporary?: boolean, strict?: boolean): Promise<Array<{
         role: RoleRecord;
         status: RoleStatus;
         capabilities: RoleCapabilities;

package/dist/application/fleet-query-service.js

@@ -75,9 +75,9 @@ export class FleetQueryService {
         this.options = options;
         this.control = options.control ?? controlRequest;
     }
-    async list() {
-        const roles = (await this.options.repository.list())
-            .filter(role => role.configured && role.lifetime === 'permanent');
+    async list(includeTemporary = false, strict = false) {
+        const roles = (await this.options.repository.list(strict))
+            .filter(role => (role.configured && role.lifetime === 'permanent') || (includeTemporary && role.lifetime === 'temporary'));
         return Promise.all(roles.map(async (role) => {
             const status = await this.status(role);
             return { role, status, capabilities: roleCapabilities(role, status, this.options.capabilityContext) };

package/dist/application/log-service.js

@@ -3,7 +3,6 @@ import { createHmac, randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 import { realExec } from '../exec.js';
 import { logsRoot } from '../paths.js';
-import { unitFor } from '../supervisor/systemd.js';
 import { ROLE_NAME_RE } from '../config.js';
 import { FleetError } from './errors.js';
 const STANDARD_REDACTIONS = [
@@ -78,12 +77,13 @@ export class StructuredLogService {
     }
     async tail(roleId, requested, cursor) {
         const limit = Math.min(Math.max(requested, 1), 1_000);
-        const args = this.backend.id === 'systemd'
-            ? {
-                cmd: 'journalctl',
-                args: ['--user', '-u', unitFor(roleId), '-o', 'json', '--no-pager', '-n', String(limit)],
-            }
-            : this.backend.logsArgs(roleId, false);
+        const source = this.backend.logsArgs(roleId, false);
+        const args = { cmd: source.cmd, args: [...source.args] };
+        const count = args.args.indexOf('-n');
+        if (count >= 0)
+            args.args[count + 1] = String(limit);
+        if (args.cmd === 'journalctl')
+            args.args.push('-o', 'json', '--no-pager', '-n', String(limit));
         if (!['journalctl', 'tail', 'tmux'].includes(args.cmd))
             throw new FleetError('capability_unavailable', 'log backend is unsupported');
         const result = await this.exec(args.cmd, args.args);
@@ -93,7 +93,7 @@ export class StructuredLogService {
         const parsed = lines.map((line, index) => {
             let text = line;
             let at;
-            if (this.backend.id === 'systemd') {
+            if (args.cmd === 'journalctl') {
                 try {
                     const json = JSON.parse(line);
                     text = typeof json.MESSAGE === 'string' ? json.MESSAGE : line;

package/dist/application/model-catalog.d.ts

@@ -14,7 +14,7 @@ export interface HarnessModelCatalog {
 export declare function codexModelCatalog(path?: string): HarnessModelCatalog;
 /**
  * Claude Code 2.1 has no typed model-list endpoint. These exact IDs are the
- * versioned adapter contract shipped by the installed 2.1 CLI, not aliases and
+ * versioned adapter contract verified with CLI 2.1.281, not aliases and
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export declare function claudeModelCatalog(): HarnessModelCatalog;

package/dist/application/model-catalog.js

@@ -41,17 +41,20 @@ export function codexModelCatalog(path = join(homedir(), '.codex', 'models_cache
 }
 /**
  * Claude Code 2.1 has no typed model-list endpoint. These exact IDs are the
- * versioned adapter contract shipped by the installed 2.1 CLI, not aliases and
+ * versioned adapter contract verified with CLI 2.1.281, not aliases and
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export function claudeModelCatalog() {
     const reasoningEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
     return {
         models: [
+            { id: 'claude-fable-5-1', label: 'Claude Fable 5.1', reasoningEfforts, source: 'claude-adapter-2.1' },
+            { id: 'claude-opus-5-5', label: 'Claude Opus 5.5', reasoningEfforts, source: 'claude-adapter-2.1' },
+            { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5', reasoningEfforts: [], source: 'claude-adapter-2.1' },
             { id: 'claude-fable-5', label: 'Claude Fable 5', reasoningEfforts, source: 'claude-adapter-2.1' },
             { id: 'claude-opus-5', label: 'Claude Opus 5', reasoningEfforts, source: 'claude-adapter-2.1' },
             { id: 'claude-sonnet-5', label: 'Claude Sonnet 5', reasoningEfforts, source: 'claude-adapter-2.1' },
         ],
-        warnings: ['Claude Code exposes no typed model-list endpoint; choices are exact 2.1 adapter IDs and entitlement is validated at launch.'],
+        warnings: ['Claude Code exposes no typed model-list endpoint; choices require a current Claude runtime (verified with 2.1.281); older bundled SDKs need CLAUDE_CODE_EXECUTABLE. Entitlement is validated at launch.'],
     };
 }

package/dist/application/preset-provenance.d.ts

@@ -0,0 +1,19 @@
+export declare const PROVENANCE_KINDS: {
+    readonly role: "roles";
+    readonly brain: "brains";
+    readonly template: "agent_templates";
+    readonly layout: "room_layouts";
+};
+export type ProvenanceKind = keyof typeof PROVENANCE_KINDS;
+export type ProvenanceStatus = 'predefined' | 'changed' | 'custom';
+export interface ProvenanceEntry {
+    status: ProvenanceStatus;
+    preset?: string;
+}
+export type Provenance = Record<ProvenanceKind, Record<string, ProvenanceEntry>>;
+export declare class PresetProvenance {
+    private configPath?;
+    private presetRoot;
+    constructor(configPath?: string | undefined, presetRoot?: string);
+    read(): Provenance;
+}

package/dist/application/preset-provenance.js

@@ -0,0 +1,59 @@
+/** Where each configured definition came from, compared with the packaged presets.
+ * A definition is `predefined` when it has the same value as the shipped preset of
+ * the same name, `changed` when a preset of that name exists but the value differs,
+ * and `custom` otherwise. Values are compared after parsing, so the formatting the
+ * configuration editor writes does not count as a change. Preset text is returned
+ * so users can see exactly what ships; it contains no host data.
+ */
+import { isDeepStrictEqual } from 'node:util';
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { parse } from 'yaml';
+import { defaultConfigPath } from '../paths.js';
+import { splitRootFor } from '../config.js';
+import { packagedPresetRoot } from '../preset-bootstrap.js';
+export const PROVENANCE_KINDS = { role: 'roles', brain: 'brains', template: 'agent_templates', layout: 'room_layouts' };
+const MAX_BYTES = 256 * 1024;
+/** Regular, bounded YAML files of one directory, by definition name. Anything else is skipped. */
+function yamlFiles(dir) {
+    const files = new Map();
+    if (!existsSync(dir) || !lstatSync(dir).isDirectory())
+        return files;
+    for (const file of readdirSync(dir).sort()) {
+        if (!/\.ya?ml$/.test(file))
+            continue;
+        const path = join(dir, file), stat = lstatSync(path);
+        if (!stat.isFile() || stat.size > MAX_BYTES)
+            continue;
+        files.set(basename(file, extname(file)), readFileSync(path, 'utf8'));
+    }
+    return files;
+}
+const parsed = (text) => { try {
+    return parse(text);
+}
+catch {
+    return Symbol('unparseable');
+} };
+export class PresetProvenance {
+    configPath;
+    presetRoot;
+    constructor(configPath, presetRoot = join(packagedPresetRoot(), 'fleet')) {
+        this.configPath = configPath;
+        this.presetRoot = presetRoot;
+    }
+    read() {
+        const split = splitRootFor(this.configPath ?? defaultConfigPath());
+        const result = {};
+        for (const [kind, dir] of Object.entries(PROVENANCE_KINDS)) {
+            const presets = yamlFiles(join(this.presetRoot, dir)), installed = yamlFiles(join(split, dir));
+            result[kind] = Object.fromEntries([...installed].map(([name, text]) => {
+                const preset = presets.get(name);
+                if (preset === undefined)
+                    return [name, { status: 'custom' }];
+                return [name, { status: isDeepStrictEqual(parsed(text), parsed(preset)) ? 'predefined' : 'changed', preset }];
+            }));
+        }
+        return result;
+    }
+}

package/dist/application/resource-observer.d.ts

@@ -0,0 +1,43 @@
+import { type FSWatcher } from 'node:fs';
+export interface FleetResourceState {
+    protocolVersion: 1;
+    producerGeneration: string;
+    position: number;
+    health: 'healthy' | 'failed' | 'unsupported';
+}
+export interface FleetResourceScope {
+    configPath?: string;
+    subscribeMutations?: (listener: () => void) => () => void;
+    /** Durable notification owners may reinstall degraded watches without idle content polling. */
+    retryWatchFailures?: boolean;
+    roots?: string[];
+    /** Overrides full Fleet discovery for narrow owners such as task delivery. */
+    paths?: string[];
+    /** Path routing precedes a coalesced committed callback. Undefined means
+     * unknown/recovered coverage and requires conservative discovery. */
+    onInvalidated?: (path: string | undefined) => void;
+    watch?: (path: string, listener: (event: string, filename: string | null) => void) => Pick<FSWatcher, 'on' | 'close'>;
+}
+/** Only call after durable persistence succeeds. Observers cannot fail a commit. */
+export declare function publishFleetResourceCommit(path: string): void;
+/** Native notifications cover supported local mounts. No idle content scan or
+ * silent claim of coverage after watch failure. Parents survive atomic rename.
+ * Discovery reads directory metadata only, never opens a controller or transcript. */
+export declare function observeFleetResources(scope: FleetResourceScope, onCommitted: (state: FleetResourceState) => void, signal: AbortSignal): {
+    snapshot: () => {
+        health: "healthy" | "failed" | "unsupported";
+        protocolVersion: 1;
+        producerGeneration: string;
+        position: number;
+    };
+    cursor: (accepts: (path: string) => boolean, lifetime: AbortSignal) => {
+        snapshot: () => {
+            position: number;
+            health: "healthy" | "failed" | "unsupported";
+            protocolVersion: 1;
+            producerGeneration: string;
+        };
+        dispose: () => void;
+    };
+    dispose: () => void;
+};