rubjs 2.9.3 → 3.0.0

package/README.md

@@ -1,63 +1,70 @@
 <p align="center">
   <br>
-  <b>فریمورک API روبیکا برای جاوااسکریپت</b>
+  <b>فریم‌ورک قدرتمند روبیکا برای جاوااسکریپت </b>
 </p>
 
 # RubJS
 
-> یک فریمورک مدرن، زیبا و کاملاً غیرهمزمان (Asynchronous) برای تعامل با API رسمی روبیکا با استفاده از زبان جاوااسکریپت
+> یک فریم‌ورک مدرن، زیبا و کاملاً غیرهمزمان برای تعامل با API رسمی روبیکا با ساختاری مشابه Express
 
 ---
 
-### معرفی
+## 🚀 معرفی
 
-**RubJS** فریمورکی پیشرفته و در عین حال ساده برای کار با API روبیکا است که به شما امکان می‌دهد به‌راحتی از طریق یک حساب کاربری (کلاینت سفارشی) با روبیکا ارتباط برقرار کنید. این فریمورک به صورت کامل غیرهمزمان طراحی شده تا بهترین کارایی را در برنامه‌های مدرن جاوااسکریپتی ارائه دهد.
+**RubJS** یک فریم‌ورک سبک و ماژولار برای توسعه سریع ربات‌های روبیکایی است. این فریم‌ورک با معماری مبتنی بر Middleware، سیستم فرمان‌دهی، زمان‌بندی و تایپ‌سیف، به شما این امکان را می‌دهد که در کمترین زمان، ربات‌هایی سریع، تمیز و قابل گسترش بسازید.
 
 ---
 
-### نمونه کد اولیه
+## ⚡ نمونه کد اولیه
 
-```javascript
-const { Client, Utils, Filters } = require("rubjs");
+```js
+const { Client, Utils } = require("rubjs");
 
-const bot = new Client("bot");
+const bot = new Client("rubjs");
 
-const object_guid = "object_guid";
-
-const customFilter = (msg) => msg.object_guid === object_guid;
+bot.command("/admin", authMiddleware, async (ctx) => {
+  await ctx.reply("شما ادمین هستید ✅");
+});
 
-bot.onMessageUpdates([customFilter, Filters.isText], async (message) => {
-  await message.reply(`Hello ${Utils.Italic("from")} ${Utils.Bold("RubJS")}!`);
+bot.command("message", logMiddleware, async (ctx) => {
+  await ctx.reply("سلام");
 });
 
 bot.run();
 ```
+## ✨ ویژگی‌ها
+
 <div dir="rtl">
 
-## ویژگی‌ها
-> **آماده و سریع**:
-به سادگی با نصب از npm آماده استفاده است و در کمترین زمان می‌توانید شروع به توسعه کنید.
+### پشتیبانی از پلاگین‌ها (Plugin System)  
+امکان افزودن قابلیت‌های جدید با پلاگین‌های جداگانه
+
+### طراحی middleware-based  
+با الهام از Express و Koa، تمام فرمان‌ها و رویدادها قابل ترکیب با چندین middleware هستند.
+
+### تایپ‌سیف کامل (TypeScript Ready)  
+طراحی شده با پشتیبانی کامل از تایپ‌ها برای توسعه‌دهندگان حرفه‌ای.
 
-> **سادگی در عین قدرت**:
-رابط کاربری ساده و قابل فهم که در عین حال تمام قابلیت‌های پیشرفته و رسمی API روبیکا را پوشش می‌دهد.
+### سیستم فرمان‌ها (Commands)  
+استفاده از `bot.command(pattern, ...middlewares)` برای مدیریت پیام‌های فرمان‌محور.
 
-> **طراحی زیبا و مدرن**:
-انتزاع مناسب از جزئیات سطح پایین، برای تمرکز روی منطق برنامه و توسعه سریع‌تر.
+### ابزارهای داخلی توسعه  
+مثل `Utils.Bold`, `Utils.Italic` و ... برای زیباتر کردن پاسخ‌ها به کاربر.
 
-> **کاملاً غیرهمزمان**:
-تمامی عملیات به صورت async/await انجام می‌شود تا تجربه توسعه روان و بهینه داشته باشید.
 
-> **دسترسی کامل به API**:
-امکان اجرای تمامی عملیات رسمی کلاینت روبیکا و استفاده از امکانات پیشرفته در برنامه شما.
 </div>
 
 
-## نصب
+
+## 📦 نصب
+
+
 ```bash
 npm install rubjs
 ```
 
+
 ### مستندات و آموزش‌ها
 برای مشاهده مستندات کامل، نمونه‌های بیشتر و راهنمای استفاده، به صفحه رسمی مستندات RubJS مراجعه کنید:
 
-🔗 [مشاهده مستندات RubJS](https://hadi-rostami.github.io/rubjs-docs/)
+🔗 [مشاهده مستندات RubJS](https://hadi-rostami.github.io/rubjs-docs/)

package/lib/clients/VoiceChatClient.d.ts

@@ -0,0 +1,30 @@
+import Client from '..';
+declare class VoiceChatClient {
+    private pc;
+    private source;
+    private track;
+    private ffmpeg?;
+    private buffer;
+    private frameSize;
+    private playlist;
+    private currentIndex;
+    private chatGuid?;
+    private voiceChatId?;
+    private client?;
+    private isPaused;
+    private lastPosition;
+    private intervalId?;
+    private isManualSkip;
+    private getMusicUrl?;
+    constructor(getMusicUrl?: () => Promise<string>);
+    play(filePath?: string): Promise<void>;
+    stop(): void;
+    resume(): void;
+    next(): Promise<void>;
+    previous(): void;
+    addToPlaylist(filePath: string): void;
+    removeFromPlaylist(filePath: string): void;
+    joinVoiceChat(chatGuid: string, voiceChatId: string, client: Client): Promise<void>;
+    private clearIntervals;
+}
+export default VoiceChatClient;

package/lib/clients/VoiceChatClient.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const optional_require_1 = require("optional-require");
+const optionalWrtc = (0, optional_require_1.optionalRequire)('wrtc');
+class VoiceChatClient {
+    constructor(getMusicUrl) {
+        this.buffer = Buffer.alloc(0);
+        this.frameSize = 960;
+        this.playlist = [];
+        this.currentIndex = 0;
+        this.isPaused = false;
+        this.lastPosition = 0;
+        this.isManualSkip = false;
+        if (!optionalWrtc) {
+            throw new Error('wrtc module is not installed. Some features may be disabled.');
+        }
+        this.pc = new optionalWrtc.RTCPeerConnection();
+        this.source = new optionalWrtc.nonstandard.RTCAudioSource();
+        this.track = this.source.createTrack();
+        this.pc.addTrack(this.track);
+        this.getMusicUrl = getMusicUrl;
+    }
+    async play(filePath) {
+        if (this.ffmpeg)
+            this.stop();
+        if (!filePath) {
+            if (this.playlist.length === 0) {
+                if (this.getMusicUrl) {
+                    this.playlist = [await this.getMusicUrl()];
+                }
+                else
+                    return;
+            }
+            filePath = this.playlist[this.currentIndex];
+        }
+        if (!this.chatGuid || !this.voiceChatId || !this.client) {
+            throw new Error('Voice chat not initialized. Call `joinVoiceChat` first.');
+        }
+        this.isPaused = false;
+        this.isManualSkip = false;
+        this.buffer = Buffer.alloc(0);
+        const seekArgs = this.lastPosition > 0 ? ['-ss', this.lastPosition.toString()] : [];
+        this.ffmpeg = (0, child_process_1.spawn)('ffmpeg', [
+            '-loglevel',
+            'quiet',
+            '-re',
+            '-threads',
+            '1',
+            '-protocol_whitelist',
+            'file,http,https,tcp,tls',
+            ...seekArgs,
+            '-i',
+            filePath,
+            '-acodec',
+            'pcm_s16le',
+            '-ar',
+            '48000',
+            '-ac',
+            '1',
+            '-f',
+            's16le',
+            'pipe:1',
+        ]);
+        if (this.ffmpeg?.stdout) {
+            this.ffmpeg.stdout.on('readable', () => {
+                let chunk;
+                while ((chunk = this.ffmpeg.stdout.read(this.frameSize)) !== null) {
+                    if (this.isPaused)
+                        return;
+                    const samples = new Int16Array(chunk.buffer, chunk.byteOffset, chunk.length / 2);
+                    const trimmedSamples = samples.slice(0, 960);
+                    this.source.onData({ samples: trimmedSamples, sampleRate: 48000 });
+                    this.lastPosition += 0.02;
+                }
+            });
+        }
+        this.ffmpeg.on('close', async (code) => {
+            if (!this.isManualSkip && code !== null && !this.isPaused) {
+                await this.next();
+            }
+            this.isManualSkip = false;
+        });
+        this.clearIntervals();
+        this.intervalId = setInterval(async () => {
+            try {
+                if (!this.client || !this.chatGuid || !this.voiceChatId)
+                    return;
+                await this.client.getGroupVoiceChatUpdates(this.chatGuid, this.voiceChatId);
+            }
+            catch { }
+        }, 10 * 1000);
+        this.intervalId = setInterval(async () => {
+            try {
+                if (this.isPaused ||
+                    !this.client ||
+                    !this.chatGuid ||
+                    !this.voiceChatId ||
+                    !this.client.userGuid)
+                    return;
+                await this.client.sendVoiceChatActivity(this.chatGuid, this.voiceChatId, this.client.userGuid);
+            }
+            catch { }
+        }, 2 * 1000);
+    }
+    stop() {
+        if (this.ffmpeg) {
+            this.ffmpeg.kill();
+            this.ffmpeg = undefined;
+            this.isPaused = true;
+            this.buffer = Buffer.alloc(0);
+        }
+    }
+    resume() {
+        if (this.isPaused)
+            this.play();
+    }
+    async next() {
+        if (this.playlist.length > this.currentIndex + 1) {
+            this.isManualSkip = true;
+            this.stop();
+            this.currentIndex += 1;
+            this.lastPosition = 0;
+            this.isPaused = true;
+            this.play(this.playlist[this.currentIndex]);
+        }
+        else {
+            if (this.getMusicUrl) {
+                this.playlist = [...this.playlist, await this.getMusicUrl()];
+                await this.next();
+            }
+        }
+    }
+    previous() {
+        if (this.currentIndex > 0) {
+            this.isManualSkip = true;
+            this.stop();
+            this.currentIndex--;
+            this.lastPosition = 0;
+            this.isPaused = true;
+            this.play();
+        }
+    }
+    addToPlaylist(filePath) {
+        this.playlist.push(filePath);
+    }
+    removeFromPlaylist(filePath) {
+        const index = this.playlist.indexOf(filePath);
+        if (index !== -1) {
+            this.playlist.splice(index, 1);
+            if (index <= this.currentIndex && this.currentIndex > 0) {
+                this.currentIndex--;
+            }
+        }
+    }
+    async joinVoiceChat(chatGuid, voiceChatId, client) {
+        this.chatGuid = chatGuid;
+        this.voiceChatId = voiceChatId;
+        this.client = client;
+        const offer = await this.pc.createOffer();
+        if (!offer.sdp || !client.userGuid)
+            return;
+        await this.pc.setLocalDescription(offer);
+        const connect = await client.joinGroupVoiceChat(chatGuid, voiceChatId, offer.sdp, client.userGuid);
+        const sdpAnswer = connect.sdp_answer_data;
+        await this.pc.setRemoteDescription(new optionalWrtc.RTCSessionDescription({
+            type: 'answer',
+            sdp: sdpAnswer,
+        }));
+        await client.setVoiceChatState(chatGuid, voiceChatId);
+    }
+    clearIntervals() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.default = VoiceChatClient;

package/lib/clients/index.d.ts

@@ -0,0 +1,3 @@
+import LoginClient from './loginClient';
+import VoiceChatClient from './VoiceChatClient';
+export { LoginClient, VoiceChatClient };

package/lib/clients/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceChatClient = exports.LoginClient = void 0;
+const loginClient_1 = __importDefault(require("./loginClient"));
+exports.LoginClient = loginClient_1.default;
+const VoiceChatClient_1 = __importDefault(require("./VoiceChatClient"));
+exports.VoiceChatClient = VoiceChatClient_1.default;

package/lib/clients/loginClient.d.ts

@@ -0,0 +1,47 @@
+import Network from '../core/network_login';
+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, datas: AuthResult, sessionPath?: string): Promise<{
+        isOk: boolean;
+        status: string;
+        sessionData?: undefined;
+    } | {
+        isOk: boolean;
+        status: string;
+        sessionData: {
+            phone: any;
+            auth: string;
+            guid: any;
+            agent: string;
+            private_key: string;
+        };
+    } | undefined>;
+    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/lib/clients/loginClient.js

@@ -0,0 +1,108 @@
+"use strict";
+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("../core/crypto"));
+const network_login_1 = __importDefault(require("../core/network_login"));
+const session_1 = __importDefault(require("../core/session"));
+class LoginClient {
+    static async sendCode(phone_number, pass_key) {
+        const network = new network_login_1.default();
+        const data = {
+            phone_number,
+            pass_key: pass_key || null,
+            send_type: 'SMS',
+        };
+        const result = await 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 async signIn(phone_code, datas, sessionPath) {
+        if (!datas.auth || !datas.key)
+            return;
+        const network = new network_login_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 = await network.bulder('signIn', data, auth, true);
+        if (response?.status === 'CodeIsInvalid') {
+            return { isOk: false, status: 'CodeIsInvalid' };
+        }
+        if (!response)
+            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);
+        await this.registerDevice(network, auth);
+        const sessionData = {
+            phone: response.user.phone,
+            auth: auth.auth,
+            guid: response.user.user_guid,
+            agent: network.userAgent,
+            private_key: privateKey,
+        };
+        if (sessionPath) {
+            const session = new session_1.default(sessionPath);
+            session.saveSession(sessionData);
+        }
+        return { isOk: true, status: 'Sucessfull', sessionData };
+    }
+    static async registerDevice(network, datas) {
+        const browserData = await this.getBrowser(network.userAgent, network.defaultPlatform.lang_code, network.defaultPlatform.app_version);
+        await network.bulder('registerDevice', browserData, datas);
+    }
+    static async getBrowser(userAgent, langCode, appVersion) {
+        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 = Object.entries(this.systemVersions).find(([key]) => userAgent.includes(key))?.[1] || 'Unknown';
+        const deviceHash = '2' + (userAgent.match(/\d+/g)?.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;

package/lib/core/client.d.ts

@@ -0,0 +1,38 @@
+import Network from './network';
+import { ClientTypes } from '../types/index.type';
+import SessionManager from './session';
+import Methods from './methods';
+type M = ClientTypes.Middleware<ClientTypes.ContextMap['message']>;
+type H = ClientTypes.Handler<ClientTypes.ContextMap['message']>;
+export default class Client extends Methods {
+    private session;
+    platform: ClientTypes.PlatformType;
+    timeout: number;
+    initialize: boolean;
+    key?: Buffer<ArrayBuffer>;
+    privateKey?: string;
+    decode_auth?: string;
+    auth?: string;
+    sessionDb: SessionManager;
+    network: Network;
+    plugins: ClientTypes.RubPlugin[];
+    errorMiddlewares: ClientTypes.ErrorMiddleware[];
+    cmd: {
+        pattern: string | RegExp;
+        middlewares: ClientTypes.MiddlewareChain<ClientTypes.ContextMap['message']>;
+    }[];
+    handlers: {
+        [K in ClientTypes.TypeUpdate]: ClientTypes.MiddlewareChain<ClientTypes.ContextMap[K]>[];
+    };
+    userGuid?: string;
+    constructor(session: ClientTypes.SessionType, platform?: ClientTypes.PlatformType, timeout?: number);
+    on<K extends ClientTypes.TypeUpdate>(updateType: K, handler: ClientTypes.Handler<ClientTypes.ContextMap[K]>): void;
+    on<K extends ClientTypes.TypeUpdate>(updateType: K, m1: ClientTypes.Middleware<ClientTypes.ContextMap[K]>, handler: ClientTypes.Handler<ClientTypes.ContextMap[K]>): void;
+    on<K extends ClientTypes.TypeUpdate>(updateType: K, m1: ClientTypes.Middleware<ClientTypes.ContextMap[K]>, m2: ClientTypes.Middleware<ClientTypes.ContextMap[K]>, handler: ClientTypes.Handler<ClientTypes.ContextMap[K]>): void;
+    on<K extends ClientTypes.TypeUpdate>(updateType: K, m1: ClientTypes.Middleware<ClientTypes.ContextMap[K]>, m2: ClientTypes.Middleware<ClientTypes.ContextMap[K]>, m3: ClientTypes.Middleware<ClientTypes.ContextMap[K]>, handler: ClientTypes.Handler<ClientTypes.ContextMap[K]>): void;
+    command(pattern: string | RegExp, handler: H): void;
+    command(pattern: string | RegExp, m1: M, handler: H): void;
+    command(pattern: string | RegExp, m1: M, m2: M, handler: H): void;
+    command(pattern: string | RegExp, m1: M, m2: M, m3: M, handler: H): void;
+}
+export {};

package/lib/core/client.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const network_1 = __importDefault(require("./network"));
+const session_1 = __importDefault(require("./session"));
+const methods_1 = __importDefault(require("./methods"));
+class Client extends methods_1.default {
+    constructor(session, platform = 'Web', timeout = 5000) {
+        super();
+        this.session = session;
+        this.platform = platform;
+        this.timeout = timeout;
+        this.initialize = false;
+        this.plugins = [];
+        this.errorMiddlewares = [];
+        this.cmd = [];
+        this.handlers = {
+            chat: [],
+            message: [],
+            activities: [],
+            notifications: [],
+        };
+        this.sessionDb = new session_1.default(session);
+        this.network = new network_1.default(this);
+        this.start();
+    }
+    on(updateType, ...funcs) {
+        if (funcs.length === 0) {
+            throw new Error('At least one handler is required.');
+        }
+        const last = funcs[funcs.length - 1];
+        if (last.length !== 1) {
+            throw new Error('Last argument must be a handler (ctx => Promise<void>)');
+        }
+        this.handlers[updateType].push(funcs);
+    }
+    command(pattern, ...handlers) {
+        if (handlers.length === 0) {
+            throw new Error('At least one handler is required.');
+        }
+        const last = handlers[handlers.length - 1];
+        if (last.length !== 1) {
+            throw new Error('Last handler must be of type (ctx) => Promise<void>');
+        }
+        this.cmd.push({
+            pattern,
+            middlewares: handlers,
+        });
+    }
+}
+exports.default = Client;

package/lib/core/crypto.d.ts

@@ -0,0 +1,12 @@
+declare class Crypto {
+    static AES_IV: Buffer<ArrayBuffer>;
+    static decode_auth: (auth: string) => string;
+    static passphrase(auth: string): string;
+    static secret(length: number): string;
+    static decrypt(data_enc: string, key: Buffer<ArrayBufferLike>): string;
+    static encrypt(data: string, key: Buffer<ArrayBufferLike>): string;
+    static sign(data_enc: string, privateKey: string): string;
+    static createKeys(): string[];
+    static decrypt_RSA_OAEP(private_key: string, data: string): string;
+}
+export default Crypto;