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

package/dist/session/control.js

@@ -0,0 +1,218 @@
+import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createConnection, createServer } from 'node:net';
+import { join } from 'node:path';
+const MAX_LINE_BYTES = 64 * 1024;
+export const controlSocketPath = (stateDir) => join(stateDir, '.control.sock');
+export const controlTokenPath = (stateDir) => join(stateDir, '.control-token');
+function sameToken(actual, supplied) {
+    const a = Buffer.from(actual);
+    const b = Buffer.from(supplied);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+/** Private, versioned JSONL control plane for CLI and future console frontends. */
+export class RoleControlServer {
+    session;
+    log;
+    server;
+    socketPath;
+    token;
+    sockets = new Set();
+    constructor(stateDir, session, log) {
+        this.session = session;
+        this.log = log;
+        this.socketPath = controlSocketPath(stateDir);
+        const tokenPath = controlTokenPath(stateDir);
+        this.token = existsSync(tokenPath)
+            ? readFileSync(tokenPath, 'utf8').trim()
+            : randomBytes(32).toString('hex');
+        writeFileSync(tokenPath, this.token + '\n', { mode: 0o600 });
+        chmodSync(tokenPath, 0o600);
+        rmSync(this.socketPath, { force: true });
+        this.server = createServer(socket => this.accept(socket));
+    }
+    async start() {
+        await new Promise((resolve, reject) => {
+            this.server.once('error', reject);
+            this.server.listen(this.socketPath, () => {
+                this.server.off('error', reject);
+                try {
+                    chmodSync(this.socketPath, 0o600);
+                }
+                catch { /* platform dependent */ }
+                resolve();
+            });
+        });
+    }
+    async close() {
+        for (const socket of this.sockets)
+            socket.destroy();
+        await new Promise(resolve => this.server.close(() => resolve()));
+        rmSync(this.socketPath, { force: true });
+    }
+    accept(socket) {
+        this.sockets.add(socket);
+        socket.setEncoding('utf8');
+        let buffer = '';
+        let unsubscribe;
+        socket.on('data', chunk => {
+            buffer += chunk;
+            if (Buffer.byteLength(buffer) > MAX_LINE_BYTES) {
+                socket.destroy(new Error('control request too large'));
+                return;
+            }
+            for (;;) {
+                const newline = buffer.indexOf('\n');
+                if (newline < 0)
+                    break;
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                if (!line.trim())
+                    continue;
+                void this.handle(line, socket).then(stop => {
+                    if (stop) {
+                        if (unsubscribe) {
+                            unsubscribe();
+                            this.session.setControllerAttached(false);
+                        }
+                        unsubscribe = stop;
+                    }
+                });
+            }
+        });
+        socket.on('close', () => {
+            this.sockets.delete(socket);
+            if (unsubscribe) {
+                unsubscribe();
+                this.session.setControllerAttached(false);
+            }
+        });
+        socket.on('error', error => this.log(`control socket: ${error.message}`));
+    }
+    async handle(line, socket) {
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            this.write(socket, { version: 1, id: '?', ok: false, error: 'invalid JSON' });
+            return;
+        }
+        if (request.version !== 1 || typeof request.id !== 'string'
+            || !sameToken(this.token, request.token ?? '')) {
+            this.write(socket, { version: 1, id: request.id ?? '?', ok: false, error: 'unauthorized' });
+            return;
+        }
+        try {
+            switch (request.command) {
+                case 'status':
+                case 'snapshot':
+                    this.write(socket, { version: 1, id: request.id, ok: true, result: this.session.snapshot() });
+                    return;
+                case 'submit_prompt': {
+                    if (!request.text?.trim())
+                        throw new Error('text is required');
+                    const result = await this.session.submitPrompt(request.text);
+                    this.write(socket, { version: 1, id: request.id, ok: result.accepted, result,
+                        error: result.accepted ? undefined : result.detail });
+                    return;
+                }
+                case 'respond_permission': {
+                    if (!request.permissionId || !request.optionId)
+                        throw new Error('permissionId and optionId are required');
+                    const accepted = this.session.respondPermission(request.permissionId, request.optionId);
+                    this.write(socket, {
+                        version: 1, id: request.id, ok: accepted,
+                        result: { accepted }, error: accepted ? undefined : 'stale or invalid permission response',
+                    });
+                    return;
+                }
+                case 'interrupt':
+                    await this.session.interrupt();
+                    this.write(socket, { version: 1, id: request.id, ok: true });
+                    return;
+                case 'follow': {
+                    const since = Number.isFinite(request.since) ? Number(request.since) : 0;
+                    this.write(socket, {
+                        version: 1, id: request.id, ok: true,
+                        result: { events: this.session.eventsSince(since), snapshot: this.session.snapshot() },
+                    });
+                    this.session.setControllerAttached(true);
+                    return this.session.subscribe(event => {
+                        if (!socket.destroyed)
+                            socket.write(JSON.stringify({ version: 1, event }) + '\n');
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.write(socket, {
+                version: 1,
+                id: request.id,
+                ok: false,
+                error: error?.message ?? String(error),
+            });
+        }
+    }
+    write(socket, response) {
+        if (!socket.destroyed)
+            socket.write(JSON.stringify(response) + '\n');
+    }
+}
+export async function controlRequest(stateDir, request, timeoutMs = 120_000) {
+    const token = readFileSync(controlTokenPath(stateDir), 'utf8').trim();
+    const id = randomUUID();
+    const socket = createConnection(controlSocketPath(stateDir));
+    socket.setEncoding('utf8');
+    const response = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            socket.destroy();
+            reject(new Error('role control request timed out'));
+        }, timeoutMs);
+        let buffer = '';
+        socket.once('error', error => { clearTimeout(timer); reject(error); });
+        socket.on('data', chunk => {
+            buffer += chunk;
+            const newline = buffer.indexOf('\n');
+            if (newline < 0)
+                return;
+            clearTimeout(timer);
+            try {
+                resolve(JSON.parse(buffer.slice(0, newline)));
+            }
+            catch (error) {
+                reject(error);
+            }
+            socket.end();
+        });
+        socket.once('connect', () => socket.write(JSON.stringify({
+            version: 1, id, token, ...request,
+        }) + '\n'));
+    });
+    return response;
+}
+export async function followControl(stateDir, onMessage) {
+    const token = readFileSync(controlTokenPath(stateDir), 'utf8').trim();
+    const socket = createConnection(controlSocketPath(stateDir));
+    socket.setEncoding('utf8');
+    let buffer = '';
+    socket.on('data', chunk => {
+        buffer += chunk;
+        for (;;) {
+            const newline = buffer.indexOf('\n');
+            if (newline < 0)
+                break;
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            if (line.trim())
+                onMessage(JSON.parse(line));
+        }
+    });
+    await new Promise((resolve, reject) => {
+        socket.once('connect', resolve);
+        socket.once('error', reject);
+    });
+    const send = (request) => socket.write(JSON.stringify({ version: 1, id: randomUUID(), token, ...request }) + '\n');
+    send({ command: 'follow', since: 0 });
+    return { socket, send };
+}

package/dist/session/events.d.ts

@@ -0,0 +1,14 @@
+import type { SessionEvent, SessionEventKind } from './types.js';
+/** Bounded, typed event stream shared by CLI frontends and future ACP/Toad facades. */
+export declare class SessionEvents {
+    private readonly path;
+    private seq;
+    private readonly events;
+    private readonly listeners;
+    constructor(path: string);
+    emit(kind: SessionEventKind, fields?: Omit<SessionEvent, 'version' | 'seq' | 'at' | 'kind'>): SessionEvent;
+    since(seq: number): SessionEvent[];
+    subscribe(listener: (event: SessionEvent) => void): () => void;
+    private restore;
+    private rotateIfNeeded;
+}

package/dist/session/events.js

@@ -0,0 +1,67 @@
+import { appendFileSync, existsSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+const MAX_EVENTS = 1_000;
+const MAX_EVENT_FILE_BYTES = 2 * 1024 * 1024;
+/** Bounded, typed event stream shared by CLI frontends and future ACP/Toad facades. */
+export class SessionEvents {
+    path;
+    seq = 0;
+    events = [];
+    listeners = new Set();
+    constructor(path) {
+        this.path = path;
+        this.restore();
+    }
+    emit(kind, fields = {}) {
+        const event = {
+            version: 1,
+            seq: ++this.seq,
+            at: new Date().toISOString(),
+            kind,
+            ...fields,
+        };
+        this.events.push(event);
+        if (this.events.length > MAX_EVENTS)
+            this.events.shift();
+        try {
+            this.rotateIfNeeded();
+            appendFileSync(this.path, JSON.stringify(event) + '\n', { mode: 0o600 });
+        }
+        catch { /* diagnostics must never terminate a role */ }
+        for (const listener of this.listeners)
+            listener(event);
+        return event;
+    }
+    since(seq) {
+        return this.events.filter(event => event.seq > seq);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    restore() {
+        try {
+            if (!existsSync(this.path))
+                return;
+            const lines = readFileSync(this.path, 'utf8').trim().split('\n').slice(-MAX_EVENTS);
+            for (const line of lines) {
+                const event = JSON.parse(line);
+                if (event.version === 1 && typeof event.seq === 'number') {
+                    this.events.push(event);
+                    this.seq = Math.max(this.seq, event.seq);
+                }
+            }
+        }
+        catch { /* begin a fresh projection if the diagnostic file is corrupt */ }
+    }
+    rotateIfNeeded() {
+        if (!existsSync(this.path) || statSync(this.path).size < MAX_EVENT_FILE_BYTES)
+            return;
+        const rotated = this.path + '.1';
+        try {
+            renameSync(this.path, rotated);
+        }
+        catch {
+            writeFileSync(this.path, '', { mode: 0o600 });
+        }
+    }
+}

package/dist/session/tmux.d.ts

@@ -0,0 +1,20 @@
+import type { Tmux } from '../tmux.js';
+import type { SessionEvent, SessionHandle, SessionSnapshot, TurnResult } from './types.js';
+/** SessionHandle adapter for the existing tmux transport. */
+export declare class TmuxSession implements SessionHandle {
+    private readonly name;
+    readonly pid: number;
+    private readonly tmux;
+    private readonly processAlive;
+    readonly backend: "tmux";
+    constructor(name: string, pid: number, tmux: Tmux, processAlive: (pid: number) => boolean);
+    isAlive(): boolean;
+    snapshot(): SessionSnapshot;
+    submitPrompt(text: string): Promise<TurnResult>;
+    interrupt(): Promise<void>;
+    respondPermission(): boolean;
+    eventsSince(): SessionEvent[];
+    subscribe(): () => void;
+    setControllerAttached(): void;
+    close(): Promise<void>;
+}

package/dist/session/tmux.js

@@ -0,0 +1,46 @@
+/** SessionHandle adapter for the existing tmux transport. */
+export class TmuxSession {
+    name;
+    pid;
+    tmux;
+    processAlive;
+    backend = 'tmux';
+    constructor(name, pid, tmux, processAlive) {
+        this.name = name;
+        this.pid = pid;
+        this.tmux = tmux;
+        this.processAlive = processAlive;
+    }
+    isAlive() {
+        return this.processAlive(this.pid);
+    }
+    snapshot() {
+        return {
+            backend: 'tmux',
+            alive: this.isAlive(),
+            readiness: this.isAlive() ? 'idle' : 'failed',
+        };
+    }
+    async submitPrompt(text) {
+        if (!this.isAlive())
+            return { accepted: false, outcome: 'failed', detail: 'tmux pane is offline' };
+        await this.tmux.sendText(this.name, text);
+        return { accepted: true, outcome: 'inconclusive' };
+    }
+    async interrupt() {
+        await this.tmux.sendKey(this.name, 'C-c');
+    }
+    respondPermission() {
+        return false;
+    }
+    eventsSince() {
+        return [];
+    }
+    subscribe() {
+        return () => { };
+    }
+    setControllerAttached() { }
+    async close() {
+        await this.tmux.kill(this.name);
+    }
+}

package/dist/session/types.d.ts

@@ -0,0 +1,47 @@
+import type { SessionBackendId } from '../config.js';
+export type SessionReadiness = 'starting' | 'idle' | 'running' | 'awaiting_permission' | 'failed';
+export interface TurnResult {
+    accepted: boolean;
+    outcome: 'completed' | 'refused' | 'cancelled' | 'failed' | 'inconclusive';
+    detail?: string;
+}
+export interface SessionSnapshot {
+    backend: SessionBackendId;
+    alive: boolean;
+    readiness: SessionReadiness;
+    sessionId?: string;
+    lastError?: string;
+    pendingPermissionId?: string;
+}
+export type SessionEventKind = 'state' | 'agent_text' | 'thought' | 'tool_call' | 'tool_update' | 'permission' | 'turn_stop' | 'error';
+export interface SessionEvent {
+    version: 1;
+    seq: number;
+    at: string;
+    kind: SessionEventKind;
+    turnId?: string;
+    toolCallId?: string;
+    permissionId?: string;
+    text?: string;
+    title?: string;
+    status?: string;
+    stopReason?: string;
+    options?: Array<{
+        optionId: string;
+        name: string;
+        kind: string;
+    }>;
+}
+export interface SessionHandle {
+    readonly backend: SessionBackendId;
+    readonly pid: number;
+    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>;
+}

package/dist/session/types.js

@@ -0,0 +1 @@
+export {};

package/dist/spawn.d.ts

@@ -1,14 +1,19 @@
+import { type ApprovalMode, type FilesystemMode, type SessionBackendId, type UnattendedMode } from './config.js';
 import { type OpsDeps } from './ops.js';
 export interface SpawnOpts {
     name: string;
     temp?: boolean;
     harness?: string;
+    session?: SessionBackendId;
     mission?: string;
     identity?: string;
     cwd?: string;
     coordinator?: string;
     model?: string;
     permissionMode?: string;
+    approval?: ApprovalMode;
+    filesystem?: FilesystemMode;
+    unattended?: UnattendedMode;
     sandbox?: string;
     profile?: string;
     launcher?: string;

package/dist/spawn.js

@@ -3,13 +3,15 @@ import { existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from 'no
 import { join } from 'node:path';
 import { stringify } from 'yaml';
 import { agentDir, fleetDDir } from './paths.js';
-import { loadConfig, resolveMonitorConfig } from './config.js';
+import { loadConfig, resolveMonitorConfig, resolvePermissions, } from './config.js';
 import { applyRole, up } from './ops.js';
 import { START_STAGGER_FILE } from './runner.js';
 function roleFromOpts(o, defaultHarness) {
     const r = {};
     if (o.harness)
         r.harness = o.harness;
+    if (o.session)
+        r.session = o.session;
     if (o.identity)
         r.identity = o.identity;
     if (o.cwd)
@@ -40,12 +42,29 @@ function roleFromOpts(o, defaultHarness) {
         harnessOptions.monitor = true;
     if (Object.keys(harnessOptions).length)
         r.harness_options = harnessOptions;
+    if (o.approval || o.filesystem || o.unattended) {
+        r.permissions = {
+            ...(o.approval ? { approval: o.approval } : {}),
+            ...(o.filesystem ? { filesystem: o.filesystem } : {}),
+            ...(o.unattended ? { unattended: o.unattended } : {}),
+        };
+    }
     if (o.bioFile)
         r.bio = readFileSync(o.bioFile, 'utf8').trim();
     if (o.personaFile)
         r.persona = readFileSync(o.personaFile, 'utf8').trim();
     return r;
 }
+function validateSpawnOpts(o) {
+    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.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))
+        throw new Error(`invalid --unattended '${o.unattended}'; allowed: deny, wait`);
+}
 function assertNameFree(o) {
     const cfg = loadConfig(o.configPath);
     if (cfg.roles.some(r => r.name === o.name))
@@ -55,6 +74,7 @@ function assertNameFree(o) {
 }
 /** Permanent spawn: persist to ~/fleet.d/<Name>.yaml, then bring it up. */
 export async function spawnPermanent(o, deps) {
+    validateSpawnOpts(o);
     assertNameFree(o);
     const cfg = loadConfig(o.configPath);
     mkdirSync(fleetDDir(), { recursive: true });
@@ -76,6 +96,7 @@ const detachedSupervisor = (binPath, args, dir) => {
 };
 /** Temp spawn: state under ~/.ours-fleet/tmp, plain tmux, auto-clean on exit. */
 export async function spawnTemp(o, binPath, launch = detachedSupervisor) {
+    validateSpawnOpts(o);
     assertNameFree(o);
     const cfg = loadConfig(o.configPath);
     const defaultHarness = cfg.defaults.harness;
@@ -88,9 +109,11 @@ export async function spawnTemp(o, binPath, launch = detachedSupervisor) {
         ...fromOpts,
         name: o.name,
         harness: o.harness ?? defaultHarness ?? 'claude-code',
+        session: o.session ?? cfg.defaults.session ?? 'tmux',
         identity: o.identity ?? o.name,
         model: o.model?.trim() || cfg.defaults.model,
         harness_options: Object.keys(mergedHarnessOptions).length ? mergedHarnessOptions : undefined,
+        permissions: resolvePermissions(cfg.defaults.permissions, fromOpts.permissions),
         // Temp agents inherit the fleet-wide monitor defaults via the snapshot (design §2).
         monitor: resolveMonitorConfig(cfg.defaults.monitor, fromOpts.monitor),
         sourceFile: '(temp)',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.9.3",
-  "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux consoles, systemd/launchd supervision, ours.network messaging.",
+  "version": "0.10.0-nightly.1",
+  "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux or ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
   "repository": {
@@ -26,6 +26,7 @@
     "prepublishOnly": "npm run build && npm test"
   },
   "dependencies": {
+    "@agentclientprotocol/sdk": "^1.3.0",
     "commander": "^12.1.0",
     "yaml": "^2.5.0"
   },