@ours.network/fleet 1.2.0-nightly.9 → 2.0.0

package/dist/application/codex-models.js

@@ -0,0 +1,56 @@
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveBundledAcpAgent } from '../harness/acp-agent.js';
+import { probeCodexRuntime } from '../harness/codex-runtime.js';
+import { codexOfferedModels, profileEnv } from '../subscriptions/cli.js';
+import { profileHome, readSubscriptionState } from '../subscriptions/store.js';
+const KNOWN_FOR_MS = 5 * 60_000;
+const UNKNOWN_FOR_MS = 10_000;
+/** When the profile's sign-in last changed; a new sign-in must not reuse another account's answer. */
+function signInStamp(home) {
+    try {
+        return statSync(join(home, 'auth.json')).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * The models offered to the active Codex account by the runtime that sessions will actually use.
+ * An answer is reused only for the same executable, version, profile and sign-in.
+ */
+export function createCodexModelDiscovery(overrides = {}) {
+    const deps = {
+        runtime: () => probeCodexRuntime(resolveBundledAcpAgent('@agentclientprotocol/codex-acp', 'codex-acp', 'codex-acp'), process.env),
+        ask: codexOfferedModels,
+        now: Date.now,
+        ...overrides,
+    };
+    let cached;
+    let pending;
+    return async () => {
+        let key, executable, env;
+        try {
+            const profileId = readSubscriptionState().providers.codex.activeProfileId;
+            const profile = profileHome('codex', profileId);
+            const runtime = await deps.runtime();
+            executable = runtime.executable;
+            env = profileEnv('CODEX_HOME', profileId, profile);
+            key = [runtime.executable, runtime.version, profileId, signInStamp(profile)].join('\n');
+        }
+        catch (error) {
+            return { state: 'unknown', reason: error instanceof Error ? error.message : String(error) };
+        }
+        if (cached && cached.key === key && cached.until > deps.now())
+            return cached.value;
+        if (pending?.key === key)
+            return pending.answer;
+        const answer = deps.ask(executable, env).then(value => {
+            cached = { key, until: deps.now() + (value.state === 'known' ? KNOWN_FOR_MS : UNKNOWN_FOR_MS), value };
+            return value;
+        }).finally(() => { if (pending?.key === key)
+            pending = undefined; });
+        pending = { key, answer };
+        return answer;
+    };
+}

package/dist/application/conversation-history.d.ts

@@ -0,0 +1,31 @@
+import type { ConversationEventV1 } from '../session/conversation-types.js';
+import type { ConversationPageView } from './session-control.js';
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export declare function conversationEventVisible(event: ConversationEventV1, sessionGeneration: string, resumedSessionId?: string): boolean;
+export interface ConversationTailPage extends ConversationPageView {
+    /** Pass as `before` to read the next older page. */
+    olderCursor?: string;
+    hasOlder: boolean;
+    /** Latest page only: older events the view still needs, the current session's latest capabilities and still-pending permission requests. */
+    context: ConversationEventV1[];
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export declare function conversationTailPage(stateDir: string, request: {
+    before?: string;
+    limit?: number;
+}, snapshot: ConversationPageView['snapshot'], resumedSessionId?: string, signal?: AbortSignal): Promise<ConversationTailPage>;
+/** Read the existing ACP session ledger without opening its writer/recovery store. */
+export declare function resumedConversationPage(stateDir: string, request: {
+    after?: string;
+    limit?: number;
+}, live: ConversationPageView, expectedSessionId: string): Promise<ConversationPageView>;
+/** Download authorization requires an actual published attachment, never an orphan copy. */
+export declare function conversationHasAttachment(stateDir: string, attachment: import('../file-delivery/types.js').DeliveredFile): Promise<boolean>;
+export declare function conversationPreview(stateDir: string, signal: AbortSignal): Promise<{
+    text: string;
+    at: string;
+}>;

package/dist/application/conversation-history.js

@@ -0,0 +1,339 @@
+import { createReadStream } from 'node:fs';
+import { open, readFile, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+const HISTORICAL_KINDS = ['file.attached', 'fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'];
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export function conversationEventVisible(event, sessionGeneration, resumedSessionId) {
+    return event.source !== 'agent_replay' && (event.sessionGeneration === sessionGeneration || (!!resumedSessionId && HISTORICAL_KINDS.includes(event.kind) && event.acpSessionId === resumedSessionId));
+}
+/** Newest-first lines of a file, read in chunks from its end; `visit` returns false to stop. */
+async function readLinesBackward(path, visit, signal) {
+    signal?.throwIfAborted();
+    const file = await open(path, 'r');
+    try {
+        let position = (await file.stat()).size;
+        let carry = Buffer.alloc(0);
+        while (position > 0) {
+            signal?.throwIfAborted();
+            const size = Math.min(256 * 1024, position);
+            position -= size;
+            const chunk = Buffer.alloc(size);
+            await file.read(chunk, 0, size, position);
+            signal?.throwIfAborted();
+            let buffer = Buffer.concat([chunk, carry]);
+            let end = buffer.length;
+            for (let i = buffer.length - 1; i >= 0; i--) {
+                if (buffer[i] !== 10)
+                    continue;
+                if (end > i + 1 && !visit(buffer.toString('utf8', i + 1, end)))
+                    return false;
+                end = i;
+            }
+            carry = buffer.subarray(0, end);
+        }
+        if (carry.length && !visit(carry.toString('utf8')))
+            return false;
+        return true;
+    }
+    finally {
+        await file.close();
+    }
+}
+// Rotated segments never change, so their last cursor is reused until the file itself changes.
+const lastSeqs = new Map();
+/** The last event cursor in a segment, read from its tail; undefined when none is readable. */
+async function lastSeq(path) {
+    const info = await stat(path).catch(() => undefined);
+    const key = info && `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}`;
+    const known = key ? lastSeqs.get(path) : undefined;
+    if (key && known?.key === key)
+        return known.seq;
+    let seq;
+    await readLinesBackward(path, line => { try {
+        const value = Number(JSON.parse(line).seq);
+        if (Number.isSafeInteger(value)) {
+            seq = value;
+            return false;
+        }
+    }
+    catch { } return true; });
+    if (key) {
+        lastSeqs.delete(path);
+        lastSeqs.set(path, { key, seq });
+        if (lastSeqs.size > 4096)
+            lastSeqs.delete(lastSeqs.keys().next().value);
+    }
+    return seq;
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export async function conversationTailPage(stateDir, request, snapshot, resumedSessionId, signal) {
+    signal?.throwIfAborted();
+    const before = request.before === undefined ? Infinity : Number(request.before);
+    if (before !== Infinity && (!Number.isSafeInteger(before) || before < 0))
+        throw new Error('before must be a ledger cursor');
+    const limit = Math.min(1000, Math.max(1, Number.isFinite(request.limit) ? Math.floor(request.limit) : 200));
+    let files = [];
+    try {
+        files = (await readdir(join(stateDir, '.conversation'))).filter(n => /^events-\d{6}\.jsonl$/.test(n)).sort().reverse();
+    }
+    catch { }
+    const events = [];
+    let newest;
+    let hasOlder = false;
+    const observation = snapshot;
+    const barrier = observation.ledgerBarrier;
+    // Current supervisors capture these sanitized inventories together with the
+    // ledger barrier. The browser uses them directly, including authoritative
+    // empty arrays. Looking for their old ledger events would scan the entire
+    // generation on every open. Legacy/incomplete snapshots still need context.
+    const complete = !snapshot.observationFailure && Number.isSafeInteger(barrier) && barrier >= 0
+        && Number.isSafeInteger(observation.stateRevision) && observation.stateRevision >= 0;
+    const needsCapabilities = !complete || !Array.isArray(observation.commands);
+    const pending = new Set(complete && Array.isArray(observation.pendingPermissions)
+        && snapshot.pendingPermissionIds.every(id => observation.pendingPermissions.some(permission => permission.permissionId === id))
+        ? [] : snapshot.pendingPermissionIds);
+    let capabilities;
+    const context = [];
+    // Context only accompanies the newest page; older pages stop as soon as they are full.
+    const wantsContext = () => before === Infinity && ((needsCapabilities && !capabilities) || pending.size > 0);
+    const generation = `"sessionGeneration":${JSON.stringify(snapshot.sessionGeneration)}`;
+    for (const file of files) {
+        const more = await readLinesBackward(join(stateDir, '.conversation', file), line => {
+            if (hasOlder) {
+                // The page is full; only the current generation's context kinds matter. Generations are
+                // appended in order, so the first line of an older one ends the search.
+                if (!line.includes(generation))
+                    return !line.includes('"sessionGeneration":') && wantsContext();
+                if (!line.includes('"capabilities.updated"') && !line.includes('"permission.requested"'))
+                    return wantsContext();
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                return true;
+            }
+            const seq = Number(event.seq);
+            if (!Number.isSafeInteger(seq))
+                return true;
+            if (barrier !== undefined && seq > barrier)
+                return true;
+            newest ??= seq;
+            if (seq < before && conversationEventVisible(event, snapshot.sessionGeneration, resumedSessionId)) {
+                const inPage = !hasOlder && events.length < limit;
+                if (event.sessionGeneration === snapshot.sessionGeneration) {
+                    if (event.kind === 'capabilities.updated' && !capabilities) {
+                        capabilities = event;
+                        if (!inPage)
+                            context.push(event);
+                    }
+                    if (event.kind === 'permission.requested' && event.permissionId && pending.delete(event.permissionId) && !inPage)
+                        context.push(event);
+                }
+                if (inPage)
+                    events.push(event);
+                else
+                    hasOlder = true;
+            }
+            return !hasOlder || wantsContext();
+        }, signal);
+        if (!more)
+            break;
+    }
+    events.reverse();
+    context.reverse();
+    return { events, snapshot, hasOlder, context, hasMore: false,
+        ...(events.length ? { olderCursor: String(events[0].seq) } : {}),
+        ...(before === Infinity && (barrier !== undefined || newest !== undefined) ? { nextCursor: String(barrier ?? newest) } : {}) };
+}
+/** Read the existing ACP session ledger without opening its writer/recovery store. */
+export async function resumedConversationPage(stateDir, request, live, expectedSessionId) {
+    let sessionId;
+    let files;
+    try {
+        sessionId = (await readFile(join(stateDir, '.acp-session-id'), 'utf8')).trim();
+        files = (await readdir(join(stateDir, '.conversation'))).filter(n => /^events-\d{6}\.jsonl$/.test(n)).sort();
+    }
+    catch {
+        return live;
+    }
+    if (!sessionId || sessionId !== expectedSessionId || !files.length)
+        return live;
+    const after = Number(request.after ?? 0);
+    if (!Number.isSafeInteger(after) || after < 0)
+        return live;
+    const limit = Math.min(1000, Math.max(1, Number.isFinite(request.limit) ? Math.floor(request.limit) : 200));
+    const events = [];
+    let next = String(after);
+    let first;
+    let hasMore = false;
+    scan: for (const file of files) {
+        // Forward polling asks for the newest few events: skip whole segments that end at or before the cursor.
+        const end = await lastSeq(join(stateDir, '.conversation', file));
+        if (end !== undefined && end <= after)
+            continue;
+        const input = createReadStream(join(stateDir, '.conversation', file), { encoding: 'utf8' });
+        const lines = createInterface({ input, crlfDelay: Infinity });
+        try {
+            for await (const line of lines) {
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const cursor = Number(event.seq);
+                if (!Number.isSafeInteger(cursor) || cursor <= after)
+                    continue;
+                const historical = ['file.attached', 'fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'].includes(event.kind);
+                const visible = event.source !== 'agent_replay' && (event.sessionGeneration === live.snapshot.sessionGeneration || (historical && event.acpSessionId === sessionId));
+                if (!visible) {
+                    next = String(cursor);
+                    continue;
+                }
+                if (events.length === limit) {
+                    hasMore = true;
+                    break scan;
+                }
+                first ??= String(cursor);
+                events.push(event);
+                next = String(cursor);
+            }
+        }
+        finally {
+            lines.close();
+            input.destroy();
+        }
+    }
+    // If a fresh/resumed session changed during the read, use the live page only.
+    if ((await readFile(join(stateDir, '.acp-session-id'), 'utf8')).trim() !== sessionId)
+        return live;
+    return { ...live, events, firstAvailableCursor: first, nextCursor: next, hasMore };
+}
+/** Download authorization requires an actual published attachment, never an orphan copy. */
+export async function conversationHasAttachment(stateDir, attachment) {
+    const dir = join(stateDir, '.conversation');
+    const names = (await readdir(dir)).filter(n => /^events-\d+\.jsonl$/.test(n)).sort().reverse();
+    let found = false;
+    for (const name of names) {
+        await readLinesBackward(join(dir, name), line => {
+            try {
+                const e = JSON.parse(line);
+                const a = e.payload.attachment;
+                if (e.kind === 'file.attached' && e.source === 'agent' && a?.id === attachment.id
+                    && e.sessionGeneration === attachment.sessionGeneration && e.acpSessionId === attachment.acpSessionId
+                    && e.turnId === attachment.turnId && JSON.stringify(a) === JSON.stringify(attachment))
+                    found = true;
+            }
+            catch { /* unreadable lines cannot authorize a download */ }
+            return !found;
+        });
+        if (found)
+            break;
+    }
+    return found;
+}
+/** Passive, bounded last assistant text for directory previews. Never opens the
+ * ledger writer/recovery path or acquires a session/controller. An incomplete
+ * newest append is not committed yet; completed malformed records still fail. */
+/** Bytes of a segment's tail a preview may consider, and the newest events it reads. */
+const PREVIEW_WINDOW_BYTES = 2 * 1024 * 1024;
+const PREVIEW_EVENTS = 200;
+/**
+ * Newest-first completed events from the last PREVIEW_WINDOW_BYTES of one
+ * segment, read backwards in chunks until `need` events are found. A record
+ * cut by the window start is not complete and is skipped. Only the newest
+ * segment can have an in-flight append; elsewhere a partial record fails.
+ */
+async function previewSegmentEvents(path, newest, need, signal) {
+    const events = [];
+    const file = await open(path, 'r');
+    try {
+        const size = (await file.stat()).size, floor = Math.max(0, size - PREVIEW_WINDOW_BYTES);
+        let position = size, carry = Buffer.alloc(0), trailing = true;
+        const take = (line) => {
+            const event = JSON.parse(line);
+            if (event.schemaVersion !== 1 || !Number.isSafeInteger(event.seq))
+                throw Error('preview ledger invalid');
+            events.push(event);
+        };
+        while (position > floor && events.length < need) {
+            signal.throwIfAborted();
+            const length = Math.min(64 * 1024, position - floor);
+            position -= length;
+            const chunk = Buffer.alloc(length);
+            await file.read(chunk, 0, length, position);
+            const buffer = Buffer.concat([chunk, carry]);
+            let end = buffer.length;
+            for (let i = buffer.length - 1; i >= 0 && events.length < need; i--) {
+                if (buffer[i] !== 10)
+                    continue;
+                if (trailing) {
+                    if (end > i + 1 && !newest)
+                        throw Error('preview ledger has partial record');
+                    trailing = false;
+                }
+                else
+                    take(buffer.toString('utf8', i + 1, end));
+                end = i;
+            }
+            carry = buffer.subarray(0, end);
+        }
+        if (trailing && position === floor && (!newest || floor > 0) && size > 0)
+            throw Error('preview ledger has partial record');
+        // At the file start the remaining bytes are the first complete record.
+        if (!trailing && floor === 0 && position === 0 && events.length < need)
+            take(carry.toString('utf8'));
+    }
+    finally {
+        await file.close();
+    }
+    return events;
+}
+export async function conversationPreview(stateDir, signal) {
+    signal.throwIfAborted();
+    const dir = join(stateDir, '.conversation');
+    let files;
+    try {
+        files = (await readdir(dir)).filter(name => /^events-\d{6}\.jsonl$/.test(name)).sort().reverse();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { text: 'No recent agent output', at: '' };
+        throw error;
+    }
+    const events = [];
+    for (const name of files) {
+        signal.throwIfAborted();
+        events.push(...await previewSegmentEvents(join(dir, name), name === files[0], PREVIEW_EVENTS - events.length, signal));
+        if (events.length >= PREVIEW_EVENTS)
+            break;
+    }
+    signal.throwIfAborted();
+    const assistant = (event) => ['message.chunk', 'message.replace'].includes(event.kind) && event.payload?.role === 'assistant' && typeof event.payload?.content?.type === 'string';
+    const end = events.findIndex(assistant);
+    if (end < 0)
+        return { text: 'No recent agent output', at: '' };
+    const last = events[end], parts = [];
+    for (let i = end; i < events.length; i++) {
+        const event = events[i];
+        if (last.messageId !== undefined) {
+            if (!assistant(event) || event.messageId !== last.messageId)
+                continue;
+        }
+        else if (!assistant(event) || event.messageId !== undefined)
+            break;
+        const content = event.payload.content;
+        parts.unshift(content.type === 'text' ? content.text : `[${content.type}]`);
+        if (event.kind === 'message.replace')
+            break;
+    }
+    return { text: parts.join('').replace(/\s+/g, ' ').trim().slice(0, 300) || 'No recent agent output', at: last.at ?? '' };
+}

package/dist/application/conversation-role-observer.d.ts

@@ -0,0 +1,62 @@
+import { type FSWatcher } from 'node:fs';
+import { type SessionBackendId } from '../config.js';
+export interface ConversationRoleState {
+    roleId: string;
+    /** Connection-owned ordering; never a session stateRevision. */
+    roleRevision: number;
+    roleLifetime: string;
+    availability: 'available' | 'unavailable' | 'missing';
+    fallbackHarness?: string;
+    backend?: SessionBackendId;
+    stateDir?: string;
+    health: 'healthy' | 'unsupported' | 'failed';
+    failure?: 'watch-unsupported' | 'watch-error' | 'watch-closed' | 'role-read-failed' | 'observer-disposed';
+}
+export interface ConversationRoleObservation {
+    snapshot(): ConversationRoleState;
+    subscribe(listener: (state: ConversationRoleState) => void): {
+        snapshot: ConversationRoleState;
+        unsubscribe(): void;
+    };
+    dispose(): void;
+}
+export type ObserveConversationRole = (listener: (state: ConversationRoleState) => void) => ConversationRoleObservation;
+export interface ConversationRoleObserverOptions {
+    roleId: string;
+    configPath?: string;
+    permanentRoot?: string;
+    temporaryRoot?: string;
+    watch?: (path: string, listener: (event: string, filename: string | null) => void) => Pick<FSWatcher, 'on' | 'close'>;
+    subscribeMutations?: (listener: () => void) => () => void;
+}
+/** Native directory notifications are assumed reliable on qualified host/mount setups.
+ * No periodic reads or claim of detecting every silently dropped filesystem event.
+ */
+export declare class ConversationRoleObserver implements ConversationRoleObservation {
+    private readonly options;
+    private readonly listener;
+    private state;
+    private watchers;
+    private detach?;
+    private disposed;
+    private readonly listeners;
+    private queued;
+    private fingerprint?;
+    private readonly configPath;
+    private readonly permanent;
+    private readonly temporary;
+    constructor(options: ConversationRoleObserverOptions, listener: (state: ConversationRoleState) => void);
+    snapshot(): ConversationRoleState;
+    subscribe(listener: (state: ConversationRoleState) => void): {
+        snapshot: ConversationRoleState;
+        unsubscribe: () => void;
+    };
+    private publish;
+    dispose(): void;
+    private release;
+    private fail;
+    private schedule;
+    private refresh;
+    private install;
+    private watchFailure;
+}