rubjs 1.0.0 → 2.2.3

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

@@ -0,0 +1,3 @@
+import Client from '../..';
+declare function download(this: Client): Promise<any>;
+export default download;

package/rubjs/methods/utilities/download.js

@@ -0,0 +1,17 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function download() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.builder('download', {});
+    });
+}
+exports.default = download;

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

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function downloadProfilePicture(this: Client, object_guid: string): Promise<Buffer | null>;
+export default downloadProfilePicture;

package/rubjs/methods/utilities/downloadProfilePicture.js

@@ -0,0 +1,27 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function downloadProfilePicture(object_guid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let avatars = yield this.getAvatars(object_guid);
+        if (avatars) {
+            avatars = avatars.avatars[0].main;
+            const url = `https://messenger${avatars.dc_id}.iranlms.ir/InternFile.ashx`;
+            const response = yield this.network.session.get(url, {
+                params: { id: avatars.file_id, ach: avatars.access_hash_rec },
+                responseType: "arraybuffer",
+            });
+            if (response.status === 200)
+                return yield response.data;
+        }
+    });
+}
+exports.default = downloadProfilePicture;

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

@@ -1,3 +1,6 @@
-import start from "./start";
+import download from "./download";
+import downloadProfilePicture from "./downloadProfilePicture";
 import run from "./run";
-export { start, run, };
+import start from "./start";
+import thumbnail from "./thumbnail";
+export { download, downloadProfilePicture, run, start, thumbnail };

package/rubjs/methods/utilities/index.js

@@ -3,8 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = exports.start = void 0;
-const start_1 = __importDefault(require("./start"));
-exports.start = start_1.default;
+exports.thumbnail = exports.start = exports.run = exports.downloadProfilePicture = exports.download = void 0;
+const download_1 = __importDefault(require("./download"));
+exports.download = download_1.default;
+const downloadProfilePicture_1 = __importDefault(require("./downloadProfilePicture"));
+exports.downloadProfilePicture = downloadProfilePicture_1.default;
 const run_1 = __importDefault(require("./run"));
 exports.run = run_1.default;
+const start_1 = __importDefault(require("./start"));
+exports.start = start_1.default;
+const thumbnail_1 = __importDefault(require("./thumbnail"));
+exports.thumbnail = thumbnail_1.default;

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,8 +19,9 @@ 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) {
             if (this.auth)
@@ -38,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;
                 }
@@ -51,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

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

package/rubjs/methods/utilities/thumbnail.js

@@ -0,0 +1,61 @@
+"use strict";
+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 fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const sharp_1 = __importDefault(require("sharp"));
+class ThumbnailGenerator {
+    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`);
+            try {
+                yield new Promise((resolve, reject) => {
+                    (0, fluent_ffmpeg_1.default)(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: "320x?",
+                    });
+                });
+                const thumbnailBuffer = yield promises_1.default.readFile(tempImagePath);
+                const base64Thumbnail = thumbnailBuffer.toString("base64");
+                yield promises_1.default.unlink(tempImagePath);
+                return base64Thumbnail;
+            }
+            catch (error) {
+                console.error("Error generating video thumbnail:", error);
+                throw error;
+            }
+        });
+    }
+    static fromImage(imagePath_1) {
+        return __awaiter(this, arguments, void 0, function* (imagePath, width = 320) {
+            try {
+                const buffer = yield (0, sharp_1.default)(imagePath).resize(width).toBuffer();
+                return buffer.toString("base64");
+            }
+            catch (error) {
+                console.error("Error generating image thumbnail:", error);
+                throw error;
+            }
+        });
+    }
+}
+exports.default = ThumbnailGenerator;

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,5 +25,13 @@ declare class Network {
     handleConnect(): Promise<void>;
     resetConnection(): Promise<void>;
     handleMessage(message: string): Promise<void>;
+    uploadFile(file: Buffer<ArrayBufferLike> | string, mime?: string | null, fileName?: string | null, chunk?: number, callback?: any): Promise<{
+        mime: string;
+        size: number;
+        dc_id: string;
+        file_id: string;
+        file_name: string;
+        access_hash_rec: string;
+    }>;
 }
 export default Network;

package/rubjs/network/index.js

@@ -1,4 +1,37 @@
 "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) {
@@ -16,6 +49,9 @@ 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;
@@ -41,8 +77,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() {
@@ -54,8 +90,8 @@ 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;
                     }
                 }
@@ -88,9 +124,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
@@ -111,9 +147,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(); }));
@@ -157,9 +193,10 @@ class Network {
                     if (!messageData)
                         return;
                     const isValid = filters.length === 0 ||
-                        filters.every((filter) => __awaiter(this, void 0, void 0, function* () { return yield filter(messageData); }));
+                        filters.every((filter) => filter(messageData));
+                    const dataMessage = new types_1.Message(this.client, messageData);
                     if (isValid) {
-                        yield callback(messageData);
+                        yield callback(dataMessage);
                     }
                 }));
             }
@@ -168,5 +205,80 @@ class Network {
             }
         });
     }
+    uploadFile(file_1) {
+        return __awaiter(this, arguments, void 0, function* (file, mime = null, fileName = null, chunk = 1048576, callback = null) {
+            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() || "";
+            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") {
+                    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);
+            }
+        });
+    }
 }
 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,110 @@
+"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();
+        }
+        return {
+            text: resultText,
+            metadata: { meta_data_parts: entities },
+        };
+    }
+}
+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/types/{sign_in.d.ts → 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;