3xui-api-client 3.0.1 → 3.1.0

package/index.js

@@ -8,6 +8,7 @@ const {
     CredentialSecurity,
     ErrorSecurity
 } = require('./src/security/SecurityEnhancer');
+const { convertBandwidthFields } = require('./src/utils/ByteConversion');
 
 /**
  * 3X-UI API Client Library
@@ -74,10 +75,19 @@ class ThreeXUI {
         }
 
         this.cookie = null;
+        this.csrfToken = null;
         this.options = options;
         this.loginMutex = false; // Add mutex to prevent concurrent logins
         this.loginRetryCount = 0; // Add retry counter
         this.maxLoginRetries = 3; // Maximum login attempts
+        // Delay (ms) between forced re-login attempts on 401.
+        // Helps avoid tripping fail2ban or 3x-ui login-rate limits,
+        // especially in serverless environments where many cold-start
+        // instances may race to re-authenticate simultaneously.
+        this.loginRetryBackoff = options.loginRetryBackoff !== undefined
+            ? options.loginRetryBackoff
+            : 500;
+        this.panelType = options.panelType || 'auto'; // 'modern', 'legacy', or 'auto' for detection
 
         // Initialize security monitoring
         this.securityMonitor = new SecurityMonitor({
@@ -168,6 +178,13 @@ class ThreeXUI {
             if (existingSession && existingSession.cookie) {
                 this.cookie = existingSession.cookie;
                 this.api.defaults.headers.Cookie = this.cookie;
+                if (existingSession.csrfToken) {
+                    this.csrfToken = existingSession.csrfToken;
+                }
+                // Restore panel type from session if auto-detection was used
+                if (existingSession.panelType && this.panelType === 'auto') {
+                    this.panelType = existingSession.panelType;
+                }
                 // Reset retry count on successful session restore
                 this.loginRetryCount = 0;
                 return {
@@ -183,11 +200,66 @@ class ThreeXUI {
             params.append('username', this.username);
             params.append('password', this.password);
 
-            const response = await this.api.post('/login', params, {
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded'
+            const loginHeaders = {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            };
+
+            // Newer (React-based) 3x-ui panels require a CSRF token + session
+            // cookie obtained from /csrf-token before /login will accept
+            // credentials. Older (Vue-based) panels don't expose this
+            // endpoint (404), in which case we fall back to the classic
+            // direct login below.
+            const csrfInfo = await this._getCsrfToken();
+            if (csrfInfo) {
+                loginHeaders['X-CSRF-Token'] = csrfInfo.token;
+                loginHeaders['Cookie'] = csrfInfo.cookie;
+            }
+
+            // Try modern endpoint first (/panel/api/login), then fall back to legacy endpoint (/login)
+            // This supports both newer (React-based) and older (Vue-based) 3x-ui panels
+            let response;
+            let lastError;
+            let detectedPanelType = this.panelType;
+
+            // Determine which endpoint to try based on panelType setting
+            const tryModernFirst = this.panelType !== 'legacy';
+            const tryLegacyFallback = this.panelType !== 'modern';
+
+            if (tryModernFirst) {
+                // Try modern endpoint first (/panel/api/login)
+                try {
+                    response = await this.api.post('/panel/api/login', params, {
+                        headers: loginHeaders
+                    });
+                    if (this.panelType === 'auto') {
+                        detectedPanelType = 'modern';
+                    }
+                } catch (modernError) {
+                    lastError = modernError;
+                    // If modern endpoint fails and fallback is enabled, try legacy endpoint
+                    if (tryLegacyFallback) {
+                        try {
+                            response = await this.api.post('/login', params, {
+                                headers: loginHeaders
+                            });
+                            if (this.panelType === 'auto') {
+                                detectedPanelType = 'legacy';
+                            }
+                        } catch {
+                            // Both endpoints failed, throw the last error
+                            throw lastError;
+                        }
+                    } else {
+                        throw modernError;
+                    }
                 }
-            });
+            } else {
+                // Try legacy endpoint first (/login) if explicitly set
+                response = await this.api.post('/login', params, {
+                    headers: loginHeaders
+                });
+                detectedPanelType = 'legacy';
+            }
 
             if (response.data.success) {
                 const cookies = response.headers['set-cookie'];
@@ -195,11 +267,24 @@ class ThreeXUI {
                     this.cookie = cookies[0].split(';')[0];
                     this.api.defaults.headers.Cookie = this.cookie;
 
+                    // On newer panels, every non-safe request (POST/PUT/DELETE)
+                    // also requires this CSRF token, not just /login.
+                    if (csrfInfo) {
+                        this.csrfToken = csrfInfo.token;
+                    }
+
+                    // Update panel type after successful detection
+                    if (this.panelType === 'auto') {
+                        this.panelType = detectedPanelType;
+                    }
+
                     // Store session if session manager is available
                     if (this.sessionManager) {
                         try {
                             await this.sessionManager.storeSession(this.baseURL, this.username, {
                                 cookie: this.cookie,
+                                csrfToken: this.csrfToken,
+                                panelType: detectedPanelType, // Store detected panel type for future use
                                 loginTime: new Date().toISOString()
                             });
                         } catch (sessionError) {
@@ -243,6 +328,43 @@ class ThreeXUI {
         }
     }
 
+    /**
+     * Detect newer (React-based) 3x-ui panels and obtain the CSRF token +
+     * session cookie required by their /login endpoint.
+     *
+     * Older (Vue-based) panels don't expose /csrf-token and respond with a
+     * 404, in which case this returns null so login() falls back to the
+     * classic direct login flow.
+     *
+     * @returns {Promise<{token: string, cookie: string} | null>}
+     */
+    async _getCsrfToken() {
+        try {
+            const response = await this.api.get('/csrf-token', {
+                headers: { 'X-Requested-With': 'XMLHttpRequest' },
+                validateStatus: (status) => status === 200 || status === 404
+            });
+
+            if (response.status !== 200 || !response.data || !response.data.success || !response.data.obj) {
+                return null;
+            }
+
+            const cookies = response.headers['set-cookie'];
+            if (!cookies || cookies.length === 0) {
+                return null;
+            }
+
+            return {
+                token: response.data.obj,
+                cookie: cookies[0].split(';')[0]
+            };
+        } catch {
+            // /csrf-token unreachable or errored - treat as an old panel
+            // and let login() proceed with the classic flow.
+            return null;
+        }
+    }
+
     /**
      * Logout and clear session
      */
@@ -254,6 +376,7 @@ class ThreeXUI {
         }
 
         this.cookie = null;
+        this.csrfToken = null;
         delete this.api.defaults.headers.Cookie;
 
         if (this.sessionManager) {
@@ -269,7 +392,7 @@ class ThreeXUI {
         return this._request('post', '/getTwoFactorEnable');
     }
 
-    async _request(method, path, data = {}) {
+    async _request(method, path, data = {}, extraHeaders = {}) {
         // Check session validity first with mutex protection if token is not provided
         if (!this.token) {
             if (!this.loginMutex && this.sessionManager && !await this.sessionManager.hasValidSession(this.baseURL, this.username)) {
@@ -284,7 +407,7 @@ class ThreeXUI {
                 method,
                 url: path,
                 data,
-                ...(method.toLowerCase() === 'post' ? { headers: { 'Content-Type': 'application/json' } } : {})
+                headers: { ...this._buildRequestHeaders(method), ...extraHeaders }
             });
             // Reset retry counter on successful request
             this.loginRetryCount = 0;
@@ -294,14 +417,20 @@ class ThreeXUI {
                 if (this.token) {
                     throw new Error('API Token is invalid or expired. Please check your credentials.');
                 }
-                // Cookie might have expired, try to login again with retry limit
+                // Cookie might have expired, try to login again with retry limit.
+                // A configurable backoff delay is applied before each re-login to
+                // avoid burning through the retry budget or tripping login-rate limits
+                // (e.g. fail2ban) when many instances race to re-authenticate.
                 if (this.loginRetryCount < this.maxLoginRetries) {
+                    if (this.loginRetryBackoff > 0) {
+                        await new Promise(resolve => setTimeout(resolve, this.loginRetryBackoff));
+                    }
                     await this._ensureAuthenticated(true); // Force refresh
                     const response = await this.api.request({
                         method,
                         url: path,
                         data,
-                        ...(method.toLowerCase() === 'post' ? { headers: { 'Content-Type': 'application/json' } } : {})
+                        headers: { ...this._buildRequestHeaders(method), ...extraHeaders }
                     });
                     return response.data;
                 } else {
@@ -312,6 +441,30 @@ class ThreeXUI {
         }
     }
 
+    /**
+     * Build per-request headers, including the JSON content type for POST
+     * bodies and (on cookie-authenticated sessions against newer
+     * React-based panels) the X-CSRF-Token header required for non-safe
+     * HTTP methods.
+     *
+     * @param {string} method - HTTP method for the request
+     * @returns {Object} Headers to merge into the request
+     */
+    _buildRequestHeaders(method) {
+        const headers = {};
+
+        if (method.toLowerCase() === 'post') {
+            headers['Content-Type'] = 'application/json';
+        }
+
+        const isSafeMethod = ['get', 'head', 'options'].includes(method.toLowerCase());
+        if (!isSafeMethod && !this.token && this.csrfToken) {
+            headers['X-CSRF-Token'] = this.csrfToken;
+        }
+
+        return headers;
+    }
+
     /**
      * Ensure authentication with mutex protection
      * @param {boolean} forceRefresh - Force a new login
@@ -443,6 +596,7 @@ class ThreeXUI {
      */
     async addClientWithCredentials(inboundId, protocol, options = {}) {
         const credentials = this.generateCredentials(protocol, options);
+        const convertedOptions = convertBandwidthFields(options);
 
         const clientConfig = {
             id: inboundId,
@@ -450,10 +604,10 @@ class ThreeXUI {
                 clients: [{
                     ...credentials,
                     enable: true,
-                    expiryTime: options.expiryTime || 0,
-                    limitIp: options.limitIp || 0,
-                    totalGB: options.totalGB || 0,
-                    subId: options.subId || this.generateUUID()
+                    expiryTime: convertedOptions.expiryTime || 0,
+                    limitIp: convertedOptions.limitIp || 0,
+                    totalGB: convertedOptions.totalGB || 0,
+                    subId: convertedOptions.subId || this.generateUUID()
                 }]
             })
         };
@@ -492,17 +646,19 @@ class ThreeXUI {
                 throw new Error(`Client with ID ${clientId} not found in inbound ${inboundId}`);
             }
 
+            // Convert bandwidth fields (GB to bytes)
+            const convertedOptions = convertBandwidthFields(options);
+
             // Convert user-friendly options to API format
             const processedOptions = {
-                email: options.email || existingClients[clientIndex].email,
-                limitIp: options.limitIp !== undefined ? options.limitIp : existingClients[clientIndex].limitIp,
-                // totalGB is specified in gigabytes in 3x-ui config; do not convert to bytes
-                totalGB: options.totalGB !== undefined ? options.totalGB : existingClients[clientIndex].totalGB,
-                expiryTime: options.expiryDays ? Date.now() + (options.expiryDays * 24 * 60 * 60 * 1000) : existingClients[clientIndex].expiryTime,
-                enable: options.enable !== undefined ? options.enable : existingClients[clientIndex].enable,
-                flow: options.flow || existingClients[clientIndex].flow,
-                encryption: options.encryption || existingClients[clientIndex].encryption || 'none',
-                subId: options.subId || existingClients[clientIndex].subId
+                email: convertedOptions.email || existingClients[clientIndex].email,
+                limitIp: convertedOptions.limitIp !== undefined ? convertedOptions.limitIp : existingClients[clientIndex].limitIp,
+                totalGB: convertedOptions.totalGB !== undefined ? convertedOptions.totalGB : existingClients[clientIndex].totalGB,
+                expiryTime: convertedOptions.expiryDays ? Date.now() + (convertedOptions.expiryDays * 24 * 60 * 60 * 1000) : existingClients[clientIndex].expiryTime,
+                enable: convertedOptions.enable !== undefined ? convertedOptions.enable : existingClients[clientIndex].enable,
+                flow: convertedOptions.flow || existingClients[clientIndex].flow,
+                encryption: convertedOptions.encryption || existingClients[clientIndex].encryption || 'none',
+                subId: convertedOptions.subId || existingClients[clientIndex].subId
             };
 
             // Update the specific client while preserving others
@@ -527,8 +683,8 @@ class ThreeXUI {
                 ...result,
                 updatedOptions: processedOptions,
                 conversions: {
-                    totalGB: options.totalGB !== undefined ? `${options.totalGB}GB` : 'unchanged',
-                    expiryDays: options.expiryDays ? `${options.expiryDays} days → ${new Date(processedOptions.expiryTime).toISOString()}` : 'unchanged'
+                    totalGB: convertedOptions.totalGB !== undefined ? `${options.totalGB} GB → ${convertedOptions.totalGB} bytes` : 'unchanged',
+                    expiryDays: convertedOptions.expiryDays ? `${convertedOptions.expiryDays} days → ${new Date(processedOptions.expiryTime).toISOString()}` : 'unchanged'
                 }
             };
         } catch (error) {
@@ -669,7 +825,11 @@ class ThreeXUI {
      * @returns {Promise<Object>} Addition response
      */
     addModernClient(data) {
-        return this._request('post', '/panel/api/clients/add', data);
+        const convertedData = {
+            ...data,
+            client: data.client ? convertBandwidthFields(data.client) : undefined
+        };
+        return this._request('post', '/panel/api/clients/add', convertedData);
     }
 
     /**
@@ -679,7 +839,8 @@ class ThreeXUI {
      * @returns {Promise<Object>} Update response
      */
     updateModernClient(email, data) {
-        return this._request('post', `/panel/api/clients/update/${encodeURIComponent(email)}`, data);
+        const convertedData = convertBandwidthFields(data);
+        return this._request('post', `/panel/api/clients/update/${encodeURIComponent(email)}`, convertedData);
     }
 
     /**
@@ -836,8 +997,15 @@ class ThreeXUI {
         return this._request('post', `/panel/api/nodes/del/${encodeURIComponent(id)}`);
     }
 
-    setNodeEnable(id) {
-        return this._request('post', `/panel/api/nodes/setEnable/${encodeURIComponent(id)}`);
+    /**
+     * Enable or disable a node.
+     * @param {number|string} id - Node ID
+     * @param {boolean} [enable] - Desired enabled state. If omitted, the panel toggles the current state.
+     * @returns {Promise<Object>} Result of the operation
+     */
+    setNodeEnable(id, enable) {
+        const data = typeof enable === 'boolean' ? { enable } : {};
+        return this._request('post', `/panel/api/nodes/setEnable/${encodeURIComponent(id)}`, data);
     }
 
     testNode(data) {
@@ -916,11 +1084,21 @@ class ThreeXUI {
     }
 
     /**
-     * Import inbounds
-     * @param {Array} inbounds - Array of inbound configurations
+     * Import one or more inbounds. The panel endpoint only accepts a single
+     * inbound per request (as a form-encoded `data` field containing the
+     * inbound JSON), so each inbound is sent as a separate request.
+     * @param {Object|Object[]} inbounds - Inbound configuration, or array of configurations
+     * @returns {Promise<Object[]>} One response object per imported inbound
      */
     importInbounds(inbounds) {
-        return this._request('post', '/panel/api/inbounds/import', { inbounds });
+        const list = Array.isArray(inbounds) ? inbounds : [inbounds];
+        return Promise.all(list.map((inboundConfig) => {
+            const validatedConfig = InputValidator.validateInboundConfig(inboundConfig);
+            const body = new URLSearchParams({ data: JSON.stringify(validatedConfig) }).toString();
+            return this._request('post', '/panel/api/inbounds/import', body, {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            });
+        }));
     }
 
     /**
@@ -1027,10 +1205,10 @@ class ThreeXUI {
 
     /**
      * Get CPU usage history
-     * @param {string} bucket - Time bucket (e.g., 'min', 'hour')
+     * @param {number} bucket - Bucket size in seconds. Must be one of: 2, 30, 60, 120, 180, 300
      */
-    getCPUHistory(bucket = 'min') {
-        return this._request('get', `/panel/api/server/cpuHistory/${bucket}`);
+    getCPUHistory(bucket = 60) {
+        return this._request('get', `/panel/api/server/cpuHistory/${encodeURIComponent(bucket)}`);
     }
 
     /**
@@ -1049,9 +1227,24 @@ class ThreeXUI {
 
     /**
      * Download database
+     * @returns {Promise<string>} Raw SQLite database file content as a string (starts with "SQLite format 3 ..."), not a Buffer
      */
-    getDb() {
-        return this._request('get', '/panel/api/server/getDb');
+    async getDb() {
+        const response = await this._request('get', '/panel/api/server/getDb');
+        // Add response validation
+        if (!response || typeof response !== 'object') {
+            throw new Error('getDb: Invalid response format');
+        }
+        if (response.success === false) {
+            throw new Error(`getDb failed: ${response.msg || 'Unknown error'}`);
+        }
+        if (!response.obj) {
+            throw new Error('getDb: Response missing database content');
+        }
+        if (typeof response.obj !== 'string') {
+            throw new Error(`getDb: Expected string content, got ${typeof response.obj}`);
+        }
+        return response;
     }
 
     /**
@@ -1070,9 +1263,20 @@ class ThreeXUI {
 
     /**
      * Install specific Xray version
-     * @param {string} version - Version to install
+     * @param {string} version - Version to install (e.g., "1.8.0")
      */
     installXray(version) {
+        // Validate version parameter
+        if (!version || typeof version !== 'string') {
+            throw new Error('installXray: version must be a non-empty string');
+        }
+        if (version.toLowerCase() === 'latest') {
+            throw new Error(
+                'installXray: "latest" is not a valid version. ' +
+                'Use client.getXrayVersion() to get available versions, ' +
+                'then pass a specific version like "1.8.0"'
+            );
+        }
         return this._request('post', `/panel/api/server/installXray/${version}`);
     }
 
@@ -1140,8 +1344,25 @@ class ThreeXUI {
         return this._request('get', '/panel/api/server/getNewVlessEnc');
     }
 
-    getNewEchCert() {
-        return this._request('post', '/panel/api/server/getNewEchCert');
+    /**
+     * Generate a new ECH (Encrypted Client Hello) certificate.
+     * @param {string} [sni] - Optional SNI to embed in the generated certificate.
+     *   Sent as `application/x-www-form-urlencoded` since the panel reads it via `c.PostForm`.
+     * @returns {Promise<Object>} Generated ECH certificate data
+     */
+    getNewEchCert(sni) {
+        const body = sni ? new URLSearchParams({ sni }).toString() : '';
+        return this._request('post', '/panel/api/server/getNewEchCert', body, {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        });
+    }
+
+    /**
+     * Get the panel's configured web certificate/key file paths.
+     * @returns {Promise<Object>} Web certificate file info
+     */
+    getWebCertFiles() {
+        return this._request('get', '/panel/api/server/getWebCertFiles');
     }
 
     // ===========================================
@@ -1152,52 +1373,106 @@ class ThreeXUI {
      * Get all panel settings
      */
     getAllSettings() {
-        return this._request('post', '/panel/setting/all');
+        return this._request('post', '/panel/api/setting/all');
     }
 
     /**
      * Update panel settings
-     * @param {Object} settings - Settings to update
-     */
-    updateSetting(settings) {
-        return this._request('post', '/panel/setting/update', settings);
+     * NOTE: The API requires ALL settings to be sent together, not just the changed ones.
+     * This method automatically fetches current settings, applies your changes, and sends all.
+     * @param {Object} updates - Settings to update (partial object, will be merged with current)
+     * @returns {Promise} Response from /panel/api/setting/update
+     */
+    async updateSetting(updates) {
+        if (!updates || typeof updates !== 'object') {
+            throw new Error('updates must be an object');
+        }
+
+        // Fetch current settings
+        const currentResponse = await this.getAllSettings();
+        if (!currentResponse.success || !currentResponse.obj) {
+            throw new Error('Failed to fetch current settings for merge');
+        }
+
+        // Merge updates with current settings (updates override current)
+        const mergedSettings = {
+            ...currentResponse.obj,
+            ...updates
+        };
+
+        // Send all settings together
+        return this._request('post', '/panel/api/setting/update', mergedSettings);
     }
 
     /**
      * Update admin username and password
+     * ⚠️ CRITICAL: This endpoint changes your login credentials.
+     * After a successful update, the internal client credentials are refreshed
+     * and the session is re-authenticated with new credentials.
      * @param {string} oldUsername - Current username
      * @param {string} oldPassword - Current password
      * @param {string} newUsername - New username
      * @param {string} newPassword - New password
      */
-    updateUser(oldUsername, oldPassword, newUsername, newPassword) {
-        return this._request('post', '/panel/setting/updateUser', {
+    async updateUser(oldUsername, oldPassword, newUsername, newPassword) {
+        const response = await this._request('post', '/panel/api/setting/updateUser', {
             oldUsername,
             oldPassword,
             newUsername,
             newPassword
         });
+
+        if (response && response.success) {
+            // Update internal credentials to match new credentials
+            const oldUsername_ = this.username;
+            this.username = newUsername;
+            this.password = newPassword;
+
+            // Clear old session from session manager
+            if (this.sessionManager) {
+                try {
+                    await this.sessionManager.deleteSession(this.baseURL, oldUsername_);
+                } catch (error) {
+                    console.warn('[3xui-api-client] Could not delete old session:', error.message);
+                }
+            }
+
+            // Re-authenticate with new credentials to ensure session is valid
+            try {
+                await this.login(true); // Force refresh with new credentials
+            } catch (error) {
+                // If login fails after credential change, restore old credentials and re-throw
+                this.username = oldUsername;
+                this.password = oldPassword;
+                if (this.sessionManager) {
+                    await this.sessionManager.deleteSession(this.baseURL, newUsername);
+                }
+                throw new Error(`Credential update succeeded but re-authentication failed: ${error.message}`);
+            }
+        }
+
+        return response;
     }
 
     /**
      * Restart the panel
      */
     restartPanel() {
-        return this._request('post', '/panel/setting/restartPanel');
+        return this._request('post', '/panel/api/setting/restartPanel');
     }
 
     /**
      * Get default settings
      */
     getDefaultSettings() {
-        return this._request('post', '/panel/setting/defaultSettings');
+        return this._request('post', '/panel/api/setting/defaultSettings');
     }
 
     /**
      * Get default Xray JSON config
      */
     getDefaultJsonConfig() {
-        return this._request('get', '/panel/setting/getDefaultJsonConfig');
+        return this._request('get', '/panel/api/setting/getDefaultJsonConfig');
     }
 
     // ===========================================
@@ -1208,45 +1483,57 @@ class ThreeXUI {
      * Get Xray configuration
      */
     getXrayConfig() {
-        return this._request('post', '/panel/xray/');
+        return this._request('post', '/panel/api/xray/');
     }
 
     /**
      * Update Xray configuration
-     * @param {string} config - Xray configuration content
+     * @param {string|object} config - Xray configuration content (JSON string or object)
      */
     updateXrayConfig(config) {
-        return this._request('post', '/panel/xray/update', { content: config });
+        // Parse JSON string to object before sending
+        if (typeof config === 'string') {
+            try {
+                config = JSON.parse(config);
+            } catch (error) {
+                throw new Error(`updateXrayConfig: Invalid JSON: ${error.message}`);
+            }
+        }
+        // Validate it's an object
+        if (!config || typeof config !== 'object') {
+            throw new Error('updateXrayConfig: config must be a valid JSON object or string');
+        }
+        return this._request('post', '/panel/api/xray/update', { content: JSON.stringify(config) });
     }
 
     /**
      * Manage WARP
-     * @param {string} action - Action to perform (data, del, config, reg, license)
+     * @param {string} action - Action to perform (data, del, config, reg, changeIp, license, interval)
      * @param {Object} [data] - Additional data for the action
      */
     manageWarp(action, data = {}) {
-        return this._request('post', `/panel/xray/warp/${action}`, data);
+        return this._request('post', `/panel/api/xray/warp/${action}`, data);
     }
 
     /**
      * Get outbound traffic statistics
      */
     getOutboundsTraffic() {
-        return this._request('get', '/panel/xray/getOutboundsTraffic');
+        return this._request('get', '/panel/api/xray/getOutboundsTraffic');
     }
 
     /**
      * Reset outbound traffic statistics
      */
     resetOutboundsTraffic() {
-        return this._request('post', '/panel/xray/resetOutboundsTraffic');
+        return this._request('post', '/panel/api/xray/resetOutboundsTraffic');
     }
 
     /**
      * Get Xray execution result
      */
     getXrayResult() {
-        return this._request('get', '/panel/xray/getXrayResult');
+        return this._request('get', '/panel/api/xray/getXrayResult');
     }
 
     // Security Methods