rubjs 2.8.6 → 2.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rubjs",
-  "version": "2.8.6",
+  "version": "2.8.7",
   "main": "rubjs/index.js",
   "types": "rubjs/index.d.ts",
   "keywords": [

package/rubjs/index.d.ts

@@ -1,6 +1,6 @@
 import Client from "./client";
 import Crypto from "./crypto";
 import * as Types from "./types";
-import { Filters, Utils, VoiceChatClient, SendLiveClient } from "./utils";
+import { Filters, Utils, VoiceChatClient, SendLiveClient, LoginClient } from "./utils";
 export default Client;
-export { Client, Crypto, Utils, VoiceChatClient, Filters, Types, SendLiveClient, };
+export { Client, Crypto, Utils, VoiceChatClient, Filters, Types, SendLiveClient, LoginClient, };

package/rubjs/index.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SendLiveClient = exports.Types = exports.Filters = exports.VoiceChatClient = exports.Utils = exports.Crypto = exports.Client = void 0;
+exports.LoginClient = exports.SendLiveClient = exports.Types = exports.Filters = exports.VoiceChatClient = exports.Utils = exports.Crypto = exports.Client = void 0;
 const client_1 = __importDefault(require("./client"));
 exports.Client = client_1.default;
 const crypto_1 = __importDefault(require("./crypto"));
@@ -48,4 +48,5 @@ Object.defineProperty(exports, "Filters", { enumerable: true, get: function () {
 Object.defineProperty(exports, "Utils", { enumerable: true, get: function () { return utils_1.Utils; } });
 Object.defineProperty(exports, "VoiceChatClient", { enumerable: true, get: function () { return utils_1.VoiceChatClient; } });
 Object.defineProperty(exports, "SendLiveClient", { enumerable: true, get: function () { return utils_1.SendLiveClient; } });
+Object.defineProperty(exports, "LoginClient", { enumerable: true, get: function () { return utils_1.LoginClient; } });
 exports.default = client_1.default;

package/rubjs/network/index.d.ts

@@ -9,6 +9,7 @@ declare class Network {
     private wssUrl;
     private ws;
     private agent;
+    private reconnecting;
     session: Axios;
     constructor(client: Client);
     getDcs(): Promise<boolean>;

package/rubjs/network/index.js

@@ -67,6 +67,7 @@ class Network {
             connection: "keep-alive",
             "user-agent": client.userAgent,
         };
+        this.reconnecting = false;
         if (client.defaultPlatform.platform === "Android") {
             delete this.Headers.origin;
             delete this.Headers.referer;
@@ -146,6 +147,7 @@ class Network {
             this.ws = new ws_1.default(this.wssUrl);
             this.ws.on("open", () => __awaiter(this, void 0, void 0, function* () {
                 console.log("WebSocket connected.");
+                this.reconnecting = false;
                 yield this.handleConnect();
                 this.resetInactivityTimer();
             }));
@@ -154,12 +156,18 @@ class Network {
                 this.resetInactivityTimer();
             }));
             this.ws.on("error", () => __awaiter(this, void 0, void 0, function* () {
-                console.error("WebSocket error, reconnecting...");
-                yield this.resetConnection();
+                if (!this.reconnecting) {
+                    console.error("WebSocket error, reconnecting...");
+                    this.reconnecting = true;
+                    yield this.resetConnection();
+                }
             }));
             this.ws.on("close", () => __awaiter(this, void 0, void 0, function* () {
-                console.warn("WebSocket closed, reconnecting...");
-                yield this.resetConnection();
+                if (!this.reconnecting) {
+                    console.warn("WebSocket closed, reconnecting...");
+                    this.reconnecting = true;
+                    yield this.resetConnection();
+                }
             }));
         });
     }
@@ -189,7 +197,10 @@ class Network {
             var _a;
             (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
             this.ws = null;
-            setTimeout(() => this.getUpdates(), 5000);
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                yield this.getUpdates();
+                this.reconnecting = false;
+            }), 5000);
         });
     }
     handleMessage(message) {

package/rubjs/network/loginNetwork.d.ts

@@ -0,0 +1,39 @@
+import { AxiosInstance } from "axios";
+interface PlatformInfo {
+    app_name: string;
+    app_version: string;
+    platform: string;
+    package: string;
+    lang_code: string;
+}
+interface AuthInfo {
+    auth?: string;
+    decode_auth?: string;
+    key?: Buffer;
+    privateKey?: string;
+}
+interface SendOptions {
+    input?: Record<string, any>;
+    method?: string;
+    tmp_session?: boolean;
+}
+interface ServerResponse {
+    data_enc?: string;
+    status?: string;
+    status_det?: string;
+    data?: Record<string, any>;
+}
+declare class Network {
+    private Headers;
+    private agent;
+    private apiUrl;
+    session: AxiosInstance;
+    defaultPlatform: PlatformInfo;
+    userAgent: string;
+    constructor();
+    getDcs(): Promise<boolean>;
+    request(url: string, data: Record<string, any>): Promise<any>;
+    send({ input, method, tmp_session }: SendOptions, { auth, decode_auth, key, privateKey }: AuthInfo): Promise<ServerResponse | undefined>;
+    bulder(name: string, input: Record<string, any>, { auth, key, decode_auth, privateKey }: AuthInfo, tmp_session?: boolean): Promise<Record<string, any> | undefined>;
+}
+export default Network;

package/rubjs/network/loginNetwork.js

@@ -0,0 +1,122 @@
+"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 https_1 = __importDefault(require("https"));
+const axios_1 = __importDefault(require("axios"));
+const __1 = require("..");
+class Network {
+    constructor() {
+        this.apiUrl = null;
+        this.defaultPlatform = {
+            app_name: "Main",
+            app_version: "4.4.9",
+            platform: "Web",
+            package: "web.rubika.ir",
+            lang_code: "fa",
+        };
+        this.userAgent = `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36`;
+        this.Headers = {
+            origin: "https://web.rubika.ir",
+            referer: "https://web.rubika.ir/",
+            "content-type": "application/json",
+            connection: "keep-alive",
+            "user-agent": this.userAgent,
+        };
+        this.agent = new https_1.default.Agent({ rejectUnauthorized: false });
+        this.session = axios_1.default.create({
+            headers: this.Headers,
+            timeout: 10000,
+            httpsAgent: this.agent,
+        });
+    }
+    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] + "/";
+                        return true;
+                    }
+                }
+                catch (_a) {
+                    console.error("Error while fetching dcs");
+                }
+                yield new Promise((resolve) => setTimeout(resolve, 3000));
+            }
+        });
+    }
+    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 (_a) {
+                    console.error("Error in request");
+                }
+            }
+            throw new Error("Failed to get response after 3 attempts");
+        });
+    }
+    send(_a, _b) {
+        return __awaiter(this, arguments, void 0, function* ({ input = {}, method = "getUserInfo", tmp_session }, { auth, decode_auth, key, privateKey }) {
+            if (!this.apiUrl)
+                yield this.getDcs();
+            const payload = {
+                api_version: "6",
+                [tmp_session ? "tmp_session" : "auth"]: tmp_session ? auth : decode_auth,
+            };
+            const data_enc = JSON.stringify({
+                client: this.defaultPlatform,
+                method,
+                input,
+            });
+            payload["data_enc"] = __1.Crypto.encrypt(data_enc, key);
+            if (!tmp_session && privateKey) {
+                payload["sign"] = __1.Crypto.sign(payload["data_enc"], privateKey);
+            }
+            return yield this.request(this.apiUrl, payload);
+        });
+    }
+    bulder(name_1, input_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (name, input, { auth, key, decode_auth, privateKey }, tmp_session = false) {
+            if (!auth)
+                auth = __1.Crypto.secret(32);
+            if (!key)
+                key = Buffer.from(__1.Crypto.passphrase(auth), "utf8");
+            const result = yield this.send({
+                input,
+                tmp_session,
+                method: name,
+            }, { auth, key, decode_auth, privateKey });
+            if (result) {
+                const { data_enc } = result;
+                if (data_enc) {
+                    const decrypted = __1.Crypto.decrypt(data_enc, key);
+                    const parsed = JSON.parse(decrypted);
+                    if (parsed.status === "OK" && parsed.status_det === "OK") {
+                        return Object.assign(Object.assign({}, parsed.data), { auth_data: auth, key_data: key });
+                    }
+                }
+            }
+        });
+    }
+}
+exports.default = Network;

package/rubjs/utils/filters.d.ts

@@ -26,7 +26,8 @@ declare class Filters {
     static isPoll(message: MessageUpdate): boolean;
     static isLive(message: MessageUpdate): boolean;
     static isEvent(message: MessageUpdate): boolean;
-    static startsWithCommand(text: string, object_guid?: string): (message: MessageUpdate) => boolean;
+    static isLength(length: number, object_guid?: string): (message: MessageUpdate) => boolean;
+    static startsWithCommand(text: string, object_guid?: string, length?: number): (message: MessageUpdate) => boolean;
     static equalCommand(text: string, object_guid?: string): (message: MessageUpdate) => boolean;
 }
 export default Filters;

package/rubjs/utils/filters.js

@@ -122,14 +122,31 @@ class Filters {
     static isEvent(message) {
         return !!Filters.findKey(message, "event_data");
     }
-    static startsWithCommand(text, object_guid) {
+    static isLength(length, object_guid) {
         return (message) => {
-            var _a;
+            var _a, _b;
+            if (object_guid) {
+                if (object_guid !== message.object_guid)
+                    return false;
+            }
+            if ((_a = message === null || message === void 0 ? void 0 : message.message) === null || _a === void 0 ? void 0 : _a.text) {
+                return ((_b = message === null || message === void 0 ? void 0 : message.message) === null || _b === void 0 ? void 0 : _b.text.length) === length;
+            }
+            return false;
+        };
+    }
+    static startsWithCommand(text, object_guid, length) {
+        return (message) => {
+            var _a, _b;
             if (object_guid) {
                 if (object_guid !== message.object_guid)
                     return false;
             }
             if ((_a = message === null || message === void 0 ? void 0 : message.message) === null || _a === void 0 ? void 0 : _a.text) {
+                if (length) {
+                    if (((_b = message === null || message === void 0 ? void 0 : message.message) === null || _b === void 0 ? void 0 : _b.text.length) !== length)
+                        return false;
+                }
                 return message.message.text.startsWith(text);
             }
         };

package/rubjs/utils/index.d.ts

@@ -2,4 +2,5 @@ import Filters from "./filters";
 import Utils from "./utils";
 import VoiceChatClient from "./VoiceChatClient";
 import SendLiveClient from "./sendLiveClient";
-export { Filters, Utils, VoiceChatClient, SendLiveClient };
+import LoginClient from "./loginClient";
+export { Filters, Utils, VoiceChatClient, SendLiveClient, LoginClient };

package/rubjs/utils/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SendLiveClient = exports.VoiceChatClient = exports.Utils = exports.Filters = void 0;
+exports.LoginClient = exports.SendLiveClient = exports.VoiceChatClient = exports.Utils = exports.Filters = void 0;
 const filters_1 = __importDefault(require("./filters"));
 exports.Filters = filters_1.default;
 const utils_1 = __importDefault(require("./utils"));
@@ -12,3 +12,5 @@ const VoiceChatClient_1 = __importDefault(require("./VoiceChatClient"));
 exports.VoiceChatClient = VoiceChatClient_1.default;
 const sendLiveClient_1 = __importDefault(require("./sendLiveClient"));
 exports.SendLiveClient = sendLiveClient_1.default;
+const loginClient_1 = __importDefault(require("./loginClient"));
+exports.LoginClient = loginClient_1.default;

package/rubjs/utils/loginClient.d.ts

@@ -0,0 +1,36 @@
+import Network from "../network/loginNetwork";
+interface AuthResult {
+    isOk: boolean;
+    status?: string;
+    phone_code_hash?: string;
+    code_digits_count?: number;
+    auth?: string;
+    key?: Buffer;
+    decode_auth?: string;
+    phone_number?: string;
+}
+interface AuthFace {
+    auth: string;
+    key: Buffer;
+    privateKey: any;
+    decode_auth?: string;
+}
+declare class LoginClient {
+    static systemVersions: Record<string, string>;
+    static sendCode(phone_number: string, pass_key?: string): Promise<AuthResult>;
+    static signIn(phone_code: string, sessionPath: string, datas: AuthResult): Promise<{
+        isOk: boolean;
+        status: string;
+    }>;
+    static registerDevice(network: Network, datas: AuthFace): Promise<void>;
+    static getBrowser(userAgent: string, langCode: string, appVersion: string): Promise<{
+        token: string;
+        lang_code: string;
+        token_type: string;
+        app_version: string;
+        system_version: string;
+        device_model: string;
+        device_hash: string;
+    }>;
+}
+export default LoginClient;

package/rubjs/utils/loginClient.js

@@ -0,0 +1,120 @@
+"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 loginNetwork_1 = __importDefault(require("../network/loginNetwork"));
+const session_1 = __importDefault(require("../session"));
+class LoginClient {
+    static sendCode(phone_number, pass_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const network = new loginNetwork_1.default();
+            const data = {
+                phone_number,
+                pass_key: pass_key || null,
+                send_type: "SMS",
+            };
+            const result = yield network.bulder("sendCode", data, {}, true);
+            if (result)
+                return {
+                    isOk: true,
+                    status: result.status,
+                    phone_code_hash: result.phone_code_hash,
+                    code_digits_count: result.code_digits_count,
+                    auth: result.auth_data,
+                    key: result.key_data,
+                    phone_number,
+                };
+            return {
+                isOk: false,
+            };
+        });
+    }
+    static signIn(phone_code, sessionPath, datas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const network = new loginNetwork_1.default();
+            const [publicKey, privateKey] = crypto_1.default.createKeys();
+            const data = {
+                phone_code,
+                phone_number: datas.phone_number,
+                phone_code_hash: datas.phone_code_hash,
+                public_key: publicKey,
+            };
+            const auth = {
+                auth: datas.auth,
+                key: datas.key,
+                privateKey,
+            };
+            const response = yield network.bulder("signIn", data, auth, true);
+            if ((response === null || response === void 0 ? void 0 : response.status) === "CodeIsInvalid") {
+                return { isOk: false, status: "CodeIsInvalid" };
+            }
+            const sampleAuth = crypto_1.default.decrypt_RSA_OAEP(privateKey, response.auth);
+            auth.key = Buffer.from(crypto_1.default.passphrase(sampleAuth), "utf8");
+            auth.auth = sampleAuth;
+            auth.decode_auth = crypto_1.default.decode_auth(sampleAuth);
+            const session = new session_1.default(sessionPath);
+            session.saveSession({
+                phone: response.user.phone,
+                auth: auth.auth,
+                guid: response.user.user_guid,
+                agent: network.userAgent,
+                private_key: privateKey,
+            });
+            yield this.registerDevice(network, auth);
+            return { isOk: true, status: "Sucessfull" };
+        });
+    }
+    static registerDevice(network, datas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const browserData = yield this.getBrowser(network.userAgent, network.defaultPlatform.lang_code, network.defaultPlatform.app_version);
+            const sendData = {};
+            yield network.bulder("registerDevice", browserData, datas);
+        });
+    }
+    static getBrowser(userAgent, langCode, appVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const match = userAgent
+                .toLowerCase()
+                .match(/(opera|chrome|safari|firefox|msie|trident)\/(\d+)/);
+            if (!match) {
+                throw new Error(`Cannot parse user-agent: ${userAgent}`);
+            }
+            const deviceModel = `${match[1]} ${match[2]}`;
+            const systemVersion = ((_a = Object.entries(this.systemVersions).find(([key]) => userAgent.includes(key))) === null || _a === void 0 ? void 0 : _a[1]) || "Unknown";
+            const deviceHash = "2" + (((_b = userAgent.match(/\d+/g)) === null || _b === void 0 ? void 0 : _b.join("")) || "");
+            return {
+                token: "",
+                lang_code: langCode,
+                token_type: "Web",
+                app_version: `WB_${appVersion}`,
+                system_version: systemVersion,
+                device_model: deviceModel.charAt(0).toUpperCase() + deviceModel.slice(1),
+                device_hash: deviceHash,
+            };
+        });
+    }
+}
+LoginClient.systemVersions = {
+    "Windows NT 10.0": "Windows 10",
+    "Windows NT 6.2": "Windows 8",
+    "Windows NT 6.1": "Windows 7",
+    "Windows NT 6.0": "Windows Vista",
+    "Windows NT 5.1": "Windows XP",
+    "Windows NT 5.0": "Windows 2000",
+    Mac: "Mac/iOS",
+    X11: "UNIX",
+    Linux: "Linux",
+};
+exports.default = LoginClient;