@ours.network/fleet 0.9.3 → 0.10.0-nightly.1

package/dist/runner.js

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parse } from 'yaml';
 import { agentDir, home, stateRoot } from './paths.js';
-import { loadConfig, findRole } from './config.js';
+import { loadConfig, findRole, resolvePermissions } from './config.js';
 import { getAdapter } from './harness/registry.js';
 import { Tmux } from './tmux.js';
 import { createMonitor } from './monitor.js';
@@ -11,6 +11,9 @@ import { realExec, shq } from './exec.js';
 import { resolveIsolation } from './isolation/policy.js';
 import { selectIsolationBackend } from './isolation/registry.js';
 import { resourceArgs, cpuControllerDelegated } from './isolation/resources.js';
+import { AcpSession } from './session/acp.js';
+import { RoleControlServer } from './session/control.js';
+import { TmuxSession } from './session/tmux.js';
 const defaultDeps = () => ({
     tmux: new Tmux(),
     exec: realExec,
@@ -182,10 +185,17 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         writeFileSync(bootedFile, '');
     const runCwd = role.cwd && existsSync(role.cwd) ? role.cwd : dir;
     const prep = await adapter.prepareSession(role, { stateDir: dir, runCwd });
-    const launch = adapter.buildLaunch(role, mode, { sessionId }, prep);
+    const sessionBackend = role.session ?? 'tmux';
+    const launch = sessionBackend === 'acp'
+        ? (() => {
+            if (!adapter.buildAcpLaunch)
+                throw new Error(`harness '${role.harness}' does not support the ACP session backend`);
+            return adapter.buildAcpLaunch(role, prep);
+        })()
+        : adapter.buildLaunch(role, mode, { sessionId }, prep);
     // Isolation is additive: only roles that declare `isolation:` are wrapped. The
     // env prefix + exit capture in buildPaneCommand stay host-side (see §5.3).
-    let paneArgv = launch.argv;
+    let wrappedArgv = launch.argv;
     if (role.isolation) {
         const addDirs = role.harness === 'codex'
             ? (role.harness_options?.add_dirs ?? [])
@@ -204,14 +214,14 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             deps.log(`[${name}] isolation: ${sel.backend.id} (net=${policy.network}) ${sel.detail}`);
             rmSync(degradedMarker, { force: true });
         }
-        paneArgv = sel.backend.wrap(launch.argv, policy, ctx);
+        wrappedArgv = sel.backend.wrap(launch.argv, policy, ctx);
         // Resource caps wrap the sandbox from OUTSIDE, at the pane's own cgroup scope
         // (§5.4). Applies even when the sandbox degraded to none.
         const { argv: rprefix, warnings } = resourceArgs(policy.resources, deps.cpuDelegated());
         for (const w of warnings)
             deps.log(`[${name}] WARNING ${w}`);
         if (rprefix.length)
-            paneArgv = [...rprefix, ...paneArgv];
+            wrappedArgv = [...rprefix, ...wrappedArgv];
     }
     // Start-stagger: space this launch at least start_stagger_ms after the previous
     // agent launch across the whole host, so a burst of boots (systemd starts every
@@ -232,34 +242,79 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     // (backlog before the tip is the SessionStart hook's job). Disabled roles keep
     // the legacy in-session watch. Temp snapshots predating `monitor:` are treated
     // as disabled (monitor may be undefined on an old role.yaml).
+    const resolvedMonitorDeps = monitorDeps(deps, role.env);
     const monitor = role.monitor?.enabled ? deps.createMonitor({
-        name, agentDir: dir, cfg: role.monitor,
-        deps: monitorDeps(deps, role.env),
+        name, identity: role.identity, agentDir: dir, cfg: role.monitor,
+        deps: resolvedMonitorDeps,
     }) : null;
     if (monitor)
         await monitor.prime();
     rmSync(exitFile, { force: true });
-    await deps.tmux.kill(name);
-    await deps.tmux.newSession(name, runCwd, buildPaneCommand(launch, role.env, exitFile, paneArgv));
-    let pid = null;
-    for (let i = 0; i < 40 && pid === null; i++) {
-        pid = await deps.tmux.panePid(name);
-        if (pid === null)
-            await deps.sleep(250);
+    let pid;
+    let sessionHandle;
+    let acpSession;
+    let control;
+    if (sessionBackend === 'acp') {
+        acpSession = await AcpSession.start({
+            name,
+            argv: wrappedArgv,
+            cwd: runCwd,
+            env: { ...launch.env, ...(role.env ?? {}) },
+            stateDir: dir,
+            mode,
+            permissions: role.permissions ?? resolvePermissions(undefined, undefined),
+            log: deps.log,
+        });
+        pid = acpSession.pid;
+        sessionHandle = acpSession;
+        control = new RoleControlServer(dir, acpSession, deps.log);
+        await control.start();
+        resolvedMonitorDeps.delivery = {
+            submit: async (text) => {
+                const result = await acpSession.submitPrompt(text);
+                return { accepted: result.accepted, detail: result.detail };
+            },
+        };
+        const firstPrompt = mode === 'fresh'
+            ? `Read and follow ${join(dir, 'briefing.md')} now.`
+            : adapter.vocabulary.restartPrompt(role.identity, join(dir, 'WORKLOG.md'), role);
+        const started = await acpSession.submitPrompt(firstPrompt);
+        if (!started.accepted) {
+            monitor?.stop();
+            await control.close();
+            await acpSession.close();
+            throw new Error(`[${name}] ACP session rejected startup prompt: ${started.detail ?? started.outcome}`);
+        }
+    }
+    else {
+        await deps.tmux.kill(name);
+        await deps.tmux.newSession(name, runCwd, buildPaneCommand(launch, role.env, exitFile, wrappedArgv));
+        let panePid = null;
+        for (let i = 0; i < 40 && panePid === null; i++) {
+            panePid = await deps.tmux.panePid(name);
+            if (panePid === null)
+                await deps.sleep(250);
+        }
+        if (panePid === null)
+            throw new Error(`[${name}] could not resolve tmux pane pid`);
+        pid = panePid;
+        sessionHandle = new TmuxSession(name, pid, deps.tmux, deps.isAlive);
     }
-    if (pid === null)
-        throw new Error(`[${name}] could not resolve tmux pane pid`);
-    deps.log(`[${name}] up; pid=${pid} cwd=${runCwd} harness=${role.harness} mode=${mode}`);
+    deps.log(`[${name}] up; pid=${pid} cwd=${runCwd} harness=${role.harness} session=${sessionBackend} mode=${mode}`);
     // The monitor loop lives exactly as long as the session: it starts once the
     // pane pid is known and is stopped when that pid dies (task dies with runner).
     const monitorLoop = monitor?.run(pid);
     const start = deps.now();
-    while (deps.isAlive(pid))
+    while (sessionHandle.isAlive())
         await deps.sleep(2000);
     if (monitor) {
         monitor.stop();
         await monitorLoop;
     }
+    if (control)
+        await control.close();
+    if (acpSession)
+        await acpSession.close();
     const elapsed = (deps.now() - start) / 1000;
     const code = existsSync(exitFile) ? readFileSync(exitFile, 'utf8').trim() : 'crash';
     const rotate = (why) => {

package/dist/session/acp.d.ts

@@ -0,0 +1,49 @@
+import type { CommonPermissions } from '../config.js';
+import type { SessionEvent, SessionHandle, SessionSnapshot, TurnResult } from './types.js';
+export interface AcpSessionOptions {
+    name: string;
+    argv: string[];
+    cwd: string;
+    env: Record<string, string>;
+    stateDir: string;
+    mode: 'fresh' | 'resume';
+    permissions: CommonPermissions;
+    log(line: string): void;
+}
+/**
+ * Persistent ACP v1 client. It is the sole owner of the agent's stdio; all
+ * human/automation attachment happens through the fleet role-control protocol.
+ */
+export declare class AcpSession implements SessionHandle {
+    private readonly options;
+    readonly backend: "acp";
+    readonly pid: number;
+    private readonly child;
+    private readonly events;
+    private readonly sessionFile;
+    private readonly pendingPermissions;
+    private connection;
+    private sessionId?;
+    private readiness;
+    private lastError?;
+    private promptTail;
+    private capabilities?;
+    private controllerCount;
+    private constructor();
+    static start(options: AcpSessionOptions): Promise<AcpSession>;
+    isAlive(): boolean;
+    snapshot(): SessionSnapshot;
+    submitPrompt(text: string): Promise<TurnResult>;
+    interrupt(): Promise<void>;
+    respondPermission(permissionId: string, optionId: string): boolean;
+    eventsSince(seq: number): SessionEvent[];
+    subscribe(listener: (event: SessionEvent) => void): () => void;
+    setControllerAttached(attached: boolean): void;
+    close(): Promise<void>;
+    private initialize;
+    private runPrompt;
+    private requestPermission;
+    private withinAutomaticBoundary;
+    private recordUpdate;
+    private fail;
+}

package/dist/session/acp.js

@@ -0,0 +1,280 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { Readable, Writable } from 'node:stream';
+import * as acp from '@agentclientprotocol/sdk';
+import { SessionEvents } from './events.js';
+/**
+ * Persistent ACP v1 client. It is the sole owner of the agent's stdio; all
+ * human/automation attachment happens through the fleet role-control protocol.
+ */
+export class AcpSession {
+    options;
+    backend = 'acp';
+    pid;
+    child;
+    events;
+    sessionFile;
+    pendingPermissions = new Map();
+    connection;
+    sessionId;
+    readiness = 'starting';
+    lastError;
+    promptTail = Promise.resolve();
+    capabilities;
+    controllerCount = 0;
+    constructor(options, child, connection) {
+        this.options = options;
+        this.child = child;
+        this.connection = connection;
+        this.pid = child.pid ?? -1;
+        this.events = new SessionEvents(join(options.stateDir, '.session-events.jsonl'));
+        this.sessionFile = join(options.stateDir, '.acp-session-id');
+        child.stderr.on('data', chunk => options.log(`[${options.name}] acp: ${String(chunk).trimEnd()}`));
+        child.once('exit', (code, signal) => {
+            if (this.readiness !== 'failed') {
+                this.readiness = 'failed';
+                this.lastError = `ACP agent exited (${code ?? signal ?? 'unknown'})`;
+            }
+            this.events.emit('state', { status: 'failed', text: this.lastError });
+        });
+    }
+    static async start(options) {
+        if (!options.argv.length)
+            throw new Error('ACP agent command is empty');
+        const child = spawn(options.argv[0], options.argv.slice(1), {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        await new Promise((resolve, reject) => {
+            child.once('spawn', resolve);
+            child.once('error', reject);
+        });
+        let instance;
+        const app = acp.client({ name: 'ours-fleet' })
+            .onNotification(acp.methods.client.session.update, ({ params }) => {
+            instance?.recordUpdate(params.update);
+        })
+            .onRequest(acp.methods.client.session.requestPermission, ({ params }) => {
+            if (!instance)
+                return { outcome: { outcome: 'cancelled' } };
+            return instance.requestPermission(params);
+        });
+        const stream = acp.ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const connection = app.connect(stream);
+        instance = new AcpSession(options, child, connection);
+        try {
+            await instance.initialize();
+            return instance;
+        }
+        catch (error) {
+            instance.fail(error);
+            await instance.close();
+            throw error;
+        }
+    }
+    isAlive() {
+        return this.child.exitCode === null && !this.child.killed;
+    }
+    snapshot() {
+        return {
+            backend: 'acp',
+            alive: this.isAlive(),
+            readiness: this.readiness,
+            sessionId: this.sessionId,
+            lastError: this.lastError,
+            pendingPermissionId: this.pendingPermissions.keys().next().value,
+        };
+    }
+    submitPrompt(text) {
+        const operation = this.promptTail.then(() => this.runPrompt(text));
+        this.promptTail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async interrupt() {
+        if (!this.sessionId)
+            return;
+        await this.connection.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.sessionId });
+    }
+    respondPermission(permissionId, optionId) {
+        const pending = this.pendingPermissions.get(permissionId);
+        if (!pending || !pending.options.some(option => option.optionId === optionId))
+            return false;
+        this.pendingPermissions.delete(permissionId);
+        pending.resolve({ outcome: { outcome: 'selected', optionId } });
+        this.readiness = 'running';
+        return true;
+    }
+    eventsSince(seq) {
+        return this.events.since(seq);
+    }
+    subscribe(listener) {
+        return this.events.subscribe(listener);
+    }
+    setControllerAttached(attached) {
+        this.controllerCount = Math.max(0, this.controllerCount + (attached ? 1 : -1));
+    }
+    async close() {
+        for (const pending of this.pendingPermissions.values())
+            pending.resolve({ outcome: { outcome: 'cancelled' } });
+        this.pendingPermissions.clear();
+        if (this.sessionId && this.capabilities?.sessionCapabilities?.close != null) {
+            await this.connection.agent.request(acp.methods.agent.session.close, { sessionId: this.sessionId }).catch(() => undefined);
+        }
+        this.connection.close();
+        if (this.isAlive())
+            this.child.kill('SIGTERM');
+    }
+    async initialize() {
+        const initialized = await this.connection.agent.request(acp.methods.agent.initialize, {
+            protocolVersion: acp.PROTOCOL_VERSION,
+            clientCapabilities: {},
+            clientInfo: { name: 'ours-fleet', version: '1' },
+        });
+        if (initialized.protocolVersion !== acp.PROTOCOL_VERSION)
+            throw new Error(`ACP protocol mismatch: agent selected ${initialized.protocolVersion}, client supports ${acp.PROTOCOL_VERSION}`);
+        this.capabilities = initialized.agentCapabilities;
+        const persisted = this.options.mode === 'resume' && existsSync(this.sessionFile)
+            ? readFileSync(this.sessionFile, 'utf8').trim()
+            : '';
+        if (persisted && this.capabilities?.sessionCapabilities?.resume != null) {
+            await this.connection.agent.request(acp.methods.agent.session.resume, {
+                sessionId: persisted,
+                cwd: this.options.cwd,
+                mcpServers: [],
+            });
+            this.sessionId = persisted;
+        }
+        else if (persisted && this.capabilities?.loadSession) {
+            await this.connection.agent.request(acp.methods.agent.session.load, {
+                sessionId: persisted,
+                cwd: this.options.cwd,
+                mcpServers: [],
+            });
+            this.sessionId = persisted;
+        }
+        else {
+            const created = await this.connection.agent.request(acp.methods.agent.session.new, {
+                cwd: this.options.cwd,
+                mcpServers: [],
+            });
+            this.sessionId = created.sessionId;
+        }
+        writeFileSync(this.sessionFile, this.sessionId + '\n', { mode: 0o600 });
+        this.readiness = 'idle';
+        this.events.emit('state', { status: 'idle', text: `ACP session ${this.sessionId}` });
+    }
+    async runPrompt(text) {
+        if (!this.sessionId || !this.isAlive())
+            return { accepted: false, outcome: 'failed', detail: this.lastError ?? 'ACP session is offline' };
+        this.readiness = 'running';
+        const turnId = randomUUID();
+        this.events.emit('state', { turnId, status: 'running' });
+        try {
+            const response = await this.connection.agent.request(acp.methods.agent.session.prompt, {
+                sessionId: this.sessionId,
+                prompt: [{ type: 'text', text }],
+            });
+            this.readiness = 'idle';
+            this.events.emit('turn_stop', { turnId, stopReason: response.stopReason });
+            this.events.emit('state', { status: 'idle' });
+            const outcome = response.stopReason === 'cancelled'
+                ? 'cancelled'
+                : response.stopReason === 'refusal'
+                    ? 'refused'
+                    : 'completed';
+            return { accepted: true, outcome, detail: response.stopReason };
+        }
+        catch (error) {
+            this.lastError = error?.message ?? String(error);
+            this.readiness = this.isAlive() ? 'idle' : 'failed';
+            this.events.emit('error', { turnId, text: this.lastError });
+            if (this.isAlive())
+                this.events.emit('state', { status: 'idle' });
+            return { accepted: false, outcome: 'failed', detail: this.lastError };
+        }
+    }
+    requestPermission(params) {
+        const choose = (kinds) => params.options.find(option => kinds.includes(option.kind));
+        if (this.options.permissions.approval === 'allow' && this.withinAutomaticBoundary(params)) {
+            const option = choose(['allow_always', 'allow_once']);
+            return Promise.resolve(option
+                ? { outcome: { outcome: 'selected', optionId: option.optionId } }
+                : { outcome: { outcome: 'cancelled' } });
+        }
+        if (this.options.permissions.approval === 'deny'
+            || (this.controllerCount === 0 && this.options.permissions.unattended === 'deny')) {
+            const option = choose(['reject_always', 'reject_once']);
+            return Promise.resolve(option
+                ? { outcome: { outcome: 'selected', optionId: option.optionId } }
+                : { outcome: { outcome: 'cancelled' } });
+        }
+        const permissionId = randomUUID();
+        this.readiness = 'awaiting_permission';
+        this.events.emit('permission', {
+            permissionId,
+            toolCallId: params.toolCall.toolCallId,
+            title: params.toolCall.title ?? 'Permission requested',
+            status: 'pending',
+            options: params.options.map(option => ({
+                optionId: option.optionId, name: option.name, kind: option.kind,
+            })),
+        });
+        return new Promise(resolve => {
+            this.pendingPermissions.set(permissionId, { options: params.options, resolve });
+        });
+    }
+    withinAutomaticBoundary(params) {
+        const filesystem = this.options.permissions.filesystem;
+        if (filesystem === 'unrestricted')
+            return true;
+        if (filesystem === 'read-only' && params.toolCall.kind !== 'read')
+            return false;
+        const locations = params.toolCall.locations ?? [];
+        if (locations.length === 0)
+            return false;
+        const cwd = resolve(this.options.cwd);
+        return locations.every(location => {
+            const path = resolve(location.path);
+            const rel = relative(cwd, path);
+            return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+        });
+    }
+    recordUpdate(update) {
+        switch (update.sessionUpdate) {
+            case 'agent_message_chunk':
+                this.events.emit('agent_text', {
+                    text: update.content.type === 'text' ? update.content.text : `[${update.content.type}]`,
+                });
+                break;
+            case 'agent_thought_chunk':
+                this.events.emit('thought', {
+                    text: update.content.type === 'text' ? update.content.text : `[${update.content.type}]`,
+                });
+                break;
+            case 'tool_call':
+                this.events.emit('tool_call', {
+                    toolCallId: update.toolCallId,
+                    title: update.title,
+                    status: update.status,
+                });
+                break;
+            case 'tool_call_update':
+                this.events.emit('tool_update', {
+                    toolCallId: update.toolCallId,
+                    title: update.title ?? undefined,
+                    status: update.status ?? undefined,
+                });
+                break;
+            default:
+                break;
+        }
+    }
+    fail(error) {
+        this.lastError = error?.message ?? String(error);
+        this.readiness = 'failed';
+        this.events.emit('error', { text: this.lastError });
+    }
+}

package/dist/session/control.d.ts

@@ -0,0 +1,41 @@
+import { type Socket } from 'node:net';
+import type { SessionHandle } from './types.js';
+export interface ControlRequest {
+    version: 1;
+    id: string;
+    token: string;
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow';
+    text?: string;
+    permissionId?: string;
+    optionId?: string;
+    since?: number;
+}
+export interface ControlResponse {
+    version: 1;
+    id: string;
+    ok: boolean;
+    result?: unknown;
+    error?: string;
+}
+export declare const controlSocketPath: (stateDir: string) => string;
+export declare const controlTokenPath: (stateDir: string) => string;
+/** Private, versioned JSONL control plane for CLI and future console frontends. */
+export declare class RoleControlServer {
+    private readonly session;
+    private readonly log;
+    private readonly server;
+    private readonly socketPath;
+    private readonly token;
+    private readonly sockets;
+    constructor(stateDir: string, session: SessionHandle, log: (line: string) => void);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private accept;
+    private handle;
+    private write;
+}
+export declare function controlRequest(stateDir: string, request: Omit<ControlRequest, 'version' | 'id' | 'token'>, timeoutMs?: number): Promise<ControlResponse>;
+export declare function followControl(stateDir: string, onMessage: (message: Record<string, unknown>) => void): Promise<{
+    socket: Socket;
+    send(request: Omit<ControlRequest, 'version' | 'id' | 'token'>): void;
+}>;