@stepflowjs/trigger-websocket 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { Trigger, TriggerHandler } from '@stepflowjs/core';
+
+interface WebSocketTriggerConfig {
+    /** WebSocket server URL to connect to */
+    url: string;
+    /** WebSocket sub-protocols */
+    protocols?: string[];
+    /** Custom headers for connection */
+    headers?: Record<string, string>;
+    /** Auto-reconnect on disconnect */
+    reconnect?: boolean;
+    /** Reconnect interval in milliseconds */
+    reconnectInterval?: number;
+    /** Maximum reconnect attempts */
+    maxReconnectAttempts?: number;
+    /** Message parsing type */
+    messageType?: "json" | "text";
+}
+/**
+ * WebSocket trigger for Stepflow workflows
+ *
+ * Connects to a WebSocket server and triggers workflows on incoming messages.
+ * Supports auto-reconnect with configurable retry logic.
+ *
+ * @example
+ * ```typescript
+ * const trigger = new WebSocketTrigger({
+ *   url: 'wss://api.example.com/events',
+ *   messageType: 'json',
+ *   reconnect: true,
+ *   reconnectInterval: 5000,
+ *   maxReconnectAttempts: 10,
+ * });
+ *
+ * await trigger.start(async (event) => {
+ *   await stepflow.trigger('process-event', event.data);
+ * });
+ * ```
+ */
+declare class WebSocketTrigger implements Trigger<WebSocketTriggerConfig> {
+    readonly config: WebSocketTriggerConfig;
+    readonly type = "websocket";
+    private ws?;
+    private handler?;
+    private reconnectAttempts;
+    private shouldReconnect;
+    private reconnectTimeout?;
+    constructor(config: WebSocketTriggerConfig);
+    /**
+     * Start the trigger with a handler function
+     * @param handler Function to call when WebSocket messages are received
+     */
+    start(handler: TriggerHandler): Promise<void>;
+    /**
+     * Connect to the WebSocket server
+     * @private
+     */
+    private connect;
+    /**
+     * Attempt to reconnect to the WebSocket server
+     * @private
+     */
+    private attemptReconnect;
+    /**
+     * Stop the trigger and close the WebSocket connection
+     */
+    stop(): Promise<void>;
+    /**
+     * Health check - returns true if WebSocket is connected
+     */
+    healthCheck(): Promise<boolean>;
+}
+
+export { WebSocketTrigger, type WebSocketTriggerConfig };

package/dist/index.js

@@ -0,0 +1,138 @@
+// src/index.ts
+import WebSocket from "ws";
+var WebSocketTrigger = class {
+  constructor(config) {
+    this.config = config;
+  }
+  type = "websocket";
+  ws;
+  handler;
+  reconnectAttempts = 0;
+  shouldReconnect = true;
+  reconnectTimeout;
+  /**
+   * Start the trigger with a handler function
+   * @param handler Function to call when WebSocket messages are received
+   */
+  async start(handler) {
+    this.handler = handler;
+    this.shouldReconnect = true;
+    await this.connect();
+  }
+  /**
+   * Connect to the WebSocket server
+   * @private
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        const options = {};
+        if (this.config.headers) {
+          options.headers = this.config.headers;
+        }
+        this.ws = new WebSocket(
+          this.config.url,
+          this.config.protocols,
+          options
+        );
+        this.ws.on("open", () => {
+          this.reconnectAttempts = 0;
+          resolve();
+        });
+        this.ws.on("message", async (rawData) => {
+          try {
+            let data;
+            const messageStr = rawData.toString();
+            if (this.config.messageType === "text") {
+              data = messageStr;
+            } else {
+              try {
+                data = JSON.parse(messageStr);
+              } catch (error) {
+                console.error(
+                  "Failed to parse WebSocket message as JSON:",
+                  error
+                );
+                data = messageStr;
+              }
+            }
+            const triggerEvent = {
+              id: crypto.randomUUID(),
+              type: this.type,
+              source: this.config.url,
+              data,
+              metadata: {
+                messageType: this.config.messageType || "json"
+              },
+              timestamp: /* @__PURE__ */ new Date()
+            };
+            await this.handler?.(triggerEvent);
+          } catch (error) {
+            console.error("Error handling WebSocket message:", error);
+          }
+        });
+        this.ws.on("close", () => {
+          if (this.shouldReconnect && this.config.reconnect !== false) {
+            this.attemptReconnect();
+          }
+        });
+        this.ws.on("error", (error) => {
+          console.error("WebSocket error:", error);
+          if (this.reconnectAttempts === 0) {
+            reject(error);
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Attempt to reconnect to the WebSocket server
+   * @private
+   */
+  attemptReconnect() {
+    const maxAttempts = this.config.maxReconnectAttempts ?? 10;
+    const interval = this.config.reconnectInterval ?? 5e3;
+    if (this.reconnectAttempts < maxAttempts) {
+      this.reconnectAttempts++;
+      console.log(
+        `WebSocket reconnect attempt ${this.reconnectAttempts}/${maxAttempts}`
+      );
+      this.reconnectTimeout = setTimeout(() => {
+        this.connect().catch((error) => {
+          console.error("WebSocket reconnect failed:", error);
+        });
+      }, interval);
+    } else {
+      console.error(
+        `WebSocket max reconnect attempts (${maxAttempts}) reached`
+      );
+    }
+  }
+  /**
+   * Stop the trigger and close the WebSocket connection
+   */
+  async stop() {
+    this.shouldReconnect = false;
+    this.handler = void 0;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = void 0;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = void 0;
+    }
+  }
+  /**
+   * Health check - returns true if WebSocket is connected
+   */
+  async healthCheck() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+};
+export {
+  WebSocketTrigger
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { Trigger, TriggerHandler, TriggerEvent } from \"@stepflowjs/core\";\nimport WebSocket from \"ws\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport interface WebSocketTriggerConfig {\n  /** WebSocket server URL to connect to */\n  url: string;\n  /** WebSocket sub-protocols */\n  protocols?: string[];\n  /** Custom headers for connection */\n  headers?: Record<string, string>;\n  /** Auto-reconnect on disconnect */\n  reconnect?: boolean;\n  /** Reconnect interval in milliseconds */\n  reconnectInterval?: number;\n  /** Maximum reconnect attempts */\n  maxReconnectAttempts?: number;\n  /** Message parsing type */\n  messageType?: \"json\" | \"text\";\n}\n\n// ============================================================================\n// WebSocketTrigger Implementation\n// ============================================================================\n\n/**\n * WebSocket trigger for Stepflow workflows\n *\n * Connects to a WebSocket server and triggers workflows on incoming messages.\n * Supports auto-reconnect with configurable retry logic.\n *\n * @example\n * ```typescript\n * const trigger = new WebSocketTrigger({\n *   url: 'wss://api.example.com/events',\n *   messageType: 'json',\n *   reconnect: true,\n *   reconnectInterval: 5000,\n *   maxReconnectAttempts: 10,\n * });\n *\n * await trigger.start(async (event) => {\n *   await stepflow.trigger('process-event', event.data);\n * });\n * ```\n */\nexport class WebSocketTrigger implements Trigger<WebSocketTriggerConfig> {\n  readonly type = \"websocket\";\n  private ws?: WebSocket;\n  private handler?: TriggerHandler;\n  private reconnectAttempts = 0;\n  private shouldReconnect = true;\n  private reconnectTimeout?: NodeJS.Timeout;\n\n  constructor(readonly config: WebSocketTriggerConfig) {}\n\n  /**\n   * Start the trigger with a handler function\n   * @param handler Function to call when WebSocket messages are received\n   */\n  async start(handler: TriggerHandler): Promise<void> {\n    this.handler = handler;\n    this.shouldReconnect = true;\n    await this.connect();\n  }\n\n  /**\n   * Connect to the WebSocket server\n   * @private\n   */\n  private async connect(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      try {\n        // Create WebSocket connection\n        const options: WebSocket.ClientOptions = {};\n        if (this.config.headers) {\n          options.headers = this.config.headers;\n        }\n\n        this.ws = new WebSocket(\n          this.config.url,\n          this.config.protocols,\n          options,\n        );\n\n        // Handle connection open\n        this.ws.on(\"open\", () => {\n          this.reconnectAttempts = 0;\n          resolve();\n        });\n\n        // Handle incoming messages\n        this.ws.on(\"message\", async (rawData: WebSocket.RawData) => {\n          try {\n            let data: unknown;\n\n            // Parse message based on messageType\n            const messageStr = rawData.toString();\n            if (this.config.messageType === \"text\") {\n              data = messageStr;\n            } else {\n              // Default to JSON parsing\n              try {\n                data = JSON.parse(messageStr);\n              } catch (error) {\n                console.error(\n                  \"Failed to parse WebSocket message as JSON:\",\n                  error,\n                );\n                data = messageStr;\n              }\n            }\n\n            // Create trigger event\n            const triggerEvent: TriggerEvent = {\n              id: crypto.randomUUID(),\n              type: this.type,\n              source: this.config.url,\n              data,\n              metadata: {\n                messageType: this.config.messageType || \"json\",\n              },\n              timestamp: new Date(),\n            };\n\n            // Invoke handler\n            await this.handler?.(triggerEvent);\n          } catch (error) {\n            console.error(\"Error handling WebSocket message:\", error);\n          }\n        });\n\n        // Handle connection close\n        this.ws.on(\"close\", () => {\n          if (this.shouldReconnect && this.config.reconnect !== false) {\n            this.attemptReconnect();\n          }\n        });\n\n        // Handle errors\n        this.ws.on(\"error\", (error) => {\n          console.error(\"WebSocket error:\", error);\n          // If connection fails during initial connect, reject the promise\n          if (this.reconnectAttempts === 0) {\n            reject(error);\n          }\n        });\n      } catch (error) {\n        reject(error);\n      }\n    });\n  }\n\n  /**\n   * Attempt to reconnect to the WebSocket server\n   * @private\n   */\n  private attemptReconnect(): void {\n    const maxAttempts = this.config.maxReconnectAttempts ?? 10;\n    const interval = this.config.reconnectInterval ?? 5000;\n\n    if (this.reconnectAttempts < maxAttempts) {\n      this.reconnectAttempts++;\n      console.log(\n        `WebSocket reconnect attempt ${this.reconnectAttempts}/${maxAttempts}`,\n      );\n\n      this.reconnectTimeout = setTimeout(() => {\n        this.connect().catch((error) => {\n          console.error(\"WebSocket reconnect failed:\", error);\n        });\n      }, interval);\n    } else {\n      console.error(\n        `WebSocket max reconnect attempts (${maxAttempts}) reached`,\n      );\n    }\n  }\n\n  /**\n   * Stop the trigger and close the WebSocket connection\n   */\n  async stop(): Promise<void> {\n    this.shouldReconnect = false;\n    this.handler = undefined;\n\n    // Clear any pending reconnect timeout\n    if (this.reconnectTimeout) {\n      clearTimeout(this.reconnectTimeout);\n      this.reconnectTimeout = undefined;\n    }\n\n    // Close WebSocket connection\n    if (this.ws) {\n      this.ws.close();\n      this.ws = undefined;\n    }\n  }\n\n  /**\n   * Health check - returns true if WebSocket is connected\n   */\n  async healthCheck(): Promise<boolean> {\n    return this.ws?.readyState === WebSocket.OPEN;\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@stepflowjs/trigger-websocket",
+  "version": "0.0.1",
+  "description": "WebSocket trigger for Stepflow with auto-reconnect",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "ws": "^8.18.0",
+    "@stepflowjs/core": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.0",
+    "tsup": "^8.5.1",
+    "vitest": "^4.0.17"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "license": "MIT",
+  "author": "Stepflow Contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://stepflow-production.up.railway.app",
+    "directory": "packages/triggers/websocket"
+  },
+  "homepage": "https://stepflow-production.up.railway.app",
+  "bugs": {
+    "url": "https://stepflow-production.up.railway.app"
+  },
+  "keywords": [
+    "stepflow",
+    "trigger",
+    "websocket",
+    "realtime",
+    "workflow",
+    "orchestration"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "clean": "rm -rf dist"
+  }
+}