@djangocfg/centrifugo 2.1.54 → 2.1.55

package/src/core/client/CentrifugoRPCClient.ts

@@ -1,38 +1,62 @@
 /**
- * Base Centrifugo RPC Client
+ * Centrifugo RPC Client
  *
- * Handles WebSocket connection and RPC call correlation.
+ * Facade for WebSocket connection and RPC call handling.
  * Provides both RPC (request/response) and Subscription (pub/sub) patterns.
+ *
+ * Architecture:
+ * - connection.ts  - Connection lifecycle management
+ * - subscriptions.ts - Channel subscription management
+ * - rpc.ts - RPC methods (namedRPC, namedRPCNoWait)
+ * - version.ts - API version checking
+ * - types.ts - Type definitions
  */
 
-import { Centrifuge } from 'centrifuge';
-
-import { getConsolaLogger } from '../logger/consolaLogger';
-import { dispatchCentrifugoError } from '../../events';
+import type { Centrifuge, Subscription } from 'centrifuge';
 
 import type { Logger } from '../logger';
-export interface CentrifugoClientOptions {
-  url: string;
-  token: string;
-  userId: string;
-  timeout?: number;
-  logger?: Logger;
-  /**
-   * Callback to get fresh token when current token expires.
-   * Centrifuge-js calls this automatically on token expiration.
-   */
-  getToken?: () => Promise<string>;
-}
+import type {
+  CentrifugoClientOptions,
+  PendingRequest,
+  RPCOptions,
+  RetryOptions,
+  VersionCheckResult,
+} from './types';
+
+import {
+  createConnectionState,
+  setupConnectionHandlers,
+  connect as connectToServer,
+  disconnect as disconnectFromServer,
+  type ConnectionState,
+} from './connection';
+
+import {
+  subscribe as subscribeToChannel,
+  unsubscribe as unsubscribeFromChannel,
+  unsubscribeAll as unsubscribeFromAllChannels,
+  getActiveSubscriptions as getClientSubscriptions,
+  getServerSideSubscriptions as getServerSubscriptions,
+  getAllSubscriptions as getCombinedSubscriptions,
+  type SubscriptionManager,
+} from './subscriptions';
+
+import {
+  handleResponse,
+  call as legacyCall,
+  rpc as legacyRpc,
+  namedRPC as nativeNamedRPC,
+  namedRPCNoWait as nativeNamedRPCNoWait,
+  type RPCManager,
+} from './rpc';
+
+import { checkApiVersion as checkVersion } from './version';
+
+// Re-export types for backwards compatibility
+export type { CentrifugoClientOptions } from './types';
 
 export class CentrifugoRPCClient {
-  private centrifuge: Centrifuge;
-  private subscription: any;
-  private channelSubscriptions: Map<string, any> = new Map();
-  private pendingRequests: Map<string, { resolve: Function; reject: Function }> = new Map();
-  private readonly userId: string;
-  private readonly replyChannel: string;
-  private readonly timeout: number;
-  private readonly logger: Logger;
+  private state: ConnectionState;
 
   constructor(options: CentrifugoClientOptions);
   /** @deprecated Use options object instead */
@@ -50,588 +74,148 @@ export class CentrifugoRPCClient {
     timeout: number = 30000,
     logger?: Logger
   ) {
-    // Handle both old and new API
-    let url: string;
-    let actualToken: string;
-    let actualUserId: string;
-    let actualTimeout: number;
-    let actualLogger: Logger | undefined;
-    let getToken: (() => Promise<string>) | undefined;
-
-    if (typeof urlOrOptions === 'object') {
-      // New options-based API
-      url = urlOrOptions.url;
-      actualToken = urlOrOptions.token;
-      actualUserId = urlOrOptions.userId;
-      actualTimeout = urlOrOptions.timeout ?? 30000;
-      actualLogger = urlOrOptions.logger;
-      getToken = urlOrOptions.getToken;
-    } else {
-      // Legacy positional arguments API
-      url = urlOrOptions;
-      actualToken = token!;
-      actualUserId = userId!;
-      actualTimeout = timeout;
-      actualLogger = logger;
-    }
-
-    this.userId = actualUserId;
-    this.replyChannel = `user#${actualUserId}`;
-    this.timeout = actualTimeout;
-    this.logger = actualLogger || getConsolaLogger('client');
-
-    // Build Centrifuge options
-    const centrifugeOptions: any = {
-      token: actualToken,
-    };
-
-    // Add getToken callback for automatic token refresh
-    if (getToken) {
-      centrifugeOptions.getToken = async () => {
-        this.logger.info('Token expired, refreshing...');
-        try {
-          const newToken = await getToken();
-          this.logger.success('Token refreshed successfully');
-          return newToken;
-        } catch (error) {
-          this.logger.error('Failed to refresh token', error);
-          throw error;
-        }
-      };
-    }
-
-    this.centrifuge = new Centrifuge(url, centrifugeOptions);
-
-    this.centrifuge.on('disconnected', (ctx) => {
-      // Reject all pending requests
-      this.pendingRequests.forEach(({ reject }) => {
-        reject(new Error('Disconnected from Centrifugo'));
-      });
-      this.pendingRequests.clear();
-    });
+    this.state = createConnectionState(urlOrOptions, token, userId, timeout, logger);
+    setupConnectionHandlers(this.state, (data) => this.handleResponse(data));
   }
 
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Connection API
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
   async connect(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      let resolved = false;
-
-      // Listen to Centrifuge connection events
-      const onConnected = () => {
-        if (!resolved) {
-          resolved = true;
-          resolve();
-        }
-      };
-
-      const onError = (ctx: any) => {
-        if (!resolved) {
-          resolved = true;
-          reject(new Error(ctx.message || 'Connection error'));
-        }
-      };
-
-      this.centrifuge.on('connected', onConnected);
-      this.centrifuge.on('error', onError);
-
-      // Start connection
-      this.centrifuge.connect();
-
-      // Subscribe to reply channel
-      this.subscription = this.centrifuge.newSubscription(this.replyChannel);
-
-      this.subscription.on('publication', (ctx: any) => {
-        this.handleResponse(ctx.data);
-      });
-
-      this.subscription.on('subscribed', () => {
-        // Subscription successful (optional, we already resolved on 'connected')
-      });
-
-      this.subscription.on('error', (ctx: any) => {
-        // Error code 105 = "already subscribed" (server-side subscription from JWT)
-        // This is not an error - the channel is already active via server-side subscription
-        if (ctx.error?.code === 105) {
-          // This is fine, server-side subscription exists
-        } else {
-          this.logger.error(`Subscription error for ${this.replyChannel}:`, ctx.error);
-        }
-      });
-
-      this.subscription.subscribe();
-    });
+    return connectToServer(this.state, (data) => this.handleResponse(data));
   }
 
   async disconnect(): Promise<void> {
-    // Unsubscribe from all event channels
-    this.unsubscribeAll();
+    disconnectFromServer(this.state);
+  }
 
-    // Unsubscribe from RPC reply channel
-    if (this.subscription) {
-      this.subscription.unsubscribe();
-    }
+  getCentrifuge(): Centrifuge {
+    return this.state.centrifuge;
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Subscription API
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-    this.centrifuge.disconnect();
+  subscribe(channel: string, callback: (data: any) => void): () => void {
+    return subscribeToChannel(this.subscriptionManager, channel, callback);
   }
 
-  async call<T = any>(method: string, params: any): Promise<T> {
-    const correlationId = this.generateCorrelationId();
+  unsubscribe(channel: string): void {
+    unsubscribeFromChannel(this.subscriptionManager, channel);
+  }
 
-    const message = {
-      method,
-      params,
-      correlation_id: correlationId,
-      reply_to: this.replyChannel,
-    };
+  unsubscribeAll(): void {
+    unsubscribeFromAllChannels(this.subscriptionManager);
+  }
 
-    // Create promise for response
-    const promise = new Promise<T>((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        this.pendingRequests.delete(correlationId);
-        reject(new Error(`RPC timeout: ${method}`));
-      }, this.timeout);
-
-      this.pendingRequests.set(correlationId, {
-        resolve: (result: T) => {
-          clearTimeout(timeoutId);
-          resolve(result);
-        },
-        reject: (error: Error) => {
-          clearTimeout(timeoutId);
-          reject(error);
-        },
-      });
-    });
-
-    // Publish request
-    await this.centrifuge.publish('rpc.requests', message);
-
-    return promise;
+  getActiveSubscriptions(): string[] {
+    return getClientSubscriptions(this.subscriptionManager);
   }
 
-  private handleResponse(data: any): void {
-    const correlationId = data.correlation_id;
-    if (!correlationId) {
-      return;
-    }
-
-    const pending = this.pendingRequests.get(correlationId);
-    if (!pending) {
-      return;
-    }
-
-    this.pendingRequests.delete(correlationId);
-
-    if (data.error) {
-      pending.reject(new Error(data.error.message || 'RPC error'));
-    } else {
-      pending.resolve(data.result);
-    }
+  getServerSideSubscriptions(): string[] {
+    return getServerSubscriptions(this.subscriptionManager);
   }
 
-  private generateCorrelationId(): string {
-    return `rpc-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  getAllSubscriptions(): string[] {
+    return getCombinedSubscriptions(this.subscriptionManager);
   }
 
   // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  // RPC Pattern API (Request-Response via Correlation ID)
+  // RPC Pattern API (Legacy - Correlation ID)
   // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  /**
-   * Send RPC request and wait for response.
-   * 
-   * Uses correlation ID pattern to match request with response:
-   * 1. Generate unique correlation_id
-   * 2. Subscribe to personal reply channel (user#{userId})
-   * 3. Publish request with correlation_id
-   * 4. Wait for response with matching correlation_id
-   * 5. Return response or timeout
-   * 
-   * @param method - RPC method name (e.g., 'tasks.get_stats')
-   * @param params - Request parameters
-   * @param options - RPC options
-   * @returns Promise that resolves with response data
-   * 
-   * @example
-   * const result = await client.rpc('tasks.get_stats', { bot_id: '123' });
-   * console.log('Stats:', result);
-   * 
-   * @example
-   * // With custom timeout and reply channel
-   * const result = await client.rpc('bot.command', 
-   *   { command: 'start' },
-   *   { timeout: 30000, replyChannel: 'bot#123#replies' }
-   * );
-   */
+  async call<T = any>(method: string, params: any): Promise<T> {
+    return legacyCall(this.rpcManager, method, params, this.state.replyChannel);
+  }
+
   async rpc<TRequest = any, TResponse = any>(
     method: string,
     params: TRequest,
-    options: {
-      timeout?: number;
-      replyChannel?: string;
-    } = {}
+    options: RPCOptions = {}
   ): Promise<TResponse> {
-    const {
-      timeout = 10000,
-      replyChannel = `user#${this.userId}`,
-    } = options;
-
-    const correlationId = this.generateCorrelationId();
-    
-    this.logger.info(`RPC request: ${method}`, { correlationId, params });
-
-    return new Promise<TResponse>((resolve, reject) => {
-      let timeoutId: NodeJS.Timeout | null = null;
-      let unsubscribe: (() => void) | null = null;
-
-      // Cleanup function
-      const cleanup = () => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-          timeoutId = null;
-        }
-        if (unsubscribe) {
-          unsubscribe();
-          unsubscribe = null;
-        }
-      };
-
-      // Set timeout
-      timeoutId = setTimeout(() => {
-        cleanup();
-        const error = new Error(`RPC timeout: ${method} (${timeout}ms)`);
-        this.logger.error(`RPC timeout: ${method}`, { correlationId, timeout });
-        reject(error);
-      }, timeout);
-
-      // Subscribe to reply channel
-      try {
-        unsubscribe = this.subscribe(replyChannel, (data: any) => {
-          try {
-            // Check if this is our response
-            if (data.correlation_id === correlationId) {
-              cleanup();
-              
-              // Check for error in response
-              if (data.error) {
-                this.logger.error(`RPC error: ${method}`, { 
-                  correlationId, 
-                  error: data.error 
-                });
-                reject(new Error(data.error.message || 'RPC error'));
-                return;
-              }
-              
-              this.logger.success(`RPC response: ${method}`, { 
-                correlationId,
-                hasResult: !!data.result 
-              });
-              resolve(data.result as TResponse);
-            }
-          } catch (error) {
-            cleanup();
-            this.logger.error(`Error processing RPC response: ${method}`, error);
-            reject(error);
-          }
-        });
-
-        // Publish request to RPC channel
-        // Note: This uses Centrifuge's publish, not our HTTP publish
-        // The backend should be subscribed to this channel
-        const rpcChannel = `rpc#${method}`;
-        const sub = this.centrifuge.getSubscription(rpcChannel);
-        
-        if (sub) {
-          // If we have a subscription, use it to publish
-          sub.publish({
-            correlation_id: correlationId,
-            method,
-            params,
-            reply_to: replyChannel,
-            timestamp: Date.now(),
-          }).catch((error: any) => {
-            cleanup();
-            this.logger.error(`Failed to publish RPC request: ${method}`, error);
-            reject(error);
-          });
-        } else {
-          // Otherwise, we need to publish via HTTP API
-          // This requires the backend to expose a publish endpoint
-          cleanup();
-          reject(new Error(
-            `Cannot publish RPC request: no subscription to ${rpcChannel}. ` +
-            `Backend should provide a publish endpoint or use server-side subscriptions.`
-          ));
-        }
-      } catch (error) {
-        cleanup();
-        this.logger.error(`Failed to setup RPC: ${method}`, error);
-        reject(error);
-      }
-    });
+    return legacyRpc(this.rpcManager, method, params, options);
   }
 
   // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  // Channel Subscription API (for gRPC events)
+  // Native Centrifugo RPC (via RPC Proxy)
   // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  /**
-   * Subscribe to a Centrifugo channel for real-time events.
-   *
-   * @param channel - Channel name (e.g., 'bot#bot-123#heartbeat')
-   * @param callback - Callback for received messages
-   * @returns Unsubscribe function
-   *
-   * @example
-   * const unsubscribe = client.subscribe('bot#bot-123#heartbeat', (data) => {
-   *   console.log('Heartbeat:', data);
-   * });
-   *
-   * // Later: unsubscribe when done
-   * unsubscribe();
-   */
-  subscribe(channel: string, callback: (data: any) => void): () => void {
-    // Check if already subscribed - reuse existing subscription
-    const existingSub = this.channelSubscriptions.get(channel);
-    if (existingSub) {
-      this.logger.warning(`Already subscribed to ${channel}, reusing existing subscription`);
-      
-      // Add new callback handler to existing subscription
-      const handler = (ctx: any) => {
-        try {
-          callback(ctx.data);
-        } catch (error) {
-          this.logger.error(`Error in subscription callback for ${channel}`, error);
-        }
-      };
-      
-      existingSub.on('publication', handler);
-      
-      // Return unsubscribe that only removes this specific handler
-      return () => {
-        existingSub.off('publication', handler);
-      };
-    }
-
-    // Create new subscription using Centrifuge's getSubscription or newSubscription
-    let sub = this.centrifuge.getSubscription(channel);
-    if (!sub) {
-      sub = this.centrifuge.newSubscription(channel);
-    }
-
-    // Handle publications with error handling
-    const publicationHandler = (ctx: any) => {
-      try {
-        callback(ctx.data);
-      } catch (error) {
-        this.logger.error(`Error in subscription callback for ${channel}`, error);
-      }
-    };
-    
-    sub.on('publication', publicationHandler);
-
-    // Handle subscription lifecycle
-    sub.on('subscribed', () => {
-      this.logger.success(`Subscribed to ${channel}`);
-    });
-
-    sub.on('error', (ctx: any) => {
-      this.logger.error(`Subscription error for ${channel}`, ctx.error);
-    });
-
-    // Start subscription
-    sub.subscribe();
-
-    // Store subscription
-    this.channelSubscriptions.set(channel, sub);
-
-    // Return unsubscribe function
-    return () => this.unsubscribe(channel);
+  async namedRPC<TRequest = any, TResponse = any>(
+    method: string,
+    data: TRequest,
+    options?: { timeout?: number }
+  ): Promise<TResponse> {
+    return nativeNamedRPC(this.rpcManager, method, data, options);
   }
 
-  /**
-   * Unsubscribe from a channel.
-   * Properly removes subscription from both internal map and Centrifuge client.
-   *
-   * @param channel - Channel name
-   */
-  unsubscribe(channel: string): void {
-    const sub = this.channelSubscriptions.get(channel);
-    if (!sub) {
-      return;
-    }
-
-    try {
-      // Unsubscribe from channel
-      sub.unsubscribe();
-      
-      // Remove subscription from Centrifuge client registry
-      this.centrifuge.removeSubscription(sub);
-      
-      // Remove from our internal map
-      this.channelSubscriptions.delete(channel);
-      
-      this.logger.info(`Unsubscribed from ${channel}`);
-    } catch (error) {
-      this.logger.error(`Error unsubscribing from ${channel}`, error);
-      // Still remove from our map even if there was an error
-      this.channelSubscriptions.delete(channel);
-    }
+  namedRPCNoWait<TRequest = any>(
+    method: string,
+    data: TRequest,
+    options?: RetryOptions
+  ): void {
+    nativeNamedRPCNoWait(this.rpcManager, method, data, options);
   }
 
-  /**
-   * Unsubscribe from all channels.
-   * Properly removes all subscriptions from both internal map and Centrifuge client.
-   */
-  unsubscribeAll(): void {
-    if (this.channelSubscriptions.size === 0) {
-      return;
-    }
-
-    this.channelSubscriptions.forEach((sub, channel) => {
-      try {
-        sub.unsubscribe();
-        this.centrifuge.removeSubscription(sub);
-      } catch (error) {
-        this.logger.error(`Error unsubscribing from ${channel}`, error);
-      }
-    });
-    
-    this.channelSubscriptions.clear();
-    this.logger.info('Unsubscribed from all channels');
-  }
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // API Version Checking
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  /**
-   * Get list of active client-side subscriptions.
-   */
-  getActiveSubscriptions(): string[] {
-    return Array.from(this.channelSubscriptions.keys());
+  async checkApiVersion(clientVersion: string): Promise<VersionCheckResult> {
+    return checkVersion(
+      {
+        namedRPC: (method, data) => this.namedRPC(method, data),
+        logger: this.state.logger,
+      },
+      clientVersion
+    );
   }
 
-  /**
-   * Get list of server-side subscriptions (from JWT token).
-   *
-   * These are channels automatically subscribed by Centrifugo server
-   * based on the 'channels' claim in the JWT token.
-   */
-  getServerSideSubscriptions(): string[] {
-    try {
-      // Access Centrifuge.js internal state for server-side subs
-      // @ts-ignore - accessing internal property
-      const serverSubs = this.centrifuge._serverSubs || {};
-      return Object.keys(serverSubs);
-    } catch (error) {
-      return [];
-    }
-  }
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Internal Helpers
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  /**
-   * Get all active subscriptions (both client-side and server-side).
-   */
-  getAllSubscriptions(): string[] {
-    const clientSubs = this.getActiveSubscriptions();
-    const serverSubs = this.getServerSideSubscriptions();
+  private handleResponse(data: any): void {
+    handleResponse(this.state.pendingRequests, data);
+  }
 
-    // Combine and deduplicate
-    return Array.from(new Set([...clientSubs, ...serverSubs]));
+  private get subscriptionManager(): SubscriptionManager {
+    return {
+      channelSubscriptions: this.state.channelSubscriptions,
+      centrifuge: this.state.centrifuge,
+      logger: this.state.logger,
+    };
   }
 
-  /**
-   * Get native Centrifuge client for direct access to low-level APIs.
-   * Use with caution - prefer using the high-level methods when possible.
-   */
-  getCentrifuge(): Centrifuge {
-    return this.centrifuge;
+  private get rpcManager(): RPCManager {
+    return {
+      centrifuge: this.state.centrifuge,
+      pendingRequests: this.state.pendingRequests,
+      channelSubscriptions: this.state.channelSubscriptions,
+      userId: this.state.userId,
+      timeout: this.state.timeout,
+      logger: this.state.logger,
+      subscribe: (channel, callback) => this.subscribe(channel, callback),
+    };
   }
 
   // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  // Native Centrifugo RPC (via RPC Proxy)
+  // Getters for Testing/Debugging
   // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  /**
-   * Call RPC method via native Centrifugo RPC proxy.
-   *
-   * This uses Centrifugo's built-in RPC mechanism which proxies
-   * requests to the backend (Django) via HTTP.
-   *
-   * Flow:
-   * 1. Client calls namedRPC('terminal.input', data)
-   * 2. Centrifuge.js sends RPC over WebSocket
-   * 3. Centrifugo proxies to Django: POST /centrifugo/rpc/
-   * 4. Django routes to @websocket_rpc handler
-   * 5. Response returned to client
-   *
-   * @param method - RPC method name (e.g., 'terminal.input')
-   * @param data - Request data
-   * @returns Promise that resolves with response data
-   *
-   * @example
-   * const result = await client.namedRPC('terminal.input', {
-   *   session_id: 'abc-123',
-   *   data: btoa('ls -la')
-   * });
-   * console.log('Result:', result); // { success: true }
-   */
-  async namedRPC<TRequest = any, TResponse = any>(
-    method: string,
-    data: TRequest,
-    options?: { timeout?: number }
-  ): Promise<TResponse> {
-    this.logger.info(`Native RPC: ${method}`, { data });
-
-    try {
-      // Note: centrifuge.rpc does not support timeout parameter directly
-      // Timeout should be handled at higher level or via AbortController
-      const result = await this.centrifuge.rpc(method, data);
-
-      this.logger.success(`Native RPC success: ${method}`, {
-        hasData: !!result.data
-      });
-
-      return result.data as TResponse;
-    } catch (error) {
-      this.logger.error(`Native RPC failed: ${method}`, error);
-
-      // Dispatch error event for ErrorsTracker
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const errorCode = (error as any)?.code;
-      dispatchCentrifugoError({
-        method,
-        error: errorMessage,
-        code: errorCode,
-        data,
-      });
-
-      throw error;
-    }
+  /** @internal */
+  get logger(): Logger {
+    return this.state.logger;
+  }
+
+  /** @internal */
+  get userId(): string {
+    return this.state.userId;
   }
 
-  /**
-   * Fire-and-forget RPC call - sends without waiting for response.
-   * Use for latency-sensitive operations like terminal input.
-   *
-   * Flow:
-   * 1. Client calls namedRPCNoWait('terminal.input', data)
-   * 2. Centrifuge.js sends RPC over WebSocket
-   * 3. Client returns immediately (doesn't wait for response)
-   * 4. Backend processes asynchronously
-   *
-   * @param method - RPC method name (e.g., 'terminal.input')
-   * @param data - Request data
-   *
-   * @example
-   * // Terminal input - user types, we send immediately
-   * client.namedRPCNoWait('terminal.input', {
-   *   session_id: 'abc-123',
-   *   data: btoa('ls')
-   * });
-   */
-  namedRPCNoWait<TRequest = any>(method: string, data: TRequest): void {
-    this.logger.info(`Native RPC (fire-and-forget): ${method}`, { data });
-
-    // Fire and forget - don't await the promise
-    this.centrifuge.rpc(method, data).catch((error) => {
-      // Log but don't throw - this is fire-and-forget
-      this.logger.warning(`Fire-and-forget RPC failed: ${method}`, error);
-    });
+  /** @internal */
+  get replyChannel(): string {
+    return this.state.replyChannel;
   }
 }