rubjs 2.9.2 → 3.0.0

package/README.md

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