@ywfe/openclaw-plugin-caryscloud-im 0.1.6 → 0.1.7

package/dist/ws-client.js

@@ -1,680 +0,0 @@
-import WebSocket from 'ws';
-import { ConnectionError, MessageError, } from './shared/errors.js';
-import { DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_CONNECTION_TIMEOUT, DEFAULT_RECONNECT_BASE_DELAY, DEFAULT_RECONNECT_MAX_DELAY, DEFAULT_MESSAGE_QUEUE_MAX_SIZE, DEFAULT_PONG_TIMEOUT, } from './shared/constants.js';
-const DEFAULT_AUTH_TIMEOUT = 10000;
-const DEFAULT_RECONNECT_RESET_WINDOW = 10000;
-const DEFAULT_RATE_LIMIT_RETRY_SECONDS = 60;
-export class WebSocketClient {
-    ws = null;
-    _state = 'idle';
-    messageHandlers = [];
-    logger;
-    uuid;
-    wsUrl;
-    authToken;
-    isDestroyed = false;
-    heartbeatInterval;
-    connectionTimeout;
-    reconnectBaseDelay;
-    reconnectMaxDelay;
-    messageQueueMaxSize;
-    pongTimeout;
-    authTimeout;
-    reconnectResetWindow;
-    targetUserId;
-    sendTestMessage;
-    reconnectAttempts = 0;
-    reconnectTimer = null;
-    connectionTimer = null;
-    authTimer = null;
-    reconnectResetTimer = null;
-    heartbeatTimer = null;
-    pongTimer = null;
-    messageQueue = [];
-    lastPongTime = 0;
-    constructor(options, logger) {
-        this.wsUrl = options.wsUrl;
-        this.uuid = options.uuid;
-        this.authToken = options.authToken;
-        this.logger = logger;
-        this.targetUserId = options.targetUserId;
-        this.sendTestMessage = options.sendTestMessage ?? false;
-        this.heartbeatInterval = options.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL;
-        this.connectionTimeout = options.connectionTimeout ?? DEFAULT_CONNECTION_TIMEOUT;
-        this.reconnectBaseDelay = options.reconnectBaseDelay ?? DEFAULT_RECONNECT_BASE_DELAY;
-        this.reconnectMaxDelay = options.reconnectMaxDelay ?? DEFAULT_RECONNECT_MAX_DELAY;
-        this.messageQueueMaxSize = options.messageQueueMaxSize ?? DEFAULT_MESSAGE_QUEUE_MAX_SIZE;
-        this.pongTimeout = options.pongTimeout ?? DEFAULT_PONG_TIMEOUT;
-        this.authTimeout = options.authTimeout ?? DEFAULT_AUTH_TIMEOUT;
-        this.reconnectResetWindow = options.reconnectResetWindow ?? DEFAULT_RECONNECT_RESET_WINDOW;
-    }
-    get state() {
-        return this._state;
-    }
-    getIsReady() {
-        return this._state === 'connected' && !this.isDestroyed;
-    }
-    isInConflict() {
-        return this._state === 'conflict';
-    }
-    getUuid() {
-        return this.uuid;
-    }
-    async initialize() {
-        if (this._state === 'connecting' || this._state === 'authenticating') {
-            this.logger.warn('Already connecting, skipping...');
-            return;
-        }
-        if (this.isDestroyed) {
-            throw new ConnectionError('Client has been destroyed, cannot initialize');
-        }
-        this._state = 'connecting';
-        this.reconnectAttempts = 0;
-        try {
-            await this.connect();
-        }
-        catch (error) {
-            this._state = 'disconnected';
-            this.logger.error(`Initial connection failed: ${error}`);
-            this.scheduleReconnect('INITIAL_CONNECT_FAILED');
-        }
-    }
-    async connect() {
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const resolveOnce = () => {
-                if (settled)
-                    return;
-                settled = true;
-                resolve();
-            };
-            const rejectOnce = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                reject(error);
-            };
-            try {
-                // Append auth token as query param for public endpoints (e.g. wss://host/ws?token=xxx)
-                const url = this.authToken
-                    ? `${this.wsUrl}${this.wsUrl.includes('?') ? '&' : '?'}token=${this.authToken}`
-                    : this.wsUrl;
-                this.logger.info(`Connecting to ${url}...`);
-                this.ws = new WebSocket(url);
-                this.connectionTimer = setTimeout(() => {
-                    this.logger.error(`Connection timeout (${this.connectionTimeout}ms)`);
-                    this.handleConnectionTimeout();
-                    rejectOnce(new ConnectionError('Connection timeout'));
-                }, this.connectionTimeout);
-                this.ws.on('open', () => {
-                    this.handleOpen();
-                    resolveOnce();
-                });
-                this.ws.on('message', (data) => {
-                    this.handleMessage(data);
-                });
-                this.ws.on('close', (code, reason) => {
-                    const reasonText = reason.toString();
-                    this.handleClose(code, reasonText);
-                    rejectOnce(new ConnectionError(`Connection closed before ready: code=${code}, reason=${reasonText || 'N/A'}`));
-                });
-                this.ws.on('error', (error) => {
-                    this.handleError(error);
-                    rejectOnce(error);
-                });
-                this.ws.on('pong', () => {
-                    this.handlePong();
-                });
-            }
-            catch (error) {
-                this.logger.error(`Connection error: ${error}`);
-                rejectOnce(error);
-            }
-        });
-    }
-    handleOpen() {
-        this.logger.info('WebSocket connected');
-        this.clearConnectionTimer();
-        if (this.authToken) {
-            this._state = 'authenticating';
-            this.startAuthTimeout();
-            if (!this.sendAuthMessage()) {
-                this._state = 'error';
-                this.closeSocket(1011, 'Failed to send auth message');
-            }
-            return;
-        }
-        this.markConnected('Connected without auth token');
-    }
-    sendAuthMessage() {
-        const authMsg = {
-            type: 'auth',
-            payload: {
-                token: this.authToken,
-                uuid: this.uuid,
-            },
-        };
-        try {
-            this.ws?.send(JSON.stringify(authMsg));
-            this.logger.info('Auth message sent');
-            return true;
-        }
-        catch (error) {
-            this.logger.error(`Failed to send auth message: ${error}`);
-            return false;
-        }
-    }
-    handleMessage(data) {
-        try {
-            const message = JSON.parse(data.toString());
-            if (message.type === 'auth_response') {
-                this.handleAuthResponse(message);
-                return;
-            }
-            if (message.type === 'pong') {
-                this.handlePong();
-                return;
-            }
-            if (message.type === 'conflict') {
-                this.handleConflict(message);
-                return;
-            }
-            if (this.isRateLimitMessage(message)) {
-                this.handleRateLimitedMessage(message);
-                return;
-            }
-            this.messageHandlers.forEach(handler => {
-                try {
-                    handler(message);
-                }
-                catch (error) {
-                    this.logger.error(`Error in message handler: ${error}`);
-                }
-            });
-        }
-        catch (error) {
-            this.logger.error(`Failed to parse message: ${error}`);
-        }
-    }
-    handleAuthResponse(message) {
-        this.clearAuthTimer();
-        const authSuccess = message.success === true || message.payload?.success === true;
-        if (authSuccess) {
-            this.markConnected('Authentication successful');
-            return;
-        }
-        if (this.isRateLimitMessage(message)) {
-            this.handleRateLimitedMessage(message, 'Auth rejected by rate limit');
-            return;
-        }
-        const errorMessage = this.extractErrorMessage(message);
-        this.logger.error(`Authentication failed: ${errorMessage}`);
-        this._state = 'error';
-        this.scheduleReconnect('AUTH_FAILED');
-        this.closeSocket(1008, 'Authentication failed');
-    }
-    handleConflict(message) {
-        this.logger.error(`UUID conflict detected: ${message.reason || 'duplicate UUID'}`);
-        this._state = 'conflict';
-        this.clearAuthTimer();
-        this.stopHeartbeat();
-        this.clearReconnectResetTimer();
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.messageHandlers.forEach(handler => {
-            try {
-                handler({
-                    type: 'SYSTEM_CONFLICT',
-                    payload: {
-                        uuid: this.uuid,
-                        message: message.reason || 'UUID conflict detected',
-                    },
-                });
-            }
-            catch (error) {
-                this.logger.error(`Error in conflict handler: ${error}`);
-            }
-        });
-    }
-    handleClose(code, reason) {
-        this.logger.warn(`WebSocket closed: code=${code}, reason=${reason}`);
-        this.clearConnectionTimer();
-        this.clearAuthTimer();
-        this.clearReconnectResetTimer();
-        this.stopHeartbeat();
-        if (this._state === 'conflict' || this.isDestroyed) {
-            this.logger.info('Skipping reconnection (conflict or destroyed)');
-            return;
-        }
-        if (this._state !== 'rate_limited') {
-            this._state = 'disconnected';
-        }
-        this.scheduleReconnect('CONNECTION_CLOSED');
-    }
-    handleError(error) {
-        this.logger.error(`WebSocket error: ${error.message}`);
-        this._state = 'error';
-    }
-    handleConnectionTimeout() {
-        this.clearConnectionTimer();
-        if (this.ws && this.ws.readyState !== WebSocket.OPEN) {
-            this.logger.error('Connection timeout, forcing close');
-            this._state = 'error';
-            this.scheduleReconnect('CONNECTION_TIMEOUT');
-            this.closeSocket(1000, 'Connection timeout');
-        }
-    }
-    scheduleReconnect(reason, minDelayMs) {
-        if (this.isDestroyed || this._state === 'conflict') {
-            this.logger.info('Skipping reconnection');
-            return;
-        }
-        if (this.reconnectTimer) {
-            this.logger.debug(`Reconnect already scheduled, skipping duplicate (reason: ${reason})`);
-            return;
-        }
-        this.reconnectAttempts++;
-        const backoffDelay = this.calculateReconnectDelay(this.reconnectAttempts);
-        const explicitDelay = typeof minDelayMs === 'number' && Number.isFinite(minDelayMs) && minDelayMs > 0
-            ? minDelayMs
-            : 0;
-        const delay = Math.max(backoffDelay, explicitDelay);
-        this.logger.info(`Scheduling reconnect attempt #${this.reconnectAttempts} in ${delay}ms (reason: ${reason})`);
-        this.reconnectTimer = setTimeout(async () => {
-            this.reconnectTimer = null;
-            if (this.isDestroyed || this._state === 'conflict') {
-                return;
-            }
-            try {
-                this.logger.info(`Reconnecting (attempt #${this.reconnectAttempts})...`);
-                this._state = 'connecting';
-                await this.connect();
-                this.logger.info('Reconnect socket opened, waiting for readiness confirmation');
-            }
-            catch (error) {
-                this.logger.error(`Reconnect attempt #${this.reconnectAttempts} failed: ${error}`);
-                this.scheduleReconnect('RECONNECT_FAILED');
-            }
-        }, delay);
-    }
-    calculateReconnectDelay(attempt) {
-        const jitter = Math.floor(Math.random() * 1000);
-        const baseDelay = Math.min(this.reconnectBaseDelay * Math.pow(2, Math.max(attempt - 1, 0)), this.reconnectMaxDelay);
-        return baseDelay + jitter;
-    }
-    startAuthTimeout() {
-        this.clearAuthTimer();
-        this.authTimer = setTimeout(() => {
-            if (this.isDestroyed || this._state !== 'authenticating') {
-                return;
-            }
-            this.logger.warn(`Auth response timeout (${this.authTimeout}ms)`);
-            this._state = 'error';
-            this.scheduleReconnect('AUTH_TIMEOUT');
-            this.closeSocket(1008, 'Auth response timeout');
-        }, this.authTimeout);
-    }
-    clearAuthTimer() {
-        if (this.authTimer) {
-            clearTimeout(this.authTimer);
-            this.authTimer = null;
-        }
-    }
-    clearReconnectResetTimer() {
-        if (this.reconnectResetTimer) {
-            clearTimeout(this.reconnectResetTimer);
-            this.reconnectResetTimer = null;
-        }
-    }
-    clearConnectionTimer() {
-        if (this.connectionTimer) {
-            clearTimeout(this.connectionTimer);
-            this.connectionTimer = null;
-        }
-    }
-    closeSocket(code, reason) {
-        if (!this.ws)
-            return;
-        if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-            try {
-                this.ws.close(code, reason);
-            }
-            catch (error) {
-                this.logger.debug(`Ignored error during socket close: ${error}`);
-            }
-        }
-    }
-    markConnected(message) {
-        this.clearAuthTimer();
-        this._state = 'connected';
-        this.startHeartbeat();
-        this.flushMessageQueue();
-        this.scheduleReconnectAttemptReset();
-        this.logger.info(message);
-        if (this.sendTestMessage && this.targetUserId) {
-            this.sendConnectionTestMessage();
-        }
-    }
-    scheduleReconnectAttemptReset() {
-        this.clearReconnectResetTimer();
-        this.reconnectResetTimer = setTimeout(() => {
-            this.reconnectResetTimer = null;
-            if (!this.ws || this.ws.readyState !== WebSocket.OPEN || this._state !== 'connected') {
-                return;
-            }
-            if (this.reconnectAttempts > 0) {
-                this.logger.info(`Connection stable for ${this.reconnectResetWindow}ms, resetting reconnect attempts`);
-            }
-            this.reconnectAttempts = 0;
-        }, this.reconnectResetWindow);
-    }
-    extractErrorMessage(message) {
-        const candidates = [
-            message?.error,
-            message?.message,
-            message?.reason,
-            message?.payload?.error,
-            message?.payload?.message,
-            message?.payload?.reason,
-        ];
-        for (const candidate of candidates) {
-            if (typeof candidate === 'string' && candidate.trim() !== '') {
-                return candidate.trim();
-            }
-        }
-        return 'Unknown error';
-    }
-    extractRetryAfterMs(message) {
-        const retryAfterCandidates = [
-            message?.retry_after,
-            message?.retryAfter,
-            message?.payload?.retry_after,
-            message?.payload?.retryAfter,
-        ];
-        for (const candidate of retryAfterCandidates) {
-            let seconds = null;
-            if (typeof candidate === 'number' && Number.isFinite(candidate)) {
-                seconds = candidate;
-            }
-            else if (typeof candidate === 'string' && candidate.trim() !== '') {
-                const parsed = Number(candidate);
-                if (Number.isFinite(parsed)) {
-                    seconds = parsed;
-                }
-            }
-            if (seconds !== null && seconds > 0) {
-                return Math.min(seconds * 1000, 60 * 60 * 1000);
-            }
-        }
-        return undefined;
-    }
-    isRateLimitMessage(message) {
-        const type = String(message?.type ?? '').toLowerCase();
-        if (type === 'rate_limit' || type === 'rate_limited') {
-            return true;
-        }
-        if (this.extractRetryAfterMs(message) !== undefined) {
-            return true;
-        }
-        const codeCandidates = [
-            message?.code,
-            message?.errorCode,
-            message?.payload?.code,
-            message?.payload?.errorCode,
-        ];
-        if (codeCandidates.some(code => typeof code === 'string' && code.toLowerCase().includes('rate'))) {
-            return true;
-        }
-        const errorText = this.extractErrorMessage(message).toLowerCase();
-        return (errorText.includes('rate limit') ||
-            errorText.includes('too many requests') ||
-            errorText.includes('cooldown') ||
-            errorText.includes('try again later') ||
-            errorText.includes('429'));
-    }
-    handleRateLimitedMessage(message, logPrefix = 'Rate limited by server') {
-        this.clearAuthTimer();
-        const retryAfterMs = this.extractRetryAfterMs(message);
-        const effectiveRetryDelay = retryAfterMs ?? DEFAULT_RATE_LIMIT_RETRY_SECONDS * 1000;
-        const retryAfterSeconds = Math.ceil(effectiveRetryDelay / 1000);
-        const errorMessage = this.extractErrorMessage(message);
-        this._state = 'rate_limited';
-        this.logger.warn(`${logPrefix}: ${errorMessage}. Retrying in ${retryAfterSeconds}s`);
-        this.scheduleReconnect('RATE_LIMITED', effectiveRetryDelay);
-        this.closeSocket(1013, 'Rate limited');
-    }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.heartbeatTimer = setInterval(() => {
-            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-                try {
-                    this.ws.ping();
-                    const pingMsg = JSON.stringify({ type: 'ping', timestamp: Date.now() });
-                    this.ws.send(pingMsg);
-                    this.logger.debug('Sent ping (protocol + application layer)');
-                    if (this.pongTimer) {
-                        clearTimeout(this.pongTimer);
-                    }
-                    this.pongTimer = setTimeout(() => {
-                        this.logger.error('Pong timeout, reconnecting...');
-                        this.ws?.close(1000, 'Pong timeout');
-                    }, this.pongTimeout);
-                }
-                catch (error) {
-                    this.logger.error(`Failed to send ping: ${error}`);
-                }
-            }
-        }, this.heartbeatInterval);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-        if (this.pongTimer) {
-            clearTimeout(this.pongTimer);
-            this.pongTimer = null;
-        }
-    }
-    handlePong() {
-        this.lastPongTime = Date.now();
-        if (this.pongTimer) {
-            clearTimeout(this.pongTimer);
-            this.pongTimer = null;
-        }
-    }
-    flushMessageQueue() {
-        if (this.messageQueue.length > 0 && this.ws?.readyState === WebSocket.OPEN) {
-            this.logger.info(`Flushing ${this.messageQueue.length} queued messages`);
-            while (this.messageQueue.length > 0) {
-                const message = this.messageQueue.shift();
-                if (message) {
-                    try {
-                        this.ws?.send(JSON.stringify(message));
-                    }
-                    catch (error) {
-                        this.logger.error(`Failed to send queued message: ${error}`);
-                        this.messageQueue.unshift(message);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    async sendTextMessage(toUserId, text) {
-        if (!this.getIsReady()) {
-            throw new MessageError('Client not ready');
-        }
-        const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-        const message = {
-            type: 'text',
-            from: this.uuid,
-            to: toUserId,
-            text,
-            messageId,
-            timestamp: Date.now(),
-        };
-        return this.sendMessage(message);
-    }
-    sendConnectionTestMessage() {
-        if (!this.targetUserId) {
-            this.logger.warn('Cannot send test message: targetUserId not configured');
-            return;
-        }
-        const testMessage = {
-            type: 'text',
-            from: this.uuid,
-            to: this.targetUserId,
-            text: '🔗 OpenClaw CarysCloud IM 连接成功！Connection established successfully!',
-            messageId: `test_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
-            timestamp: Date.now(),
-        };
-        try {
-            this.ws?.send(JSON.stringify(testMessage));
-            this.logger.info(`✅ Connection test message sent to ${this.targetUserId}`);
-        }
-        catch (error) {
-            this.logger.error(`Failed to send connection test message: ${error}`);
-        }
-    }
-    async sendImageMessage(toUserId, imageFile) {
-        if (!this.getIsReady()) {
-            throw new MessageError('Client not ready');
-        }
-        const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-        const reader = new FileReader();
-        const base64 = await new Promise((resolve, reject) => {
-            reader.onload = () => resolve(reader.result);
-            reader.onerror = reject;
-            reader.readAsDataURL(imageFile);
-        });
-        const message = {
-            type: 'image',
-            from: this.uuid,
-            to: toUserId,
-            payload: {
-                base64,
-                filename: imageFile.name,
-                size: imageFile.size,
-            },
-            messageId,
-            timestamp: Date.now(),
-        };
-        return this.sendMessage(message);
-    }
-    async sendFileMessage(toUserId, file) {
-        if (!this.getIsReady()) {
-            throw new MessageError('Client not ready');
-        }
-        const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-        const reader = new FileReader();
-        const base64 = await new Promise((resolve, reject) => {
-            reader.onload = () => resolve(reader.result);
-            reader.onerror = reject;
-            reader.readAsDataURL(file);
-        });
-        const message = {
-            type: 'file',
-            from: this.uuid,
-            to: toUserId,
-            payload: {
-                base64,
-                filename: file.name,
-                size: file.size,
-            },
-            messageId,
-            timestamp: Date.now(),
-        };
-        return this.sendMessage(message);
-    }
-    sendMessage(message) {
-        return new Promise((resolve, reject) => {
-            if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-                if (this.messageQueue.length >= this.messageQueueMaxSize) {
-                    this.messageQueue.shift();
-                    this.logger.warn('Message queue full, dropping oldest message');
-                }
-                this.messageQueue.push(message);
-                this.logger.info('Message queued (not connected)');
-                resolve(message.messageId);
-                return;
-            }
-            try {
-                this.ws.send(JSON.stringify(message), (error) => {
-                    if (error) {
-                        this.logger.error(`Failed to send message: ${error}`);
-                        if (this.messageQueue.length < this.messageQueueMaxSize) {
-                            this.messageQueue.push(message);
-                        }
-                        reject(new MessageError(`Failed to send message: ${error.message}`, error));
-                    }
-                    else {
-                        resolve(message.messageId);
-                    }
-                });
-            }
-            catch (error) {
-                this.logger.error(`Send error: ${error}`);
-                reject(new MessageError(`Send error: ${error}`, error));
-            }
-        });
-    }
-    onMessage(handler) {
-        this.messageHandlers.push(handler);
-    }
-    offMessage(handler) {
-        const index = this.messageHandlers.indexOf(handler);
-        if (index > -1) {
-            this.messageHandlers.splice(index, 1);
-        }
-    }
-    async destroy() {
-        this.isDestroyed = true;
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.clearConnectionTimer();
-        this.clearAuthTimer();
-        this.clearReconnectResetTimer();
-        this.stopHeartbeat();
-        if (this.ws) {
-            const ws = this.ws;
-            this.ws = null;
-            try {
-                // Only close if the connection is fully established
-                if (ws.readyState === WebSocket.OPEN) {
-                    ws.close(1000, 'Client destroyed');
-                }
-                else if (ws.readyState === WebSocket.CONNECTING) {
-                    // For connecting state, just terminate without close frame
-                    // to avoid "closed before connection was established" error
-                    ws.terminate();
-                }
-            }
-            catch (error) {
-                // Ignore errors during close/terminate - connection might already be dead
-                this.logger.debug(`Ignored error during WebSocket cleanup: ${error}`);
-            }
-            try {
-                ws.removeAllListeners();
-            }
-            catch {
-                // Ignore errors removing listeners
-            }
-        }
-        this.messageHandlers = [];
-        this.messageQueue = [];
-        this._state = 'idle';
-        this.logger.info('Client destroyed');
-    }
-    isUserSignExpired() {
-        return false;
-    }
-    async refreshUserSign() {
-        this.logger.info('refreshUserSign called (no-op for WebSocket)');
-    }
-}
-//# sourceMappingURL=ws-client.js.map