@borgee/agents-host 0.2.1 → 0.2.2

package/dist/agents-host.js

@@ -174,7 +174,6 @@ export class AgentsHost {
                 ? this.enqueueProgressChannelTurn(message.channel_id, () => this.handleMessage(message))
                 : this.handleMessage(message);
             this.trackActiveTurn(task);
-            return task;
         });
         const agentId = await this.ensureSelfAgentId();
         console.log('[agents-host] connected', {

package/dist/chat/chat-control-plane.d.ts

@@ -1,6 +1,6 @@
 import type { ChannelMessageEvent, MeResponseUser, PostedMessage } from '../types.js';
 export interface ChatControlPlane {
-    connect(onMessage: (message: ChannelMessageEvent) => void | Promise<void>): Promise<void>;
+    connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(channelId: string, content: string): Promise<PostedMessage>;
     editMessage(messageId: string, content: string): Promise<void>;

package/dist/chat/sdk-chat-control-plane.d.ts

@@ -11,11 +11,12 @@ type SdkChatControlPlaneOptions = Pick<BorgeePluginOptions, 'cursorStore' | 'plu
  */
 export declare class SdkChatControlPlane implements ChatControlPlane {
     private readonly client;
+    private pendingMessages;
     private unsubscribe;
     private connected;
     private me;
     constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, options?: SdkChatControlPlaneOptions);
-    connect(onMessage: (message: ChannelMessageEvent) => void | Promise<void>): Promise<void>;
+    connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(channelId: string, content: string): Promise<PostedMessage>;
     editMessage(messageId: string, content: string): Promise<void>;

package/dist/chat/sdk-chat-control-plane.js

@@ -6,6 +6,7 @@ import { createBorgeePlugin, } from '@borgee/plugin-sdk';
  */
 export class SdkChatControlPlane {
     client;
+    pendingMessages = [];
     unsubscribe = null;
     connected = false;
     me = null;
@@ -13,28 +14,35 @@ export class SdkChatControlPlane {
         this.client = createClient({ baseUrl, apiKey, ...options });
     }
     async connect(onMessage) {
-        this.unsubscribe = this.client.on('message', async (event) => {
-            await onMessage(mapInboundToChannelMessage(event));
+        this.unsubscribe = this.client.on('message', (event) => {
+            const message = mapInboundToChannelMessage(event);
+            if (!this.connected) {
+                this.pendingMessages.push(message);
+                return;
+            }
+            onMessage(message);
         });
         try {
-            // The SDK resolves connect after session.resume_ack, before every replay
-            // frame necessarily runs. Mark the consumer ready first so replay ACKs
-            // wait for the real handler instead of acknowledging an in-memory buffer.
-            this.connected = true;
             await this.client.connect();
+            this.connected = true;
             if (this.client.agentId) {
                 this.me = { id: this.client.agentId };
             }
+            for (const message of this.pendingMessages) {
+                onMessage(message);
+            }
+            this.pendingMessages = [];
         }
         catch (error) {
-            this.connected = false;
             this.unsubscribe?.();
             this.unsubscribe = null;
+            this.pendingMessages = [];
             throw error;
         }
     }
     async close() {
         this.connected = false;
+        this.pendingMessages = [];
         this.unsubscribe?.();
         this.unsubscribe = null;
         await this.client.close();

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

@@ -4,6 +4,28 @@ export interface ClaudeChannelSessionStore {
 }
 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 +34,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/copilot/session-store.d.ts

@@ -4,6 +4,28 @@ export interface CopilotChannelSessionStore {
 }
 export interface FileCopilotChannelSessionStoreOptions {
     resolvePath(agentId: string): string;
+    fileSystem?: CopilotSessionStoreFileSystem;
+    platform?: NodeJS.Platform;
+}
+interface CopilotSessionStoreDirectoryHandle {
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+interface CopilotSessionStoreFileHandle extends CopilotSessionStoreDirectoryHandle {
+    writeFile(data: string, options: {
+        encoding: BufferEncoding;
+    }): Promise<void>;
+}
+interface CopilotSessionStoreFileSystem {
+    mkdir(path: string, options: {
+        recursive: true;
+        mode: number;
+    }): Promise<void>;
+    openDirectory(path: string): Promise<CopilotSessionStoreDirectoryHandle>;
+    openFile(path: string, flags: string, mode: number): Promise<CopilotSessionStoreFileHandle>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
 }
 export declare class FileCopilotChannelSessionStore implements CopilotChannelSessionStore {
     private readonly options;
@@ -12,3 +34,4 @@ export declare class FileCopilotChannelSessionStore implements CopilotChannelSes
     load(agentId: string): Promise<Record<string, string>>;
     save(agentId: string, sessions: Record<string, string>): Promise<void>;
 }
+export {};

package/dist/providers/copilot/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();
     }
 }
@@ -30,7 +81,7 @@ export class FileCopilotChannelSessionStore {
         this.options = options;
     }
     async loadFromPath(filePath) {
-        const raw = await readFile(filePath, 'utf8');
+        const raw = await (this.options.fileSystem ?? nodeFileSystem).readFile(filePath, 'utf8');
         return normalizePersistedSessions(JSON.parse(raw), filePath);
     }
     async load(agentId) {
@@ -48,11 +99,13 @@ export class FileCopilotChannelSessionStore {
     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') {
@@ -60,21 +113,21 @@ export class FileCopilotChannelSessionStore {
                 }
                 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) {
@@ -86,7 +139,7 @@ export class FileCopilotChannelSessionStore {
                 }
             }
             try {
-                await unlink(temporaryPath);
+                await fileSystem.unlink(temporaryPath);
             }
             catch {
                 // Cleanup is best effort.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.2.1",
-    "@borgee/plugin-sdk": "0.1.4",
+    "@borgee/plugin-sdk": "0.1.5",
     "cross-spawn": "^7.0.6",
     "yaml": "^2.8.1"
   },