@ours.network/fleet 0.9.3 → 0.9.5

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;
+}>;

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);
+    }
+}