mtmsdk 0.0.52 → 0.0.53

package/src/openclaw/gateway.ts

@@ -1,392 +0,0 @@
-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);
-  }
-}