@ekhein/sekiro-node-client 1.0.0

package/README.md

@@ -0,0 +1,57 @@
+# Sekiro Node.js Client
+
+A Node.js client for the Sekiro WebSocket API.
+
+## Installation
+
+```bash
+npm install sekiro-node-client
+```
+
+## Usage
+
+```javascript
+import SekiroClient from 'sekiro-node-client';
+
+// Create client instance
+const client = new SekiroClient('ws://your-sekiro-server:port', {
+  reconnectInterval: 2000,
+  maxReconnectAttempts: 10
+});
+
+// Register action handlers
+client.registerAction('test', (request, success, failure) => {
+  try {
+    // Process request
+    success({ result: 'ok', data: request });
+  } catch (error) {
+    failure(error.message);
+  }
+});
+
+// Graceful shutdown
+process.on('SIGINT', () => {
+  client.close();
+  process.exit();
+});
+```
+
+## API
+
+### `new SekiroClient(wsURL, [options])`
+Creates a new SekiroClient instance.
+
+**Parameters:**
+- `wsURL`: WebSocket server URL (required)
+- `options`: Configuration options (optional)
+  - `reconnectInterval`: Base reconnect interval in ms (default: 2000)
+  - `maxReconnectAttempts`: Maximum reconnect attempts (default: 10)
+  - `wsOptions`: Additional WebSocket options
+
+### Methods:
+- `registerAction(action, handler)`: Register a handler for an action
+- `close()`: Close the WebSocket connection
+
+## License
+
+MIT

package/SekiroClient.js

@@ -0,0 +1,106 @@
+import { randomUUID } from 'crypto';
+import { WebSocket } from 'partysocket';
+import { WebSocket as Client } from 'ws';
+import { SekiroResult } from './SekiroResult.js';
+import { SekiroLogger } from './SekiroLogger.js';
+
+
+/**
+ * Sekiro Client for Node.js
+ * @class
+ */
+export class SekiroClient extends WebSocket {
+
+  _handlers = new Map([])
+
+  /**
+   * Create a SekiroClient instance
+   * @param {string} wsURL - WebSocket server URL
+   * @param {object} [options] - Configuration options
+   * @param {number} [options.reconnectInterval=2000] - Base reconnect interval in ms
+   * @param {number} [options.maxReconnectAttempts=10] - Maximum reconnect attempts
+   * @param {object} [options.wsOptions] - Additional WebSocket options
+   */
+  constructor(
+    scope,
+    host = "192.168.2.102",
+    prot = 5612,
+    clientId = randomUUID().replace(/-/g, ""),
+  ) {
+    super("wss://", [], {
+      debug: false,
+      maxEnqueuedMessages: -1,
+      WebSocket: class extends Client {
+        constructor() {
+          const site  = String("ws://").concat(host, ":", prot)
+          const wsURL = new URL("/business-demo/register", site)
+          wsURL.searchParams.append("group", scope)
+          wsURL.searchParams.append("clientId", clientId)
+          super(wsURL)
+        }
+      }
+    })
+
+    super.addEventListener("open",    this.onOpen.bind(this))
+    super.addEventListener("message", this.onData.bind(this))
+    super.addEventListener("close",   this.onClose.bind(this))
+    super.addEventListener("error",   this.onError.bind(this))
+  }
+
+  /**
+   * Handle WebSocket open event
+   * @private
+   */
+  async onOpen() {
+    SekiroLogger.info("Connection established");
+  }
+
+  /**
+   * Handle WebSocket message event
+   * @private
+   * @param {string|Buffer} data - Received data
+   */
+  async onData(event) {
+    SekiroLogger.info("Received request", event.data)
+    const request = JSON.parse(event.data)
+    const handler = this._handlers.get(request.action)
+    try {
+      if (!request.action) throw new Error("Request parameter {action} is required")
+      if (!handler) throw new Error("No handler registered for action: " + request.action)
+      const data = await handler(request)
+      this.send(
+        SekiroResult.success(request, data)
+      )
+    } catch (error) {
+      this.send(
+        SekiroResult.unknown(request, error.message)
+      )
+    }
+  }
+
+  /**
+   * Handle WebSocket close event
+   * @private
+   */
+  async onClose() {
+    SekiroLogger.warn("Connection closed");
+  }
+
+  /**
+   * Handle WebSocket error event
+   * @private
+   * @param {Error} error - Error object
+   */
+  async onError(error) {
+    SekiroLogger.warn("WebSocket error:", error);
+  }
+
+  /**
+   * Register action handler
+   * @param {string} action - Action name
+   * @param {function} handler - Handler function
+   */
+  async registerAction(action, handler) {
+    this._handlers.set(action, handler)
+  }
+}

package/SekiroLogger.js

@@ -0,0 +1,12 @@
+
+export class SekiroLogger {
+
+  static info(...args) {
+    console.info("[I] [" + new Date().toLocaleString() + "]", ...args)
+  }
+
+  static warn(...args) {
+    console.warn("[W] [" + new Date().toLocaleString() + "]", ...args)
+  }
+
+}

package/SekiroResult.js

@@ -0,0 +1,15 @@
+export class SekiroResult {
+
+  static success({__sekiro_seq__}, data) {
+    return (
+      JSON.stringify({__sekiro_seq__, data, status: 0})
+    )
+  }
+
+  static unknown({__sekiro_seq__}, message) {
+    return (
+      JSON.stringify({__sekiro_seq__, message, status: -1})
+    )
+  }
+
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@ekhein/sekiro-node-client",
+  "version": "1.0.0",
+  "main": "src/index.js",
+  "type": "module",
+  "author": "ekhein",
+  "license": "ISC",
+  "description": "",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "partysocket": "^1.1.4",
+    "ws": "^8.18.2"
+  }
+}

package/test.js

@@ -0,0 +1,8 @@
+import { SekiroClient } from "./SekiroClient.js"
+
+const client = new SekiroClient("demo")
+client.registerAction("testAction", async request => {
+  return {
+    a: 1
+  }
+})