rubjs 2.4.1 → 2.5.4

package/rubjs/network/index.js

@@ -0,0 +1,347 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const ws_1 = __importDefault(require("ws"));
+const crypto_1 = __importDefault(require("../crypto"));
+const https_1 = __importDefault(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("../types");
+class Network {
+    constructor(client) {
+        this.heartbeatInterval = null;
+        this.Headers = {
+            origin: "https://web.rubika.ir",
+            referer: "https://web.rubika.ir/",
+            "content-type": "application/json",
+            connection: "keep-alive",
+        };
+        this.client = client;
+        this.Headers["user-agent"] = this.client.userAgent;
+        if (this.client.defaultPlatform.platform === "Android") {
+            delete this.Headers.origin;
+            delete this.Headers.referer;
+            this.Headers["user-agent"] = "okhttp/3.12.1";
+        }
+        this.agent = new https_1.default.Agent({ rejectUnauthorized: false });
+        const axiosConfig = {
+            headers: this.Headers,
+            timeout: this.client.timeout || 10000,
+            httpsAgent: this.agent,
+        };
+        this.session = axios_1.default.create(axiosConfig);
+        this.apiUrl = null;
+        this.wssUrl = null;
+        this.ws = null;
+    }
+    getDcs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (true) {
+                try {
+                    const response = yield axios_1.default.get("https://getdcmess.iranlms.ir/", {
+                        httpsAgent: this.agent,
+                    });
+                    if (response.status === 200) {
+                        const data = response.data.data;
+                        this.apiUrl = data.API[data.default_api] + "/";
+                        this.wssUrl = data.socket[data.default_socket];
+                        return true;
+                    }
+                }
+                catch (_a) {
+                    console.error("Error while fetching dcs");
+                    continue;
+                }
+            }
+        });
+    }
+    request(url, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < 3; i++) {
+                try {
+                    const response = yield this.session.post(url, data);
+                    if (response.status === 200) {
+                        return response.data;
+                    }
+                }
+                catch (error) {
+                    console.error("Error in request ");
+                    continue;
+                }
+            }
+            throw new Error("Failed to get response after 3 attempts");
+        });
+    }
+    send(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ input = {}, method = "getUserInfo", tmp_session, }) {
+            let api_version = this.client.apiVersion;
+            let auth = this.client.auth;
+            let client = this.client.defaultPlatform;
+            if (!this.apiUrl)
+                yield this.getDcs();
+            let url = this.apiUrl;
+            let data = { api_version };
+            data[tmp_session ? "tmp_session" : "auth"] = tmp_session
+                ? auth
+                : this.client.decode_auth;
+            if (api_version === "6") {
+                const data_enc = JSON.stringify({
+                    client,
+                    method,
+                    input,
+                });
+                data["data_enc"] = crypto_1.default.encrypt(data_enc, this.client.key);
+                if (!tmp_session) {
+                    data["sign"] = crypto_1.default.sign(data["data_enc"], this.client.privateKey);
+                }
+                return yield this.request(url, data);
+            }
+        });
+    }
+    getUpdates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.wssUrl)
+                yield this.getDcs();
+            this.ws = new ws_1.default(this.wssUrl);
+            this.ws.on("open", () => __awaiter(this, void 0, void 0, function* () { return yield this.handleConnect(); }));
+            this.ws.on("message", (message) => __awaiter(this, void 0, void 0, function* () { return yield this.handleMessage(message); }));
+            this.ws.on("error", () => __awaiter(this, void 0, void 0, function* () { return yield this.resetConnection(); }));
+        });
+    }
+    handleConnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Start Bot..");
+            const handshakeRequest = {
+                api_version: "5",
+                auth: this.client.auth,
+                data: "",
+                method: "handShake",
+            };
+            this.ws.send(JSON.stringify(handshakeRequest));
+            if (this.heartbeatInterval) {
+                clearInterval(this.heartbeatInterval);
+            }
+            this.heartbeatInterval = setInterval(() => {
+                if (this.ws.readyState === ws_1.default.OPEN) {
+                    this.ws.send(JSON.stringify({}));
+                }
+            }, 30 * 1000);
+        });
+    }
+    resetConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            setTimeout(() => this.getUpdates(), 5000);
+        });
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data_enc } = JSON.parse(message);
+                if (!data_enc)
+                    return;
+                const update = JSON.parse(crypto_1.default.decrypt(data_enc, this.client.key));
+                this.client.eventHandlers.forEach((_a) => __awaiter(this, [_a], void 0, function* ({ callback, filters = [], updateType }) {
+                    var _b;
+                    const messageData = (_b = update[updateType]) === null || _b === void 0 ? void 0 : _b[0];
+                    if (!messageData)
+                        return;
+                    const isValid = filters.length === 0 ||
+                        filters.every((filter) => {
+                            if (typeof filter === "function")
+                                return filter(messageData);
+                            for (let filterCriteria of filter) {
+                                let isMatch = filterCriteria(messageData);
+                                if (isMatch === true)
+                                    return true;
+                            }
+                            return false;
+                        });
+                    const dataMessage = new types_1.Message(this.client, messageData);
+                    if (isValid) {
+                        yield callback(dataMessage);
+                    }
+                }));
+            }
+            catch (error) {
+                console.error("Error in handleMessage:", error);
+            }
+        });
+    }
+    uploadFile(file_1) {
+        return __awaiter(this, arguments, void 0, function* (file, mime = null, fileName = null, chunk = 1048576, callback = null) {
+            var _a;
+            if (typeof file === "string") {
+                if (!fs.existsSync(file))
+                    throw new Error("File not found in the given path");
+                if (!fileName)
+                    fileName = path.basename(file);
+                file = yield fs.promises.readFile(file);
+            }
+            else if (!Buffer.isBuffer(file))
+                throw new TypeError("File argument must be a file path or bytes");
+            if (!fileName)
+                throw new Error("File name is not set");
+            if (!mime)
+                mime = fileName.split(".").pop() || "application/octet-stream";
+            let result = yield this.client.requestSendFile(fileName, file.length, mime);
+            let response;
+            let id = result.id;
+            let index = 0;
+            let dc_id = result.dc_id;
+            let total = Math.ceil(file.length / chunk);
+            let upload_url = result.upload_url;
+            let access_hash_send = result.access_hash_send;
+            while (index < total) {
+                let data = file.slice(index * chunk, index * chunk + chunk);
+                try {
+                    response = yield this.session.post(upload_url, data, {
+                        headers: {
+                            auth: this.client.auth,
+                            "file-id": id,
+                            "total-part": total.toString(),
+                            "part-number": (index + 1).toString(),
+                            "chunk-size": data.length.toString(),
+                            "access-hash-send": access_hash_send,
+                        },
+                    });
+                    if (response.data.status === "ERROR_TRY_AGAIN") {
+                        console.log("Retrying upload...");
+                        result = yield this.client.requestSendFile(fileName, file.length, mime);
+                        id = result.id;
+                        index = 0;
+                        dc_id = result.dc_id;
+                        total = Math.ceil(file.length / chunk);
+                        upload_url = result.upload_url;
+                        access_hash_send = result.access_hash_send;
+                        continue;
+                    }
+                    if (callback) {
+                        try {
+                            callback(file.length, index * chunk);
+                        }
+                        catch (err) {
+                            console.error("Callback error:", err);
+                        }
+                    }
+                    index++;
+                }
+                catch (error) {
+                    console.error("Upload error:", error);
+                    yield new Promise((resolve) => setTimeout(resolve, 5000));
+                }
+                if (response.data.status === "OK" && response.data.status_det === "OK") {
+                    if (!((_a = response.data.data) === null || _a === void 0 ? void 0 : _a.access_hash_rec))
+                        throw new Error("Error in upload file!!");
+                    return {
+                        mime,
+                        size: file.length,
+                        dc_id,
+                        file_id: id,
+                        file_name: fileName,
+                        access_hash_rec: response.data.data.access_hash_rec,
+                    };
+                }
+                throw new Error(response.data.status_det);
+            }
+        });
+    }
+    download(dc_id_1, file_id_1, access_hash_1, size_1) {
+        return __awaiter(this, arguments, void 0, function* (dc_id, file_id, access_hash, size, chunk = 131072, callback, speed = false) {
+            const headers = {
+                auth: this.client.auth,
+                "access-hash-rec": access_hash,
+                "file-id": String(file_id),
+                "user-agent": this.client.userAgent,
+            };
+            const base_url = `https://messenger${dc_id}.iranlms.ir`;
+            const fetchChunk = (start_index, last_index) => __awaiter(this, void 0, void 0, function* () {
+                const chunk_headers = Object.assign(Object.assign({}, headers), { "start-index": String(start_index), "last-index": String(last_index) });
+                try {
+                    const config = {
+                        headers: chunk_headers,
+                    };
+                    const response = yield axios_1.default.post(`${base_url}/GetFile.ashx`, {}, config);
+                    return Buffer.from(response.data);
+                }
+                catch (e) {
+                    return Buffer.alloc(0);
+                }
+            });
+            if (speed) {
+                const tasks = [];
+                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 = yield Promise.all(tasks);
+                const result = Buffer.concat(resultChunks);
+                if (callback) {
+                    yield 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 = yield fetchChunk(start_index, last_index);
+                    if (data.length === 0)
+                        break;
+                    result = Buffer.concat([result, data]);
+                    start_index = last_index + 1;
+                    if (callback) {
+                        yield callback(size, result.length);
+                    }
+                }
+                return result;
+            }
+        });
+    }
+}
+exports.default = Network;

package/rubjs/parser/index.d.ts

@@ -0,0 +1,25 @@
+type MarkdownEntity = {
+    type: string;
+    from_index: number;
+    length: number;
+    language?: string;
+    mention_text_object_guid?: string;
+    mention_text_object_type?: string;
+    link?: {
+        type: string;
+        hyperlink_data: {
+            url: string;
+        };
+    };
+};
+declare class Markdown {
+    static markdownRegExp: RegExp;
+    static markdownEntities: Record<string, string>;
+    static toMetadata(text: string): {
+        text: string;
+        metadata?: {
+            meta_data_parts: MarkdownEntity[];
+        };
+    };
+}
+export default Markdown;

package/rubjs/parser/index.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Markdown {
+    static toMetadata(text) {
+        let entities = [];
+        let match;
+        let remainingText = text;
+        let parsedTextParts = [];
+        let offset = 0;
+        while ((match = remainingText.match(this.markdownRegExp))) {
+            const matchIndex = offset + (match.index || 0);
+            parsedTextParts.push(remainingText.substring(0, match.index));
+            let matchedContent = match[3] || match[8] || match[11] || match[13];
+            if (matchedContent) {
+                offset -= matchedContent.length;
+                matchedContent = matchedContent.trim();
+                offset += matchedContent.length;
+                if (/^`*$/.test(matchedContent)) {
+                    parsedTextParts.push(match[0]);
+                }
+                else if (match[3]) {
+                    if (match[5] === "\n") {
+                        match[5] = "";
+                        offset -= 1;
+                    }
+                    parsedTextParts.push(match[1] + matchedContent + match[5]);
+                    entities.push({
+                        type: "Pre",
+                        language: "",
+                        from_index: matchIndex + match[1].length,
+                        length: matchedContent.length,
+                    });
+                    offset -= match[2].length + match[4].length;
+                }
+                else if (match[7]) {
+                    parsedTextParts.push(match[6] + matchedContent + match[9]);
+                    entities.push({
+                        type: this.markdownEntities[match[7]],
+                        from_index: matchIndex + match[6].length,
+                        length: matchedContent.length,
+                    });
+                    offset -= 2 * match[7].length;
+                }
+                else if (match[11]) {
+                    parsedTextParts.push(matchedContent);
+                    entities.push({
+                        type: "MentionText",
+                        mention_text_object_guid: match[10],
+                        from_index: matchIndex,
+                        length: matchedContent.length,
+                        mention_text_object_type: "User",
+                    });
+                    offset -= match[0].length - matchedContent.length;
+                }
+                else if (match[12]) {
+                    const [label, url] = [match[12], match[13]];
+                    let mentionType;
+                    if (url.length === 32) {
+                        if (url.startsWith("u"))
+                            mentionType = "User";
+                        else if (url.startsWith("g"))
+                            mentionType = "Group";
+                        else if (url.startsWith("c"))
+                            mentionType = "Channel";
+                    }
+                    parsedTextParts.push(label);
+                    const metaDataPart = {
+                        type: mentionType ? "MentionText" : "Link",
+                        from_index: matchIndex,
+                        length: label.length,
+                    };
+                    if (mentionType) {
+                        metaDataPart.mention_text_object_guid = url;
+                        metaDataPart.mention_text_object_type = mentionType;
+                    }
+                    else {
+                        metaDataPart.link = { type: "hyperlink", hyperlink_data: { url } };
+                    }
+                    entities.push(metaDataPart);
+                    offset -= match[0].length - label.length;
+                }
+                remainingText = remainingText.substring(match.index + match[0].length);
+                offset += match.index + match[0].length;
+            }
+        }
+        parsedTextParts.push(remainingText);
+        let resultText = parsedTextParts.join("");
+        if (!resultText.replace(/\s+/g, "").length) {
+            resultText = text;
+            entities.splice(0, entities.length);
+        }
+        if (!entities.length) {
+            resultText = resultText.trim();
+        }
+        let returnData = {
+            text: resultText,
+        };
+        if (entities.length > 0)
+            returnData.metadata = { meta_data_parts: entities };
+        return returnData;
+    }
+}
+Markdown.markdownRegExp = /(^|\s|\n)(````?)([\s\S]+?)(````?)([\s\n\.,:?!;]|$)|(^|\s)(`|\*\*|__|~~|--|\|\||\^\^)([^\n]+?)\7([\s\.,:?!;]|$)|@([a-zA-Z0-9]+)\s*\((.+?)\)|\[(.+?)\]\((.+?)\)/m;
+Markdown.markdownEntities = {
+    "`": "Mono",
+    "**": "Bold",
+    __: "Italic",
+    "||": "Spoiler",
+    "~~": "Strike",
+    "--": "Underline",
+    "^^": "Quote",
+};
+exports.default = Markdown;

package/rubjs/session/index.d.ts

@@ -0,0 +1,18 @@
+interface SessionData {
+    phone: string;
+    auth: string;
+    guid: string;
+    agent: string;
+    private_key: string;
+}
+declare class SQLiteSession {
+    private dbFile;
+    private db;
+    constructor(sessionName: string);
+    private handleError;
+    private initializeDB;
+    getSession(): SessionData | null;
+    saveSession(phone: string, auth: string, guid: string, agent: string, privateKey: string): void;
+    closeDB(): void;
+}
+export default SQLiteSession;

package/rubjs/session/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+class SQLiteSession {
+    constructor(sessionName) {
+        this.dbFile = sessionName.endsWith(".rp") ? sessionName : `${sessionName}.rp`;
+        this.db = new better_sqlite3_1.default(this.dbFile);
+        this.initializeDB();
+    }
+    handleError(operation, callback) {
+        try {
+            return callback();
+        }
+        catch (error) {
+            console.error(`Error in ${operation}:`, error);
+            throw new Error(`Failed to execute ${operation}`);
+        }
+    }
+    initializeDB() {
+        this.handleError("initializeDB", () => {
+            this.db.pragma("journal_mode = DELETE");
+            const sessionTable = this.db
+                .prepare("SELECT name FROM sqlite_master WHERE type=? AND name=?")
+                .get("table", "session");
+            if (!sessionTable) {
+                this.db.prepare(`CREATE TABLE session (
+            phone TEXT PRIMARY KEY, 
+            auth TEXT, 
+            guid TEXT, 
+            agent TEXT, 
+            private_key TEXT
+          )`).run();
+            }
+        });
+    }
+    getSession() {
+        return this.handleError("getSession", () => {
+            const result = this.db.prepare("SELECT * FROM session").get();
+            return result ? result : null;
+        });
+    }
+    saveSession(phone, auth, guid, agent, privateKey) {
+        this.handleError("saveSession", () => {
+            this.db.prepare(`INSERT OR REPLACE INTO session (phone, auth, guid, agent, private_key) 
+         VALUES (?, ?, ?, ?, ?)`).run(phone, auth, guid, agent, privateKey);
+        });
+    }
+    closeDB() {
+        this.handleError("closeDB", () => {
+            this.db.close();
+        });
+    }
+}
+exports.default = SQLiteSession;

package/rubjs/types/auth.d.ts

@@ -0,0 +1,40 @@
+interface SendCode {
+    phone_code_hash: string;
+    status: string;
+    code_digits_count: number;
+    has_confirmed_recovery_email: boolean;
+    no_recovery_alert: string;
+    send_type: string;
+    hint_pass_key: string;
+}
+interface AvatarThumbnail {
+    file_id: string;
+    mime: string;
+    dc_id: string;
+    access_hash_rec: string;
+}
+interface OnlineTime {
+    type: string;
+    exact_time: number;
+}
+interface User {
+    user_guid: string;
+    first_name: string;
+    last_name: string;
+    phone: string;
+    username: string;
+    avatar_thumbnail: AvatarThumbnail;
+    last_online: number;
+    bio: string | boolean;
+    is_deleted: boolean;
+    is_verified: boolean;
+    online_time: OnlineTime;
+}
+interface SignIn {
+    status: string;
+    auth: string;
+    user: User;
+    timestamp: number;
+}
+export { SignIn, SendCode };
+export default SendCode;

package/rubjs/types/auth.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/rubjs/types/chats.d.ts

@@ -0,0 +1,79 @@
+import MessageUpdate, { ChatUpdates } from "./decorators";
+interface Avatar {
+    file_id: string;
+    mime: string;
+    dc_id: string;
+    access_hash_rec: string;
+}
+interface getTopChatUsers {
+    abs_users: {
+        object_guid: string;
+        type: string;
+        first_name: string;
+        avatar_thumbnail: Avatar;
+        is_verified: boolean;
+        is_deleted: boolean;
+    }[];
+    timestamp: string;
+}
+interface GetObjectInfoByUsername {
+    exist: boolean;
+    type: string;
+    channel: {
+        channel_guid: string;
+        channel_title: string;
+        avatar_thumbnail: Avatar;
+        count_members: number;
+        description: string;
+        username: string;
+        is_deleted: boolean;
+        is_verified: boolean;
+        share_url: string;
+        channel_type: string;
+        sign_messages: boolean;
+        chat_reaction_setting: {
+            reaction_type: string;
+            selected_reactions: string[];
+        };
+        is_restricted_content: boolean;
+    };
+    chat: {
+        object_guid: string;
+        access: string[];
+        count_unseen: number;
+        is_mute: boolean;
+        is_pinned: boolean;
+        time_string: string;
+        last_message: {
+            message_id: string;
+            type: string;
+            text: string;
+            is_mine: boolean;
+        };
+        last_seen_my_mid: string;
+        last_seen_peer_mid: string;
+        status: string;
+        time: number;
+        pinned_message_id: string;
+        abs_object: {
+            object_guid: string;
+            type: string;
+            title: string;
+            avatar_thumbnail: [Object];
+            is_verified: boolean;
+            is_deleted: boolean;
+        };
+        is_blocked: boolean;
+        last_message_id: string;
+        last_deleted_mid: string;
+        pinned_message_ids: string[];
+    };
+    timestamp: string;
+}
+interface SendLive {
+    message_update: MessageUpdate;
+    chat_update: ChatUpdates;
+    status: string;
+    publish_text: string;
+}
+export { getTopChatUsers, GetObjectInfoByUsername, SendLive };

package/rubjs/types/chats.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });