mtmsdk 0.0.50 → 0.0.52

package/src/openclaw/gateway.ts

@@ -1,392 +1,392 @@
-import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_IDS, type GatewayClientId, type GatewayClientMode } from "./client-info";
-import type { DeviceIdentity } from "./device-identity";
-import { clearDeviceAuthToken, loadDeviceAuthToken, storeDeviceAuthToken } from "./device-auth";
-
-export type GatewayEventFrame = {
-  type: "event";
-  event: string;
-  payload?: unknown;
-  seq?: number;
-  stateVersion?: { presence: number; health: number };
-};
-
-export type GatewayResponseFrame = {
-  type: "res";
-  id: string;
-  ok: boolean;
-  payload?: unknown;
-  error?: { code: string; message: string; details?: unknown };
-};
-
-export type GatewayErrorInfo = {
-  code: string;
-  message: string;
-  details?: unknown;
-};
-
-export type GatewayHelloOk = {
-  type: "hello-ok";
-  protocol: number;
-  features?: { methods?: string[]; events?: string[] };
-  snapshot?: unknown;
-  auth?: {
-    deviceToken?: string;
-    role?: string;
-    scopes?: string[];
-    issuedAtMs?: number;
-  };
-  policy?: { tickIntervalMs?: number };
-};
-
-type Pending = {
-  resolve: (value: unknown) => void;
-  reject: (err: unknown) => void;
-};
-
-export type GatewayBrowserClientOptions = {
-  url: string;
-  token?: string;
-  password?: string;
-  deviceIdentity?: DeviceIdentity | null;
-  clientName?: GatewayClientId;
-  clientVersion?: string;
-  platform?: string;
-  mode?: GatewayClientMode;
-  instanceId?: string;
-  onHello?: (hello: GatewayHelloOk) => void;
-  onEvent?: (evt: GatewayEventFrame) => void;
-  onClose?: (info: { code: number; reason: string; error?: GatewayErrorInfo | null }) => void;
-  onGap?: (info: { expected: number; received: number }) => void;
-  autoReconnect?: boolean;
-};
-
-// 4008 = application-defined code (browser rejects 1008 "Policy Violation")
-const CONNECT_FAILED_CLOSE_CODE = 4008;
-
-export class GatewayRequestError extends Error {
-  readonly code: string;
-  readonly details?: unknown;
-
-  constructor(error: GatewayErrorInfo) {
-    super(error.message || error.code);
-    this.name = "GatewayRequestError";
-    this.code = error.code;
-    this.details = error.details;
-  }
-}
-
-export class GatewayBrowserClient {
-  private ws: WebSocket | null = null;
-  private pending = new Map<string, Pending>();
-  private closed = false;
-  private lastSeq: number | null = null;
-  private connectNonce: string | null = null;
-  private connectSent = false;
-  private connectTimer: number | null = null;
-  private backoffMs = 800;
-  private connectError: GatewayErrorInfo | null = null;
-  private pendingTokenResetRetry = false;
-  private tokenResetRetryBudgetUsed = false;
-
-  constructor(private opts: GatewayBrowserClientOptions) {}
-
-  start() {
-    this.closed = false;
-    this.connect();
-  }
-
-  stop() {
-    this.closed = true;
-    this.ws?.close();
-    this.ws = null;
-    this.pendingTokenResetRetry = false;
-    this.tokenResetRetryBudgetUsed = false;
-    this.flushPending(new Error("gateway client stopped"));
-  }
-
-  get connected() {
-    return this.ws?.readyState === WebSocket.OPEN;
-  }
-
-  private connect() {
-    if (this.closed) return;
-    try {
-      this.ws = new WebSocket(this.opts.url);
-      this.ws.onopen = () => this.queueConnect();
-      this.ws.onmessage = (ev) => this.handleMessage(String(ev.data ?? ""));
-      this.ws.onclose = (ev) => {
-        const reason = String(ev.reason ?? "");
-        const error = this.connectError;
-        this.connectError = null;
-        this.ws = null;
-        this.flushPending(new Error(`gateway closed (${ev.code}): ${reason}`));
-
-        if (this.pendingTokenResetRetry) {
-          this.pendingTokenResetRetry = false;
-          window.setTimeout(() => this.connect(), 0);
-          return;
-        }
-
-        this.opts.onClose?.({ code: ev.code, reason, error });
-        this.scheduleReconnect();
-      };
-      this.ws.onerror = () => {
-        // ignored; close handler will fire
-      };
-    } catch (err) {
-      console.error("[gateway] Failed to create WebSocket instance:", err);
-      // Simulate a close event for the UI to handle
-      this.opts.onClose?.({
-        code: 1006,
-        reason: err instanceof Error ? err.message : "Connect failed",
-        error: null,
-      });
-      this.scheduleReconnect();
-    }
-  }
-
-  private scheduleReconnect() {
-    if (this.closed || this.opts.autoReconnect === false) return;
-    const delay = this.backoffMs;
-    this.backoffMs = Math.min(this.backoffMs * 1.7, 15_000);
-    window.setTimeout(() => this.connect(), delay);
-  }
-
-  private flushPending(err: Error) {
-    for (const [, p] of this.pending) p.reject(err);
-    this.pending.clear();
-  }
-
-  private async sendConnect() {
-    if (this.connectSent) return;
-    this.connectSent = true;
-    if (this.connectTimer !== null) {
-      window.clearTimeout(this.connectTimer);
-      this.connectTimer = null;
-    }
-    const hasWebCrypto = typeof crypto !== "undefined" && !!crypto.subtle;
-
-    const scopes = ["operator.admin", "operator.approvals", "operator.pairing"];
-    const role = "operator";
-
-    // Dynamic import types for correct typing
-    let deviceIdentity = this.opts.deviceIdentity ?? null;
-    let authToken: string | undefined;
-
-    // Dynamically import device auth logic only if needed and in secure context
-    if (hasWebCrypto && !deviceIdentity) {
-      try {
-        const { loadOrCreateDeviceIdentity } = await import("./device-identity");
-
-        deviceIdentity = await loadOrCreateDeviceIdentity();
-      } catch (e) {
-        console.warn("[gateway] Failed to load device identity libs", e);
-      }
-    }
-
-    if (deviceIdentity) {
-      authToken = loadDeviceAuthToken({
-        deviceId: deviceIdentity.deviceId,
-        role,
-      })?.token;
-    }
-
-    const auth =
-      authToken || this.opts.token || this.opts.password
-        ? {
-            token: authToken ?? this.opts.token,
-            password: this.opts.password,
-          }
-        : undefined;
-
-    let device:
-      | {
-          id: string;
-          publicKey: string;
-          signature: string;
-          signedAt: number;
-          nonce: string | undefined;
-        }
-      | undefined;
-
-    if (deviceIdentity) {
-      const signedAtMs = Date.now();
-      const nonce = this.connectNonce ?? "";
-
-      try {
-        const { buildDeviceAuthPayload } = await import("./device-auth-utils");
-        const { signDevicePayload } = await import("./device-identity");
-
-        const payload = buildDeviceAuthPayload({
-          deviceId: deviceIdentity.deviceId,
-          clientId: this.opts.clientName ?? GATEWAY_CLIENT_IDS.CONTROL_UI,
-          clientMode: this.opts.mode ?? GATEWAY_CLIENT_MODES.WEBCHAT,
-          role,
-          scopes,
-          signedAtMs,
-          token: authToken ?? undefined,
-          nonce,
-        });
-        const signature = await signDevicePayload(deviceIdentity.privateKey, payload);
-        device = {
-          id: deviceIdentity.deviceId,
-          publicKey: deviceIdentity.publicKey,
-          signature,
-          signedAt: signedAtMs,
-          nonce,
-        };
-      } catch (e) {
-        console.error("[gateway] Failed to sign device payload", e);
-      }
-    }
-
-    const params = {
-      minProtocol: 3,
-      maxProtocol: 3,
-      client: {
-        id: this.opts.clientName ?? GATEWAY_CLIENT_IDS.CONTROL_UI,
-        version: this.opts.clientVersion ?? "dev",
-        platform: this.opts.platform ?? navigator.platform ?? "web",
-        mode: this.opts.mode ?? GATEWAY_CLIENT_MODES.WEBCHAT,
-        instanceId: this.opts.instanceId,
-      },
-      role,
-      scopes,
-      device,
-      caps: [],
-      auth,
-      userAgent: navigator.userAgent,
-      locale: navigator.language,
-    };
-
-    void this.request<GatewayHelloOk>("connect", params)
-      .then(async (hello) => {
-        this.connectError = null;
-        if (hello?.auth?.deviceToken && deviceIdentity) {
-          try {
-            storeDeviceAuthToken({
-              deviceId: deviceIdentity.deviceId,
-              role: hello.auth.role ?? role,
-              token: hello.auth.deviceToken,
-              scopes: hello.auth.scopes ?? [],
-            });
-          } catch (e) {
-            console.warn("[gateway] Failed to store device token", e);
-          }
-        }
-        this.backoffMs = 800;
-        this.tokenResetRetryBudgetUsed = false;
-        this.opts.onHello?.(hello);
-      })
-      .catch((err) => {
-        console.warn("[gateway] connect seq failed", err);
-
-        if (
-          !this.tokenResetRetryBudgetUsed &&
-          deviceIdentity &&
-          authToken &&
-          err instanceof GatewayRequestError &&
-          err.code === "AUTH_TOKEN_MISMATCH"
-        ) {
-          clearDeviceAuthToken({
-            deviceId: deviceIdentity.deviceId,
-            role,
-          });
-          this.pendingTokenResetRetry = true;
-          this.tokenResetRetryBudgetUsed = true;
-          this.connectError = null;
-          this.ws?.close(CONNECT_FAILED_CLOSE_CODE, "retry after clearing stale device token");
-          return;
-        }
-
-        this.connectError =
-          err instanceof GatewayRequestError
-            ? { code: err.code, message: err.message, details: err.details }
-            : { code: "CONNECT_FAILED", message: err instanceof Error ? err.message : "connect failed" };
-        // Do not close here, let the interval handle it or the error event?
-        // Original code closed it.
-        this.ws?.close(CONNECT_FAILED_CLOSE_CODE, "connect failed");
-      });
-  }
-
-  private handleMessage(raw: string) {
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      return;
-    }
-
-    const frame = parsed as { type?: unknown };
-    if (frame.type === "event") {
-      const evt = parsed as GatewayEventFrame;
-
-      if (evt.event === "connect.challenge") {
-        const payload = evt.payload as { nonce?: unknown } | undefined;
-        const nonce = payload && typeof payload.nonce === "string" ? payload.nonce : null;
-        if (nonce) {
-          this.connectNonce = nonce;
-          void this.sendConnect();
-        }
-        return;
-      }
-      const seq = typeof evt.seq === "number" ? evt.seq : null;
-      if (seq !== null) {
-        if (this.lastSeq !== null && seq > this.lastSeq + 1) {
-          this.opts.onGap?.({ expected: this.lastSeq + 1, received: seq });
-        }
-        this.lastSeq = seq;
-      }
-      try {
-        this.opts.onEvent?.(evt);
-      } catch (err) {
-        console.error("[gateway] event handler error:", err);
-      }
-      return;
-    }
-
-    if (frame.type === "res") {
-      const res = parsed as GatewayResponseFrame;
-      const pending = this.pending.get(res.id);
-      if (!pending) return;
-      this.pending.delete(res.id);
-      if (res.ok) pending.resolve(res.payload);
-      else {
-        const error = res.error;
-        pending.reject(
-          error
-            ? new GatewayRequestError({
-                code: error.code,
-                message: error.message ?? "request failed",
-                details: error.details,
-              })
-            : new Error("request failed"),
-        );
-      }
-      return;
-    }
-  }
-
-  request<T = unknown>(method: string, params?: unknown): Promise<T> {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      return Promise.reject(new Error("gateway not connected"));
-    }
-    const id = crypto.randomUUID();
-    const frame = { type: "req", id, method, params };
-    const p = new Promise<T>((resolve, reject) => {
-      this.pending.set(id, { resolve: (v) => resolve(v as T), reject });
-    });
-    this.ws.send(JSON.stringify(frame));
-    return p;
-  }
-
-  private queueConnect() {
-    this.connectNonce = null;
-    this.connectSent = false;
-    if (this.connectTimer !== null) window.clearTimeout(this.connectTimer);
-
-    this.connectTimer = window.setTimeout(() => {
-      void this.sendConnect();
-    }, 750);
-  }
-}
+import { GATEWAY_CLIENT_IDS, GATEWAY_CLIENT_MODES, type GatewayClientId, type GatewayClientMode } from "./client-info";
+import { clearDeviceAuthToken, loadDeviceAuthToken, storeDeviceAuthToken } from "./device-auth";
+import type { DeviceIdentity } from "./device-identity";
+
+export type GatewayEventFrame = {
+  type: "event";
+  event: string;
+  payload?: unknown;
+  seq?: number;
+  stateVersion?: { presence: number; health: number };
+};
+
+export type GatewayResponseFrame = {
+  type: "res";
+  id: string;
+  ok: boolean;
+  payload?: unknown;
+  error?: { code: string; message: string; details?: unknown };
+};
+
+export type GatewayErrorInfo = {
+  code: string;
+  message: string;
+  details?: unknown;
+};
+
+export type GatewayHelloOk = {
+  type: "hello-ok";
+  protocol: number;
+  features?: { methods?: string[]; events?: string[] };
+  snapshot?: unknown;
+  auth?: {
+    deviceToken?: string;
+    role?: string;
+    scopes?: string[];
+    issuedAtMs?: number;
+  };
+  policy?: { tickIntervalMs?: number };
+};
+
+type Pending = {
+  resolve: (value: unknown) => void;
+  reject: (err: unknown) => void;
+};
+
+export type GatewayBrowserClientOptions = {
+  url: string;
+  token?: string;
+  password?: string;
+  deviceIdentity?: DeviceIdentity | null;
+  clientName?: GatewayClientId;
+  clientVersion?: string;
+  platform?: string;
+  mode?: GatewayClientMode;
+  instanceId?: string;
+  onHello?: (hello: GatewayHelloOk) => void;
+  onEvent?: (evt: GatewayEventFrame) => void;
+  onClose?: (info: { code: number; reason: string; error?: GatewayErrorInfo | null }) => void;
+  onGap?: (info: { expected: number; received: number }) => void;
+  autoReconnect?: boolean;
+};
+
+// 4008 = application-defined code (browser rejects 1008 "Policy Violation")
+const CONNECT_FAILED_CLOSE_CODE = 4008;
+
+export class GatewayRequestError extends Error {
+  readonly code: string;
+  readonly details?: unknown;
+
+  constructor(error: GatewayErrorInfo) {
+    super(error.message || error.code);
+    this.name = "GatewayRequestError";
+    this.code = error.code;
+    this.details = error.details;
+  }
+}
+
+export class GatewayBrowserClient {
+  private ws: WebSocket | null = null;
+  private pending = new Map<string, Pending>();
+  private closed = false;
+  private lastSeq: number | null = null;
+  private connectNonce: string | null = null;
+  private connectSent = false;
+  private connectTimer: number | null = null;
+  private backoffMs = 800;
+  private connectError: GatewayErrorInfo | null = null;
+  private pendingTokenResetRetry = false;
+  private tokenResetRetryBudgetUsed = false;
+
+  constructor(private opts: GatewayBrowserClientOptions) {}
+
+  start() {
+    this.closed = false;
+    this.connect();
+  }
+
+  stop() {
+    this.closed = true;
+    this.ws?.close();
+    this.ws = null;
+    this.pendingTokenResetRetry = false;
+    this.tokenResetRetryBudgetUsed = false;
+    this.flushPending(new Error("gateway client stopped"));
+  }
+
+  get connected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  private connect() {
+    if (this.closed) return;
+    try {
+      this.ws = new WebSocket(this.opts.url);
+      this.ws.onopen = () => this.queueConnect();
+      this.ws.onmessage = (ev) => this.handleMessage(String(ev.data ?? ""));
+      this.ws.onclose = (ev) => {
+        const reason = String(ev.reason ?? "");
+        const error = this.connectError;
+        this.connectError = null;
+        this.ws = null;
+        this.flushPending(new Error(`gateway closed (${ev.code}): ${reason}`));
+
+        if (this.pendingTokenResetRetry) {
+          this.pendingTokenResetRetry = false;
+          window.setTimeout(() => this.connect(), 0);
+          return;
+        }
+
+        this.opts.onClose?.({ code: ev.code, reason, error });
+        this.scheduleReconnect();
+      };
+      this.ws.onerror = () => {
+        // ignored; close handler will fire
+      };
+    } catch (err) {
+      console.error("[gateway] Failed to create WebSocket instance:", err);
+      // Simulate a close event for the UI to handle
+      this.opts.onClose?.({
+        code: 1006,
+        reason: err instanceof Error ? err.message : "Connect failed",
+        error: null,
+      });
+      this.scheduleReconnect();
+    }
+  }
+
+  private scheduleReconnect() {
+    if (this.closed || this.opts.autoReconnect === false) return;
+    const delay = this.backoffMs;
+    this.backoffMs = Math.min(this.backoffMs * 1.7, 15_000);
+    window.setTimeout(() => this.connect(), delay);
+  }
+
+  private flushPending(err: Error) {
+    for (const [, p] of this.pending) p.reject(err);
+    this.pending.clear();
+  }
+
+  private async sendConnect() {
+    if (this.connectSent) return;
+    this.connectSent = true;
+    if (this.connectTimer !== null) {
+      window.clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+    const hasWebCrypto = typeof crypto !== "undefined" && !!crypto.subtle;
+
+    const scopes = ["operator.admin", "operator.approvals", "operator.pairing"];
+    const role = "operator";
+
+    // Dynamic import types for correct typing
+    let deviceIdentity = this.opts.deviceIdentity ?? null;
+    let authToken: string | undefined;
+
+    // Dynamically import device auth logic only if needed and in secure context
+    if (hasWebCrypto && !deviceIdentity) {
+      try {
+        const { loadOrCreateDeviceIdentity } = await import("./device-identity");
+
+        deviceIdentity = await loadOrCreateDeviceIdentity();
+      } catch (e) {
+        console.warn("[gateway] Failed to load device identity libs", e);
+      }
+    }
+
+    if (deviceIdentity) {
+      authToken = loadDeviceAuthToken({
+        deviceId: deviceIdentity.deviceId,
+        role,
+      })?.token;
+    }
+
+    const auth =
+      authToken || this.opts.token || this.opts.password
+        ? {
+            token: authToken ?? this.opts.token,
+            password: this.opts.password,
+          }
+        : undefined;
+
+    let device:
+      | {
+          id: string;
+          publicKey: string;
+          signature: string;
+          signedAt: number;
+          nonce: string | undefined;
+        }
+      | undefined;
+
+    if (deviceIdentity) {
+      const signedAtMs = Date.now();
+      const nonce = this.connectNonce ?? "";
+
+      try {
+        const { buildDeviceAuthPayload } = await import("./device-auth-utils");
+        const { signDevicePayload } = await import("./device-identity");
+
+        const payload = buildDeviceAuthPayload({
+          deviceId: deviceIdentity.deviceId,
+          clientId: this.opts.clientName ?? GATEWAY_CLIENT_IDS.CONTROL_UI,
+          clientMode: this.opts.mode ?? GATEWAY_CLIENT_MODES.WEBCHAT,
+          role,
+          scopes,
+          signedAtMs,
+          token: authToken ?? undefined,
+          nonce,
+        });
+        const signature = await signDevicePayload(deviceIdentity.privateKey, payload);
+        device = {
+          id: deviceIdentity.deviceId,
+          publicKey: deviceIdentity.publicKey,
+          signature,
+          signedAt: signedAtMs,
+          nonce,
+        };
+      } catch (e) {
+        console.error("[gateway] Failed to sign device payload", e);
+      }
+    }
+
+    const params = {
+      minProtocol: 3,
+      maxProtocol: 3,
+      client: {
+        id: this.opts.clientName ?? GATEWAY_CLIENT_IDS.CONTROL_UI,
+        version: this.opts.clientVersion ?? "dev",
+        platform: this.opts.platform ?? navigator.platform ?? "web",
+        mode: this.opts.mode ?? GATEWAY_CLIENT_MODES.WEBCHAT,
+        instanceId: this.opts.instanceId,
+      },
+      role,
+      scopes,
+      device,
+      caps: [],
+      auth,
+      userAgent: navigator.userAgent,
+      locale: navigator.language,
+    };
+
+    void this.request<GatewayHelloOk>("connect", params)
+      .then(async (hello) => {
+        this.connectError = null;
+        if (hello?.auth?.deviceToken && deviceIdentity) {
+          try {
+            storeDeviceAuthToken({
+              deviceId: deviceIdentity.deviceId,
+              role: hello.auth.role ?? role,
+              token: hello.auth.deviceToken,
+              scopes: hello.auth.scopes ?? [],
+            });
+          } catch (e) {
+            console.warn("[gateway] Failed to store device token", e);
+          }
+        }
+        this.backoffMs = 800;
+        this.tokenResetRetryBudgetUsed = false;
+        this.opts.onHello?.(hello);
+      })
+      .catch((err) => {
+        console.warn("[gateway] connect seq failed", err);
+
+        if (
+          !this.tokenResetRetryBudgetUsed &&
+          deviceIdentity &&
+          authToken &&
+          err instanceof GatewayRequestError &&
+          err.code === "AUTH_TOKEN_MISMATCH"
+        ) {
+          clearDeviceAuthToken({
+            deviceId: deviceIdentity.deviceId,
+            role,
+          });
+          this.pendingTokenResetRetry = true;
+          this.tokenResetRetryBudgetUsed = true;
+          this.connectError = null;
+          this.ws?.close(CONNECT_FAILED_CLOSE_CODE, "retry after clearing stale device token");
+          return;
+        }
+
+        this.connectError =
+          err instanceof GatewayRequestError
+            ? { code: err.code, message: err.message, details: err.details }
+            : { code: "CONNECT_FAILED", message: err instanceof Error ? err.message : "connect failed" };
+        // Do not close here, let the interval handle it or the error event?
+        // Original code closed it.
+        this.ws?.close(CONNECT_FAILED_CLOSE_CODE, "connect failed");
+      });
+  }
+
+  private handleMessage(raw: string) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+
+    const frame = parsed as { type?: unknown };
+    if (frame.type === "event") {
+      const evt = parsed as GatewayEventFrame;
+
+      if (evt.event === "connect.challenge") {
+        const payload = evt.payload as { nonce?: unknown } | undefined;
+        const nonce = payload && typeof payload.nonce === "string" ? payload.nonce : null;
+        if (nonce) {
+          this.connectNonce = nonce;
+          void this.sendConnect();
+        }
+        return;
+      }
+      const seq = typeof evt.seq === "number" ? evt.seq : null;
+      if (seq !== null) {
+        if (this.lastSeq !== null && seq > this.lastSeq + 1) {
+          this.opts.onGap?.({ expected: this.lastSeq + 1, received: seq });
+        }
+        this.lastSeq = seq;
+      }
+      try {
+        this.opts.onEvent?.(evt);
+      } catch (err) {
+        console.error("[gateway] event handler error:", err);
+      }
+      return;
+    }
+
+    if (frame.type === "res") {
+      const res = parsed as GatewayResponseFrame;
+      const pending = this.pending.get(res.id);
+      if (!pending) return;
+      this.pending.delete(res.id);
+      if (res.ok) pending.resolve(res.payload);
+      else {
+        const error = res.error;
+        pending.reject(
+          error
+            ? new GatewayRequestError({
+                code: error.code,
+                message: error.message ?? "request failed",
+                details: error.details,
+              })
+            : new Error("request failed"),
+        );
+      }
+      return;
+    }
+  }
+
+  request<T = unknown>(method: string, params?: unknown): Promise<T> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error("gateway not connected"));
+    }
+    const id = crypto.randomUUID();
+    const frame = { type: "req", id, method, params };
+    const p = new Promise<T>((resolve, reject) => {
+      this.pending.set(id, { resolve: (v) => resolve(v as T), reject });
+    });
+    this.ws.send(JSON.stringify(frame));
+    return p;
+  }
+
+  private queueConnect() {
+    this.connectNonce = null;
+    this.connectSent = false;
+    if (this.connectTimer !== null) window.clearTimeout(this.connectTimer);
+
+    this.connectTimer = window.setTimeout(() => {
+      void this.sendConnect();
+    }, 750);
+  }
+}