rubjs 2.4.1 → 2.4.2

package/rubjs/methods/users/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setBlockUser = exports.getUserInfo = exports.getMe = exports.deleteUserChat = exports.checkUserUsername = void 0;
+const checkUserUsername_1 = __importDefault(require("./checkUserUsername"));
+exports.checkUserUsername = checkUserUsername_1.default;
+const deleteUserChat_1 = __importDefault(require("./deleteUserChat"));
+exports.deleteUserChat = deleteUserChat_1.default;
+const getMe_1 = __importDefault(require("./getMe"));
+exports.getMe = getMe_1.default;
+const getUserInfo_1 = __importDefault(require("./getUserInfo"));
+exports.getUserInfo = getUserInfo_1.default;
+const setBlockUser_1 = __importDefault(require("./setBlockUser"));
+exports.setBlockUser = setBlockUser_1.default;

package/rubjs/methods/users/setBlockUser.d.ts

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function setBlockUser(this: Client, user_guid: string, action?: "Block" | "Unblock"): Promise<any>;
+export default setBlockUser;

package/rubjs/methods/users/setBlockUser.js

@@ -0,0 +1,19 @@
+"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 setBlockUser(user_guid_1) {
+    return __awaiter(this, arguments, void 0, function* (user_guid, action = "Block") {
+        if (!["Block", "Unblock"].includes(action))
+            throw new Error("`action` argument can only be `Block` or `Unblock`.");
+        return yield this.builder("setBlockUser", { user_guid, action });
+    });
+}
+exports.default = setBlockUser;

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

@@ -0,0 +1,4 @@
+import Client from "../..";
+import { FileInline } from "../../types/decorators";
+declare function download(this: Client, file_inline: FileInline, callback?: (totalSize: number, downloadedSize: number) => Promise<void>, speed?: boolean): Promise<Buffer<ArrayBufferLike>>;
+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(file_inline_1, callback_1) {
+    return __awaiter(this, arguments, void 0, function* (file_inline, callback, speed = false) {
+        return yield this.network.download(file_inline.dc_id, file_inline.file_id, file_inline.access_hash_rec, file_inline.size, 1054768, callback, speed);
+    });
+}
+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/get.d.ts

@@ -0,0 +1,4 @@
+import { AxiosRequestConfig } from "axios";
+import Client from "../..";
+declare function get(this: Client, url: string, config: AxiosRequestConfig<any>): Promise<import("axios").AxiosResponse<any, any>>;
+export default get;

package/rubjs/methods/utilities/get.js

@@ -0,0 +1,21 @@
+"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 axios_1 = __importDefault(require("axios"));
+function get(url, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield axios_1.default.get(url, config);
+    });
+}
+exports.default = get;

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

@@ -0,0 +1,8 @@
+import download from "./download";
+import downloadProfilePicture from "./downloadProfilePicture";
+import get from "./get";
+import post from "./post";
+import run from "./run";
+import start from "./start";
+import thumbnail from "./thumbnail";
+export { download, downloadProfilePicture, run, start, thumbnail, get, post };

package/rubjs/methods/utilities/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.post = exports.get = 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 get_1 = __importDefault(require("./get"));
+exports.get = get_1.default;
+const post_1 = __importDefault(require("./post"));
+exports.post = post_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/post.d.ts

@@ -0,0 +1,4 @@
+import { AxiosRequestConfig } from "axios";
+import Client from "../..";
+declare function post(this: Client, url: string, data: any, config: AxiosRequestConfig<any>): Promise<import("axios").AxiosResponse<any, any>>;
+export default post;

package/rubjs/methods/utilities/post.js

@@ -0,0 +1,21 @@
+"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 axios_1 = __importDefault(require("axios"));
+function post(url, data, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield axios_1.default.post(url, data, config);
+    });
+}
+exports.default = post;

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

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

package/rubjs/methods/utilities/run.js

@@ -0,0 +1,24 @@
+"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 run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        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.d.ts

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

package/rubjs/methods/utilities/start.js

@@ -0,0 +1,70 @@
+"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 crypto_1 = __importDefault(require("../../crypto"));
+const input_1 = __importDefault(require("input"));
+function start() {
+    return __awaiter(this, void 0, void 0, function* () {
+        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.getMe();
+            this.userGuid = result.user.user_guid;
+            this.initialize = true;
+        }
+        catch (error) {
+            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;
+            const phoneRegex = /^[0-9]{11}$/;
+            while (is_phone_number_true) {
+                const answer = yield input_1.default.text(`Is the ${phone_number} correct [y or n]: `);
+                if (answer.toLowerCase() === "y" && phoneRegex.test(phone_number)) {
+                    is_phone_number_true = false;
+                }
+                else {
+                    phone_number = yield input_1.default.text("Phone Number ex -> (09123456789) : ");
+                }
+            }
+            phone_number = `98${phone_number.slice(1)}`;
+            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.sendCode((phone_number = phone_number), (pass_key = pass_key));
+                    if (result.status == "OK")
+                        break;
+                }
+            }
+            let [publicKey, privateKey] = crypto_1.default.createKeys();
+            this.privateKey = privateKey;
+            while (true) {
+                let phone_code = yield input_1.default.text("Code: ");
+                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.registerDevice();
+                    break;
+                }
+            }
+            this.initialize = true;
+        }
+    });
+}
+exports.default = start;

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

@@ -0,0 +1,6 @@
+declare class ThumbnailGenerator {
+    static getTime(videoPath: string): Promise<number>;
+    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,75 @@
+"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 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`);
+            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: "400x?",
+                    });
+                });
+                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

@@ -0,0 +1,38 @@
+import { Axios } from "axios";
+import WebSocket from "ws";
+import https from "https";
+import Client from "..";
+declare class Network {
+    private heartbeatInterval;
+    Headers: {
+        [key: string]: string;
+    };
+    client: Client;
+    session: Axios;
+    apiUrl: null | string;
+    wssUrl: null | string;
+    ws: WebSocket;
+    agent: https.Agent;
+    constructor(client: Client);
+    getDcs(): Promise<boolean>;
+    request(url: string, data: Record<string, any>): Promise<any>;
+    send({ input, method, tmp_session, }: {
+        input: object;
+        method: string;
+        tmp_session: boolean;
+    }): Promise<any>;
+    getUpdates(): Promise<void>;
+    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;
+    }>;
+    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;