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

package/dist/rooms-tasks/launch-snapshot.js

@@ -0,0 +1,181 @@
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically } from '../atomic-file.js';
+import { stateRoot } from '../paths.js';
+import { canonicalJson } from '../canonical-json.js';
+import { randomUUID } from 'node:crypto';
+const launchSnapshotDir = () => join(stateRoot(), 'launch-snapshots');
+const launchSnapshotPath = (hash) => join(launchSnapshotDir(), `${hash}.json`);
+const launchSnapshotLock = () => join(stateRoot(), '.launch-snapshot.lock');
+function assertPrivateDirectory(path) {
+    const stat = lstatSync(path);
+    const uid = process.getuid?.();
+    if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0
+        || (uid !== undefined && stat.uid !== uid))
+        throw new Error('launch snapshot directory has unsafe ownership or permissions');
+}
+/** Cross-process exclusion used from seal through durable Room publication. */
+export function acquireLaunchSnapshotLock(options = {}) {
+    mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
+    const path = launchSnapshotLock();
+    const token = randomUUID();
+    let reclaimed = false;
+    for (;;) {
+        const claim = `${path}.claim.${process.pid}.${randomUUID()}`;
+        try {
+            mkdirSync(claim, { mode: 0o700 });
+            writeFileSync(join(claim, 'owner.json'), JSON.stringify({ pid: process.pid, token }), { mode: 0o600 });
+            options.beforePublish?.(claim, path);
+            renameSync(claim, path);
+            if (reclaimed)
+                sweepUnreferencedSnapshotsLocked();
+            return () => {
+                try {
+                    const owner = JSON.parse(readFileSync(join(path, 'owner.json'), 'utf8'));
+                    if (owner.token === token)
+                        rmSync(path, { recursive: true, force: true });
+                }
+                catch { /* ownership cannot be proved; never remove a successor */ }
+            };
+        }
+        catch (error) {
+            rmSync(claim, { recursive: true, force: true });
+            if (!['EEXIST', 'ENOTEMPTY'].includes(error.code ?? ''))
+                throw error;
+            let alive = true;
+            try {
+                const owner = JSON.parse(readFileSync(join(path, 'owner.json'), 'utf8'));
+                if (typeof owner.pid !== 'number')
+                    alive = false;
+                else
+                    try {
+                        process.kill(owner.pid, 0);
+                    }
+                    catch {
+                        alive = false;
+                    }
+            }
+            catch {
+                alive = false;
+            }
+            if (!alive) {
+                rmSync(path, { recursive: true, force: true });
+                reclaimed = true;
+                continue;
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+}
+function referencedByRetainedState(hash, excludeTaskFile) {
+    for (const directory of ['tasks', 'rooms']) {
+        const root = join(stateRoot(), directory);
+        if (!existsSync(root))
+            continue;
+        for (const name of readdirSync(root).filter(entry => entry.endsWith('.json'))) {
+            if (directory === 'tasks' && excludeTaskFile !== undefined && name === excludeTaskFile)
+                continue;
+            try {
+                if (readFileSync(join(root, name), 'utf8').includes(hash))
+                    return true;
+            }
+            catch {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function sweepUnreferencedSnapshotsLocked() {
+    const dir = launchSnapshotDir();
+    if (!existsSync(dir))
+        return;
+    assertPrivateDirectory(dir);
+    for (const name of readdirSync(dir).filter(entry => /^[a-f0-9]{64}\.json$/.test(entry))) {
+        const hash = name.slice(0, -5);
+        if (!referencedByRetainedState(hash))
+            unlinkSync(join(dir, name));
+    }
+}
+export function redactLaunchDefinition(value, key = '') {
+    if (key === 'prompt' && typeof value === 'string')
+        return {
+            bytes: Buffer.byteLength(value, 'utf8'),
+            sha256: createHash('sha256').update(value).digest('hex'),
+        };
+    if (['env', 'harness_options', 'session_options', 'owner_channel', 'auth_proxy'].includes(key))
+        return '<redacted>';
+    if (Array.isArray(value))
+        return value.map(item => redactLaunchDefinition(item));
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value)
+            .map(([child, item]) => [child, redactLaunchDefinition(item, child)]));
+    return value;
+}
+export function sealLaunchSnapshot(definitions) {
+    const payload = { schema_version: 1, definitions: structuredClone(definitions) };
+    const bytes = `${canonicalJson(payload)}\n`;
+    const hash = createHash('sha256').update(bytes).digest('hex');
+    const path = launchSnapshotPath(hash);
+    const dir = launchSnapshotDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    assertPrivateDirectory(dir);
+    if (!existsSync(path))
+        replaceFileAtomically(path, bytes, 0o600);
+    else
+        readLaunchSnapshot(hash);
+    return hash;
+}
+export function readLaunchSnapshot(hash) {
+    if (!/^[a-f0-9]{64}$/.test(hash))
+        throw new Error('invalid launch snapshot hash');
+    const dir = launchSnapshotDir();
+    const path = launchSnapshotPath(hash);
+    const dirStat = lstatSync(dir);
+    const fileStat = lstatSync(path);
+    const uid = process.getuid?.();
+    if (!dirStat.isDirectory() || dirStat.isSymbolicLink() || (dirStat.mode & 0o077) !== 0
+        || (uid !== undefined && dirStat.uid !== uid))
+        throw new Error('launch snapshot directory has unsafe ownership or permissions');
+    if (!fileStat.isFile() || fileStat.isSymbolicLink() || (fileStat.mode & 0o077) !== 0
+        || (uid !== undefined && fileStat.uid !== uid))
+        throw new Error(`launch snapshot ${hash} has unsafe ownership or permissions`);
+    const bytes = readFileSync(path, 'utf8');
+    if (createHash('sha256').update(bytes).digest('hex') !== hash)
+        throw new Error(`launch snapshot ${hash} failed integrity verification`);
+    const parsed = JSON.parse(bytes);
+    if (parsed.schema_version !== 1 || !parsed.definitions || typeof parsed.definitions !== 'object')
+        throw new Error(`launch snapshot ${hash} has unsupported schema`);
+    return parsed.definitions;
+}
+/** Delete a sealed snapshot only after no retained Task/Room record references it. */
+export function releaseLaunchSnapshot(hash) {
+    const release = acquireLaunchSnapshotLock();
+    try {
+        if (referencedByRetainedState(hash))
+            return;
+        const path = launchSnapshotPath(hash);
+        if (existsSync(path))
+            unlinkSync(path);
+    }
+    finally {
+        release();
+    }
+}
+/**
+ * Deletion-finalization variant: the caller already holds the global
+ * launch-snapshot lock and is about to unlink the deletion-pending task
+ * `taskId`. The reference scan excludes exactly that task file — every other
+ * retained Task/Room reference still protects the snapshot. Deleting the
+ * snapshot BEFORE the task unlink keeps every crash seam recoverable: the
+ * hidden intent survives, and a retry sees the snapshot already absent.
+ */
+export function releaseLaunchSnapshotForDeletingTask(hash, taskId) {
+    if (referencedByRetainedState(hash, `${taskId}.json`))
+        return;
+    const path = launchSnapshotPath(hash);
+    if (existsSync(path))
+        unlinkSync(path);
+}

package/dist/rooms-tasks/member-overrides.d.ts

@@ -0,0 +1,30 @@
+import { type AgentDefinition, type AgentTemplateDefinition, type FleetConfig } from '../config.js';
+import type { TemplateDefinition, TemplateSnapshot } from './types.js';
+import type { AgentLoopsConfig } from '../loops/config.js';
+export interface MemberOverride {
+    agent_template?: string;
+    brain?: string;
+    role?: string;
+    approval?: 'ask' | 'auto' | 'allow';
+    filesystem?: 'read-only' | 'workspace' | 'unrestricted';
+    unattended?: 'deny' | 'wait';
+    cwd?: string;
+    model?: string;
+    effort?: string;
+    /** Whole-block override; false is the explicit no-loops policy. */
+    loops?: AgentLoopsConfig | false;
+    overrides?: Partial<AgentDefinition>;
+}
+export type MemberOverrides = Record<string, MemberOverride>;
+export declare function hashMemberOverrides(overrides: MemberOverrides): string;
+/** Parse only the ordered member-option subsequence supplied by the CLI action. */
+export declare function parseGroupedMemberArgs(argv: string[]): MemberOverrides;
+export declare function readMembersFile(path: string): MemberOverrides;
+export interface PreparedExecutionPlan {
+    snapshot: TemplateSnapshot;
+    launchDefinitions: Record<string, AgentTemplateDefinition>;
+    overrides: MemberOverrides;
+    planHash: string;
+    overridesHash: string;
+}
+export declare function prepareExecutionPlan(template: TemplateDefinition, cfg: FleetConfig, overrides?: MemberOverrides): PreparedExecutionPlan;

package/dist/rooms-tasks/member-overrides.js

@@ -0,0 +1,204 @@
+import { createHash } from 'node:crypto';
+import { lstatSync, readFileSync } from 'node:fs';
+import { parseFleetDocument } from '../config-yaml.js';
+import { validateEffectiveAgentTemplate } from '../config.js';
+import { analyzeRolePermissions } from '../permissions.js';
+import { canonicalJson } from '../canonical-json.js';
+import { redactLaunchDefinition } from './launch-snapshot.js';
+import { snapshotTemplate } from './templates.js';
+import { readLoopsFile } from '../spawn.js';
+import { canonicalAgentLoops, resolveAgentLoops } from '../loops/config.js';
+export function hashMemberOverrides(overrides) {
+    return createHash('sha256').update(canonicalJson(overrides)).digest('hex');
+}
+const OPTION_FIELDS = {
+    '--agent-template': 'agent_template', '--brain': 'brain', '--role': 'role',
+    '--approval': 'approval', '--filesystem': 'filesystem',
+    '--unattended': 'unattended', '--cwd': 'cwd', '--model': 'model', '--effort': 'effort',
+};
+/** Parse only the ordered member-option subsequence supplied by the CLI action. */
+export function parseGroupedMemberArgs(argv) {
+    const result = {};
+    let current;
+    for (let index = 0; index < argv.length;) {
+        const flag = argv[index];
+        if (flag === '--no-loops') {
+            if (!current)
+                throw new Error(`${flag} must follow --member <slot>`);
+            if (result[current].loops !== undefined)
+                throw new Error(`duplicate loop override for member '${current}'`);
+            result[current].loops = false;
+            index += 1;
+            continue;
+        }
+        const value = argv[index + 1];
+        if (!value || value.startsWith('--'))
+            throw new Error(`${flag}: value required`);
+        if (flag === '--member') {
+            if (result[value])
+                throw new Error(`duplicate member slot '${value}'`);
+            current = value;
+            result[current] = {};
+            index += 2;
+            continue;
+        }
+        if (flag === '--loops-file') {
+            if (!current)
+                throw new Error(`${flag} must follow --member <slot>`);
+            if (result[current].loops !== undefined)
+                throw new Error(`duplicate loop override for member '${current}'`);
+            result[current].loops = readLoopsFile(value);
+            index += 2;
+            continue;
+        }
+        const field = OPTION_FIELDS[flag];
+        if (!field)
+            throw new Error(`unknown member option '${flag}'`);
+        if (!current)
+            throw new Error(`${flag} must follow --member <slot>`);
+        if (result[current][field] !== undefined)
+            throw new Error(`duplicate ${flag} for member '${current}'`);
+        result[current][field] = value;
+        index += 2;
+    }
+    for (const [slot, value] of Object.entries(result))
+        validateMemberOverride(value, `member '${slot}'`);
+    return result;
+}
+export function readMembersFile(path) {
+    const stat = lstatSync(path);
+    const uid = process.getuid?.();
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1_000_000
+        || (uid !== undefined && stat.uid !== uid) || (stat.mode & 0o077) !== 0)
+        throw new Error(`${path}: members file must be a trusted regular file no larger than 1 MB`);
+    const raw = parseFleetDocument(path, readFileSync(path, 'utf8'), 'strict').value;
+    if (!raw.members || typeof raw.members !== 'object' || Array.isArray(raw.members)
+        || Object.keys(raw).some(key => key !== 'members'))
+        throw new Error(`${path}: expected exactly a members: mapping`);
+    const members = structuredClone(raw.members);
+    for (const [slot, value] of Object.entries(members))
+        validateMemberOverride(value, `${path}: member '${slot}'`);
+    return members;
+}
+const MEMBER_KEYS = new Set(['agent_template', 'brain', 'role', 'approval', 'filesystem', 'unattended', 'cwd', 'model', 'effort', 'overrides', 'loops']);
+function validateMemberOverride(value, where) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${where}: must be a mapping`);
+    const item = value;
+    const unknown = Object.keys(item).filter(key => !MEMBER_KEYS.has(key));
+    if (unknown.length)
+        throw new Error(`${where}: unknown key '${unknown[0]}'`);
+    const allowed = {
+        approval: ['ask', 'auto', 'allow'], filesystem: ['read-only', 'workspace', 'unrestricted'],
+        unattended: ['deny', 'wait'],
+    };
+    for (const [key, choices] of Object.entries(allowed))
+        if (item[key] !== undefined && !choices.includes(item[key]))
+            throw new Error(`${where}: ${key} must be one of ${choices.join(', ')}`);
+    for (const key of ['agent_template', 'brain', 'role', 'cwd', 'model', 'effort'])
+        if (item[key] !== undefined
+            && (typeof item[key] !== 'string' || !item[key].trim()))
+            throw new Error(`${where}: ${key} must be a non-blank string`);
+    if (item.overrides !== undefined && (!item.overrides || typeof item.overrides !== 'object' || Array.isArray(item.overrides)))
+        throw new Error(`${where}: overrides must be a mapping`);
+    if (item.overrides && Object.hasOwn(item.overrides, 'loops'))
+        throw new Error(`${where}: overrides.loops is unsupported; use the top-level loops member override`);
+    if (item.loops !== undefined && item.loops !== false
+        && (!item.loops || typeof item.loops !== 'object' || Array.isArray(item.loops)))
+        throw new Error(`${where}: loops must be a mapping or false`);
+}
+const MAPS = new Set(['permissions', 'env', 'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy']);
+function merge(base, overlay) {
+    const out = structuredClone(base);
+    for (const [key, value] of Object.entries(overlay)) {
+        if (value === null)
+            throw new Error(`member override ${key}: null deletion is not supported`);
+        out[key] = MAPS.has(key) && out[key] && typeof out[key] === 'object' && !Array.isArray(out[key])
+            && typeof value === 'object' && !Array.isArray(value)
+            ? merge(out[key], value) : structuredClone(value);
+    }
+    return out;
+}
+export function prepareExecutionPlan(template, cfg, overrides = {}) {
+    for (const [slot, value] of Object.entries(overrides))
+        validateMemberOverride(value, `member '${slot}'`);
+    const slots = new Set(template.members.map(member => member.slot));
+    for (const slot of Object.keys(overrides))
+        if (!slots.has(slot))
+            throw new Error(`unknown member slot '${slot}'`);
+    const snapshot = snapshotTemplate(template, cfg.agentTemplates);
+    const launchDefinitions = {};
+    snapshot.members = snapshot.members.map(member => {
+        const input = overrides[member.slot] ?? {};
+        const source = input.agent_template ?? member.agent_template;
+        const base = cfg.agentTemplates?.[source];
+        if (!base)
+            throw new Error(`Agent Template '${source}' not found`);
+        let definition = merge(base, (input.overrides ?? {}));
+        if (input.loops === false)
+            delete definition.loops;
+        else if (input.loops !== undefined)
+            definition.loops = structuredClone(input.loops);
+        const rolePreset = input.role ? cfg.rolePresets?.[input.role] : undefined;
+        if (input.role && !rolePreset)
+            throw new Error(`Role '${input.role}' not found`);
+        const brainPreset = input.brain ? cfg.brainPresets?.[input.brain] : undefined;
+        if (input.brain && !brainPreset)
+            throw new Error(`Brain '${input.brain}' not found`);
+        if (rolePreset)
+            definition.role = { inline: structuredClone(rolePreset) };
+        if (brainPreset)
+            definition.brain = { inline: structuredClone(brainPreset) };
+        const permissions = { ...(definition.permissions ?? {}) };
+        if (input.approval)
+            permissions.approval = input.approval;
+        if (input.filesystem)
+            permissions.filesystem = input.filesystem;
+        if (input.unattended)
+            permissions.unattended = input.unattended;
+        if (Object.keys(permissions).length)
+            definition.permissions = permissions;
+        if (input.cwd)
+            definition.cwd = input.cwd;
+        if (input.model || input.effort) {
+            const brain = 'inline' in definition.brain ? structuredClone(definition.brain.inline) : {};
+            if (input.model)
+                brain.model = input.model;
+            if (input.effort)
+                brain.effort = input.effort;
+            definition.brain = { inline: brain };
+        }
+        definition = validateEffectiveAgentTemplate(definition, member.slot);
+        {
+            if (!cfg.resolveAgentDefinition)
+                throw new Error('configuration has no effective Agent resolver');
+            const role = cfg.resolveAgentDefinition(`RoomMember_${member.slot}`, {
+                ...definition, identity: `RoomMember_${member.slot}`,
+            });
+            if (definition.loops !== undefined)
+                definition.loops = canonicalAgentLoops(resolveAgentLoops(definition.loops, role, `(member '${member.slot}' resolved loops)`));
+            const analysis = analyzeRolePermissions(role);
+            if (analysis.conflicts?.length)
+                throw new Error(`member '${member.slot}' has native permission conflicts: ${analysis.conflicts.map(item => item.warning).join('; ')}`);
+            if (analysis.floor && !analysis.floor.meets && analysis.floorSeverity === 'fail')
+                throw new Error(`member '${member.slot}' fails unattended floor: ${analysis.floor.missing.join(', ')}`);
+        }
+        const id = `${member.slot}:${source}`;
+        launchDefinitions[id] = definition;
+        const hash = createHash('sha256').update(canonicalJson(definition)).digest('hex');
+        return { ...member, agent_template: source, launch_definition_id: id,
+            loop_source: input.loops !== undefined ? 'cli' : base.loops !== undefined ? 'agent-template' : 'omitted',
+            agent_template_hash: hash,
+            ...(input.role ? { role_preset: { id: input.role, hash: createHash('sha256').update(canonicalJson(rolePreset)).digest('hex') } } : {}),
+            ...(input.brain ? { brain_preset: { id: input.brain, hash: createHash('sha256').update(canonicalJson(brainPreset)).digest('hex') } } : {}),
+            agent_projection: redactLaunchDefinition(definition) };
+    });
+    const planHash = createHash('sha256').update(canonicalJson({
+        template: snapshot.content_hash, members: snapshot.members.map(member => ({
+            slot: member.slot, source: member.agent_template, hash: member.agent_template_hash,
+        })), overrides,
+    })).digest('hex');
+    snapshot.content_hash = planHash;
+    return { snapshot, launchDefinitions, overridesHash: hashMemberOverrides(overrides),
+        overrides: redactLaunchDefinition(overrides), planHash };
+}