rubjs 1.1.0 → 2.4.0

package/rubjs/methods/utilities/run.js

@@ -11,7 +11,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 function run() {
     return __awaiter(this, void 0, void 0, function* () {
-        yield this.network.getUpdates();
+        if (!this.initialize) {
+            let timeout = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                yield this.run();
+                clearTimeout(timeout);
+            }), 2000);
+        }
+        else
+            yield this.network.getUpdates();
     });
 }
 exports.default = run;

package/rubjs/methods/utilities/start.js

@@ -19,12 +19,12 @@ function start() {
         try {
             this.key = Buffer.from(crypto_1.default.passphrase(this.auth), "utf8");
             this.decode_auth = crypto_1.default.decode_auth(this.auth);
-            const result = yield this.get_user_info();
+            const result = yield this.getMe();
             this.userGuid = result.user.user_guid;
+            this.initialize = true;
         }
         catch (error) {
-            // console.log(this.auth);
-            if (!this.auth)
+            if (this.auth)
                 throw new Error("robot has any error" + error.message);
             let phone_number = yield input_1.default.text("Phone Number: ");
             let is_phone_number_true = true;
@@ -39,11 +39,11 @@ function start() {
                 }
             }
             phone_number = `98${phone_number.slice(1)}`;
-            let result = yield this.send_code(phone_number);
+            let result = yield this.sendCode(phone_number);
             if (result.status == "SendPassKey") {
                 while (true) {
                     let pass_key = yield input_1.default.text(`Password [${result.hint_pass_key}] > `);
-                    result = yield this.send_code((phone_number = phone_number), (pass_key = pass_key));
+                    result = yield this.sendCode((phone_number = phone_number), (pass_key = pass_key));
                     if (result.status == "OK")
                         break;
                 }
@@ -52,17 +52,18 @@ function start() {
             this.privateKey = privateKey;
             while (true) {
                 let phone_code = yield input_1.default.text("Code: ");
-                let response = yield this.sign_in(phone_code, phone_number, result.phone_code_hash, publicKey);
+                let response = yield this.signIn(phone_code, phone_number, result.phone_code_hash, publicKey);
                 if (response.status === "OK") {
                     response.auth = crypto_1.default.decrypt_RSA_OAEP(this.privateKey, response.auth);
                     this.key = Buffer.from(crypto_1.default.passphrase(response.auth), "utf8");
                     this.auth = response.auth;
                     this.decode_auth = crypto_1.default.decode_auth(this.auth);
                     this.sessionDb.saveSession(response.user.phone, this.auth, response.user.user_guid, this.userAgent, this.privateKey);
-                    yield this.register_device();
+                    yield this.registerDevice();
                     break;
                 }
             }
+            this.initialize = true;
         }
     });
 }

package/rubjs/methods/utilities/thumbnail.d.ts

@@ -1,4 +1,5 @@
 declare class ThumbnailGenerator {
+    static getTime(videoPath: string): Promise<number>;
     static fromVideo(videoPath: string): Promise<string>;
     static fromImage(imagePath: string, width?: number): Promise<string>;
 }

package/rubjs/methods/utilities/thumbnail.js

@@ -18,6 +18,20 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const sharp_1 = __importDefault(require("sharp"));
 class ThumbnailGenerator {
+    static getTime(videoPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                fluent_ffmpeg_1.default.ffprobe(videoPath, (err, metadata) => {
+                    if (err) {
+                        console.error("Error fetching metadata:", err);
+                        reject(err);
+                        return;
+                    }
+                    resolve(metadata.format.duration);
+                });
+            });
+        });
+    }
     static fromVideo(videoPath) {
         return __awaiter(this, void 0, void 0, function* () {
             const tempImagePath = path_1.default.join(os_1.default.tmpdir(), `thumbnail_${Date.now()}.png`);
@@ -31,7 +45,7 @@ class ThumbnailGenerator {
                         timemarks: ["00:00:00.000"],
                         filename: path_1.default.basename(tempImagePath),
                         folder: path_1.default.dirname(tempImagePath),
-                        size: "320x?",
+                        size: "400x?",
                     });
                 });
                 const thumbnailBuffer = yield promises_1.default.readFile(tempImagePath);

package/rubjs/network/index.d.ts

@@ -9,8 +9,8 @@ declare class Network {
     };
     client: Client;
     session: Axios;
-    api_url: null | string;
-    wss_url: null | string;
+    apiUrl: null | string;
+    wssUrl: null | string;
     ws: WebSocket;
     agent: https.Agent;
     constructor(client: Client);
@@ -25,7 +25,7 @@ declare class Network {
     handleConnect(): Promise<void>;
     resetConnection(): Promise<void>;
     handleMessage(message: string): Promise<void>;
-    upload_file(file: Buffer<ArrayBufferLike> | string, mime?: string | null, fileName?: string | null, chunk?: number, callback?: any): Promise<{
+    uploadFile(file: Buffer<ArrayBufferLike> | string, mime?: string | null, fileName?: string | null, chunk?: number, callback?: any): Promise<{
         mime: string;
         size: number;
         dc_id: string;
@@ -33,5 +33,6 @@ declare class Network {
         file_name: string;
         access_hash_rec: string;
     }>;
+    download(dc_id: number, file_id: number, access_hash: string, size: number, chunk?: number, callback?: (totalSize: number, downloadedSize: number) => Promise<void>, speed?: boolean): Promise<Buffer>;
 }
 export default Network;

package/rubjs/network/index.js

@@ -51,6 +51,7 @@ 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;
@@ -62,12 +63,10 @@ class Network {
         };
         this.client = client;
         this.Headers["user-agent"] = this.client.userAgent;
-        if (this.client.defaultPlatform["platform"] === "Android") {
-            delete this.Headers["origin"];
-            delete this.Headers["referer"];
+        if (this.client.defaultPlatform.platform === "Android") {
+            delete this.Headers.origin;
+            delete this.Headers.referer;
             this.Headers["user-agent"] = "okhttp/3.12.1";
-            this.client.defaultPlatform["package"] = "app.rbmain.a";
-            this.client.defaultPlatform["app_version"] = "3.6.4";
         }
         this.agent = new https_1.default.Agent({ rejectUnauthorized: false });
         const axiosConfig = {
@@ -76,8 +75,8 @@ class Network {
             httpsAgent: this.agent,
         };
         this.session = axios_1.default.create(axiosConfig);
-        this.api_url = null;
-        this.wss_url = null;
+        this.apiUrl = null;
+        this.wssUrl = null;
         this.ws = null;
     }
     getDcs() {
@@ -89,13 +88,13 @@ class Network {
                     });
                     if (response.status === 200) {
                         const data = response.data.data;
-                        this.api_url = data.API[data.default_api] + "/";
-                        this.wss_url = data.socket[data.default_socket];
+                        this.apiUrl = data.API[data.default_api] + "/";
+                        this.wssUrl = data.socket[data.default_socket];
                         return true;
                     }
                 }
-                catch (error) {
-                    console.error("Error while fetching dcs:", error);
+                catch (_a) {
+                    console.error("Error while fetching dcs");
                     continue;
                 }
             }
@@ -111,7 +110,7 @@ class Network {
                     }
                 }
                 catch (error) {
-                    console.error("Error in request:", error);
+                    console.error("Error in request ");
                     continue;
                 }
             }
@@ -123,9 +122,9 @@ class Network {
             let api_version = this.client.apiVersion;
             let auth = this.client.auth;
             let client = this.client.defaultPlatform;
-            if (!this.api_url)
+            if (!this.apiUrl)
                 yield this.getDcs();
-            let url = this.api_url;
+            let url = this.apiUrl;
             let data = { api_version };
             data[tmp_session ? "tmp_session" : "auth"] = tmp_session
                 ? auth
@@ -146,9 +145,9 @@ class Network {
     }
     getUpdates() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.wss_url)
+            if (!this.wssUrl)
                 yield this.getDcs();
-            this.ws = new ws_1.default(this.wss_url);
+            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(); }));
@@ -193,8 +192,9 @@ class Network {
                         return;
                     const isValid = filters.length === 0 ||
                         filters.every((filter) => filter(messageData));
+                    const dataMessage = new types_1.Message(this.client, messageData);
                     if (isValid) {
-                        yield callback(messageData);
+                        yield callback(dataMessage);
                     }
                 }));
             }
@@ -203,8 +203,9 @@ class Network {
             }
         });
     }
-    upload_file(file_1) {
+    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");
@@ -217,8 +218,8 @@ class Network {
             if (!fileName)
                 throw new Error("File name is not set");
             if (!mime)
-                mime = fileName.split(".").pop() || "";
-            let result = yield this.client.request_send_file(fileName, file.length, 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;
@@ -241,7 +242,7 @@ class Network {
                     });
                     if (response.data.status === "ERROR_TRY_AGAIN") {
                         console.log("Retrying upload...");
-                        result = yield this.client.request_send_file(fileName, file.length, mime);
+                        result = yield this.client.requestSendFile(fileName, file.length, mime);
                         id = result.id;
                         index = 0;
                         dc_id = result.dc_id;
@@ -265,6 +266,8 @@ class Network {
                     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,
@@ -278,5 +281,58 @@ class Network {
             }
         });
     }
+    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,112 @@
+"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",
+};
+exports.default = Markdown;

package/rubjs/session/index.js

@@ -8,7 +8,6 @@ class SQLiteSession {
     constructor(sessionName) {
         this.dbFile = sessionName.endsWith(".rp") ? sessionName : `${sessionName}.rp`;
         this.db = new better_sqlite3_1.default(this.dbFile);
-        this.db.pragma("journal_mode = WAL");
         this.initializeDB();
     }
     handleError(operation, callback) {
@@ -22,6 +21,7 @@ class SQLiteSession {
     }
     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");

package/rubjs/{methods/auth/types/sign_in.d.ts → types/auth.d.ts}

@@ -1,3 +1,12 @@
+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;
@@ -27,4 +36,5 @@ interface SignIn {
     user: User;
     timestamp: number;
 }
-export default SignIn;
+export { SignIn, SendCode };
+export default SendCode;

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/{methods/types/message_update.d.ts → types/decorators.d.ts}

@@ -74,6 +74,16 @@ interface PollData {
     type: string;
     allows_multiple_answers: boolean;
 }
+interface MetaData {
+    meta_data_parts: {
+        from_index: number;
+        length: number;
+        type: string;
+        link?: {
+            url: string;
+        };
+    }[];
+}
 interface Message {
     message_id: string;
     text?: string;
@@ -95,6 +105,7 @@ interface Message {
         message_id: string;
         object_guid: string;
     };
+    metadata?: MetaData;
     count_seen?: string;
     thumb_inline?: string;
 }
@@ -109,4 +120,49 @@ interface MessageUpdate {
     type: string;
     state: string;
 }
+interface ChatUpdates {
+    object_guid: string;
+    action: string;
+    chat: {
+        time_string: string;
+        last_message: {
+            message_id: string;
+            type: string;
+            text: string;
+            author_object_guid?: string;
+            is_mine: boolean;
+            author_title?: string;
+            author_type?: string;
+        };
+        last_seen_peer_mid?: string;
+        last_seen_my_mid?: string;
+        status?: string;
+        time: number;
+        last_message_id: string;
+        group_voice_chat_id?: string;
+    };
+    updated_parameters: string[];
+    timestamp: string;
+    type: string;
+}
+interface ShowActivities {
+    type: string;
+    object_guid: string;
+    object_type: string;
+    user_activity_guid: string;
+}
+interface ShowNotifications {
+    notification_id: string;
+    type: string;
+    title: string;
+    text: string;
+    image_file_id?: number;
+    message_data: {
+        object_guid: string;
+        object_type: string;
+        message_id: number;
+        sender_guid?: string;
+    };
+}
+export { MessageUpdate, ChatUpdates, ShowActivities, ShowNotifications, Message, FileInline };
 export default MessageUpdate;