rubjs 1.0.0

package/rubjs/methods/utilities/on_show_activities.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 on_show_activities(filters, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        this.eventHandlers.push({ callback, filters, updateType: "show_activities" });
+    });
+}
+exports.default = on_show_activities;

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

@@ -0,0 +1,4 @@
+import Client from "../..";
+import { MessageUpdate } from "../../types";
+declare function on_show_notifications(this: Client, filters: ((msg: any) => boolean)[], callback: (message: MessageUpdate) => void): Promise<void>;
+export default on_show_notifications;

package/rubjs/methods/utilities/on_show_notifications.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function on_show_notifications(filters, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        this.eventHandlers.push({
+            callback,
+            filters,
+            updateType: "show_notifications",
+        });
+    });
+}
+exports.default = on_show_notifications;

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,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 run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        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,68 @@
+"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.get_user_info();
+            this.userGuid = result.user.user_guid;
+        }
+        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.send_code(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));
+                    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.sign_in(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();
+                    break;
+                }
+            }
+        }
+    });
+}
+exports.default = start;

package/rubjs/network/index.d.ts

@@ -0,0 +1,29 @@
+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;
+    api_url: null | string;
+    wss_url: 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>;
+}
+export default Network;

package/rubjs/network/index.js

@@ -0,0 +1,172 @@
+"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"));
+const ws_1 = __importDefault(require("ws"));
+const crypto_1 = __importDefault(require("../crypto"));
+const https_1 = __importDefault(require("https"));
+class Network {
+    constructor(client) {
+        this.heartbeatInterval = null;
+        this.Headers = {
+            origin: "https://web.rubika.ir",
+            referer: "https://web.rubika.ir/",
+            "content-type": "application/json",
+            connection: "keep-alive",
+        };
+        this.client = client;
+        this.Headers["user-agent"] = this.client.userAgent;
+        if (this.client.defaultPlatform["platform"] === "Android") {
+            delete this.Headers["origin"];
+            delete this.Headers["referer"];
+            this.Headers["user-agent"] = "okhttp/3.12.1";
+            this.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 = {
+            headers: this.Headers,
+            timeout: this.client.timeout || 10000,
+            httpsAgent: this.agent,
+        };
+        this.session = axios_1.default.create(axiosConfig);
+        this.api_url = null;
+        this.wss_url = null;
+        this.ws = null;
+    }
+    getDcs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (true) {
+                try {
+                    const response = yield axios_1.default.get("https://getdcmess.iranlms.ir/", {
+                        httpsAgent: this.agent,
+                    });
+                    if (response.status === 200) {
+                        const data = response.data.data;
+                        this.api_url = data.API[data.default_api] + "/";
+                        this.wss_url = data.socket[data.default_socket];
+                        return true;
+                    }
+                }
+                catch (error) {
+                    console.error("Error while fetching dcs:", error);
+                    continue;
+                }
+            }
+        });
+    }
+    request(url, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < 3; i++) {
+                try {
+                    const response = yield this.session.post(url, data);
+                    if (response.status === 200) {
+                        return response.data;
+                    }
+                }
+                catch (error) {
+                    console.error("Error in request:", error);
+                    continue;
+                }
+            }
+            throw new Error("Failed to get response after 3 attempts");
+        });
+    }
+    send(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ input = {}, method = "getUserInfo", tmp_session, }) {
+            let api_version = this.client.apiVersion;
+            let auth = this.client.auth;
+            let client = this.client.defaultPlatform;
+            if (!this.api_url)
+                yield this.getDcs();
+            let url = this.api_url;
+            let data = { api_version };
+            data[tmp_session ? "tmp_session" : "auth"] = tmp_session
+                ? auth
+                : this.client.decode_auth;
+            if (api_version === "6") {
+                const data_enc = JSON.stringify({
+                    client,
+                    method,
+                    input,
+                });
+                data["data_enc"] = crypto_1.default.encrypt(data_enc, this.client.key);
+                if (!tmp_session) {
+                    data["sign"] = crypto_1.default.sign(data["data_enc"], this.client.privateKey);
+                }
+                return yield this.request(url, data);
+            }
+        });
+    }
+    getUpdates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.wss_url)
+                yield this.getDcs();
+            this.ws = new ws_1.default(this.wss_url);
+            this.ws.on("open", () => __awaiter(this, void 0, void 0, function* () { return yield this.handleConnect(); }));
+            this.ws.on("message", (message) => __awaiter(this, void 0, void 0, function* () { return yield this.handleMessage(message); }));
+            this.ws.on("error", () => __awaiter(this, void 0, void 0, function* () { return yield this.resetConnection(); }));
+        });
+    }
+    handleConnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Start Bot..");
+            const handshakeRequest = {
+                api_version: "5",
+                auth: this.client.auth,
+                data: "",
+                method: "handShake",
+            };
+            this.ws.send(JSON.stringify(handshakeRequest));
+            if (this.heartbeatInterval) {
+                clearInterval(this.heartbeatInterval);
+            }
+            this.heartbeatInterval = setInterval(() => {
+                if (this.ws.readyState === ws_1.default.OPEN) {
+                    this.ws.send(JSON.stringify({}));
+                }
+            }, 30 * 1000);
+        });
+    }
+    resetConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            setTimeout(() => this.getUpdates(), 5000);
+        });
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data_enc } = JSON.parse(message);
+                if (!data_enc)
+                    return;
+                const update = JSON.parse(crypto_1.default.decrypt(data_enc, this.client.key));
+                this.client.eventHandlers.forEach((_a) => __awaiter(this, [_a], void 0, function* ({ callback, filters = [], updateType }) {
+                    var _b;
+                    const messageData = (_b = update[updateType]) === null || _b === void 0 ? void 0 : _b[0];
+                    if (!messageData)
+                        return;
+                    const isValid = filters.length === 0 ||
+                        filters.every((filter) => __awaiter(this, void 0, void 0, function* () { return yield filter(messageData); }));
+                    if (isValid) {
+                        yield callback(messageData);
+                    }
+                }));
+            }
+            catch (error) {
+                console.error("Error in handleMessage:", error);
+            }
+        });
+    }
+}
+exports.default = Network;

package/rubjs/session/index.d.ts

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

package/rubjs/session/index.js

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

package/rubjs/types/chat_updates.d.ts

@@ -0,0 +1,26 @@
+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;
+}
+export default ChatUpdates;

package/rubjs/types/chat_updates.js

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

package/rubjs/types/filters_optiom.d.ts

@@ -0,0 +1,10 @@
+interface FilterOption {
+    is_text?: boolean;
+    is_link?: boolean;
+    is_group?: boolean;
+    is_channel?: boolean;
+    is_private?: boolean;
+    is_file?: boolean;
+    is_froward?: boolean;
+}
+export default FilterOption;

package/rubjs/types/filters_optiom.js

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

package/rubjs/types/get_user_info.d.ts

@@ -0,0 +1,63 @@
+interface AvatarThumbnail {
+    file_id: string;
+    mime: string;
+    dc_id: string;
+    access_hash_rec: string;
+}
+interface OnlineTime {
+    type: string;
+    exact_time: number;
+}
+interface User {
+    user_guid: string;
+    first_name: string;
+    phone: string;
+    username: string;
+    avatar_thumbnail: AvatarThumbnail;
+    last_online: number;
+    is_deleted: boolean;
+    is_verified: boolean;
+    online_time: OnlineTime;
+}
+interface LastMessage {
+    message_id: string;
+    type: string;
+    text: string;
+    author_object_guid: string;
+    is_mine: boolean;
+    author_title: string;
+    author_type: string;
+}
+interface AbsObject {
+    object_guid: string;
+    type: string;
+    first_name: string;
+    avatar_thumbnail: AvatarThumbnail;
+    is_verified: boolean;
+    is_deleted: boolean;
+}
+interface Chat {
+    object_guid: string;
+    access: string[];
+    count_unseen: number;
+    is_mute: boolean;
+    is_pinned: boolean;
+    time_string: string;
+    last_message: LastMessage;
+    last_seen_my_mid: string;
+    last_seen_peer_mid: string;
+    status: string;
+    time: number;
+    abs_object: AbsObject;
+    is_blocked: boolean;
+    last_message_id: string;
+    last_deleted_mid: string;
+}
+interface UserInfo {
+    user: User;
+    chat: Chat;
+    timestamp: string;
+    can_receive_call: boolean;
+    can_video_call: boolean;
+}
+export default UserInfo;

package/rubjs/types/get_user_info.js

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

package/rubjs/types/index.d.ts

@@ -0,0 +1,9 @@
+import UserInfo from "./get_user_info";
+import SendCode from "./send_code";
+import SignIn from "./sign_in";
+import FilterOption from "./filters_optiom";
+import MessageUpdate from "./message_update";
+import ChatUpdates from "./chat_updates";
+import ShowNotifications from "./show_notifications";
+import ShowActivities from "./show_activities";
+export { UserInfo, SendCode, SignIn, FilterOption, MessageUpdate, ChatUpdates, ShowNotifications, ShowActivities };

package/rubjs/types/index.js

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

package/rubjs/types/message_update.d.ts

@@ -0,0 +1,112 @@
+interface FileInline {
+    file_id: number;
+    mime: string;
+    dc_id: number;
+    access_hash_rec: string;
+    file_name: string;
+    width?: number;
+    height?: number;
+    size: number;
+    type: string;
+    time?: number;
+    music_performer?: string;
+    is_round?: boolean;
+    is_spoil?: boolean;
+}
+interface ContactMessage {
+    phone_number: string;
+    first_name: string;
+    last_name: string;
+    user_guid: string;
+    vcard: string;
+}
+interface LiveData {
+    live_id: string;
+    thumb_inline: string;
+    access_token: string;
+    live_status: {
+        status: string;
+        play_count: number;
+        allow_comment: boolean;
+        can_play: boolean;
+        timestamp: string;
+    };
+}
+interface Location {
+    longitude: number;
+    latitude: number;
+    map_view: {
+        tile_side_count: number;
+        tile_urls: string[];
+        x_loc: number;
+        y_loc: number;
+    };
+}
+interface EventData {
+    type: string;
+    performer_object: {
+        type: string;
+        object_guid: string;
+    };
+    group_voice_chat_duration: number;
+    title: string;
+    avatar_thumbnail: Avatar;
+    avatar: Avatar;
+}
+interface Avatar {
+    file_id: string;
+    mime: string;
+    dc_id: string;
+    access_hash_rec: string;
+}
+interface PollData {
+    poll_id: string;
+    question: string;
+    options: string[];
+    poll_status: {
+        state: string;
+        selection_index: number;
+        percent_vote_options: number[];
+        total_vote: number;
+        show_total_votes: boolean;
+    };
+    is_anonymous: boolean;
+    type: string;
+    allows_multiple_answers: boolean;
+}
+interface Message {
+    message_id: string;
+    text?: string;
+    time: string;
+    is_edited: boolean;
+    type: string;
+    reply_to_message_id: string;
+    author_type: string;
+    author_object_guid: string;
+    allow_transcription?: boolean;
+    file_inline?: FileInline;
+    contact_message: ContactMessage;
+    live_data: LiveData;
+    poll: PollData;
+    location: Location;
+    event_data: EventData;
+    forwarded_from?: {
+        type_from: string;
+        message_id: string;
+        object_guid: string;
+    };
+    count_seen?: string;
+    thumb_inline?: string;
+}
+interface MessageUpdate {
+    message_id: string;
+    action: string;
+    message: Message;
+    updated_parameters: any[];
+    timestamp: string;
+    prev_message_id: string;
+    object_guid: string;
+    type: string;
+    state: string;
+}
+export default MessageUpdate;

package/rubjs/types/message_update.js

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

package/rubjs/types/send_code.d.ts

@@ -0,0 +1,10 @@
+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;
+}
+export default SendCode;