rubjs 3.0.0 → 3.1.1

package/lib/core/network.js

@@ -1,436 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const undici_1 = require("undici");
-const user_agents_1 = __importDefault(require("user-agents"));
-const index_type_1 = require("../types/index.type");
-const crypto_1 = __importDefault(require("./crypto"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const chat_type_1 = __importDefault(require("../types/chat.type"));
-const notifications_type_1 = __importDefault(require("../types/notifications.type"));
-const types = {
-    activities: 'show_activities',
-    chat: 'chat_updates',
-    message: 'message_updates',
-    notifications: 'show_notifications',
-};
-class Network {
-    constructor(client) {
-        this.client = client;
-        this.userAgent = new user_agents_1.default().toString();
-        this.apiVersion = '6';
-        this.reconnecting = false;
-        this.defaultPlatform = this.resolvePlatform(client.platform);
-        this.headers = this.buildHeaders(client.platform);
-        this.agent = new undici_1.Agent({
-            connect: {
-                rejectUnauthorized: false,
-            },
-        });
-    }
-    /**
-     * Retrieves API and WSS server URLs
-     */
-    async getDcs() {
-        const url = 'https://getdcmess.iranlms.ir/';
-        const RETRY_DELAY = 3000;
-        while (true) {
-            try {
-                const res = await (0, undici_1.request)(url, {
-                    method: 'GET',
-                    dispatcher: this.agent,
-                });
-                if (res.statusCode === 200) {
-                    const body = (await res.body.json());
-                    if (body?.data) {
-                        const dcs = body.data;
-                        this.apiUrl = `${dcs.API[dcs.default_api]}/`;
-                        this.wssUrl = dcs.socket[dcs.default_socket];
-                        return true;
-                    }
-                }
-                console.warn('[getDcs] Unexpected status or data format:', res.statusCode);
-            }
-            catch (error) {
-                console.error('[getDcs] Error:', error);
-            }
-            await this.delay(RETRY_DELAY);
-        }
-    }
-    /**
-     * Sends a POST request with retry logic and enhanced error reporting
-     */
-    async request(url, data) {
-        const MAX_ATTEMPTS = 3;
-        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-            try {
-                const res = await (0, undici_1.request)(url, {
-                    method: 'POST',
-                    headers: {
-                        'content-type': 'application/json',
-                        ...this.headers,
-                    },
-                    body: JSON.stringify(data),
-                    dispatcher: this.agent,
-                });
-                if (res.statusCode === 200) {
-                    const responseData = await res.body.json();
-                    return responseData;
-                }
-                else {
-                    console.warn(`[request] Attempt ${attempt}: Unexpected status ${res.statusCode}`);
-                }
-            }
-            catch (error) {
-                console.error(`[request] Attempt ${attempt} failed:`, error);
-            }
-            await this.delay(1000);
-        }
-        throw new Error(`[request] Failed after ${MAX_ATTEMPTS} attempts: ${url}`);
-    }
-    async send({ input = {}, method = 'getUserInfo', tmp_session, }) {
-        while (!this.apiUrl) {
-            await this.getDcs();
-            await this.delay(1000);
-        }
-        const { auth, decode_auth, key, privateKey } = this.client;
-        if (!key)
-            return;
-        const credentialsKey = tmp_session ? 'tmp_session' : 'auth';
-        const credentialsValue = tmp_session ? auth : decode_auth;
-        const payload = {
-            api_version: this.apiVersion,
-            [credentialsKey]: credentialsValue,
-        };
-        const dataPayload = JSON.stringify({
-            client: this.defaultPlatform,
-            method,
-            input,
-        });
-        payload.data_enc = crypto_1.default.encrypt(dataPayload, key);
-        if (!tmp_session && privateKey) {
-            payload.sign = crypto_1.default.sign(payload.data_enc, privateKey);
-        }
-        return this.request(this.apiUrl, payload);
-    }
-    async getUpdates() {
-        while (!this.wssUrl) {
-            await this.getDcs();
-            await this.delay(1000);
-        }
-        this.ws = new undici_1.WebSocket(this.wssUrl);
-        this.ws.addEventListener('open', async () => {
-            await this.handleConnect();
-            this.resetInactivityTimer();
-        });
-        this.ws.addEventListener('message', async (event) => {
-            await this.handleMessage(event.data);
-            this.resetInactivityTimer();
-        });
-        this.ws.addEventListener('error', async (event) => {
-            if (!this.reconnecting) {
-                console.error('WebSocket error, reconnecting...');
-                this.reconnecting = true;
-                await this.resetConnection();
-            }
-        });
-        this.ws.addEventListener('close', async () => {
-            if (!this.reconnecting) {
-                console.warn('WebSocket closed, reconnecting...');
-                this.reconnecting = true;
-                await this.resetConnection();
-            }
-        });
-    }
-    async handleConnect() {
-        console.log('Start Bot..');
-        if (this.ws?.readyState === undici_1.WebSocket.OPEN) {
-            this.ws?.send(JSON.stringify({
-                api_version: '5',
-                auth: this.client.auth,
-                data: '',
-                method: 'handShake',
-            }));
-        }
-        if (this.heartbeatInterval)
-            clearInterval(this.heartbeatInterval);
-        this.heartbeatInterval = setInterval(() => {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                this.ws.send(JSON.stringify({}));
-            }
-        }, 30000);
-    }
-    async handleMessage(message) {
-        const { data_enc } = JSON.parse(message);
-        if (!data_enc || !this.client.key)
-            return;
-        const update = JSON.parse(crypto_1.default.decrypt(data_enc, this.client.key));
-        for (let [event, data] of Object.entries(this.client.handlers)) {
-            if (data.length === 0)
-                continue;
-            // has message
-            const updates = update[types[event]];
-            if (!Array.isArray(updates) || updates.length === 0)
-                continue;
-            // get user name
-            let username = null;
-            const notification = update.show_notifications?.[0];
-            const chatUpdate = update.chat_updates?.[0];
-            if (notification) {
-                const objectGuid = notification?.message_data?.object_guid;
-                if (objectGuid?.startsWith('u0'))
-                    username = notification.title;
-                else if (objectGuid?.startsWith('g0'))
-                    username = notification.text?.split(':')[0];
-            }
-            else if (chatUpdate) {
-                username =
-                    chatUpdate.chat?.last_message?.author_title || 'Unknown User';
-            }
-            else
-                username = 'Unknown User';
-            // start handlers
-            for (let messageData of updates) {
-                messageData = {
-                    client_guid: this.client.userGuid,
-                    ...messageData,
-                    message: {
-                        author_title: username,
-                        ...messageData.message,
-                    },
-                };
-                for (const chain of data) {
-                    await this.runMiddlewareChain(event, chain, messageData, this.client);
-                }
-            }
-        }
-        if (update?.message_updates) {
-            for (let ctx of update.message_updates) {
-                ctx = new index_type_1.Message(this.client, ctx);
-                for (const { middlewares, pattern } of this.client.cmd) {
-                    const text = ctx.message?.text;
-                    if (!text)
-                        return;
-                    if ((typeof pattern === 'string' && text === pattern) ||
-                        (pattern instanceof RegExp && pattern.test(text))) {
-                        await this.runMiddlewareChain('message', middlewares, ctx, this.client);
-                    }
-                }
-            }
-        }
-    }
-    async runMiddlewareChain(event, middlewares, ctx, client) {
-        let index = -1;
-        if (event === 'message') {
-            ctx = new index_type_1.Message(client, ctx);
-        }
-        else if (event === 'chat') {
-            ctx = new chat_type_1.default(client, ctx);
-        }
-        else if (event === 'activities') {
-            ctx = new index_type_1.Activities(client, ctx);
-        }
-        else if (event === 'notifications') {
-            ctx = new notifications_type_1.default(client, ctx);
-        }
-        const dispatch = async (i) => {
-            if (i <= index)
-                throw new Error('next() called multiple times');
-            index = i;
-            if (i === middlewares.length)
-                return;
-            const fn = middlewares[i];
-            try {
-                await fn(ctx, () => dispatch(i + 1));
-            }
-            catch (err) {
-                await this.client.runErrorMiddlewares(err, ctx);
-            }
-        };
-        await dispatch(0);
-    }
-    async resetConnection() {
-        this.ws?.close();
-        this.ws = undefined;
-        setTimeout(async () => {
-            await this.getUpdates();
-            this.reconnecting = false;
-        }, 5000);
-    }
-    resetInactivityTimer() {
-        clearTimeout(this.inactivityTimeout);
-        this.inactivityTimeout = setTimeout(async () => {
-            console.warn('No updates received for 10 minutes. Reconnecting WebSocket...');
-            await this.resetConnection();
-        }, 10 * 60 * 1000);
-    }
-    async uploadFile(filePath, chunkSize = 1048576) {
-        if (!fs_1.default.existsSync(filePath))
-            throw new Error('File not found in the given path');
-        const stat = await fs_1.default.promises.stat(filePath);
-        const fileSize = stat.size;
-        const fileName = path_1.default.basename(filePath);
-        const mime = filePath.split('.').pop();
-        let result = await this.client.requestSendFile(fileName, fileSize, mime);
-        let id = result.id;
-        let dc_id = result.dc_id;
-        let upload_url = result.upload_url;
-        let access_hash_send = result.access_hash_send;
-        let totalParts = Math.ceil(fileSize / chunkSize);
-        const stream = fs_1.default.createReadStream(filePath, { highWaterMark: chunkSize });
-        let index = 0;
-        for await (const chunk of stream) {
-            try {
-                const res = await (0, undici_1.request)(upload_url, {
-                    method: 'POST',
-                    headers: {
-                        auth: this.client.auth,
-                        'file-id': id,
-                        'total-part': totalParts.toString(),
-                        'part-number': (index + 1).toString(),
-                        'chunk-size': chunk.length.toString(),
-                        'access-hash-send': access_hash_send,
-                    },
-                    body: chunk,
-                    dispatcher: this.agent,
-                });
-                const response = await res.body.json();
-                if (response.status === 'ERROR_TRY_AGAIN') {
-                    console.log('Retrying upload...');
-                    stream.close();
-                    result = await this.client.requestSendFile(fileName, fileSize, mime);
-                    id = result.id;
-                    dc_id = result.dc_id;
-                    upload_url = result.upload_url;
-                    access_hash_send = result.access_hash_send;
-                    index = 0;
-                    return this.uploadFile(filePath, chunkSize);
-                }
-                index++;
-                if (response.status === 'OK' &&
-                    response.status_det === 'OK' &&
-                    response.data?.access_hash_rec) {
-                    return {
-                        mime,
-                        size: fileSize,
-                        dc_id,
-                        file_id: id,
-                        file_name: fileName,
-                        access_hash_rec: response.data.access_hash_rec,
-                    };
-                }
-            }
-            catch (error) {
-                console.error('Upload error:', error);
-                await new Promise((resolve) => setTimeout(resolve, 5000));
-            }
-        }
-        throw new Error('Upload failed completely.');
-    }
-    // async download(
-    // 	dc_id: number,
-    // 	file_id: number,
-    // 	access_hash: string,
-    // 	size: number,
-    // 	chunk: number = 131072,
-    // 	callback?: (totalSize: number, downloadedSize: number) => Promise<void>,
-    // 	speed: boolean = false
-    //   ): Promise<Buffer> {
-    // 	const headers = {
-    // 	  auth: this.client.auth,
-    // 	  "access-hash-rec": access_hash,
-    // 	  "file-id": String(file_id),
-    // 	  "user-agent": this.userAgent,
-    // 	};
-    // 	const base_url = `https://messenger${dc_id}.iranlms.ir`;
-    // 	const fetchChunk = async (
-    // 	  start_index: number,
-    // 	  last_index: number
-    // 	): Promise<Buffer> => {
-    // 	  const chunk_headers = {
-    // 		...headers,
-    // 		"start-index": String(start_index),
-    // 		"last-index": String(last_index),
-    // 	  };
-    // 	  try {
-    // 		const config: AxiosRequestConfig = {
-    // 		  headers: chunk_headers,
-    // 		  responseType: "arraybuffer",
-    // 		};
-    // 		const response = await axios.post(
-    // 		  `${base_url}/GetFile.ashx`,
-    // 		  {},
-    // 		  config
-    // 		);
-    // 		return Buffer.from(response.data);
-    // 	  } catch (e) {
-    // 		return Buffer.alloc(0);
-    // 	  }
-    // 	};
-    // 	if (speed) {
-    // 	  const tasks: Promise<Buffer>[] = [];
-    // 	  for (let start_index = 0; start_index < size; start_index += chunk) {
-    // 		const last_index = Math.min(start_index + chunk, size) - 1;
-    // 		tasks.push(fetchChunk(start_index, last_index));
-    // 	  }
-    // 	  const resultChunks = await Promise.all(tasks);
-    // 	  const result = Buffer.concat(resultChunks);
-    // 	  if (callback) {
-    // 		await callback(size, result.length);
-    // 	  }
-    // 	  return result;
-    // 	} else {
-    // 	  let result = Buffer.alloc(0);
-    // 	  let start_index = 0;
-    // 	  while (start_index < size) {
-    // 		const last_index = Math.min(start_index + chunk, size) - 1;
-    // 		const data = await fetchChunk(start_index, last_index);
-    // 		if (data.length === 0) break;
-    // 		result = Buffer.concat([result, data]);
-    // 		start_index = last_index + 1;
-    // 		if (callback) {
-    // 		  await callback(size, result.length);
-    // 		}
-    // 	  }
-    // 	  return result;
-    // 	}
-    //   }
-    /**
-     * Delay utility
-     */
-    delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    /**
-     * Resolves platform configuration based on input
-     */
-    resolvePlatform(platform) {
-        const isAndroid = platform?.toLowerCase() === 'android';
-        return {
-            app_name: 'Main',
-            app_version: isAndroid ? '3.6.4' : '4.4.9',
-            platform: isAndroid ? 'Android' : 'Web',
-            package: isAndroid ? 'app.rbmain.a' : 'web.rubika.ir',
-            lang_code: 'fa',
-        };
-    }
-    /**
-     * Builds HTTP headers based on platform
-     */
-    buildHeaders(platform) {
-        const headers = {
-            'content-type': 'application/json',
-            connection: 'keep-alive',
-            'user-agent': new user_agents_1.default().toString(),
-        };
-        if (platform.toLowerCase() !== 'android') {
-            headers.origin = 'https://web.rubika.ir';
-            headers.referer = 'https://web.rubika.ir/';
-        }
-        return headers;
-    }
-}
-exports.default = Network;

package/lib/types/session.type.d.ts

@@ -1,7 +0,0 @@
-export interface SessionData {
-    phone: string;
-    auth: string;
-    guid: string;
-    agent: string;
-    private_key: string;
-}