flarecord 0.0.1

package/src/utils/session.ts

@@ -0,0 +1,64 @@
+import { GatewayOpcode } from "../types/constants";
+import { GatewayPayload, GatewayState, ResumeData, IdentifyData } from "../types";
+import type { DurableObjectState } from "@cloudflare/workers-types";
+
+export class SessionManager {
+  constructor(
+    private token: string,
+    private ctx: DurableObjectState,
+    private storageKey: string,
+    private identifyProperties: {
+      os: string;
+      browser: string;
+      device: string;
+    },
+    private sendFn: (payload: GatewayPayload) => void
+  ) {}
+
+  async getResumeData(): Promise<{ sessionId: string; sequence: number } | null> {
+    const state = await this.getState();
+    if (state?.sessionId && state.sequence !== null) {
+      return { sessionId: state.sessionId, sequence: state.sequence };
+    }
+    return null;
+  }
+
+  sendResume(sessionId: string, sequence: number): void {
+    const resume: GatewayPayload = {
+      op: GatewayOpcode.RESUME,
+      d: {
+        token: this.token,
+        session_id: sessionId,
+        seq: sequence,
+      } satisfies ResumeData,
+    };
+    this.sendFn(resume);
+  }
+
+  sendIdentify(intents: number): void {
+    const identify: GatewayPayload = {
+      op: GatewayOpcode.IDENTIFY,
+      d: {
+        token: this.token,
+        properties: this.identifyProperties,
+        intents: intents,
+      } satisfies IdentifyData,
+    };
+    this.sendFn(identify);
+  }
+
+  private async getState(): Promise<GatewayState | null> {
+    const state = await this.ctx.storage.get(this.storageKey);
+    return this.validateState(state);
+  }
+
+  private validateState(state: unknown): GatewayState | null {
+    if (state === null || state === undefined) {
+      return null;
+    }
+    if (typeof state === "object" && "heartbeatInterval" in state) {
+      return state as GatewayState;
+    }
+    return null;
+  }
+}

package/src/utils/websocket.ts

@@ -0,0 +1,90 @@
+import { GatewayPayload } from "../types";
+import type { WebSocket } from "@cloudflare/workers-types";
+
+interface WebSocketResponse {
+  webSocket: WebSocket | null;
+}
+
+export class WebSocketManager {
+  private _ws: WebSocket | null = null;
+
+  get ws(): WebSocket | null {
+    return this._ws;
+  }
+
+  async connect(gatewayUrl: string): Promise<void> {
+    const response = await fetch(gatewayUrl, {
+      headers: { Upgrade: "websocket" },
+    });
+
+    const wsResponse = response as unknown as WebSocketResponse;
+
+    if (!wsResponse.webSocket) {
+      throw new Error("Server did not accept WebSocket connection");
+    }
+
+    this._ws = wsResponse.webSocket;
+    this._ws.accept();
+  }
+
+  setupEventListeners(
+    onMessage: (data: string | ArrayBuffer | ArrayBufferView) => void,
+    onClose: (code: number, reason: string) => void,
+    onError: (error: Error) => void
+  ): void {
+    if (!this._ws) {
+      return;
+    }
+
+    this._ws.addEventListener("message", (event: MessageEvent) => {
+      onMessage(event.data);
+    });
+
+    this._ws.addEventListener("close", (event: CloseEvent) => {
+      onClose(event.code, event.reason);
+    });
+
+    this._ws.addEventListener("error", () => {
+      onError(new Error("WebSocket error"));
+    });
+  }
+
+  send(payload: GatewayPayload): void {
+    if (!this._ws) {
+      throw new Error("WebSocket not connected");
+    }
+    try {
+    this._ws.send(JSON.stringify(payload));
+    } catch (error) {
+      throw new Error(
+        `Failed to send payload: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+
+  close(): void {
+    if (this._ws) {
+      try {
+      this._ws.close();
+      } catch (error) {
+        // Ignore errors during close
+      }
+      this._ws = null;
+    }
+  }
+
+  decodeMessage(data: string | ArrayBuffer | ArrayBufferView): string {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (data instanceof ArrayBuffer) {
+      return new TextDecoder().decode(data);
+    }
+    const view = new Uint8Array(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    return new TextDecoder().decode(view);
+  }
+}