rubjs 2.9.2 → 3.0.0

package/lib/core/network_login.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const undici_1 = require("undici");
+const crypto_1 = __importDefault(require("./crypto"));
+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 undici_1.Agent({
+            connect: {
+                rejectUnauthorized: false,
+            },
+        });
+    }
+    /**
+     * Retrieves API and WSS server URLs
+     */
+    async getDcs() {
+        const url = 'https://getdcmess.iranlms.ir/';
+        const RETRY_DELAY = 3000;
+        while (true) {
+            try {
+                const res = await (0, undici_1.request)(url, {
+                    method: 'GET',
+                    dispatcher: this.agent,
+                });
+                if (res.statusCode === 200) {
+                    const body = (await res.body.json());
+                    if (body?.data) {
+                        const dcs = body.data;
+                        this.apiUrl = `${dcs.API[dcs.default_api]}/`;
+                        return true;
+                    }
+                }
+                console.warn('[getDcs] Unexpected status or data format:', res.statusCode);
+            }
+            catch (error) {
+                console.error('[getDcs] Error:', error);
+            }
+            await this.delay(RETRY_DELAY);
+        }
+    }
+    /**
+     * Sends a POST request with retry logic and enhanced error reporting
+     */
+    async request(url, data) {
+        const MAX_ATTEMPTS = 3;
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            try {
+                const res = await (0, undici_1.request)(url, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        ...this.headers,
+                    },
+                    body: JSON.stringify(data),
+                    dispatcher: this.agent,
+                });
+                if (res.statusCode === 200) {
+                    const responseData = await res.body.json();
+                    return responseData;
+                }
+                else {
+                    console.warn(`[request] Attempt ${attempt}: Unexpected status ${res.statusCode}`);
+                }
+            }
+            catch (error) {
+                console.error(`[request] Attempt ${attempt} failed:`, error);
+            }
+            await this.delay(1000);
+        }
+        throw new Error(`[request] Failed after ${MAX_ATTEMPTS} attempts: ${url}`);
+    }
+    async send({ input = {}, method = 'getUserInfo', tmp_session }, { auth, decode_auth, key, privateKey }) {
+        if (!this.apiUrl)
+            await 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'] = crypto_1.default.encrypt(data_enc, key);
+        if (!tmp_session && privateKey) {
+            payload['sign'] = crypto_1.default.sign(payload['data_enc'], privateKey);
+        }
+        return await this.request(this.apiUrl, payload);
+    }
+    async bulder(name, input, { auth, key, decode_auth, privateKey }, tmp_session = false) {
+        if (!auth)
+            auth = crypto_1.default.secret(32);
+        if (!key)
+            key = Buffer.from(crypto_1.default.passphrase(auth), 'utf8');
+        const result = await this.send({
+            input,
+            tmp_session,
+            method: name,
+        }, { auth, key, decode_auth, privateKey });
+        if (result) {
+            const { data_enc } = result;
+            if (data_enc) {
+                const decrypted = crypto_1.default.decrypt(data_enc, key);
+                const parsed = JSON.parse(decrypted);
+                if (parsed.status === 'OK' && parsed.status_det === 'OK') {
+                    return { ...parsed.data, auth_data: auth, key_data: key };
+                }
+            }
+        }
+    }
+    /**
+     * Delay utility
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.default = Network;

package/lib/core/session.d.ts

@@ -0,0 +1,12 @@
+import { ClientTypes, SessionTypes } from '../types/index.type';
+declare class SessionManager {
+    private readonly secretKey;
+    private readonly filename;
+    private sessionData?;
+    constructor(input: string | ClientTypes.SessionType, secret?: string);
+    private encrypt;
+    private decrypt;
+    saveSession(sessionData: SessionTypes.SessionData): void;
+    getSession(): SessionTypes.SessionData | null;
+}
+export default SessionManager;

package/lib/core/session.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+class SessionManager {
+    constructor(input, secret = '12345678901234567890123456789012') {
+        this.secretKey = Buffer.from(secret);
+        this.filename =
+            typeof input === 'string' ? `${input}.json` : `${Date.now()}.rubjs.json`;
+        if (typeof input !== 'string') {
+            this.sessionData = input;
+        }
+    }
+    encrypt(sessionData, iv) {
+        const cipher = crypto_1.default.createCipheriv('aes-256-cbc', this.secretKey, iv);
+        let encrypted = cipher.update(JSON.stringify(sessionData), 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return encrypted;
+    }
+    decrypt(encryptedData, iv) {
+        const decipher = crypto_1.default.createDecipheriv('aes-256-cbc', this.secretKey, iv);
+        let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return JSON.parse(decrypted);
+    }
+    saveSession(sessionData) {
+        const iv = crypto_1.default.randomBytes(16);
+        const encryptedData = this.encrypt(sessionData, iv);
+        const payload = {
+            iv: iv.toString('hex'),
+            enData: encryptedData,
+        };
+        fs_1.default.writeFileSync(this.filename, JSON.stringify(payload, null, 2));
+    }
+    getSession() {
+        try {
+            if (this.sessionData) {
+                return this.decrypt(this.sessionData.enData, Buffer.from(this.sessionData.iv, 'hex'));
+            }
+            if (!fs_1.default.existsSync(this.filename)) {
+                const defaultSession = {
+                    phone: '',
+                    auth: '',
+                    guid: '',
+                    agent: '',
+                    private_key: '',
+                };
+                this.saveSession(defaultSession);
+                return defaultSession;
+            }
+            const raw = fs_1.default.readFileSync(this.filename, 'utf8');
+            const parsed = JSON.parse(raw);
+            const iv = Buffer.from(parsed.iv, 'hex');
+            return this.decrypt(parsed.enData, iv);
+        }
+        catch (error) {
+            console.error('[SessionManager] Failed to load session:', error);
+            return null;
+        }
+    }
+}
+exports.default = SessionManager;

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import Client from './core/client';
+import Filters from './core/filters';
+import Utils from './core/utils';
+import { Middleware, RubPlugin } from './types/client.type';
+import type MessageType from './types/message.type';
+import * as ContextTypes from './types/index.type';
+import * as Clients from './clients';
+export { Client, Filters, Utils, Middleware, MessageType, RubPlugin, ContextTypes, Clients, };
+export default Client;

package/lib/index.js

@@ -0,0 +1,50 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clients = exports.ContextTypes = exports.Utils = exports.Filters = exports.Client = void 0;
+const client_1 = __importDefault(require("./core/client"));
+exports.Client = client_1.default;
+const filters_1 = __importDefault(require("./core/filters"));
+exports.Filters = filters_1.default;
+const utils_1 = __importDefault(require("./core/utils"));
+exports.Utils = utils_1.default;
+const ContextTypes = __importStar(require("./types/index.type"));
+exports.ContextTypes = ContextTypes;
+const Clients = __importStar(require("./clients"));
+exports.Clients = Clients;
+exports.default = client_1.default;

package/lib/types/activities.type.d.ts

@@ -0,0 +1,12 @@
+import { Client } from '..';
+import { DecoratorsTypes } from './index.type';
+declare class Activities implements DecoratorsTypes.ShowActivities {
+    type: string;
+    object_guid: string;
+    object_type: string;
+    user_activity_guid: string;
+    store: Record<string, any>;
+    client: Client;
+    constructor(client: Client, update: DecoratorsTypes.ShowActivities);
+}
+export default Activities;

package/lib/types/activities.type.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Activities {
+    constructor(client, update) {
+        this.store = {};
+        Object.defineProperty(this, 'client', {
+            value: client,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        this.type = update.type;
+        this.object_guid = update.object_guid;
+        this.object_type = update.object_type;
+        this.user_activity_guid = update.user_activity_guid;
+    }
+}
+exports.default = Activities;

package/lib/types/chat.type.d.ts

@@ -0,0 +1,14 @@
+import { Client } from '..';
+import { DecoratorsTypes } from './index.type';
+declare class Chat implements DecoratorsTypes.ChatUpdates {
+    object_guid: string;
+    action: string;
+    chat: DecoratorsTypes.Chat;
+    updated_parameters: string[];
+    timestamp: string;
+    type: string;
+    store: Record<string, any>;
+    client: Client;
+    constructor(client: Client, update: DecoratorsTypes.ChatUpdates);
+}
+export default Chat;

package/lib/types/chat.type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Chat {
+    constructor(client, update) {
+        this.store = {};
+        Object.defineProperty(this, 'client', {
+            value: client,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        this.object_guid = update.object_guid;
+        this.action = update.action;
+        this.chat = update.chat;
+        this.updated_parameters = update.updated_parameters;
+        this.timestamp = update.timestamp;
+        this.type = update.type;
+    }
+}
+exports.default = Chat;

package/lib/types/client.type.d.ts

@@ -0,0 +1,33 @@
+import Client from '../core/client';
+import Chat from './chat.type';
+import { Activities } from './index.type';
+import Message from './message.type';
+import Notifications from './notifications.type';
+export interface Session {
+    iv: string;
+    enData: string;
+}
+export type TypeUpdate = 'activities' | 'chat' | 'message' | 'notifications';
+export type SessionType = string | Session;
+export type PlatformType = 'Android' | 'Web';
+export type ErrorMiddleware = (error: any, ctx: Message, next: () => Promise<void>) => Promise<void>;
+type PluginFunction = (client: Client) => Promise<void>;
+export interface RubPlugin {
+    name: string;
+    version?: string;
+    run: PluginFunction;
+}
+export type ContextMap = {
+    chat: Chat;
+    message: Message;
+    activities: Activities;
+    notifications: Notifications;
+};
+export type Middleware<C> = (ctx: C, next: () => Promise<void>) => Promise<void>;
+export type Handler<C> = (ctx: C) => Promise<void>;
+export type MiddlewareChain<C> = [...Middleware<C>[], Handler<C>];
+export interface Command<C> {
+    pattern: string | RegExp;
+    middlewares: MiddlewareChain<C>;
+}
+export {};

package/lib/types/decorators.type.d.ts

@@ -0,0 +1,173 @@
+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 MetaData {
+    meta_data_parts: {
+        from_index: number;
+        length: number;
+        type: string;
+        link?: {
+            url: string;
+        };
+    }[];
+}
+interface Message {
+    message_id: string;
+    text?: string;
+    time: string;
+    is_edited: boolean;
+    type: string;
+    reply_to_message_id: string;
+    author_type: string;
+    author_title: 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;
+    };
+    metadata?: MetaData;
+    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;
+    client_guid: string;
+}
+interface ChatUpdates {
+    object_guid: string;
+    action: string;
+    chat: Chat;
+    updated_parameters: string[];
+    timestamp: string;
+    type: string;
+}
+interface ChatLastMessage {
+    message_id: string;
+    type: string;
+    text: string;
+    author_object_guid?: string;
+    is_mine: boolean;
+    author_title?: string;
+    author_type?: string;
+}
+export interface Chat {
+    time_string: string;
+    last_message: ChatLastMessage;
+    last_seen_peer_mid?: string;
+    last_seen_my_mid?: string;
+    status?: string;
+    time: number;
+    last_message_id: string;
+    group_voice_chat_id?: string;
+}
+interface ShowActivities {
+    type: string;
+    object_guid: string;
+    object_type: string;
+    user_activity_guid: string;
+}
+interface ShowNotifications {
+    notification_id: string;
+    type: string;
+    title: string;
+    text: string;
+    image_file_id?: number;
+    message_data: MessageData;
+}
+interface MessageData {
+    object_guid: string;
+    object_type: string;
+    message_id: number;
+    sender_guid?: string;
+}
+export { MessageUpdate, ChatUpdates, ShowActivities, ShowNotifications, Message, FileInline, MessageData, };
+export default MessageUpdate;

package/lib/types/index.type.d.ts

@@ -0,0 +1,7 @@
+import * as ClientTypes from './client.type';
+import * as SessionTypes from './session.type';
+import * as NetworkTypes from './network.type';
+import * as DecoratorsTypes from './decorators.type';
+import Message from './message.type';
+import Activities from './activities.type';
+export { ClientTypes, SessionTypes, NetworkTypes, DecoratorsTypes, Message, Activities, };

package/lib/types/index.type.js

@@ -0,0 +1,51 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Activities = exports.Message = exports.DecoratorsTypes = exports.NetworkTypes = exports.SessionTypes = exports.ClientTypes = void 0;
+const ClientTypes = __importStar(require("./client.type"));
+exports.ClientTypes = ClientTypes;
+const SessionTypes = __importStar(require("./session.type"));
+exports.SessionTypes = SessionTypes;
+const NetworkTypes = __importStar(require("./network.type"));
+exports.NetworkTypes = NetworkTypes;
+const DecoratorsTypes = __importStar(require("./decorators.type"));
+exports.DecoratorsTypes = DecoratorsTypes;
+const message_type_1 = __importDefault(require("./message.type"));
+exports.Message = message_type_1.default;
+const activities_type_1 = __importDefault(require("./activities.type"));
+exports.Activities = activities_type_1.default;

package/lib/types/message.type.d.ts

@@ -0,0 +1,26 @@
+import { Client } from '..';
+import { DecoratorsTypes } from './index.type';
+declare class Message implements DecoratorsTypes.MessageUpdate {
+    message_id: string;
+    action: string;
+    message: DecoratorsTypes.Message;
+    updated_parameters: any[];
+    timestamp: string;
+    prev_message_id: string;
+    object_guid: string;
+    type: string;
+    state: string;
+    client_guid: string;
+    store: Record<string, any>;
+    client: Client;
+    originalType: string;
+    constructor(client: Client, update: DecoratorsTypes.MessageUpdate);
+    reply(text?: string, object_guid?: string, message_id?: string, auto_delete?: number, file_inline?: string | Buffer<ArrayBufferLike>, type?: string, is_spoil?: boolean, thumb?: string, audio_info?: boolean): Promise<any>;
+    pin(object_guid?: string, message_id?: string, action?: 'Pin' | 'Unpin'): Promise<any>;
+    reply_photo(photo: string | Buffer<ArrayBufferLike>, caption?: string, object_guid?: string, auto_delete?: number, reply_to_message_id?: string, is_spoil?: boolean, thumb?: string): Promise<any>;
+    forward(to_object_guid: string): Promise<any>;
+    delete(): Promise<any>;
+    reaction(reaction_id: number, object_guid?: string, message_id?: string, action?: 'Add' | 'Remove'): Promise<any>;
+    getReplyMessage(object_guid?: string, message_id?: string): Promise<any>;
+}
+export default Message;