@love-moon/conductor-sdk 0.1.0

package/dist/ws/client.js

@@ -0,0 +1,296 @@
+class AsyncLock {
+    tail = Promise.resolve();
+    async runExclusive(fn) {
+        const run = this.tail.then(fn, fn);
+        this.tail = run
+            .then(() => undefined)
+            .catch(() => undefined);
+        return run;
+    }
+}
+export class ConductorWebSocketClient {
+    url;
+    token;
+    reconnectDelay;
+    heartbeatInterval;
+    connectImpl;
+    handlers = [];
+    extraHeaders;
+    conn = null;
+    stop = false;
+    listenTask = null;
+    heartbeatTask = null;
+    lock = new AsyncLock();
+    waitController = new AbortController();
+    constructor(config, options = {}) {
+        this.url = config.resolvedWebsocketUrl;
+        this.token = config.agentToken;
+        this.reconnectDelay = options.reconnectDelay ?? 3000;
+        this.heartbeatInterval = options.heartbeatInterval ?? 20_000;
+        this.extraHeaders = {
+            'x-conductor-host': options.hostName ?? defaultHostName(),
+            ...(options.extraHeaders ?? {}),
+        };
+        this.connectImpl = options.connectImpl ?? defaultConnectImpl;
+    }
+    registerHandler(handler) {
+        this.handlers.push(handler);
+    }
+    async connect() {
+        this.stop = false;
+        if (this.waitController.signal.aborted) {
+            this.waitController = new AbortController();
+        }
+        await this.openConnection(true);
+    }
+    async disconnect() {
+        this.stop = true;
+        this.waitController.abort();
+        if (this.listenTask) {
+            this.listenTask = null;
+        }
+        if (this.heartbeatTask) {
+            this.heartbeatTask = null;
+        }
+        if (this.conn && !this.isConnectionClosed(this.conn)) {
+            await this.conn.close();
+        }
+        this.conn = null;
+    }
+    async sendJson(payload) {
+        await this.ensureConnection();
+        await this.sendWithReconnect(JSON.stringify(payload));
+    }
+    async ensureConnection() {
+        if (this.conn && !this.isConnectionClosed(this.conn)) {
+            return;
+        }
+        await this.openConnection(true);
+    }
+    async openConnection(force = false) {
+        await this.lock.runExclusive(async () => {
+            if (this.conn && !this.isConnectionClosed(this.conn) && !force) {
+                return;
+            }
+            await this.cancelTasks();
+            while (!this.stop) {
+                try {
+                    const headers = { Authorization: `Bearer ${this.token}`, ...this.extraHeaders };
+                    this.conn = await this.connectImpl(this.url, { headers });
+                    this.listenTask = this.listenLoop(this.conn);
+                    this.heartbeatTask = this.heartbeatLoop(this.conn);
+                    return;
+                }
+                catch (error) {
+                    if (force) {
+                        console.warn(`[WebSocket] Connection failed, retrying in ${this.reconnectDelay}ms... (${error instanceof Error ? error.message : String(error)})`);
+                    }
+                    await wait(this.reconnectDelay, this.waitController.signal);
+                }
+            }
+        });
+    }
+    async cancelTasks() {
+        this.listenTask = null;
+        this.heartbeatTask = null;
+    }
+    async listenLoop(conn) {
+        try {
+            for await (const message of conn) {
+                await this.dispatch(message);
+            }
+        }
+        catch {
+            // Ignore errors; reconnection logic handles it.
+        }
+        finally {
+            if (!this.stop && conn === this.conn) {
+                await this.openConnection(true);
+            }
+        }
+    }
+    async heartbeatLoop(conn) {
+        try {
+            while (!this.stop && !this.isConnectionClosed(conn)) {
+                await wait(this.heartbeatInterval, this.waitController.signal);
+                try {
+                    await conn.ping();
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+        finally {
+            if (!this.stop && conn === this.conn) {
+                await this.openConnection(true);
+            }
+        }
+    }
+    async dispatch(message) {
+        let payload;
+        try {
+            payload = JSON.parse(message);
+        }
+        catch {
+            return;
+        }
+        for (const handler of this.handlers) {
+            const result = handler(payload);
+            if (result && typeof result.then === 'function') {
+                await result;
+            }
+        }
+    }
+    isConnectionClosed(conn) {
+        if (!conn) {
+            return true;
+        }
+        if (typeof conn.closed === 'boolean') {
+            return conn.closed;
+        }
+        return false;
+    }
+    async sendWithReconnect(data) {
+        let attemptedReconnect = false;
+        // Loop at most twice: initial send, then one reconnect + retry
+        while (true) {
+            const conn = this.conn;
+            if (!conn || this.isConnectionClosed(conn)) {
+                await this.openConnection(true);
+            }
+            if (!this.conn || this.isConnectionClosed(this.conn)) {
+                throw new Error('WebSocket not connected');
+            }
+            try {
+                await this.conn.send(data);
+                return;
+            }
+            catch (error) {
+                if (attemptedReconnect || !this.isNotOpenError(error)) {
+                    throw error instanceof Error ? error : new Error(String(error));
+                }
+                attemptedReconnect = true;
+                await this.openConnection(true);
+            }
+        }
+    }
+    isNotOpenError(error) {
+        if (!error)
+            return false;
+        const message = error instanceof Error ? error.message : String(error);
+        return message.toLowerCase().includes('websocket is not open');
+    }
+}
+async function wait(ms, signal) {
+    if (!signal) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+        return;
+    }
+    if (signal.aborted) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+async function defaultConnectImpl(url, options) {
+    const { default: WebSocket } = await import('ws');
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(url, {
+            headers: options.headers,
+            perMessageDeflate: false,
+        });
+        ws.once('open', () => resolve(new WsAdapter(ws)));
+        ws.once('error', (err) => reject(err));
+    });
+}
+function defaultHostName() {
+    const pid = process.pid;
+    const host = process.env.HOSTNAME || process.env.COMPUTERNAME || 'unknown-host';
+    return `conductor-fire-${host}-${pid}`;
+}
+class WsAdapter {
+    ws;
+    queue = [];
+    waiters = [];
+    closed = false;
+    constructor(ws) {
+        this.ws = ws;
+        ws.on('message', (data) => this.enqueue(data.toString()));
+        ws.on('close', () => {
+            this.closed = true;
+            this.enqueue(null);
+        });
+        ws.on('error', () => {
+            this.closed = true;
+            this.enqueue(null);
+        });
+    }
+    send(data) {
+        return new Promise((resolve, reject) => {
+            this.ws.send(data, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    ping() {
+        return new Promise((resolve, reject) => {
+            this.ws.ping(undefined, undefined, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    close() {
+        return new Promise((resolve) => {
+            if (this.closed) {
+                resolve();
+                return;
+            }
+            this.ws.once('close', () => resolve());
+            this.ws.close();
+        });
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const value = await this.nextValue();
+            if (value === null) {
+                return;
+            }
+            yield value;
+        }
+    }
+    nextValue() {
+        if (this.queue.length) {
+            const value = this.queue.shift() ?? null;
+            return Promise.resolve(value);
+        }
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    enqueue(value) {
+        if (this.waiters.length) {
+            const resolve = this.waiters.shift();
+            resolve(value);
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+}

package/dist/ws/index.d.ts

@@ -0,0 +1 @@
+export * from './client.js';

package/dist/ws/index.js

@@ -0,0 +1 @@
+export * from './client.js';

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@love-moon/conductor-sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.23.0",
+    "ws": "^8.18.0",
+    "yaml": "^2.6.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.12",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  }
+}