hiddifypanel 7.1.9__py3-none-any.whl → 8.0.0.dev0__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-7.1.9
+8.0.0.dev

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='7.1.9'
+__version__='8.0.0.dev'
 from datetime import datetime
-__release_date__= datetime.strptime('2023-07-30','%Y-%m-%d')
+__release_date__= datetime.strptime('2023-08-03','%Y-%m-%d')

hiddifypanel/base.py

@@ -5,30 +5,29 @@ from flask import Flask, request, g
 from flask_babelex import Babel
 from hiddifypanel.panel.init_db import init_db
 import hiddifypanel
-from hiddifypanel.models import  *
+from hiddifypanel.models import *
 from dotenv import dotenv_values
 import os
-def create_app(cli=False,**config):
+
+
+def create_app(cli=False, **config):
     app = Flask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True)
 
-    for c,v in dotenv_values('app.cfg').items():
+    for c, v in dotenv_values('app.cfg').items():
         if v.isdecimal():
-            v= int(v)
+            v = int(v)
         else:
-            v=True if v.lower()=="true" else (False if v.lower()=="false" else v)
+            v = True if v.lower() == "true" else (False if v.lower() == "false" else v)
 
-        
-        app.config[c]=v
-        
+        app.config[c] = v
 
     app.jinja_env.line_statement_prefix = '%'
-    app.is_cli=cli
+    app.is_cli = cli
     flask_bootstrap.Bootstrap4(app)
-    
+
     hiddifypanel.panel.database.init_app(app)
     with app.app_context():
         init_db()
-        
 
     hiddifypanel.panel.common.init_app(app)
     hiddifypanel.panel.admin.init_app(app)
@@ -58,10 +57,14 @@ def create_app(cli=False,**config):
 
     @app.before_request
     def check_csrf():
-        if "/admin/user/" in request.base_url: return
-        if "/admin/domain/" in request.base_url: return
-        if "/admin/actions/" in request.base_url: return
-        if "/api/v1/" in request.base_url: return
+        if "/admin/user/" in request.base_url:
+            return
+        if "/admin/domain/" in request.base_url:
+            return
+        if "/admin/actions/" in request.base_url:
+            return
+        if "/api/v1/" in request.base_url:
+            return
         csrf.protect()
 
     app.jinja_env.globals['get_locale'] = get_locale

hiddifypanel/cache.py

@@ -0,0 +1,11 @@
+from redis_cache import RedisCache
+import redis
+
+redis_client = redis.from_url('unix:///opt/hiddify-config/other/redis/run.sock?db=0', decode_responses=True)
+
+
+def exception_handler(**kwargs):
+    pass
+
+
+cache = RedisCache(redis_client=redis_client, exception_handler=exception_handler)

hiddifypanel/drivers/abstract_driver.py

@@ -0,0 +1,5 @@
+
+
+class DriverABS:
+    def get_usage(uuid,reset=True):
+        pass

hiddifypanel/drivers/singbox_api.py

@@ -0,0 +1,52 @@
+import xtlsapi
+from hiddifypanel.models import *
+from .abstract_driver import DriverABS
+
+
+class SingboxApi(DriverABS):
+    def get_singbox_client(self):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        return xtlsapi.SingboxClient('127.0.0.1', 10086)
+
+    def get_enabled_users(self):
+        if hconfig(ConfigEnum.is_parent):
+            return
+
+    def get_inbound_tags():
+        if hconfig(ConfigEnum.is_parent):
+            return
+        try:
+            xray_client = self.get_singbox_client()
+            inbounds = [inb.name.split(">>>")[1] for inb in xray_client.stats_query('inbound')]
+            print(f"Success in get inbound tags {inbounds}")
+        except Exception as e:
+            print(f"error in get inbound tags {e}")
+            inbounds = []
+        return list(set(inbounds))
+
+    def add_client(user):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        # raise NotImplementedError()
+
+    def remove_client(user):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        # raise NotImplementedError()
+
+    def get_usage(uuid, reset=False):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        xray_client = self.get_singbox_client()
+        d = xray_client.get_client_download_traffic(f'{uuid}@hiddify.com', reset=reset)
+        u = xray_client.get_client_upload_traffic(f'{uuid}@hiddify.com', reset=reset)
+        print(f"Success {uuid} d={d} u={u}")
+        res = None
+        if d is None:
+            res = u
+        elif u is None:
+            res = d
+        else:
+            res = d + u
+        return res

hiddifypanel/drivers/ssh_liberty_bridge_api.py

@@ -0,0 +1,53 @@
+from .abstract_driver import DriverABS
+from hiddifypanel.models import *
+import redis
+
+USERS_SET = "ssh-server:users"
+USERS_USAGE = "ssh-server:users-usage"
+
+
+class SSHLibertyBridgeApi(DriverABS):
+
+    def get_ssh_redis_client(self):
+        if not getattr(self, 'redis_client'):
+            self.redis_client = redis.from_url(hconfig(ConfigEnum.ssh_server_redis_url), decode_responses=True)
+
+        return self.redis_client
+
+    def get_enabled_users(self):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        redis_client = self.get_ssh_redis_client()
+        members = redis_client.smembers(USERS_SET)
+        return [m.split("::")[0] for m in members]
+
+    def add_client(self, user):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        redis_client = self.get_ssh_redis_client()
+        redis_client.sadd(USERS_SET, f'{user.uuid}::{user.ed25519_public_key}')
+        redis_client.save()
+
+    def remove_client(self, user):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        redis_client = self.get_ssh_redis_client()
+        redis_client.srem(USERS_SET, f'{user.uuid}::{user.ed25519_public_key}')
+        redis_client.srem(USERS_USAGE, user.uuid)
+        redis_client.save()
+
+    def get_usage(self, client_uuid: str, reset: bool = True) -> int:
+        if hconfig(ConfigEnum.is_parent):
+            return
+        value = redis_client.hget(USERS_USAGE, client_uuid)
+
+        if value is None:
+            return 0
+
+        value = int(value)
+
+        if reset:
+            redis_client.hincrby(USERS_USAGE, client_uuid, -value)
+            redis_client.save()
+
+        return value

hiddifypanel/drivers/user_driver.py

@@ -0,0 +1,30 @@
+
+
+from .ssh_liberty_bridge_api import SSHLibertyBridgeApi
+from .xray_api import XrayApi
+from .singbox_api import SingboxApi
+
+
+drivers = [XrayApi(), SingboxApi(), SSHLibertyBridgeApi()]
+
+
+def get_users_usage(reset=True):
+    res = {}
+    for user in User.query.all():
+        d = 0
+        for driver in drivers:
+            d += driver.get_usage(user.uuid, reset=True) or 0
+        res[user] = {'usage': d, 'ips': ''}
+    return res
+
+
+def get_enabled_users(self):
+    d = []
+    for driver in drivers:
+        d += driver.get_enabled_users() or []
+    return d
+
+
+def add_client(self, user):
+    for driver in drivers:
+        d += driver.add_client(user)

hiddifypanel/drivers/xray_api.py

@@ -0,0 +1,113 @@
+import xtlsapi
+from hiddifypanel.models import *
+from .abstract_driver import DriverABS
+
+
+class XrayApi(DriverABS):
+    def get_xray_client(self):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        return xtlsapi.XrayClient('127.0.0.1', 10085)
+
+    def get_enabled_users(self):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        xray_client = self.get_xray_client()
+        users = User.query.all()
+        t = "xtls"
+        protocol = "vless"
+        enabled = {}
+        for u in users:
+            uuid = u.uuid
+            try:
+                xray_client.add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol, flow='xtls-rprx-vision', alter_id=0, cipher='chacha20_poly1305')
+                xray_client.remove_client(t, f'{uuid}@hiddify.com')
+                enabled[uuid] = 0
+            except xtlsapi.exceptions.EmailAlreadyExists as e:
+                enabled[uuid] = 1
+            except Exception as e:
+                print(f"error {e}")
+                enabled[uuid] = e
+        return enabled
+
+    def get_inbound_tags(self):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        try:
+            xray_client = self.get_xray_client()
+            inbounds = [inb.name.split(">>>")[1] for inb in xray_client.stats_query('inbound')]
+            print(f"Success in get inbound tags {inbounds}")
+        except Exception as e:
+            print(f"error in get inbound tags {e}")
+            inbounds = []
+        return list(set(inbounds))
+
+    def add_client(self, user):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        uuid = user.uuid
+        xray_client = self.get_xray_client()
+        tags = self.get_inbound_tags()
+        proto_map = {
+            'vless': 'vless',
+            'realityin': 'vless',
+            'xtls': 'vless',
+                    'quic': 'vless',
+                    'trojan': 'trojan',
+                    'vmess': 'vmess',
+                    'ss': 'shadowsocks',
+                    'v2ray': 'shadowsocks',
+                    'kcp': 'vless',
+                    'dispatcher': 'trojan',
+        }
+
+        def proto(t):
+            res = '', ''
+            for p, protocol in proto_map.items():
+                if p in t:
+                    res = p, protocol
+                    break
+            return res
+        for t in tags:
+            try:
+                p, protocol = proto(t)
+                if not p:
+                    continue
+                if protocol == "vless" and p != "xtls" and p != "realityin":
+                    xray_client.add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol, flow='\0',)
+                else:
+                    xray_client.add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol, flow='xtls-rprx-vision', alter_id=0, cipher='chacha20_poly1305')
+                print(f"Success add  {uuid} {t}")
+            except Exception as e:
+                print(f"error in add  {uuid} {t} {e}")
+                pass
+
+    def remove_client(self, uuid):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        xray_client = self.get_xray_client()
+        tags = self.get_inbound_tags()
+
+        for t in tags:
+            try:
+                xray_client.remove_client(t, f'{uuid}@hiddify.com')
+                print(f"Success remove  {uuid} {t}")
+            except Exception as e:
+                print(f"error in remove  {uuid} {t} {e}")
+                pass
+
+    def get_usage(self, uuid, reset=False):
+        if hconfig(ConfigEnum.is_parent):
+            return
+        xray_client = self.get_xray_client()
+        d = xray_client.get_client_download_traffic(f'{uuid}@hiddify.com', reset=reset)
+        u = xray_client.get_client_upload_traffic(f'{uuid}@hiddify.com', reset=reset)
+        print(f"Success {uuid} d={d} u={u}")
+        res = None
+        if d is None:
+            res = u
+        elif u is None:
+            res = d
+        else:
+            res = d + u
+        return res

hiddifypanel/models/config.py

@@ -1,3 +1,4 @@
+# from hiddifypanel.cache import cache
 from sqlalchemy_serializer import SerializerMixin
 from flask import Flask
 from flask_sqlalchemy import SQLAlchemy
@@ -48,6 +49,7 @@ class StrConfig(db.Model, SerializerMixin):
         }
 
 
+# @cache.cache()
 def hconfig(key: ConfigEnum, child_id=0):
     value = None
     try:
@@ -74,7 +76,7 @@ def hconfig(key: ConfigEnum, child_id=0):
 
 
 def set_hconfig(key: ConfigEnum, value, child_id=0, commit=True):
-
+    hconfig.invalidate(key, child_id)
     if key.type() == bool:
         dbconf = BoolConfig.query.filter(BoolConfig.key == key, BoolConfig.child_id == child_id).first()
         if not dbconf:

hiddifypanel/models/config_enum.py

@@ -26,7 +26,7 @@ class ConfigCategory(StrEnum):
     telegram = auto()
     http = auto()
     tls = auto()
-
+    ssh = auto()
     ssfaketls = auto()
     shadowtls = auto()
     restls = auto()
@@ -41,6 +41,9 @@ class ConfigCategory(StrEnum):
 
 
 class ConfigEnum(StrEnum):
+    ssh_server_redis_url = auto()
+    ssh_server_ports = auto()
+    ssh_server_enable = auto()
     first_setup = auto()
     core_type = auto()
     warp_enable = auto()
@@ -139,6 +142,9 @@ class ConfigEnum(StrEnum):
 
     def info(self):
         map = {
+            self.ssh_server_redis_url: {'category': ConfigCategory.hidden},
+            self.ssh_server_ports: {'category': ConfigCategory.ssh},
+            self.ssh_server_enable: {'category': ConfigCategory.ssh},
             self.core_type: {'category': ConfigCategory.advanced, 'apply_mode': 'apply'},
             self.dns_server: {'category': ConfigCategory.general, 'apply_mode': 'apply'},
             self.warp_enable: {'category': ConfigCategory.hidden, 'type': bool, 'apply_mode': 'restart'},

hiddifypanel/models/proxy.py

@@ -25,6 +25,7 @@ class ProxyTransport(StrEnum):
     # h1=auto()
     WS = auto()
     tcp = auto()
+    ssh = auto()
 
 
 class ProxyCDN(StrEnum):
@@ -40,6 +41,7 @@ class ProxyProto(StrEnum):
     ss = auto()
     v2ray = auto()
     ssr = auto()
+    ssh = auto()
 
 
 class ProxyL3(StrEnum):
@@ -49,6 +51,7 @@ class ProxyL3(StrEnum):
     reality = auto()
     http = auto()
     kcp = auto()
+    ssh = auto()
     # hysteria=auto()
 
 

hiddifypanel/models/user.py

@@ -61,6 +61,9 @@ class User(db.Model, SerializerMixin):
     max_ips = db.Column(db.Integer, default=1000, nullable=False)
     details = db.relationship('UserDetail', cascade="all,delete", backref='user',    lazy='dynamic',)
     enable = db.Column(db.Boolean, default=True, nullable=False)
+    ed25519_private_key=db.Column(db.String(100))
+    ed25519_public_key=db.Column(db.String(100))
+
 
     @property
     def remaining_days(self):

hiddifypanel/panel/admin/UserAdmin.py

@@ -6,7 +6,7 @@ from flask import Markup, g, request, url_for, abort
 from wtforms.validators import Regexp, ValidationError
 import re
 import uuid
-from hiddifypanel import xray_api
+from hiddifypanel.drivers import user_driver
 from .adminlte import AdminLTEModelView
 # from gettext import gettext as _
 from flask_babelex import gettext as __
@@ -195,7 +195,7 @@ class UserAdmin(AdminLTEModelView):
     def on_model_delete(self, model):
         if len(User.query.all()) <= 1:
             raise ValidationError(f"at least one user should exist")
-        xray_api.remove_client(model.uuid)
+        user_driver.remove_client(model.uuid)
         # hiddify.flash_config_success()
 
     # def is_accessible(self):
@@ -251,7 +251,7 @@ class UserAdmin(AdminLTEModelView):
             raise ValidationError(_('You have too much users! You can have only %(active)s active users and %(total)s users',
                                   active=g.admin.max_active_users, total=g.admin.max_users))
         if old_user and old_user.uuid != model.uuid:
-            xray_api.remove_client(old_user.uuid)
+            user_driver.remove_client(old_user.uuid)
 
         # model.expiry_time=datetime.date.today()+datetime.timedelta(days=model.expiry_time)
 
@@ -267,13 +267,13 @@ class UserAdmin(AdminLTEModelView):
 
         user = User.query.filter(User.uuid == model.uuid).first()
         if is_user_active(user):
-            xray_api.add_client(model.uuid)
+            user_driver.add_client(model.uuid)
         else:
-            xray_api.remove_client(model.uuid)
+            user_driver.remove_client(model.uuid)
         hiddify.quick_apply_users()
 
     def after_model_delete(self, model):
-        xray_api.remove_client(model.uuid)
+        user_driver.remove_client(model.uuid)
 
         hiddify.quick_apply_users()
 

hiddifypanel/panel/commercial/restapi/resources.py

@@ -5,7 +5,7 @@ import datetime
 from hiddifypanel.models import *
 from urllib.parse import urlparse
 from hiddifypanel.panel import hiddify
-from hiddifypanel import xray_api
+from hiddifypanel.drivers import user_driver
 # class AllResource(Resource):
 #     def get(self):
 #         return jsonify(
@@ -27,7 +27,7 @@ class UserResource(Resource):
     def post(self):
         data = request.json
         hiddify.add_or_update_user(**data)
-        xray_api.add_client(data['uuid'])
+        user_driver.add_client(data['uuid'])
         hiddify.quick_apply_users()
 
         return jsonify({'status': 200, 'msg': 'ok'})

hiddifypanel/panel/custom_widgets.py

@@ -1,3 +1,12 @@
+from flask_admin.contrib.sqla import ModelView
+from wtforms.widgets import TextArea
+from wtforms import TextAreaField
+from flask_bootstrap import SwitchField
+from wtforms.fields import StringField, IntegerField, SelectField
+from hiddifypanel.panel.hiddify import flash
+from hiddifypanel.panel import hiddify
+from flask_babelex import lazy_gettext as _
+from flask_babelex import gettext as __
 from flask_admin.contrib import sqla
 from hiddifypanel.panel.database import db
 import datetime
@@ -6,17 +15,8 @@ from flask import Markup, g
 from wtforms.validators import Regexp, ValidationError
 import re
 import uuid
-from hiddifypanel import xray_api
+
 # from gettext import gettext as _
-from flask_babelex import gettext as __
-from flask_babelex import lazy_gettext as _
-from hiddifypanel.panel import hiddify
-from hiddifypanel.panel.hiddify import flash
-from wtforms.fields import StringField, IntegerField, SelectField
-from flask_bootstrap import SwitchField
-from wtforms import TextAreaField
-from wtforms.widgets import TextArea
-from flask_admin.contrib.sqla import ModelView
 
 
 class DaysLeftField(IntegerField):

hiddifypanel/panel/hiddify.py

@@ -1,12 +1,14 @@
 import socket
 from sqlalchemy.orm import Load
+import glob
+import json
 from babel.dates import format_timedelta as babel_format_timedelta
 from flask_babelex import gettext as __
 from flask_babelex import lazy_gettext as _
 from hiddifypanel.models import *
 from hiddifypanel.panel.database import db
 import datetime
-from flask import jsonify, g, url_for, Markup, abort
+from flask import jsonify, g, url_for, Markup, abort, current_app
 from flask import flash as flask_flash
 from wtforms.validators import ValidationError
 import requests
@@ -667,3 +669,23 @@ def generate_x25519_keys():
 
     # Return the keys as a tuple
     return {"private_key": private_key, "public_key": public_key}
+
+
+def get_hostkeys(dojson=False):
+    key_files = glob.glob(current_app.config['HIDDIFY_CONFIG_PATH'] + "/other/ssh/host_key/*_key.pub")
+    host_keys = []
+    for file_name in key_files:
+        with open(file_name, "r") as f:
+            host_key = f.read().strip()
+            host_key = host_key.split()
+            if len(host_key) > 2:
+                host_key = host_key[:2]  # strip the hostname part
+            host_key = " ".join(host_key)
+            host_keys.append(host_key)
+    if dojson:
+        return json.dumps(host_keys)
+    return host_keys
+
+
+def get_ssh_client_version(user):
+    return 'SSH-2.0-OpenSSH_7.4p1'

hiddifypanel/panel/init_db.py

@@ -30,6 +30,8 @@ def init_db():
 
     add_column(Domain.grpc)
     add_column(ParentDomain.alias)
+    add_column(User.ed25519_private_key)
+    add_column(User.ed25519_public_key)
     add_column(User.start_date)
     add_column(User.package_days)
     add_column(User.telegram_id)
@@ -108,11 +110,34 @@ def init_db():
     return BoolConfig.query.all()
 
 
+def _v44():
+    import ed25519
+    for u in User.query.all():
+
+        privkey = ed25519.Ed25519PrivateKey.generate()
+        pubkey = privkey.public_key()
+        priv_bytes = privkey.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.OpenSSH,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        pub_bytes = pubkey.public_bytes(
+            encoding=serialization.Encoding.OpenSSH,
+            format=serialization.PublicFormat.OpenSSH,
+        )
+        u.ed25519_private_key = priv_bytes.decode()
+        u.ed25519_public_key = pub_bytes.decode()
+    db.session.add(Proxy(l3='ssh', transport='ssh', cdn='direct', proto='ssh', enable=True, name="SSH"))
+    add_config_if_not_exist(ConfigEnum.ssh_server_redis_url, "unix:///opt/hiddify-config/other/redis/run.sock?db=1")
+    add_config_if_not_exist(ConfigEnum.ssh_server_port, random.randint(5000, 20000))
+    add_config_if_not_exist(ConfigEnum.ssh_server_enable, False)
 # def _v43():
 #     if not (Domain.query.filter(Domain.domain==hconfig(ConfigEnum.domain_fronting_domain)).first()):
 #         db.session.add(Domain(domain=hconfig(ConfigEnum.domain_fronting_domain),servernames=hconfig(ConfigEnum.domain_fronting_domain),mode=DomainType.cdn))
 
 # v7.0.0
+
+
 def _v42():
 
     for k in [ConfigEnum.telegram_fakedomain, ConfigEnum.ssfaketls_fakedomain, ConfigEnum.shadowtls_fakedomain]:
@@ -366,7 +391,8 @@ def get_proxy_rows_v1():
         "restls1_2 direct ss",
         "restls1_3 direct ss",
         "tcp direct ssr",
-        "WS CDN v2ray"]
+        "WS CDN v2ray"
+    ]
     )
 
 

hiddifypanel/panel/usage.py

@@ -1,5 +1,5 @@
 from sqlalchemy.orm import Load
-from hiddifypanel import xray_api, singbox_api
+from hiddifypanel.drivers import user_driver
 from sqlalchemy import func
 from flask_babelex import gettext as __
 from flask_babelex import lazy_gettext as _
@@ -15,15 +15,8 @@ to_gig_d = 1024**3
 
 
 def update_local_usage():
-
-    res = {}
-    have_change = False
-    for user in User.query.all():
-        d = xray_api.get_usage(user.uuid, reset=True)
-        sd = singbox_api.get_usage(user.uuid, reset=True)
-        res[user] = {'usage': (d or 0)+(sd or 0), 'ips': ''}
-
-    return add_users_usage(res, 0)
+    res = user_driver.get_users_usage(reset=True)
+    return add_users_usage(res, child_id=0)
 
     # return {"status": 'success', "comments":res}
 
@@ -34,10 +27,6 @@ def add_users_usage_uuid(uuids_bytes, child_id):
     add_users_usage(dbusers_bytes, child_id)
 
 
-def is_already_valid(uuid):
-    xray_api.get_xray_client().add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol, flow='xtls-rprx-vision', alter_id=0, cipher='chacha20_poly1305')
-
-
 def add_users_usage(dbusers_bytes, child_id):
     print(dbusers_bytes)
     if not hconfig(ConfigEnum.is_parent) and hconfig(ConfigEnum.parent_panel):
@@ -46,7 +35,7 @@ def add_users_usage(dbusers_bytes, child_id):
 
     res = {}
     have_change = False
-    before_enabled_users = xray_api.get_enabled_users()
+    before_enabled_users = user_driver.get_enabled_users()
     daily_usage = {}
     today = datetime.date.today()
     for adm in AdminUser.query.all():
@@ -73,7 +62,7 @@ def add_users_usage(dbusers_bytes, child_id):
             detail.current_usage_GB = 0
 
         if before_enabled_users[user.uuid] == 0 and user.is_active:
-            xray_api.add_client(user.uuid)
+            user_driver.add_client(user)
             send_bot_message(user)
             have_change = True
         if type(usage_bytes) != int or usage_bytes == 0:
@@ -91,7 +80,7 @@ def add_users_usage(dbusers_bytes, child_id):
                 user.start_date = datetime.date.today()
 
         if before_enabled_users[user.uuid] == 1 and not is_user_active(user):
-            xray_api.remove_client(user.uuid)
+            user_driver.remove_client(user)
             have_change = True
             res[user.uuid] = f"{res[user.uuid]} !OUT of USAGE! Client Removed"