@proj-airi/server-sdk 0.3.6 → 0.4.14

package/dist/index.cjs

@@ -12,37 +12,110 @@ function sleep(ms) {
 }
 
 class Client {
+  connected = false;
   opts;
   websocket;
   eventListeners = /* @__PURE__ */ new Map();
-  authenticateAttempts = 0;
+  reconnectAttempts = 0;
+  shouldClose = false;
   constructor(options) {
     this.opts = defu.defu(
       options,
-      { url: "ws://localhost:6121/ws", possibleEvents: [] }
+      {
+        url: "ws://localhost:6121/ws",
+        possibleEvents: [],
+        onError: () => {
+        },
+        onClose: () => {
+        },
+        autoConnect: true,
+        autoReconnect: true
+      }
     );
-    this.websocket = new WebSocket__default(this.opts.url);
-    this.onEvent("module:authenticated", async (event) => {
-      const auth = event.data.authenticated;
-      if (!auth) {
-        this.authenticateAttempts++;
-        await sleep(2 ** this.authenticateAttempts * 1e3);
-        this.tryAuthenticate();
-      } else {
-        this.tryAnnounce();
+    if (this.opts.autoConnect) {
+      try {
+        this.connect();
+      } catch (err) {
+        console.error(err);
       }
-    });
-    this.websocket.onmessage = this.handleMessage.bind(this);
-    this.websocket.onopen = () => {
-      if (this.opts.token) {
-        this.tryAuthenticate();
-      } else {
-        this.tryAnnounce();
+    }
+  }
+  async retryWithExponentialBackoff(fn, attempts = 0, maxAttempts = -1) {
+    if (maxAttempts !== -1 && attempts >= maxAttempts) {
+      console.error(`Maximum retry attempts (${maxAttempts}) reached`);
+      return;
+    }
+    try {
+      await fn();
+    } catch (err) {
+      console.error("Encountered an error when retrying", err);
+      await sleep(2 ** attempts * 1e3);
+      await this.retryWithExponentialBackoff(fn, attempts++, maxAttempts);
+    }
+  }
+  async tryReconnectWithExponentialBackoff() {
+    await this.retryWithExponentialBackoff(() => this._connect(), this.reconnectAttempts);
+  }
+  _connect() {
+    return new Promise((resolve, reject) => {
+      if (this.shouldClose) {
+        resolve();
+        return;
       }
-    };
-    this.websocket.onclose = () => {
-      this.authenticateAttempts = 0;
-    };
+      if (this.connected) {
+        resolve();
+        return;
+      }
+      this.websocket = new WebSocket__default(this.opts.url);
+      this.onEvent("module:authenticated", async (event) => {
+        const auth = event.data.authenticated;
+        if (!auth) {
+          this.retryWithExponentialBackoff(() => this.tryAuthenticate());
+        } else {
+          this.tryAnnounce();
+        }
+      });
+      this.websocket.onerror = (event) => {
+        this.opts.onError?.(event);
+        if ("error" in event && event.error instanceof Error) {
+          if (event.error.message === "Received network error or non-101 status code.") {
+            this.connected = false;
+            if (!this.opts.autoReconnect) {
+              this.opts.onError?.(event);
+              this.opts.onClose?.();
+              reject(event.error);
+              return;
+            }
+            reject(event.error);
+          }
+        }
+      };
+      this.websocket.onclose = () => {
+        this.opts.onClose?.();
+        this.connected = false;
+        if (!this.opts.autoReconnect) {
+          this.opts.onClose?.();
+        } else {
+          this.tryReconnectWithExponentialBackoff();
+        }
+      };
+      this.websocket.onmessage = (event) => {
+        this.handleMessage(event);
+      };
+      this.websocket.onopen = () => {
+        this.reconnectAttempts = 0;
+        if (this.opts.token) {
+          this.tryAuthenticate();
+        } else {
+          this.tryAnnounce();
+        }
+        this.connected = true;
+        resolve();
+      };
+    });
+  }
+  async connect() {
+    await this.tryReconnectWithExponentialBackoff();
   }
   tryAnnounce() {
     this.send({
@@ -59,26 +132,41 @@ class Client {
     }
   }
   async handleMessage(event) {
-    const data = JSON.parse(event.data);
-    const listeners = this.eventListeners.get(data.type);
-    if (!listeners)
-      return;
-    for (const listener of listeners)
-      await listener(data);
+    try {
+      const data = JSON.parse(event.data);
+      const listeners = this.eventListeners.get(data.type);
+      if (!listeners)
+        return;
+      for (const listener of listeners)
+        await listener(data);
+    } catch (err) {
+      console.error("Failed to parse message:", err);
+      this.opts.onError?.(err);
+    }
   }
   onEvent(event, callback) {
     if (!this.eventListeners.get(event)) {
       this.eventListeners.set(event, []);
     }
     const listeners = this.eventListeners.get(event);
+    if (!listeners) {
+      return;
+    }
     listeners.push(callback);
     this.eventListeners.set(event, listeners);
   }
   send(data) {
-    this.websocket.send(JSON.stringify(data));
+    this.websocket?.send(JSON.stringify(data));
   }
   sendRaw(data) {
-    this.websocket.send(data);
+    this.websocket?.send(data);
+  }
+  close() {
+    this.shouldClose = true;
+    if (this.connected && this.websocket) {
+      this.websocket.close();
+      this.connected = false;
+    }
   }
 }
 

package/dist/index.d.cts

@@ -1,24 +1,34 @@
 import { WebSocketEvents, WebSocketBaseEvent, WebSocketEvent } from '@proj-airi/server-shared/types';
-import { Blob } from 'node:buffer';
 
-interface ClientOptions {
+interface ClientOptions<C = undefined> {
     url?: string;
     name: string;
-    possibleEvents?: Array<(keyof WebSocketEvents)>;
+    possibleEvents?: Array<(keyof WebSocketEvents<C>)>;
     token?: string;
+    onError?: (error: unknown) => void;
+    onClose?: () => void;
+    autoConnect?: boolean;
+    autoReconnect?: boolean;
 }
-declare class Client {
+declare class Client<C = undefined> {
+    private connected;
     private opts;
     private websocket;
     private eventListeners;
-    private authenticateAttempts;
-    constructor(options: ClientOptions);
+    private reconnectAttempts;
+    private shouldClose;
+    constructor(options: ClientOptions<C>);
+    retryWithExponentialBackoff(fn: () => void | Promise<void>, attempts?: number, maxAttempts?: number): Promise<void>;
+    tryReconnectWithExponentialBackoff(): Promise<void>;
+    private _connect;
+    connect(): Promise<void>;
     private tryAnnounce;
     private tryAuthenticate;
     private handleMessage;
-    onEvent<E extends keyof WebSocketEvents>(event: E, callback: (data: WebSocketBaseEvent<E, WebSocketEvents[E]>) => void | Promise<void>): void;
-    send(data: WebSocketEvent): void;
-    sendRaw(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    onEvent<E extends keyof WebSocketEvents<C>>(event: E, callback: (data: WebSocketBaseEvent<E, WebSocketEvents<C>[E]>) => void | Promise<void>): void;
+    send(data: WebSocketEvent<C>): void;
+    sendRaw(data: string | ArrayBufferLike | ArrayBufferView): void;
+    close(): void;
 }
 
 export { Client, type ClientOptions };

package/dist/index.d.mts

@@ -1,24 +1,34 @@
 import { WebSocketEvents, WebSocketBaseEvent, WebSocketEvent } from '@proj-airi/server-shared/types';
-import { Blob } from 'node:buffer';
 
-interface ClientOptions {
+interface ClientOptions<C = undefined> {
     url?: string;
     name: string;
-    possibleEvents?: Array<(keyof WebSocketEvents)>;
+    possibleEvents?: Array<(keyof WebSocketEvents<C>)>;
     token?: string;
+    onError?: (error: unknown) => void;
+    onClose?: () => void;
+    autoConnect?: boolean;
+    autoReconnect?: boolean;
 }
-declare class Client {
+declare class Client<C = undefined> {
+    private connected;
     private opts;
     private websocket;
     private eventListeners;
-    private authenticateAttempts;
-    constructor(options: ClientOptions);
+    private reconnectAttempts;
+    private shouldClose;
+    constructor(options: ClientOptions<C>);
+    retryWithExponentialBackoff(fn: () => void | Promise<void>, attempts?: number, maxAttempts?: number): Promise<void>;
+    tryReconnectWithExponentialBackoff(): Promise<void>;
+    private _connect;
+    connect(): Promise<void>;
     private tryAnnounce;
     private tryAuthenticate;
     private handleMessage;
-    onEvent<E extends keyof WebSocketEvents>(event: E, callback: (data: WebSocketBaseEvent<E, WebSocketEvents[E]>) => void | Promise<void>): void;
-    send(data: WebSocketEvent): void;
-    sendRaw(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    onEvent<E extends keyof WebSocketEvents<C>>(event: E, callback: (data: WebSocketBaseEvent<E, WebSocketEvents<C>[E]>) => void | Promise<void>): void;
+    send(data: WebSocketEvent<C>): void;
+    sendRaw(data: string | ArrayBufferLike | ArrayBufferView): void;
+    close(): void;
 }
 
 export { Client, type ClientOptions };

package/dist/index.d.ts

@@ -1,24 +1,34 @@
 import { WebSocketEvents, WebSocketBaseEvent, WebSocketEvent } from '@proj-airi/server-shared/types';
-import { Blob } from 'node:buffer';
 
-interface ClientOptions {
+interface ClientOptions<C = undefined> {
     url?: string;
     name: string;
-    possibleEvents?: Array<(keyof WebSocketEvents)>;
+    possibleEvents?: Array<(keyof WebSocketEvents<C>)>;
     token?: string;
+    onError?: (error: unknown) => void;
+    onClose?: () => void;
+    autoConnect?: boolean;
+    autoReconnect?: boolean;
 }
-declare class Client {
+declare class Client<C = undefined> {
+    private connected;
     private opts;
     private websocket;
     private eventListeners;
-    private authenticateAttempts;
-    constructor(options: ClientOptions);
+    private reconnectAttempts;
+    private shouldClose;
+    constructor(options: ClientOptions<C>);
+    retryWithExponentialBackoff(fn: () => void | Promise<void>, attempts?: number, maxAttempts?: number): Promise<void>;
+    tryReconnectWithExponentialBackoff(): Promise<void>;
+    private _connect;
+    connect(): Promise<void>;
     private tryAnnounce;
     private tryAuthenticate;
     private handleMessage;
-    onEvent<E extends keyof WebSocketEvents>(event: E, callback: (data: WebSocketBaseEvent<E, WebSocketEvents[E]>) => void | Promise<void>): void;
-    send(data: WebSocketEvent): void;
-    sendRaw(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    onEvent<E extends keyof WebSocketEvents<C>>(event: E, callback: (data: WebSocketBaseEvent<E, WebSocketEvents<C>[E]>) => void | Promise<void>): void;
+    send(data: WebSocketEvent<C>): void;
+    sendRaw(data: string | ArrayBufferLike | ArrayBufferView): void;
+    close(): void;
 }
 
 export { Client, type ClientOptions };

package/dist/index.mjs

@@ -6,37 +6,110 @@ function sleep(ms) {
 }
 
 class Client {
+  connected = false;
   opts;
   websocket;
   eventListeners = /* @__PURE__ */ new Map();
-  authenticateAttempts = 0;
+  reconnectAttempts = 0;
+  shouldClose = false;
   constructor(options) {
     this.opts = defu(
       options,
-      { url: "ws://localhost:6121/ws", possibleEvents: [] }
+      {
+        url: "ws://localhost:6121/ws",
+        possibleEvents: [],
+        onError: () => {
+        },
+        onClose: () => {
+        },
+        autoConnect: true,
+        autoReconnect: true
+      }
     );
-    this.websocket = new WebSocket(this.opts.url);
-    this.onEvent("module:authenticated", async (event) => {
-      const auth = event.data.authenticated;
-      if (!auth) {
-        this.authenticateAttempts++;
-        await sleep(2 ** this.authenticateAttempts * 1e3);
-        this.tryAuthenticate();
-      } else {
-        this.tryAnnounce();
+    if (this.opts.autoConnect) {
+      try {
+        this.connect();
+      } catch (err) {
+        console.error(err);
       }
-    });
-    this.websocket.onmessage = this.handleMessage.bind(this);
-    this.websocket.onopen = () => {
-      if (this.opts.token) {
-        this.tryAuthenticate();
-      } else {
-        this.tryAnnounce();
+    }
+  }
+  async retryWithExponentialBackoff(fn, attempts = 0, maxAttempts = -1) {
+    if (maxAttempts !== -1 && attempts >= maxAttempts) {
+      console.error(`Maximum retry attempts (${maxAttempts}) reached`);
+      return;
+    }
+    try {
+      await fn();
+    } catch (err) {
+      console.error("Encountered an error when retrying", err);
+      await sleep(2 ** attempts * 1e3);
+      await this.retryWithExponentialBackoff(fn, attempts++, maxAttempts);
+    }
+  }
+  async tryReconnectWithExponentialBackoff() {
+    await this.retryWithExponentialBackoff(() => this._connect(), this.reconnectAttempts);
+  }
+  _connect() {
+    return new Promise((resolve, reject) => {
+      if (this.shouldClose) {
+        resolve();
+        return;
       }
-    };
-    this.websocket.onclose = () => {
-      this.authenticateAttempts = 0;
-    };
+      if (this.connected) {
+        resolve();
+        return;
+      }
+      this.websocket = new WebSocket(this.opts.url);
+      this.onEvent("module:authenticated", async (event) => {
+        const auth = event.data.authenticated;
+        if (!auth) {
+          this.retryWithExponentialBackoff(() => this.tryAuthenticate());
+        } else {
+          this.tryAnnounce();
+        }
+      });
+      this.websocket.onerror = (event) => {
+        this.opts.onError?.(event);
+        if ("error" in event && event.error instanceof Error) {
+          if (event.error.message === "Received network error or non-101 status code.") {
+            this.connected = false;
+            if (!this.opts.autoReconnect) {
+              this.opts.onError?.(event);
+              this.opts.onClose?.();
+              reject(event.error);
+              return;
+            }
+            reject(event.error);
+          }
+        }
+      };
+      this.websocket.onclose = () => {
+        this.opts.onClose?.();
+        this.connected = false;
+        if (!this.opts.autoReconnect) {
+          this.opts.onClose?.();
+        } else {
+          this.tryReconnectWithExponentialBackoff();
+        }
+      };
+      this.websocket.onmessage = (event) => {
+        this.handleMessage(event);
+      };
+      this.websocket.onopen = () => {
+        this.reconnectAttempts = 0;
+        if (this.opts.token) {
+          this.tryAuthenticate();
+        } else {
+          this.tryAnnounce();
+        }
+        this.connected = true;
+        resolve();
+      };
+    });
+  }
+  async connect() {
+    await this.tryReconnectWithExponentialBackoff();
   }
   tryAnnounce() {
     this.send({
@@ -53,26 +126,41 @@ class Client {
     }
   }
   async handleMessage(event) {
-    const data = JSON.parse(event.data);
-    const listeners = this.eventListeners.get(data.type);
-    if (!listeners)
-      return;
-    for (const listener of listeners)
-      await listener(data);
+    try {
+      const data = JSON.parse(event.data);
+      const listeners = this.eventListeners.get(data.type);
+      if (!listeners)
+        return;
+      for (const listener of listeners)
+        await listener(data);
+    } catch (err) {
+      console.error("Failed to parse message:", err);
+      this.opts.onError?.(err);
+    }
   }
   onEvent(event, callback) {
     if (!this.eventListeners.get(event)) {
       this.eventListeners.set(event, []);
     }
     const listeners = this.eventListeners.get(event);
+    if (!listeners) {
+      return;
+    }
     listeners.push(callback);
     this.eventListeners.set(event, listeners);
   }
   send(data) {
-    this.websocket.send(JSON.stringify(data));
+    this.websocket?.send(JSON.stringify(data));
   }
   sendRaw(data) {
-    this.websocket.send(data);
+    this.websocket?.send(data);
+  }
+  close() {
+    this.shouldClose = true;
+    if (this.connected && this.websocket) {
+      this.websocket.close();
+      this.connected = false;
+    }
   }
 }
 

package/dist/utils/node/index.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const process = require('node:process');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+let running = true;
+function killProcess() {
+  running = false;
+}
+process__default.on("SIGTERM", () => {
+  killProcess();
+});
+process__default.on("SIGINT", () => {
+  killProcess();
+});
+process__default.on("uncaughtException", (e) => {
+  console.error(e);
+  killProcess();
+});
+function runUntilSignal() {
+  setTimeout(() => {
+    if (running)
+      runUntilSignal();
+  }, 10);
+}
+
+exports.runUntilSignal = runUntilSignal;

package/dist/utils/node/index.d.cts

@@ -0,0 +1,3 @@
+declare function runUntilSignal(): void;
+
+export { runUntilSignal };

package/dist/utils/node/index.d.mts

@@ -0,0 +1,3 @@
+declare function runUntilSignal(): void;
+
+export { runUntilSignal };

package/dist/utils/node/index.d.ts

@@ -0,0 +1,3 @@
+declare function runUntilSignal(): void;
+
+export { runUntilSignal };

package/dist/utils/node/index.mjs

@@ -0,0 +1,24 @@
+import process from 'node:process';
+
+let running = true;
+function killProcess() {
+  running = false;
+}
+process.on("SIGTERM", () => {
+  killProcess();
+});
+process.on("SIGINT", () => {
+  killProcess();
+});
+process.on("uncaughtException", (e) => {
+  console.error(e);
+  killProcess();
+});
+function runUntilSignal() {
+  setTimeout(() => {
+    if (running)
+      runUntilSignal();
+  }, 10);
+}
+
+export { runUntilSignal };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@proj-airi/server-sdk",
   "type": "module",
-  "version": "0.3.6",
+  "version": "0.4.14",
   "description": "Client-side SDK implementation for connecting to Airi server components and runtimes",
   "author": {
     "name": "Neko Ayaka",
@@ -19,6 +19,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
+    },
+    "./utils/node": {
+      "types": "./dist/utils/node/index.d.ts",
+      "import": "./dist/utils/node/index.mjs",
+      "require": "./dist/utils/node/index.cjs"
     }
   },
   "main": "./dist/index.cjs",
@@ -32,7 +37,7 @@
   "dependencies": {
     "crossws": "^0.3.4",
     "defu": "^6.1.4",
-    "@proj-airi/server-shared": "^0.3.6"
+    "@proj-airi/server-shared": "^0.4.14"
   },
   "scripts": {
     "dev": "pnpm run stub",