@myclaw163/clawclaw-cli 0.6.76 → 0.6.78

package/src/runtime/ws-client.ts

@@ -1,287 +1,287 @@
-// src/runtime/ws-client.ts
-// Internal WebSocket client — NOT exported from index.ts
-// Used only by runtime listeners internally.
-
-import WebSocket from 'ws';
-import { WsConnectionState } from '../sdk/types.js';
-import { appendRawWsMessage } from './raw-ws-log.js';
-
-export interface WsClientConfig {
-  url: string;
-  apiKey: string;
-  reconnectMaxMs?: number;
-  /** Heartbeat interval in ms (default: 15000). Set to 0 to disable. */
-  heartbeatIntervalMs?: number;
-  /** Diagnostic-only raw server frame log path. */
-  rawMessageLogPath?: string;
-}
-
-export interface WsCloseInfo {
-  code?: number;
-  reason: string;
-  wasClean?: boolean;
-}
-
-/** Heartbeat interval — matches old auto_play.ts */
-const DEFAULT_HEARTBEAT_INTERVAL_MS = 15000;
-
-function wsMessageToString(data: WebSocket.Data): string {
-  if (typeof data === 'string') return data;
-  if (Buffer.isBuffer(data)) return data.toString('utf8');
-  if (data instanceof ArrayBuffer) return Buffer.from(data).toString('utf8');
-  return Buffer.concat(data).toString('utf8');
-}
-
-export class WsClient {
-  private config: WsClientConfig;
-  private ws: WebSocket | null = null;
-  private _state: WsConnectionState = WsConnectionState.Disconnected;
-  private shouldReconnect = false;
-  private reconnectAttempt = 0;
-  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
-  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-
-  // Type-safe event handlers (new)
-  private typedHandlers = new Map<string, Set<(data: Record<string, any>) => void>>();
-  private disconnectHandlers: ((info: WsCloseInfo) => void)[] = [];
-  private stateChangeHandlers: ((state: WsConnectionState) => void)[] = [];
-  /** High-water mark for tick-based dedup of state.new_events (align with agones) */
-  private lastEventTick = -1;
-
-  constructor(config: WsClientConfig) {
-    this.config = config;
-  }
-
-  get connected(): boolean {
-    return this._state === WsConnectionState.Connected;
-  }
-
-  get state(): WsConnectionState {
-    return this._state;
-  }
-
-  private setState(newState: WsConnectionState): void {
-    if (this._state === newState) return;
-    this._state = newState;
-    for (const handler of this.stateChangeHandlers) {
-      handler(newState);
-    }
-  }
-
-  connect(): Promise<void> {
-    this.shouldReconnect = true;
-    this.reconnectAttempt = 0;
-    this.setState(WsConnectionState.Connecting);
-    return this._openSocket();
-  }
-
-  private _openSocket(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(this.config.url, {
-        headers: { Authorization: `Bearer ${this.config.apiKey}` },
-      });
-      this.ws = ws;
-
-      ws.onopen = () => {
-        this.setState(WsConnectionState.Connected);
-        this.reconnectAttempt = 0;
-        this._startHeartbeat();
-        resolve();
-      };
-
-      ws.onerror = (err) => {
-        reject(err);
-      };
-
-      ws.onmessage = (e) => {
-        const data = wsMessageToString(e.data);
-        if (this.config.rawMessageLogPath) {
-          appendRawWsMessage(this.config.rawMessageLogPath, data);
-        }
-        if (data === 'pong') return;
-        try {
-          const msg = JSON.parse(data);
-          this.handleMessage(msg);
-        } catch {
-          // ignore malformed messages
-        }
-      };
-
-      ws.onclose = (e: { code?: number; reason?: string; wasClean?: boolean }) => {
-        this._stopHeartbeat();
-        const info: WsCloseInfo = {
-          code: typeof e.code === 'number' ? e.code : undefined,
-          reason: e.reason ?? '',
-          wasClean: typeof e.wasClean === 'boolean' ? e.wasClean : undefined,
-        };
-        for (const handler of this.disconnectHandlers) {
-          handler(info);
-        }
-        if (this.shouldReconnect) {
-          this.setState(WsConnectionState.Reconnecting);
-          this._scheduleReconnect();
-        } else {
-          this.setState(WsConnectionState.Disconnected);
-        }
-      };
-    });
-  }
-
-  /**
-   * Central message handler: handles event_batch, state, and single events.
-   * Normalizes event format before dispatching.
-   */
-  private handleMessage(msg: any): void {
-    // event_batch: unwrap and dispatch each event individually
-    if (msg.type === 'event_batch' && Array.isArray(msg.data)) {
-      for (const event of msg.data) {
-        this.dispatchEvent(event);
-      }
-      return;
-    }
-    // state: always dispatch the full snapshot as _state for runtime feed tracking
-    // (current_speaker, sub_phase, vote progress, etc. update without necessarily
-    // shipping a new event). Process new_events with tick-based dedup if present.
-    if (msg.type === 'state' && msg.data) {
-      if (Array.isArray(msg.data.new_events)) {
-        const threshold = this.lastEventTick;
-        let maxTick = threshold;
-        for (const event of msg.data.new_events) {
-          const evtTick: number = event.tick ?? -1;
-          if (evtTick <= threshold) continue; // already processed
-          if (evtTick > maxTick) maxTick = evtTick;
-          this.dispatchEvent(event);
-        }
-        this.lastEventTick = maxTick;
-      }
-      this.dispatchEvent({ type: '_state', data: msg.data });
-      return;
-    }
-    // All other messages are dispatched as events
-    this.dispatchEvent(msg);
-  }
-
-  /**
-   * Normalize event format and dispatch to typed + legacy handlers.
-   *
-   * Server sends two formats:
-   *   - { type, field1, field2 }
-   *   - { type, data: { field1, field2 } }
-   * Normalize to consistent data object for typed handlers.
-   */
-  private dispatchEvent(raw: any): void {
-    const type: string = raw.type;
-    if (!type) return;
-
-    // Normalize: extract data payload
-    const { type: _t, data, ...rest } = raw;
-    const normalizedData: Record<string, any> =
-      data && typeof data === 'object' && !Array.isArray(data) ? data : rest;
-
-    // Typed handlers (new API)
-    const handlers = this.typedHandlers.get(type);
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(normalizedData);
-      }
-    }
-
-    // Catch-all `*` handlers
-    const wildcardHandlers = this.typedHandlers.get('*');
-    if (wildcardHandlers) {
-      for (const handler of wildcardHandlers) {
-        handler({ type, ...normalizedData });
-      }
-    }
-  }
-
-  // ─── Public API ───
-
-  /**
-   * Register a handler for a specific event type.
-   * Handler receives normalized data (always a flat object, never nested under .data).
-   * Returns an unsubscribe function.
-   */
-  on(eventType: string, handler: (data: Record<string, any>) => void): () => void {
-    let set = this.typedHandlers.get(eventType);
-    if (!set) {
-      set = new Set();
-      this.typedHandlers.set(eventType, set);
-    }
-    set.add(handler);
-    return () => { set!.delete(handler); };
-  }
-
-  /** Send an action via WebSocket. */
-  send(action: { toJSON(): Record<string, any> }): void {
-    if (this._state !== WsConnectionState.Connected || !this.ws) return;
-    this.ws.send(JSON.stringify({ type: 'action', data: action.toJSON() }));
-  }
-
-  /** Register a handler for state changes. */
-  onStateChange(handler: (state: WsConnectionState) => void): void {
-    this.stateChangeHandlers.push(handler);
-  }
-
-  onDisconnect(handler: (info: WsCloseInfo) => void): () => void {
-    this.disconnectHandlers.push(handler);
-    return () => {
-      const idx = this.disconnectHandlers.indexOf(handler);
-      if (idx >= 0) this.disconnectHandlers.splice(idx, 1);
-    };
-  }
-
-  /** Clear all typed event handlers (used when replacing WsClient). */
-  clearHandlers(): void {
-    this.typedHandlers.clear();
-    this.stateChangeHandlers = [];
-    this.disconnectHandlers = [];
-  }
-
-  disconnect(): void {
-    this.shouldReconnect = false;
-    this._stopHeartbeat();
-    if (this.reconnectTimer !== null) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.onclose = null;
-      this.ws.close();
-      this.ws = null;
-    }
-    this.setState(WsConnectionState.Disconnected);
-  }
-
-  // ─── Heartbeat ───
-
-  private _startHeartbeat(): void {
-    this._stopHeartbeat();
-    const intervalMs = this.config.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
-    if (intervalMs <= 0) return;
-    this.heartbeatTimer = setInterval(() => {
-      if (this.ws && this._state === WsConnectionState.Connected) {
-        this.ws.send('ping');
-      }
-    }, intervalMs);
-  }
-
-  private _stopHeartbeat(): void {
-    if (this.heartbeatTimer !== null) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-
-  private _scheduleReconnect(): void {
-    const maxMs = this.config.reconnectMaxMs ?? 30000;
-    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempt), maxMs);
-    this.reconnectAttempt++;
-    this.reconnectTimer = setTimeout(() => {
-      if (this.shouldReconnect) {
-        this.setState(WsConnectionState.Connecting);
-        this._openSocket().catch(() => {});
-      }
-    }, delay);
-  }
-}
+// src/runtime/ws-client.ts
+// Internal WebSocket client — NOT exported from index.ts
+// Used only by runtime listeners internally.
+
+import WebSocket from 'ws';
+import { WsConnectionState } from '../sdk/types.js';
+import { appendRawWsMessage } from './raw-ws-log.js';
+
+export interface WsClientConfig {
+  url: string;
+  apiKey: string;
+  reconnectMaxMs?: number;
+  /** Heartbeat interval in ms (default: 15000). Set to 0 to disable. */
+  heartbeatIntervalMs?: number;
+  /** Diagnostic-only raw server frame log path. */
+  rawMessageLogPath?: string;
+}
+
+export interface WsCloseInfo {
+  code?: number;
+  reason: string;
+  wasClean?: boolean;
+}
+
+/** Heartbeat interval — matches old auto_play.ts */
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 15000;
+
+function wsMessageToString(data: WebSocket.Data): string {
+  if (typeof data === 'string') return data;
+  if (Buffer.isBuffer(data)) return data.toString('utf8');
+  if (data instanceof ArrayBuffer) return Buffer.from(data).toString('utf8');
+  return Buffer.concat(data).toString('utf8');
+}
+
+export class WsClient {
+  private config: WsClientConfig;
+  private ws: WebSocket | null = null;
+  private _state: WsConnectionState = WsConnectionState.Disconnected;
+  private shouldReconnect = false;
+  private reconnectAttempt = 0;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+
+  // Type-safe event handlers (new)
+  private typedHandlers = new Map<string, Set<(data: Record<string, any>) => void>>();
+  private disconnectHandlers: ((info: WsCloseInfo) => void)[] = [];
+  private stateChangeHandlers: ((state: WsConnectionState) => void)[] = [];
+  /** High-water mark for tick-based dedup of state.new_events (align with agones) */
+  private lastEventTick = -1;
+
+  constructor(config: WsClientConfig) {
+    this.config = config;
+  }
+
+  get connected(): boolean {
+    return this._state === WsConnectionState.Connected;
+  }
+
+  get state(): WsConnectionState {
+    return this._state;
+  }
+
+  private setState(newState: WsConnectionState): void {
+    if (this._state === newState) return;
+    this._state = newState;
+    for (const handler of this.stateChangeHandlers) {
+      handler(newState);
+    }
+  }
+
+  connect(): Promise<void> {
+    this.shouldReconnect = true;
+    this.reconnectAttempt = 0;
+    this.setState(WsConnectionState.Connecting);
+    return this._openSocket();
+  }
+
+  private _openSocket(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.config.url, {
+        headers: { Authorization: `Bearer ${this.config.apiKey}` },
+      });
+      this.ws = ws;
+
+      ws.onopen = () => {
+        this.setState(WsConnectionState.Connected);
+        this.reconnectAttempt = 0;
+        this._startHeartbeat();
+        resolve();
+      };
+
+      ws.onerror = (err) => {
+        reject(err);
+      };
+
+      ws.onmessage = (e) => {
+        const data = wsMessageToString(e.data);
+        if (this.config.rawMessageLogPath) {
+          appendRawWsMessage(this.config.rawMessageLogPath, data);
+        }
+        if (data === 'pong') return;
+        try {
+          const msg = JSON.parse(data);
+          this.handleMessage(msg);
+        } catch {
+          // ignore malformed messages
+        }
+      };
+
+      ws.onclose = (e: { code?: number; reason?: string; wasClean?: boolean }) => {
+        this._stopHeartbeat();
+        const info: WsCloseInfo = {
+          code: typeof e.code === 'number' ? e.code : undefined,
+          reason: e.reason ?? '',
+          wasClean: typeof e.wasClean === 'boolean' ? e.wasClean : undefined,
+        };
+        for (const handler of this.disconnectHandlers) {
+          handler(info);
+        }
+        if (this.shouldReconnect) {
+          this.setState(WsConnectionState.Reconnecting);
+          this._scheduleReconnect();
+        } else {
+          this.setState(WsConnectionState.Disconnected);
+        }
+      };
+    });
+  }
+
+  /**
+   * Central message handler: handles event_batch, state, and single events.
+   * Normalizes event format before dispatching.
+   */
+  private handleMessage(msg: any): void {
+    // event_batch: unwrap and dispatch each event individually
+    if (msg.type === 'event_batch' && Array.isArray(msg.data)) {
+      for (const event of msg.data) {
+        this.dispatchEvent(event);
+      }
+      return;
+    }
+    // state: always dispatch the full snapshot as _state for runtime feed tracking
+    // (current_speaker, sub_phase, vote progress, etc. update without necessarily
+    // shipping a new event). Process new_events with tick-based dedup if present.
+    if (msg.type === 'state' && msg.data) {
+      if (Array.isArray(msg.data.new_events)) {
+        const threshold = this.lastEventTick;
+        let maxTick = threshold;
+        for (const event of msg.data.new_events) {
+          const evtTick: number = event.tick ?? -1;
+          if (evtTick <= threshold) continue; // already processed
+          if (evtTick > maxTick) maxTick = evtTick;
+          this.dispatchEvent(event);
+        }
+        this.lastEventTick = maxTick;
+      }
+      this.dispatchEvent({ type: '_state', data: msg.data });
+      return;
+    }
+    // All other messages are dispatched as events
+    this.dispatchEvent(msg);
+  }
+
+  /**
+   * Normalize event format and dispatch to typed + legacy handlers.
+   *
+   * Server sends two formats:
+   *   - { type, field1, field2 }
+   *   - { type, data: { field1, field2 } }
+   * Normalize to consistent data object for typed handlers.
+   */
+  private dispatchEvent(raw: any): void {
+    const type: string = raw.type;
+    if (!type) return;
+
+    // Normalize: extract data payload
+    const { type: _t, data, ...rest } = raw;
+    const normalizedData: Record<string, any> =
+      data && typeof data === 'object' && !Array.isArray(data) ? data : rest;
+
+    // Typed handlers (new API)
+    const handlers = this.typedHandlers.get(type);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(normalizedData);
+      }
+    }
+
+    // Catch-all `*` handlers
+    const wildcardHandlers = this.typedHandlers.get('*');
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        handler({ type, ...normalizedData });
+      }
+    }
+  }
+
+  // ─── Public API ───
+
+  /**
+   * Register a handler for a specific event type.
+   * Handler receives normalized data (always a flat object, never nested under .data).
+   * Returns an unsubscribe function.
+   */
+  on(eventType: string, handler: (data: Record<string, any>) => void): () => void {
+    let set = this.typedHandlers.get(eventType);
+    if (!set) {
+      set = new Set();
+      this.typedHandlers.set(eventType, set);
+    }
+    set.add(handler);
+    return () => { set!.delete(handler); };
+  }
+
+  /** Send an action via WebSocket. */
+  send(action: { toJSON(): Record<string, any> }): void {
+    if (this._state !== WsConnectionState.Connected || !this.ws) return;
+    this.ws.send(JSON.stringify({ type: 'action', data: action.toJSON() }));
+  }
+
+  /** Register a handler for state changes. */
+  onStateChange(handler: (state: WsConnectionState) => void): void {
+    this.stateChangeHandlers.push(handler);
+  }
+
+  onDisconnect(handler: (info: WsCloseInfo) => void): () => void {
+    this.disconnectHandlers.push(handler);
+    return () => {
+      const idx = this.disconnectHandlers.indexOf(handler);
+      if (idx >= 0) this.disconnectHandlers.splice(idx, 1);
+    };
+  }
+
+  /** Clear all typed event handlers (used when replacing WsClient). */
+  clearHandlers(): void {
+    this.typedHandlers.clear();
+    this.stateChangeHandlers = [];
+    this.disconnectHandlers = [];
+  }
+
+  disconnect(): void {
+    this.shouldReconnect = false;
+    this._stopHeartbeat();
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setState(WsConnectionState.Disconnected);
+  }
+
+  // ─── Heartbeat ───
+
+  private _startHeartbeat(): void {
+    this._stopHeartbeat();
+    const intervalMs = this.config.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    if (intervalMs <= 0) return;
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this._state === WsConnectionState.Connected) {
+        this.ws.send('ping');
+      }
+    }, intervalMs);
+  }
+
+  private _stopHeartbeat(): void {
+    if (this.heartbeatTimer !== null) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  private _scheduleReconnect(): void {
+    const maxMs = this.config.reconnectMaxMs ?? 30000;
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempt), maxMs);
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(() => {
+      if (this.shouldReconnect) {
+        this.setState(WsConnectionState.Connecting);
+        this._openSocket().catch(() => {});
+      }
+    }, delay);
+  }
+}