rubjs 2.9.3 → 3.0.1

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/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/api.d.ts

@@ -0,0 +1,16 @@
+import Network from '.';
+interface SendPayloadInputs {
+    input?: Record<string, any>;
+    method?: string;
+    tmp_session: boolean;
+}
+/**
+ * Retrieves API and WSS server URLs
+ */
+export declare function getDcs(network: Network): Promise<boolean>;
+/**
+ * Sends a POST request with retry logic and enhanced error reporting
+ */
+export declare function sendRequest(network: Network, url: string, data: any): Promise<unknown>;
+export declare function sendPayload(network: Network, datas: SendPayloadInputs): Promise<any>;
+export {};

package/lib/core/network/api.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDcs = getDcs;
+exports.sendRequest = sendRequest;
+exports.sendPayload = sendPayload;
+const undici_1 = require("undici");
+const crypto_1 = __importDefault(require("../crypto"));
+/**
+ * Retrieves API and WSS server URLs
+ */
+async function getDcs(network) {
+    const url = 'https://getdcmess.iranlms.ir/';
+    const RETRY_DELAY = 3000;
+    while (true) {
+        try {
+            const res = await (0, undici_1.request)(url, {
+                method: 'GET',
+                dispatcher: network.agent,
+            });
+            if (res.statusCode === 200) {
+                const body = (await res.body.json());
+                if (body?.data) {
+                    const dcs = body.data;
+                    network.apiUrl = `${dcs.API[dcs.default_api]}/`;
+                    network.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 network.delay(RETRY_DELAY);
+    }
+}
+/**
+ * Sends a POST request with retry logic and enhanced error reporting
+ */
+async function sendRequest(network, 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',
+                    ...network.headers,
+                },
+                body: JSON.stringify(data),
+                dispatcher: network.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 network.delay(1000);
+    }
+    throw new Error(`[request] Failed after ${MAX_ATTEMPTS} attempts: ${url}`);
+}
+async function sendPayload(network, datas) {
+    await network.getDcs();
+    while (!network.apiUrl) {
+        await network.delay(1000);
+    }
+    const { auth, decode_auth, key, privateKey } = network.client;
+    if (!key)
+        return;
+    const credentialsKey = datas.tmp_session ? 'tmp_session' : 'auth';
+    const credentialsValue = datas.tmp_session ? auth : decode_auth;
+    const dataPayload = JSON.stringify({
+        client: network.defaultPlatform,
+        method: datas.method,
+        input: datas.input,
+    });
+    const payload = {
+        api_version: '6',
+        data_enc: crypto_1.default.encrypt(dataPayload, key),
+        [credentialsKey]: credentialsValue,
+    };
+    if (!datas.tmp_session && privateKey) {
+        payload.sign = crypto_1.default.sign(payload.data_enc, privateKey);
+    }
+    return network.request(network.apiUrl, payload);
+}

package/lib/core/network/file.d.ts

@@ -0,0 +1,3 @@
+import Network from '.';
+export declare function uploadFile(network: Network, filePath: string, chunkSize?: number): Promise<any>;
+export declare function download(network: Network, dc_id: number, file_id: number, access_hash: string, size: number, chunk?: number): Promise<Buffer>;

package/lib/core/network/file.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFile = uploadFile;
+exports.download = download;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const undici_1 = require("undici");
+async function uploadFile(network, 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 network.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: network.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: network.agent,
+            });
+            const response = await res.body.json();
+            if (response.status === 'ERROR_TRY_AGAIN') {
+                console.log('Retrying upload...');
+                stream.close();
+                result = await network.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 uploadFile(network, 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 function download(network, dc_id, file_id, access_hash, size, chunk = 131072) {
+    const headersBase = {
+        auth: network.client.auth,
+        'access-hash-rec': access_hash,
+        'file-id': String(file_id),
+        'user-agent': network.userAgent,
+    };
+    const base_url = `https://messenger${dc_id}.iranlms.ir`;
+    const fetchChunk = async (start_index, last_index) => {
+        const headers = {
+            ...headersBase,
+            'start-index': String(start_index),
+            'last-index': String(last_index),
+        };
+        try {
+            const { body, statusCode } = await (0, undici_1.request)(`${base_url}/GetFile.ashx`, {
+                method: 'POST',
+                headers,
+            });
+            if (statusCode !== 200 || !body)
+                return Buffer.alloc(0);
+            const chunks = [];
+            for await (const chunk of body) {
+                chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+            }
+            return Buffer.concat(chunks);
+        }
+        catch (err) {
+            console.error(`[fetchChunk] Failed at ${start_index}-${last_index}`, err);
+            return Buffer.alloc(0);
+        }
+    };
+    let result = Buffer.alloc(0);
+    let start_index = 0;
+    while (start_index < size) {
+        const last_index = Math.min(start_index + chunk, size) - 1;
+        const chunkData = await fetchChunk(start_index, last_index);
+        if (chunkData.length === 0)
+            break;
+        result = Buffer.concat([result, chunkData]);
+        start_index = last_index + 1;
+    }
+    return result;
+}

package/lib/core/network/index.d.ts

@@ -0,0 +1,25 @@
+import Client from '../client';
+import { Agent, WebSocket as UndiciWebSocket } from 'undici';
+import { delay } from './utils';
+import { NetworkTypes } from '../../types/index.type';
+export default class Network {
+    client: Client;
+    headers: Record<string, string>;
+    defaultPlatform: NetworkTypes.Platform;
+    agent: Agent;
+    userAgent: string;
+    ws?: InstanceType<typeof UndiciWebSocket>;
+    apiUrl?: string;
+    wssUrl?: string;
+    heartbeatInterval?: NodeJS.Timeout;
+    inactivityTimeout?: NodeJS.Timeout;
+    reconnecting: boolean;
+    constructor(client: Client);
+    getDcs: () => Promise<boolean>;
+    request: (url: string, data: any) => Promise<unknown>;
+    send: (opts: any) => Promise<any>;
+    getUpdates: () => Promise<void>;
+    uploadFile: (filePath: string, chunkSize?: number) => Promise<any>;
+    download: (dc_id: number, file_id: number, access_hash: string, size: number, chunk?: number) => Promise<Buffer<ArrayBufferLike>>;
+    delay: typeof delay;
+}

package/lib/core/network/index.js

@@ -0,0 +1,31 @@
+"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 utils_1 = require("./utils");
+const api_1 = require("./api");
+const websocket_1 = require("./websocket");
+const user_agents_1 = __importDefault(require("user-agents"));
+const file_1 = require("./file");
+class Network {
+    constructor(client) {
+        this.client = client;
+        this.userAgent = new user_agents_1.default().toString();
+        this.reconnecting = false;
+        this.getDcs = () => (0, api_1.getDcs)(this);
+        this.request = (url, data) => (0, api_1.sendRequest)(this, url, data);
+        this.send = (opts) => (0, api_1.sendPayload)(this, opts);
+        this.getUpdates = async () => (0, websocket_1.setupWebSocket)(this);
+        this.uploadFile = (filePath, chunkSize) => (0, file_1.uploadFile)(this, filePath, chunkSize);
+        this.download = (dc_id, file_id, access_hash, size, chunk = 131072) => (0, file_1.download)(this, dc_id, file_id, access_hash, size, chunk);
+        this.delay = utils_1.delay;
+        this.defaultPlatform = (0, utils_1.resolvePlatform)(client.platform);
+        this.headers = (0, utils_1.buildHeaders)(client.platform);
+        this.agent = new undici_1.Agent({
+            connect: { rejectUnauthorized: false },
+        });
+    }
+}
+exports.default = Network;

package/lib/core/network/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function delay(ms: number): Promise<unknown>;
+export declare function resolvePlatform(platform: string): {
+    app_name: string;
+    app_version: string;
+    platform: string;
+    package: string;
+    lang_code: string;
+};
+export declare function buildHeaders(platform: string): Record<string, string>;

package/lib/core/network/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+exports.resolvePlatform = resolvePlatform;
+exports.buildHeaders = buildHeaders;
+const user_agents_1 = __importDefault(require("user-agents"));
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function 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',
+    };
+}
+function 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;
+}

package/lib/core/network/websocket.d.ts

@@ -0,0 +1,3 @@
+import Network from '.';
+export declare function setupWebSocket(network: Network): Promise<void>;
+export declare function openSocket(network: Network): Promise<void>;

package/lib/core/network/websocket.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWebSocket = setupWebSocket;
+exports.openSocket = openSocket;
+const crypto_1 = __importDefault(require("../crypto"));
+const undici_1 = require("undici");
+const contextConstructors_1 = require("../context/contextConstructors");
+const TYPES = {
+    chat: 'chat_updates',
+    message: 'message_updates',
+    activities: 'show_activities',
+    notifications: 'show_notifications',
+};
+async function setupWebSocket(network) {
+    while (!network.wssUrl) {
+        await network.delay(1000);
+    }
+    network.ws = new undici_1.WebSocket(network.wssUrl);
+    network.ws.addEventListener('open', async () => await openSocket(network));
+    network.ws.addEventListener('message', async (event) => await getMessage(event.data, network));
+    network.ws.addEventListener('error', async () => {
+        if (!network.reconnecting) {
+            console.error('WebSocket error, reconnecting...');
+            network.reconnecting = true;
+            await resetConnection(network);
+        }
+    });
+    network.ws.addEventListener('close', async () => {
+        if (!network.reconnecting) {
+            console.warn('WebSocket closed, reconnecting...');
+            network.reconnecting = true;
+            await resetConnection(network);
+        }
+    });
+}
+async function openSocket(network) {
+    try {
+        console.log('Starting bot...');
+        if (network.ws && network.ws.readyState === undici_1.WebSocket.OPEN) {
+            const payload = JSON.stringify({
+                api_version: '5',
+                auth: network.client.auth,
+                data: '',
+                method: 'handShake',
+            });
+            network.ws.send(payload);
+            if (network.heartbeatInterval)
+                clearInterval(network.heartbeatInterval);
+            network.heartbeatInterval = setInterval(() => {
+                try {
+                    if (network.ws?.readyState === undici_1.WebSocket.OPEN) {
+                        network.ws.send(JSON.stringify({}));
+                    }
+                }
+                catch (err) {
+                    console.error('Error sending heartbeat', err);
+                }
+            }, 30000);
+        }
+        else {
+            console.warn('WebSocket is not open; cannot send handshake');
+        }
+    }
+    catch (err) {
+        console.error('Error during openSocket execution', err);
+    }
+}
+async function resetConnection(network) {
+    network.ws?.close();
+    network.ws = undefined;
+    setTimeout(async () => {
+        try {
+            await network.getUpdates();
+        }
+        catch (e) {
+            console.error('Failed to reconnect:', e);
+        }
+        finally {
+            network.reconnecting = false;
+        }
+    }, 5000);
+}
+function resetInactivityTimer(network) {
+    if (network.inactivityTimeout)
+        clearTimeout(network.inactivityTimeout);
+    network.inactivityTimeout = setTimeout(() => {
+        console.warn('No updates received for 10 minutes. Reconnecting WebSocket...');
+        void resetConnection(network).catch((err) => {
+            console.error('Error during inactivity reset:', err);
+        });
+    }, 10 * 60 * 1000);
+}
+async function getMessage(message, network) {
+    try {
+        const { data_enc } = JSON.parse(message);
+        if (!data_enc || !network.client.key)
+            return;
+        resetInactivityTimer(network);
+        const update = JSON.parse(crypto_1.default.decrypt(data_enc, network.client.key));
+        const tasks = [];
+        for (const ctxKey of Object.keys(TYPES)) {
+            const updateKey = TYPES[ctxKey];
+            const author_title = getAuthorTitle(update);
+            const items = update[updateKey];
+            if (!Array.isArray(items) || items.length === 0)
+                continue;
+            const handlers = network.client.handlers[ctxKey];
+            if (!handlers || handlers.length === 0)
+                continue;
+            tasks.push(handleCategory(ctxKey, handlers, items, network, author_title));
+        }
+        if (tasks.length === 1) {
+            await tasks[0];
+        }
+        else if (tasks.length > 1) {
+            await Promise.all(tasks);
+        }
+    }
+    catch (err) {
+        console.error('[getMessage] Failed to decrypt or process message:', err);
+    }
+}
+async function handleCategory(type, handlers, updates, network, author_title) {
+    const CtxClass = contextConstructors_1.ContextConstructors[type];
+    if (!CtxClass) {
+        console.warn(`[handleCategory] No constructor found for type: ${type}`);
+        return;
+    }
+    for (let update of updates) {
+        if (!update.message)
+            update.message = {};
+        update.client_guid = network.client.userGuid;
+        update.message.author_title = author_title;
+        const ctx = new CtxClass(network.client, update);
+        for (const { filters, handler, prefix } of handlers) {
+            // Prefix logic
+            if (type === 'message' && prefix) {
+                const text = ctx.message.text;
+                if (!text)
+                    continue;
+                if (typeof prefix === 'string' && text !== prefix)
+                    continue;
+                if (prefix instanceof RegExp && !prefix.test(text))
+                    continue;
+            }
+            // filters
+            const passed = await checkFilters(ctx, filters);
+            if (passed) {
+                await handler(ctx);
+            }
+        }
+    }
+}
+// utils
+async function checkFilters(ctx, filters) {
+    for (const filter of filters) {
+        if (Array.isArray(filter)) {
+            // OR logic
+            const results = await Promise.all(filter.map((f) => Promise.resolve(f(ctx))));
+            if (!results.some(Boolean))
+                return false;
+        }
+        else {
+            // AND logic
+            const result = await Promise.resolve(filter(ctx));
+            if (!result)
+                return false;
+        }
+    }
+    return true;
+}
+const getAuthorTitle = (update) => {
+    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'))
+            return notification.title;
+        else if (objectGuid?.startsWith('g0'))
+            return notification.text?.split(':')[0];
+    }
+    else if (chatUpdate) {
+        return chatUpdate.chat?.last_message?.author_title || 'Unknown User';
+    }
+    else
+        return 'Unknown User';
+};

package/lib/core/session.d.ts

@@ -0,0 +1,12 @@
+import { ClientTypes, SessionTypes } from '../types/index.type';
+declare class SessionManager {
+    private readonly secretKey;
+    private readonly filename;
+    private sessionData?;
+    constructor(input: string | ClientTypes.SessionType, secret?: string);
+    private encrypt;
+    private decrypt;
+    saveSession(sessionData: SessionTypes.SessionData): void;
+    getSession(): SessionTypes.SessionData | null;
+}
+export default SessionManager;