@borgee/agents-host 0.2.1 → 0.2.26

package/dist/providers/claude/session-store.d.ts

@@ -1,9 +1,32 @@
 export interface ClaudeChannelSessionStore {
     load(agentId: string): Promise<Record<string, string>>;
     save(agentId: string, sessions: Record<string, string>): Promise<void>;
+    close?(): Promise<void> | void;
 }
 export interface FileClaudeChannelSessionStoreOptions {
     resolvePath(agentId: string): string;
+    fileSystem?: ClaudeSessionStoreFileSystem;
+    platform?: NodeJS.Platform;
+}
+interface ClaudeSessionStoreDirectoryHandle {
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+interface ClaudeSessionStoreFileHandle extends ClaudeSessionStoreDirectoryHandle {
+    writeFile(data: string, options: {
+        encoding: BufferEncoding;
+    }): Promise<void>;
+}
+interface ClaudeSessionStoreFileSystem {
+    mkdir(path: string, options: {
+        recursive: true;
+        mode: number;
+    }): Promise<void>;
+    openDirectory(path: string): Promise<ClaudeSessionStoreDirectoryHandle>;
+    openFile(path: string, flags: string, mode: number): Promise<ClaudeSessionStoreFileHandle>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
 }
 export declare class FileClaudeChannelSessionStore implements ClaudeChannelSessionStore {
     private readonly options;
@@ -12,3 +35,4 @@ export declare class FileClaudeChannelSessionStore implements ClaudeChannelSessi
     load(agentId: string): Promise<Record<string, string>>;
     save(agentId: string, sessions: Record<string, string>): Promise<void>;
 }
+export {};

package/dist/providers/claude/session-store.js

@@ -1,12 +1,63 @@
 import { randomUUID } from 'node:crypto';
 import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
 import { dirname } from 'node:path';
-async function syncDirectory(path) {
-    const directoryHandle = await open(path, 'r');
+const nodeFileSystem = {
+    async mkdir(path, options) {
+        await mkdir(path, options);
+    },
+    async openDirectory(path) {
+        return open(path, 'r');
+    },
+    async openFile(path, flags, mode) {
+        return open(path, flags, mode);
+    },
+    async readFile(path, encoding) {
+        return readFile(path, encoding);
+    },
+    async rename(from, to) {
+        await rename(from, to);
+    },
+    async unlink(path) {
+        await unlink(path);
+    },
+};
+function shouldIgnoreDirectorySyncError(platform, error) {
+    const code = error.code;
+    return platform === 'win32' && (code === 'EPERM' || code === 'EINVAL');
+}
+async function syncDirectory(path, fileSystem, platform) {
+    let directoryHandle;
     try {
-        await directoryHandle.sync();
+        try {
+            directoryHandle = await fileSystem.openDirectory(path);
+        }
+        catch (error) {
+            if (!shouldIgnoreDirectorySyncError(platform, error)) {
+                throw error;
+            }
+            return;
+        }
+        try {
+            await directoryHandle.sync();
+        }
+        catch (error) {
+            if (!shouldIgnoreDirectorySyncError(platform, error)) {
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        if (directoryHandle) {
+            try {
+                await directoryHandle.close();
+            }
+            catch {
+                // Preserve the original directory durability failure.
+            }
+        }
+        throw error;
     }
-    finally {
+    if (directoryHandle) {
         await directoryHandle.close();
     }
 }
@@ -32,7 +83,7 @@ export class FileClaudeChannelSessionStore {
     async loadFromPath(filePath) {
         let raw;
         try {
-            raw = await readFile(filePath, 'utf8');
+            raw = await (this.options.fileSystem ?? nodeFileSystem).readFile(filePath, 'utf8');
         }
         catch (error) {
             throw error;
@@ -54,11 +105,13 @@ export class FileClaudeChannelSessionStore {
     async save(agentId, sessions) {
         const filePath = this.options.resolvePath(agentId);
         const parentPath = dirname(filePath);
-        await mkdir(parentPath, { recursive: true, mode: 0o700 });
+        const fileSystem = this.options.fileSystem ?? nodeFileSystem;
+        const platform = this.options.platform ?? process.platform;
+        await fileSystem.mkdir(parentPath, { recursive: true, mode: 0o700 });
         const entries = Object.entries(sessions).sort(([left], [right]) => left.localeCompare(right));
         if (entries.length === 0) {
             try {
-                await unlink(filePath);
+                await fileSystem.unlink(filePath);
             }
             catch (error) {
                 if (error.code !== 'ENOENT') {
@@ -66,21 +119,21 @@ export class FileClaudeChannelSessionStore {
                 }
                 return;
             }
-            await syncDirectory(parentPath);
+            await syncDirectory(parentPath, fileSystem, platform);
             return;
         }
         const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
         let temporaryHandle;
         try {
-            temporaryHandle = await open(temporaryPath, 'wx', 0o600);
+            temporaryHandle = await fileSystem.openFile(temporaryPath, 'wx', 0o600);
             await temporaryHandle.writeFile(JSON.stringify(Object.fromEntries(entries)), {
                 encoding: 'utf8',
             });
             await temporaryHandle.sync();
             await temporaryHandle.close();
             temporaryHandle = undefined;
-            await rename(temporaryPath, filePath);
-            await syncDirectory(parentPath);
+            await fileSystem.rename(temporaryPath, filePath);
+            await syncDirectory(parentPath, fileSystem, platform);
         }
         catch (error) {
             if (temporaryHandle) {
@@ -92,7 +145,7 @@ export class FileClaudeChannelSessionStore {
                 }
             }
             try {
-                await unlink(temporaryPath);
+                await fileSystem.unlink(temporaryPath);
             }
             catch {
                 // Cleanup is best effort.

package/dist/providers/codex/adapter.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderAdapter } from '../provider-adapter.js';
+import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
+import { ProviderTurnPreparer } from '../../context/turn-preparation.js';
+import { CodexCliClient } from './cli-client.js';
+export declare class CodexProviderAdapter implements ProviderAdapter {
+    private readonly cli;
+    private readonly turnPreparer;
+    constructor(cli: CodexCliClient, turnPreparer: ProviderTurnPreparer);
+    generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    dispose(): Promise<void>;
+}

package/dist/providers/codex/adapter.js

@@ -0,0 +1,19 @@
+import { createAwaitingUserProgressHandler, parseProviderReply } from '../awaiting-user.js';
+export class CodexProviderAdapter {
+    cli;
+    turnPreparer;
+    constructor(cli, turnPreparer) {
+        this.cli = cli;
+        this.turnPreparer = turnPreparer;
+    }
+    async generateReply(input, options) {
+        const preparedTurn = await this.turnPreparer.prepare(input);
+        const text = await this.cli.generateReply(preparedTurn, {
+            onProgress: createAwaitingUserProgressHandler(options?.onProgress),
+        });
+        return parseProviderReply(text);
+    }
+    async dispose() {
+        await this.cli.dispose();
+    }
+}

package/dist/providers/codex/cli-client.d.ts

@@ -0,0 +1,103 @@
+import spawn from 'cross-spawn';
+import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
+import { type DebugLogger } from '../../debug.js';
+import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
+import type { CodexChannelSessionStore } from './session-store.js';
+interface CodexAcpRuntime {
+    spawn: typeof spawn;
+    client: typeof client;
+    ndJsonStream: typeof ndJsonStream;
+    methods: typeof methods;
+    protocolVersion: typeof PROTOCOL_VERSION;
+    cwd: string;
+    idleSessionTtlMs: number;
+    shutdownGracePeriodMs: number;
+    shutdownForceKillWaitMs: number;
+    readFile(path: string, options?: {
+        encoding?: BufferEncoding;
+    }): Promise<string>;
+    readdir(path: string): Promise<string[]>;
+    writeFile(path: string, data: string, options?: {
+        encoding?: BufferEncoding;
+        mode?: number;
+    }): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number;
+    }): Promise<void>;
+    unlink(path: string): Promise<void>;
+}
+export declare class CodexCliClient {
+    private readonly command;
+    private readonly args;
+    private readonly sessionStore?;
+    private readonly resolveSessionStoreAgentId;
+    private readonly logger;
+    private readonly runtime;
+    private readonly channels;
+    private readonly persistedSessions;
+    private readonly closingSessions;
+    private readonly pendingSessionStarts;
+    private readonly pendingSessionCloses;
+    private readonly pendingSessionStoreOperations;
+    private readonly fatalPromise;
+    private rejectFatalPromise;
+    private child?;
+    private connection?;
+    private startPromise?;
+    private shutdownPromise?;
+    private childExitPromise?;
+    private resolveChildExit?;
+    private fatalError;
+    private disposing;
+    private backendClosed;
+    private loadedSessionStoreAgentId;
+    private sessionStoreLoadPromise;
+    private sessionStoreWriteQueue;
+    private sessionCapabilities;
+    constructor(command: string, args?: string[], runtimeOverrides?: Partial<CodexAcpRuntime>, sessionStore?: CodexChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger);
+    generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
+    generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
+    dispose(): Promise<void>;
+    private ensureStarted;
+    private startBackend;
+    private getOrCreateChannelState;
+    private processChannelQueue;
+    private getOrCreateSession;
+    private startFreshSession;
+    private restoreOrCreateSession;
+    private restoreSession;
+    private clearBufferedSessionReplay;
+    private resolveSessionCwd;
+    private recycleSessionIfInjectionScopeChanged;
+    private resolveSessionAdditionalDirectories;
+    private resolveSessionVisibilityKey;
+    private resolveProjectedContextDirectory;
+    private buildProjectedPromptContext;
+    private copyProjectedFile;
+    private pruneProjectedGatewayAuthFiles;
+    private refreshProjectedPromptContextBestEffort;
+    private rewritePromptContextPaths;
+    private runTurn;
+    private raceWithFatal;
+    private invalidateSession;
+    private rejectQueuedTurnsAfterSessionTaint;
+    private failAll;
+    private closeSession;
+    private clearIdleTimer;
+    private reconcileIdleChannelState;
+    private ensureSessionStoreLoaded;
+    private readPersistedSessionId;
+    private persistSession;
+    private persistSessionBestEffort;
+    private clearPersistedSession;
+    private clearPersistedSessionBestEffort;
+    private flushSessionStore;
+    private trackSessionStoreOperation;
+    private evictIdleChannel;
+    private shutdownBackend;
+    private waitForPendingSessionStarts;
+    private waitForPendingSessionCloses;
+    private waitForChildExit;
+}
+export {};