rubjs 2.9.2 → 3.0.0

package/lib/core/methods/utilities/thumbnail.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const optional_require_1 = require("optional-require");
+const sharp = (0, optional_require_1.optionalRequire)('sharp', { default: true });
+const ffmpeg = (0, optional_require_1.optionalRequire)('fluent-ffmpeg', { default: true });
+class ThumbnailGenerator {
+    static async getTime(videoPath) {
+        if (!ffmpeg) {
+            throw new Error('fluent-ffmpeg module is not installed. Some features may be disabled.');
+        }
+        return new Promise((resolve, reject) => {
+            ffmpeg.ffprobe(videoPath, (err, metadata) => {
+                if (err) {
+                    console.error('Error fetching metadata:', err);
+                    reject(err);
+                    return;
+                }
+                resolve(metadata.format.duration);
+            });
+        });
+    }
+    static async fromVideo(videoPath) {
+        if (!ffmpeg) {
+            throw new Error('fluent-ffmpeg module is not installed. Some features may be disabled.');
+        }
+        const tempImagePath = path_1.default.join(os_1.default.tmpdir(), `thumbnail_${Date.now()}.png`);
+        try {
+            await new Promise((resolve, reject) => {
+                ffmpeg(videoPath)
+                    .on('end', () => resolve(undefined))
+                    .on('error', reject)
+                    .screenshots({
+                    count: 1,
+                    timemarks: ['00:00:00.000'],
+                    filename: path_1.default.basename(tempImagePath),
+                    folder: path_1.default.dirname(tempImagePath),
+                    size: '400x?',
+                });
+            });
+            const thumbnailBuffer = await promises_1.default.readFile(tempImagePath);
+            const base64Thumbnail = thumbnailBuffer.toString('base64');
+            await promises_1.default.unlink(tempImagePath);
+            return base64Thumbnail;
+        }
+        catch (error) {
+            console.error('Error generating video thumbnail:', error);
+            throw error;
+        }
+    }
+    static async fromImage(imagePath, width = 320) {
+        if (!sharp) {
+            throw new Error('sharp module is not installed. Some features may be disabled.');
+        }
+        try {
+            const buffer = await sharp(imagePath).resize(width).toBuffer();
+            return buffer.toString('base64');
+        }
+        catch (error) {
+            console.error('Error generating image thumbnail:', error);
+            throw error;
+        }
+    }
+}
+exports.default = ThumbnailGenerator;

package/lib/core/methods/utilities/useError.d.ts

@@ -0,0 +1,4 @@
+import { ClientTypes } from "../../../types/index.type";
+import Client from "../../client";
+declare function useError(this: Client, mw: ClientTypes.ErrorMiddleware): Promise<void>;
+export default useError;

package/lib/core/methods/utilities/useError.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function useError(mw) {
+    this.errorMiddlewares.push(mw);
+}
+exports.default = useError;

package/lib/core/methods/utilities/usePlugin.d.ts

@@ -0,0 +1,4 @@
+import { ClientTypes } from '../../../types/index.type';
+import Client from '../../client';
+declare function usePlugin(this: Client, plugin: ClientTypes.RubPlugin): Promise<void>;
+export default usePlugin;

package/lib/core/methods/utilities/usePlugin.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function usePlugin(plugin) {
+    const existingIndex = this.plugins.findIndex((p) => p.name === plugin.name);
+    if (existingIndex !== -1) {
+        const existing = this.plugins[existingIndex];
+        if (existing.version &&
+            plugin.version &&
+            existing.version === plugin.version) {
+            console.warn(`[usePlugin] Plugin "${plugin.name}" version ${plugin.version} is already registered.`);
+            return;
+        }
+        console.log(`[usePlugin] Replacing plugin "${plugin.name}" version ${existing.version ?? 'unknown'} with version ${plugin.version ?? 'unknown'}.`);
+        this.plugins.splice(existingIndex, 1);
+    }
+    try {
+        await plugin.run(this);
+        this.plugins.push(plugin);
+        console.log(`[usePlugin] Plugin "${plugin.name}" version ${plugin.version ?? 'unknown'} loaded successfully.`);
+    }
+    catch (error) {
+        console.error(`[usePlugin] Failed to run plugin "${plugin.name}":`, error);
+    }
+}
+exports.default = usePlugin;

package/lib/core/network.d.ts

@@ -0,0 +1,49 @@
+import { NetworkTypes } from '../types/index.type';
+import Client from './client';
+export default class Network {
+    private client;
+    headers: Record<string, string>;
+    userAgent: string;
+    defaultPlatform: NetworkTypes.Platform;
+    private apiVersion;
+    private agent;
+    private apiUrl?;
+    private wssUrl?;
+    private ws?;
+    private heartbeatInterval?;
+    private inactivityTimeout?;
+    private reconnecting;
+    constructor(client: Client);
+    /**
+     * Retrieves API and WSS server URLs
+     */
+    getDcs(): Promise<boolean>;
+    /**
+     * Sends a POST request with retry logic and enhanced error reporting
+     */
+    request(url: string, data: Record<string, any>): Promise<any>;
+    send({ input, method, tmp_session, }: {
+        input?: Record<string, any>;
+        method?: string;
+        tmp_session: boolean;
+    }): Promise<any>;
+    getUpdates(): Promise<void>;
+    handleConnect(): Promise<void>;
+    handleMessage(message: string): Promise<void>;
+    private runMiddlewareChain;
+    resetConnection(): Promise<void>;
+    private resetInactivityTimer;
+    uploadFile(filePath: string, chunkSize?: number): Promise<any>;
+    /**
+     * Delay utility
+     */
+    delay(ms: number): Promise<void>;
+    /**
+     * Resolves platform configuration based on input
+     */
+    private resolvePlatform;
+    /**
+     * Builds HTTP headers based on platform
+     */
+    private buildHeaders;
+}

package/lib/core/network.js

@@ -0,0 +1,436 @@
+"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/core/network_login.d.ts

@@ -0,0 +1,47 @@
+interface PlatformInfo {
+    app_name: string;
+    app_version: string;
+    platform: string;
+    package: string;
+    lang_code: string;
+}
+interface AuthInfo {
+    auth?: string;
+    decode_auth?: string;
+    key?: Buffer;
+    privateKey?: string;
+}
+interface SendOptions {
+    input?: Record<string, any>;
+    method?: string;
+    tmp_session?: boolean;
+}
+interface ServerResponse {
+    data_enc?: string;
+    status?: string;
+    status_det?: string;
+    data?: Record<string, any>;
+}
+declare class Network {
+    private headers;
+    private agent;
+    private apiUrl;
+    defaultPlatform: PlatformInfo;
+    userAgent: string;
+    constructor();
+    /**
+     * Retrieves API and WSS server URLs
+     */
+    getDcs(): Promise<boolean>;
+    /**
+     * Sends a POST request with retry logic and enhanced error reporting
+     */
+    request(url: string, data: Record<string, any>): Promise<any>;
+    send({ input, method, tmp_session }: SendOptions, { auth, decode_auth, key, privateKey }: AuthInfo): Promise<ServerResponse | undefined>;
+    bulder(name: string, input: Record<string, any>, { auth, key, decode_auth, privateKey }: AuthInfo, tmp_session?: boolean): Promise<Record<string, any> | undefined>;
+    /**
+     * Delay utility
+     */
+    delay(ms: number): Promise<void>;
+}
+export default Network;