@ours.network/fleet 0.18.1 → 0.19.0-nightly.2

package/dist/owner-channel/mcp.js

@@ -1,145 +0,0 @@
-import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { createInterface } from 'node:readline';
-export class OursMcpError extends Error {
-}
-/** Minimal MCP stdio client. One instance owns exactly one ours identity binding. */
-export class OursMcpClient {
-    command;
-    env;
-    log;
-    child;
-    nextId = 0;
-    tail = Promise.resolve();
-    constructor(command = 'ours-mcp', env = {}, log = () => undefined) {
-        this.command = command;
-        this.env = env;
-        this.log = log;
-    }
-    async start() {
-        if (this.child && this.child.exitCode === null)
-            return;
-        // ours-mcp normally records the long-lived client PID so an identity lease
-        // survives connector churn. An owner-channel connector has the opposite
-        // lifecycle: each supervised attempt owns a fresh connector and must make
-        // its lease reclaimable when that connector exits, even though the fleet
-        // supervisor itself remains alive. POSIX exec preserves the shell PID as
-        // the proxy PID, giving the daemon an exact process-lifetime fence without
-        // interpolating the command path into shell text.
-        const child = spawn('/bin/sh', [
-            '-c', 'OURS_CLIENT_PID=$$; export OURS_CLIENT_PID; exec "$1" "$2"',
-            'ours-fleet-owner-proxy', this.command, 'proxy',
-        ], {
-            env: {
-                ...process.env,
-                ...this.env,
-                // Bindings are keyed by this value. Sharing it would silently rebind a
-                // role's normal mailbox or another owner channel.
-                CLAUDE_CODE_SESSION_ID: `ours-fleet-owner-${process.pid}-${randomUUID()}`,
-            },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        await new Promise((resolve, reject) => {
-            child.once('spawn', resolve);
-            child.once('error', reject);
-        });
-        this.child = child;
-        child.once('exit', (code, signal) => {
-            this.log(`ours-mcp proxy launcher exited (${code ?? signal ?? 'unknown'})`);
-        });
-        child.stdin.on('error', error => this.log(`ours-mcp stdin: ${error.message}`));
-        createInterface({ input: child.stderr }).on('line', line => this.log(`ours-mcp: ${line}`));
-        try {
-            await this.request('initialize', {
-                protocolVersion: '2025-03-26', capabilities: {},
-                clientInfo: { name: 'ours-fleet-owner-channel', version: '1' },
-            });
-            await this.notify('notifications/initialized', {});
-        }
-        catch (error) {
-            await this.close();
-            throw error;
-        }
-    }
-    async callTool(name, args = {}) {
-        const result = await this.request('tools/call', { name, arguments: args });
-        const text = (result.content ?? [])
-            .filter(item => item.type === 'text').map(item => item.text ?? '').join('\n').trim();
-        if (result.isError)
-            throw new OursMcpError(text || `ours tool ${name} failed`);
-        if (result.structuredContent !== undefined)
-            return result.structuredContent;
-        if (!text)
-            return {};
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return text;
-        }
-    }
-    async close() {
-        const child = this.child;
-        this.child = undefined;
-        if (!child || child.exitCode !== null)
-            return;
-        // EOF asks the proxy to close normally. Once this exact process exits, the
-        // daemon can reclaim its lease even while the supervisor stays alive.
-        child.stdin.end();
-        const exited = await new Promise(resolve => {
-            const timer = setTimeout(() => resolve(false), 1_000);
-            child.once('exit', () => { clearTimeout(timer); resolve(true); });
-        });
-        if (exited || child.exitCode !== null)
-            return;
-        child.kill('SIGTERM');
-        await new Promise(resolve => {
-            const timer = setTimeout(() => { child.kill('SIGKILL'); resolve(); }, 5_000);
-            child.once('exit', () => { clearTimeout(timer); resolve(); });
-        });
-    }
-    request(method, params) {
-        const run = this.tail.then(() => this.requestNow(method, params));
-        this.tail = run.then(() => undefined, () => undefined);
-        return run;
-    }
-    async requestNow(method, params) {
-        const child = this.child;
-        if (!child || child.exitCode !== null)
-            throw new OursMcpError('ours-mcp proxy is not running');
-        const id = ++this.nextId;
-        await this.write(child, { jsonrpc: '2.0', id, method, params });
-        const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
-        try {
-            for await (const line of lines) {
-                let response;
-                try {
-                    response = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                if (response.id !== id)
-                    continue;
-                if (response.error !== undefined)
-                    throw new OursMcpError(JSON.stringify(response.error));
-                return response.result ?? {};
-            }
-            throw new OursMcpError('ours-mcp proxy closed its output');
-        }
-        finally {
-            lines.close();
-        }
-    }
-    async notify(method, params) {
-        const child = this.child;
-        if (!child || child.exitCode !== null)
-            throw new OursMcpError('ours-mcp proxy is not running');
-        await this.write(child, { jsonrpc: '2.0', method, params });
-    }
-    write(child, value) {
-        return new Promise((resolve, reject) => {
-            child.stdin.write(JSON.stringify(value) + '\n', error => error ? reject(error) : resolve());
-        });
-    }
-}

package/dist/session/activity.d.ts

@@ -1,31 +0,0 @@
-import type { SessionActivity } from './types.js';
-/**
- * How long after the agent's last session update it still counts as working.
- *
- * FLEET-002: a wake delivered by ACP steering answers `startedNewTurn` and runs
- * an entire turn that fleet never receives a `session/prompt` response for (ACP
- * has no turn-end session update), so `readiness` stays `idle` throughout. Tool
- * reservations and update recency are the only activity evidence fleet holds.
- * The trade-off is deliberate and one-directional: at worst a role reads busy
- * for one window after it genuinely stopped, instead of reading ready — or
- * being classified stalled — while it is executing tools.
- */
-export declare const ACTIVITY_WINDOW_MS = 60000;
-export type ActivityState = 'active' | 'quiet' | 'unobservable';
-export interface ObservedActivity {
-    state: ActivityState;
-    activeToolCalls?: number;
-    lastUpdateAt?: string;
-}
-/**
- * Classify agent-side activity. `unobservable` is NOT `quiet`: a backend that
- * cannot see the agent (tmux) has no evidence, and no evidence must never be
- * reported as "doing nothing".
- */
-export declare function classifyActivity(activity: SessionActivity | undefined, now?: number): ObservedActivity;
-/**
- * One operator-facing line that never lets turn occupancy pose as liveness:
- * the readiness value is labelled as the turn field it is, and the activity
- * verdict is stated separately with the evidence behind it.
- */
-export declare function describeSessionState(readiness: string | undefined, activity: SessionActivity | undefined, now?: number): string;

package/dist/session/activity.js

@@ -1,48 +0,0 @@
-/**
- * How long after the agent's last session update it still counts as working.
- *
- * FLEET-002: a wake delivered by ACP steering answers `startedNewTurn` and runs
- * an entire turn that fleet never receives a `session/prompt` response for (ACP
- * has no turn-end session update), so `readiness` stays `idle` throughout. Tool
- * reservations and update recency are the only activity evidence fleet holds.
- * The trade-off is deliberate and one-directional: at worst a role reads busy
- * for one window after it genuinely stopped, instead of reading ready — or
- * being classified stalled — while it is executing tools.
- */
-export const ACTIVITY_WINDOW_MS = 60_000;
-/**
- * Classify agent-side activity. `unobservable` is NOT `quiet`: a backend that
- * cannot see the agent (tmux) has no evidence, and no evidence must never be
- * reported as "doing nothing".
- */
-export function classifyActivity(activity, now = Date.now()) {
-    if (!activity)
-        return { state: 'unobservable' };
-    const lastUpdate = activity.lastUpdateAt ? Date.parse(activity.lastUpdateAt) : NaN;
-    const recent = Number.isFinite(lastUpdate) && now - lastUpdate <= ACTIVITY_WINDOW_MS;
-    return {
-        state: activity.activeToolCalls > 0 || recent ? 'active' : 'quiet',
-        activeToolCalls: activity.activeToolCalls,
-        ...(activity.lastUpdateAt ? { lastUpdateAt: activity.lastUpdateAt } : {}),
-    };
-}
-/**
- * One operator-facing line that never lets turn occupancy pose as liveness:
- * the readiness value is labelled as the turn field it is, and the activity
- * verdict is stated separately with the evidence behind it.
- */
-export function describeSessionState(readiness, activity, now = Date.now()) {
-    const observed = classifyActivity(activity, now);
-    const evidence = [];
-    if (observed.activeToolCalls)
-        evidence.push(`${observed.activeToolCalls} tool calls in flight`);
-    if (observed.lastUpdateAt) {
-        const age = Math.max(0, Math.round((now - Date.parse(observed.lastUpdateAt)) / 1000));
-        if (Number.isFinite(age))
-            evidence.push(`last agent update ${age}s ago`);
-    }
-    const detail = observed.state === 'unobservable'
-        ? 'no agent-side evidence on this backend'
-        : evidence.join(', ') || 'no updates yet';
-    return `turn: ${readiness ?? 'unknown'} (turn occupancy only) | activity: ${observed.state} (${detail})`;
-}