hiddifypanel 10.80.12.dev1__py3-none-any.whl → 10.85.0b2__py3-none-any.whl

hiddifypanel/panel/init_db.py

@@ -9,19 +9,20 @@ import uuid
 from hiddifypanel import Events, hutils
 from hiddifypanel.cache import cache
 from hiddifypanel.models import *
-from hiddifypanel.panel import hiddify
+
 from hiddifypanel.database import db, db_execute
-from flask import g
-from sqlalchemy import func, text
+
+
 from loguru import logger
-MAX_DB_VERSION = 100
+MAX_DB_VERSION = 120
 
 
-def _v98(child_id):
-    add_config_if_not_exist(ConfigEnum.path_xhttp,hutils.random.get_random_string(7, 15))
+
+def _v101(child_id):
+    add_config_if_not_exist(ConfigEnum.path_xhttp, hutils.random.get_random_string(7, 15))
     add_config_if_not_exist(ConfigEnum.xhttp_enable, False)
     db.session.bulk_save_objects(get_proxy_rows_v1())
-    
+
 
 def _v97(child_id):
     keys = hutils.crypto.generate_ssh_host_keys()
@@ -41,36 +42,33 @@ def _v97(child_id):
 
 
 def _v96(child_id):
-    result = (
-        db.session.query(
-            DailyUsage.child_id,
-            DailyUsage.admin_id,
-            DailyUsage.date,
-            func.max(DailyUsage.online).label('online'),
-            func.sum(DailyUsage.usage).label('usage'),
-            func.count(DailyUsage.usage).label('count'),
-        )
-        .group_by(DailyUsage.child_id, DailyUsage.admin_id, DailyUsage.date)
-        .all()
-    )
+    from sqlalchemy import func
+    result = (db.session.query(DailyUsage.child_id,
+                               DailyUsage.admin_id,
+                               DailyUsage.date,
+                               func.max(DailyUsage.online).label('online'),
+                               func.sum(DailyUsage.usage).label('usage'),
+                               func.count(DailyUsage.usage).label('count'),
+                               )
+              .group_by(DailyUsage.child_id, DailyUsage.admin_id, DailyUsage.date)
+              .all()
+              )
 
     for r in result:
         if r.count > 1:
             # Delete existing records for this group
-            db.session.query(DailyUsage).filter(
-                DailyUsage.child_id == r.child_id,
-                DailyUsage.admin_id == r.admin_id,
-                DailyUsage.date == r.date
-            ).delete()
+            db.session.query(DailyUsage).filter(DailyUsage.child_id == r.child_id,
+                                                DailyUsage.admin_id == r.admin_id,
+                                                DailyUsage.date == r.date
+                                                ).delete()
 
             # Add the aggregated record
-            new_record = DailyUsage(
-                child_id=r.child_id,
-                admin_id=r.admin_id,
-                date=r.date,
-                online=r.online,
-                usage=r.usage
-            )
+            new_record = DailyUsage(child_id=r.child_id,
+                                    admin_id=r.admin_id,
+                                    date=r.date,
+                                    online=r.online,
+                                    usage=r.usage
+                                    )
             db.session.add(new_record)
 
     # Commit the changes to the database
@@ -143,8 +141,7 @@ def _v79(child_id):
 
 def _v78(child_id):
     # equalize panel unique id and root child unique id
-    root_child_unique_id = Child.query.filter(
-        Child.name == "Root").first().unique_id
+    root_child_unique_id = Child.query.filter(Child.name == "Root").first().unique_id
     set_hconfig(ConfigEnum.unique_id, root_child_unique_id)
 
 
@@ -287,8 +284,7 @@ def _v55():
     set_hconfig(ConfigEnum.hysteria_port, hystria_port)
     set_hconfig(ConfigEnum.tuic_enable, True)
     set_hconfig(ConfigEnum.hysteria_enable, True)
-    Proxy.query.filter(Proxy.proto.in_(
-        ["tuic", "hysteria2", "hysteria"])).delete()
+    Proxy.query.filter(Proxy.proto.in_(["tuic", "hysteria2", "hysteria"])).delete()
     db.session.add(Proxy(l3='tls', transport='custom',
                    cdn='direct', proto='tuic', enable=True, name="TUIC"))
     db.session.add(Proxy(l3='tls', transport='custom', cdn='direct',
@@ -321,8 +317,7 @@ def _v48():
 
 
 def _v47():
-    StrConfig.query.filter(
-        StrConfig.key == ConfigEnum.ssh_server_enable).delete()
+    StrConfig.query.filter(StrConfig.key == ConfigEnum.ssh_server_enable).delete()
 
 
 def _v45():
@@ -358,8 +353,7 @@ def _v41():
 
 def _v38():
     add_config_if_not_exist(ConfigEnum.dns_server, "1.1.1.1")
-    add_config_if_not_exist(ConfigEnum.warp_mode, "all" if hconfig(
-        ConfigEnum.warp_enable) else "disable")
+    add_config_if_not_exist(ConfigEnum.warp_mode, "all" if hconfig(ConfigEnum.warp_enable) else "disable")
     add_config_if_not_exist(ConfigEnum.warp_plus_code, '')
 
 
@@ -376,14 +370,11 @@ def _v31():
     add_config_if_not_exist(ConfigEnum.reality_short_ids,
                             uuid.uuid4().hex[0:random.randint(1, 8) * 2])
     key_pair = hutils.crypto.generate_x25519_keys()
-    add_config_if_not_exist(
-        ConfigEnum.reality_private_key, key_pair['private_key'])
-    add_config_if_not_exist(
-        ConfigEnum.reality_public_key, key_pair['public_key'])
+    add_config_if_not_exist(ConfigEnum.reality_private_key, key_pair['private_key'])
+    add_config_if_not_exist(ConfigEnum.reality_public_key, key_pair['public_key'])
     db.session.bulk_save_objects(get_proxy_rows_v1())
     if not (AdminUser.query.filter(AdminUser.id == 1).first()):
-        db.session.add(AdminUser(id=1, uuid=hconfig(
-            ConfigEnum.admin_secret), name="Owner", mode=AdminMode.super_admin, comment=""))
+        db.session.add(AdminUser(id=1, uuid=hconfig(ConfigEnum.admin_secret), name="Owner", mode=AdminMode.super_admin, comment=""))
         execute("update admin_user set id=1 where name='owner'")
     for i in range(1, 10):
         for d in hutils.network.get_random_domains(50):
@@ -418,8 +409,7 @@ def _v20():
     if hconfig(ConfigEnum.domain_fronting_domain):
         fake_domains = [hconfig(ConfigEnum.domain_fronting_domain)]
 
-        direct_domain = Domain.query.filter(
-            Domain.mode in [DomainType.direct, DomainType.relay]).first()
+        direct_domain = Domain.query.filter(Domain.mode in [DomainType.direct, DomainType.relay]).first()
         if direct_domain:
             direct_host = direct_domain.domain
         else:
@@ -427,8 +417,7 @@ def _v20():
 
         for fd in fake_domains:
             if not Domain.query.filter(Domain.domain == fd).first():
-                db.session.add(Domain(
-                    domain=fd, mode='fake', alias='moved from domain fronting', cdn_ip=direct_host))
+                db.session.add(Domain(domain=fd, mode='fake', alias='moved from domain fronting', cdn_ip=direct_host))
 
 
 def _v19():
@@ -441,8 +430,7 @@ def _v19():
     set_hconfig(ConfigEnum.path_ws, hutils.random.get_random_string(7, 15))
     add_config_if_not_exist(ConfigEnum.tuic_enable, False)
     add_config_if_not_exist(ConfigEnum.shadowtls_enable, False)
-    add_config_if_not_exist(
-        ConfigEnum.shadowtls_fakedomain, "en.wikipedia.org")
+    add_config_if_not_exist(ConfigEnum.shadowtls_fakedomain, "en.wikipedia.org")
     add_config_if_not_exist(ConfigEnum.utls, "chrome")
     add_config_if_not_exist(ConfigEnum.telegram_bot_token, "")
     add_config_if_not_exist(ConfigEnum.package_mode, "release")
@@ -485,7 +473,7 @@ def _v1():
         BoolConfig(key=ConfigEnum.allow_invalid_sni, value=True),
         BoolConfig(key=ConfigEnum.kcp_enable, value=False),
         StrConfig(key=ConfigEnum.kcp_ports, value="88"),
-        BoolConfig(key=ConfigEnum.auto_update, value=True),
+        BoolConfig(key=ConfigEnum.auto_update, value=os.environ.get('HIDDIFY_DISABLE_UPDATE',"").lower() not in {'1','true'}),
         BoolConfig(key=ConfigEnum.speed_test, value=True),
         BoolConfig(key=ConfigEnum.only_ipv4, value=False),
         BoolConfig(key=ConfigEnum.vmess_enable, value=True),
@@ -527,8 +515,7 @@ def _v1():
 def _v7():
     try:
         Proxy.query.filter(Proxy.name == 'tls XTLS direct trojan').delete()
-        Proxy.query.filter(
-            Proxy.name == 'tls XTLSVision direct trojan').delete()
+        Proxy.query.filter(Proxy.name == 'tls XTLSVision direct trojan').delete()
     except BaseException:
         pass
     add_config_if_not_exist(ConfigEnum.telegram_lib, "erlang")
@@ -686,13 +673,12 @@ def make_proxy_rows(cfgs):
             enable = l3 != "http" or proto == "vmess"
             enable = enable and transport != 'tcp'
             name = f'{l3} {c}'
-            # is_exist = Proxy.query.filter(Proxy.name == name).first() or Proxy.query.filter(
-            #     Proxy.l3 == l3, Proxy.transport == transport, Proxy.cdn == cdn, Proxy.proto == proto).first()
+            # is_exist = Proxy.query.filter(Proxy.name == name).first() or Proxy.query.filter(            #     Proxy.l3 == l3, Proxy.transport == transport, Proxy.cdn == cdn, Proxy.proto == proto).first()
             # if not is_exist:
             yield Proxy(l3=l3, transport=transport, cdn=cdn, proto=proto, enable=enable, name=name)
 
 
-def add_config_if_not_exist(key: ConfigEnum, val: str | int, child_id: int | None = None):
+def add_config_if_not_exist(key: "ConfigEnum", val: str | int, child_id: int | None = None):
     if child_id is None:
         child_id = Child.current().id
 
@@ -705,8 +691,7 @@ def add_column(column):
     try:
         column_type = column.type.compile(db.engine.dialect)
 
-        db_execute(
-            f'ALTER TABLE {column.table.name} ADD COLUMN {column.name} {column_type}', commit=True)
+        db_execute(f'ALTER TABLE {column.table.name} ADD COLUMN {column.name} {column_type}', commit=True)
     except BaseException:
         pass
 
@@ -716,7 +701,7 @@ def execute(query: str):
 
         db_execute(query)
     except BaseException as e:
-        logger.debug(e)
+        logger.debug(f'migrating_db: {e}')
         pass
 
 
@@ -725,21 +710,20 @@ def add_new_enum_values():
         Proxy.l3, Proxy.proto, Proxy.cdn, Proxy.transport,
         User.mode, Domain.mode, BoolConfig.key, StrConfig.key
     ]
+    from sqlalchemy import text
     for col in columns:
         enum_class = col.type.enum_class
         column_name = col.name
         table_name = col.table
 
         # Get the existing values in the enum
-        existing_values = [f'{e}' if isinstance(
-            e, ConfigEnum) else e.value for e in enum_class]
+        existing_values = [f'{e}' if isinstance(e, ConfigEnum) else e.value for e in enum_class]
 
         # Get the values in the enum column in the database
         # result = db.engine.execute(f"SELECT DISTINCT `{column_name}` FROM {table_name}")
         # db_values = {row[0] for row in result}
 
-        result = db.session.execute(
-            text(f"SHOW COLUMNS FROM {table_name} LIKE '{column_name}';")).fetchall()
+        result = db.session.execute(text(f"SHOW COLUMNS FROM {table_name} LIKE '{column_name}';")).fetchall()
         db_values = []
 
         for row in result:
@@ -759,12 +743,13 @@ def add_new_enum_values():
         # enumstr = ','.join([f"'{a}'" for a in [*existing_values, *old_values]])
         enumstr = ','.join([f"'{a}'" for a in [*existing_values]])
         expired_enumstr = ','.join([f"'{a}'" for a in [*old_values]])
-        db_execute(
-            f"delete from {table_name} where `{column_name}` in ({expired_enumstr});", commit=True)
-        db_execute(
-            f"ALTER TABLE {table_name} MODIFY COLUMN `{column_name}` ENUM({enumstr});", commit=True)
+        db_execute(f"delete from {table_name} where `{column_name}` in ({expired_enumstr});", commit=True)
+        db_execute(f"ALTER TABLE {table_name} MODIFY COLUMN `{column_name}` ENUM({enumstr});", commit=True)
 
 
+def is_db_latest():
+    return str(hconfig(ConfigEnum.db_version))==str(latest_db_version())
+
 def latest_db_version():
     for ver in range(MAX_DB_VERSION, 1, -1):
         db_action = sys.modules[__name__].__dict__.get(f'_v{ver}', None)
@@ -784,13 +769,13 @@ def upgrade_database():
         logger.info("no backup found...")
         return
     if os.path.isfile(sqlite_db):
-        logger.info(
-            "Finding Old Version Database... importing configs from latest backup")
+        logger.info("Finding Old Version Database... importing configs from latest backup")
         newest_file = max([(f, os.path.getmtime(os.path.join(backup_root, f)))
                           for f in os.listdir(backup_root) if os.path.isfile(os.path.join(backup_root, f))], key=lambda x: x[1])[0]
         with open(f'{backup_root}{newest_file}', 'r') as f:
             logger.info(f"importing configs from {newest_file}")
             json_data = json.load(f)
+            from hiddifypanel.panel import hiddify
             hiddify.set_db_from_json(json_data,
                                      set_users=True,
                                      set_domains=True,
@@ -803,8 +788,7 @@ def upgrade_database():
                                      override_child_unique_id=0,
                                      replace_owner_admin=True
                                      )
-            db_version = int(
-                [d['value'] for d in json_data['hconfigs'] if d['key'] == "db_version"][0])
+            db_version = int([d['value'] for d in json_data['hconfigs'] if d['key'] == "db_version"][0])
             os.rename(sqlite_db, sqlite_db + ".old")
             set_hconfig(ConfigEnum.db_version, db_version, commit=True)
 
@@ -813,14 +797,17 @@ def upgrade_database():
 
 def init_db():
     db.create_all()
-
+    
     # set_hconfig(ConfigEnum.db_version, 71)
     # temporary fix
     add_column(Child.mode)
     add_column(Child.name)
+
     db_version = int(hconfig(ConfigEnum.db_version) or 0)
+
     if db_version == latest_db_version():
         return
+    from flask import g
     cache.invalidate_all_cached_functions()
     migrate(db_version)
     Child.query.filter(Child.id == 0).first().mode = ChildMode.virtual
@@ -841,8 +828,7 @@ def init_db():
             if not db_action or (start_version == 0 and ver == 10):
                 continue
 
-            logger.info(
-                f"Updating db from version {db_version} for node {child.id}")
+            logger.info(f"Updating db from version {db_version} for node {child.id}")
 
             if ver < 70:
                 if child.id != 0:
@@ -852,8 +838,7 @@ def init_db():
                 db_action(child.id)
 
             Events.db_init_event.notify(db_version=db_version)
-            logger.info(
-                f"Updated successfuly db from version {db_version} to {ver}")
+            logger.info(f"Updated successfuly db from version {db_version} to {ver}")
 
             db_version = ver
             db.session.commit()
@@ -870,14 +855,17 @@ def migrate(db_version):
         for column in table_obj.columns:
             add_column(column)
     Events.db_prehook.notify()
+    if db_version < 100:
+        execute('update str_config set `key`="xhttp_enable" where `key`="splithttp_enable";')
+        execute('update str_config set `key`="path_xhttp" where `key`="path_splithttp";')
+        execute("UPDATE proxy SET transport = 'xhttp' WHERE transport = 'splithttp';")
     if db_version < 97:
         execute('ALTER TABLE str_config MODIFY value VARCHAR(3072);')
     if db_version < 82:
         execute('ALTER TABLE child DROP INDEX `name`;')
     if db_version < 77:
         execute('ALTER TABLE user_detail DROP COLUMN connected_ips;')
-        execute(
-            'update user_detail set connected_devices="" where connected_devices IS NULL')
+        execute('update user_detail set connected_devices="" where connected_devices IS NULL')
 
     if db_version < 70:
         execute('CREATE INDEX date ON daily_usage (date);')
@@ -909,8 +897,7 @@ def migrate(db_version):
 
     if db_version < 52:
         execute(f'update domain set mode="sub_link_only", sub_link_only=false where sub_link_only = true or mode=1  or mode="1"')
-        execute(
-            f'update domain set mode="direct", sub_link_only=false where mode=0  or mode="0"')
+        execute(f'update domain set mode="direct", sub_link_only=false where mode=0  or mode="0"')
         execute(f'update proxy set transport="WS" where transport = "ws"')
         execute(f'update admin_user set mode="agent" where mode = "slave"')
         execute(f'update admin_user set mode="super_admin" where id=1')
@@ -950,12 +937,9 @@ def migrate(db_version):
             execute(f'DROP TABLE str_config')
             execute(f'ALTER TABLE str_config_old RENAME TO str_config')
 
-        execute(
-            'ALTER TABLE user RENAME COLUMN monthly_usage_limit_GB TO usage_limit_GB')
-        execute(
-            f'update admin_user set parent_admin_id=1 where parent_admin_id is NULL and 1!=id')
-        execute(
-            f'update admin_user set max_users=100,max_active_users=100 where max_users is NULL')
+        execute('ALTER TABLE user RENAME COLUMN monthly_usage_limit_GB TO usage_limit_GB')
+        execute(f'update admin_user set parent_admin_id=1 where parent_admin_id is NULL and 1!=id')
+        execute(f'update admin_user set max_users=100,max_active_users=100 where max_users is NULL')
         execute(f'update dailyusage set child_id=0 where child_id is NULL')
         execute(f'update dailyusage set admin_id=1 where admin_id is NULL')
         execute(f'update dailyusage set admin_id=1 where admin_id = 0')

hiddifypanel/panel/run_commander.py

@@ -1,6 +1,5 @@
 from typing import List
 from strenum import StrEnum
-from flask import current_app
 import subprocess
 import os
 
@@ -34,7 +33,7 @@ def commander(command: Command, run_in_background=True, **kwargs: str | int) ->
     base_cmd: List[str] = [
         'sudo',
         os.path.join(
-            current_app.config['HIDDIFY_CONFIG_PATH'], 'common/commander.py')
+            os.environ['HIDDIFY_CONFIG_PATH'], 'common/commander.py')
     ]
 
     if command == Command.apply:
@@ -80,6 +79,6 @@ def commander(command: Command, run_in_background=True, **kwargs: str | int) ->
     else:
         raise Exception('WTF is happening!')
     if run_in_background:
-        subprocess.Popen(base_cmd, cwd=str(current_app.config['HIDDIFY_CONFIG_PATH']), start_new_session=True)
+        subprocess.Popen(base_cmd, cwd=str(os.environ['HIDDIFY_CONFIG_PATH']), start_new_session=True)
     else:
-        return subprocess.check_output(base_cmd, cwd=str(current_app.config['HIDDIFY_CONFIG_PATH'])).decode()
+        return subprocess.check_output(base_cmd, cwd=str(os.environ['HIDDIFY_CONFIG_PATH'])).decode()

hiddifypanel/panel/usage.py

@@ -1,4 +1,4 @@
-from flask_babel import lazy_gettext as _
+
 from sqlalchemy import func
 from typing import Dict
 import datetime
@@ -16,8 +16,8 @@ from celery import shared_task
 @shared_task(ignore_result=False)
 def update_local_usage():
     lock_key = "lock-update-local-usage"
-    if not cache.redis_client.set(lock_key, "locked", nx=True, ex=600):
-        return {"msg": "last update task is not finished yet."}
+    # if not cache.redis_client.set(lock_key, "locked", nx=True, ex=600):
+    #     return {"msg": "last update task is not finished yet."}
     try:
         res=update_local_usage_not_lock()
         cache.redis_client.set(lock_key, "locked", nx=False, ex=60)
@@ -43,7 +43,7 @@ def update_local_usage_not_lock():
 def add_users_usage_uuid(uuids_bytes: Dict[str, Dict], child_id, sync=False):
     uuids_bytes = {u: v for u, v in uuids_bytes.items() if v}
     uuids = uuids_bytes.keys()
-    users = User.query.filter(User.uuid.in_(uuids))
+    users = db.session.query(User).filter(User.uuid.in_(uuids))
     dbusers_bytes = {u: uuids_bytes.get(u.uuid, 0) for u in users}
     _add_users_usage(dbusers_bytes, child_id, sync)  # type: ignore
 
@@ -58,7 +58,7 @@ def _reset_priodic_usage():
     if datetime.datetime.now().hour > 5 and current_time - last_usage_check < 60 * 60 * 24:
         return
     logger.debug("reseting user usage if needed")
-    for user in User.query.filter(User.mode != UserMode.no_reset).all():
+    for user in db.session.query(User).filter(User.mode != UserMode.no_reset).all():
         if user.user_should_reset():
             logger.info(f"reseting user usage for {user.uuid}")
             user.reset_usage(commit=False)
@@ -76,14 +76,14 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
     daily_usage = {}
     today = datetime.date.today()
     changes = False
-    for adm in AdminUser.query.all():
-        daily_usage[adm.id] = DailyUsage.query.filter(DailyUsage.date == today, DailyUsage.admin_id == adm.id, DailyUsage.child_id == child_id).first()
+    for adm in db.session.query(AdminUser).all():
+        daily_usage[adm.id] = db.session.query(DailyUsage).filter(DailyUsage.date == today, DailyUsage.admin_id == adm.id, DailyUsage.child_id == child_id).first()
         if daily_usage[adm.id] is None:
             logger.info(f"creating a new daily usage {today} admin={adm.id} child={child_id}")
             daily_usage[adm.id] = DailyUsage(date=today, admin_id=adm.id, child_id=child_id)
             db.session.add(daily_usage[adm.id])
             changes = True
-        daily_usage[adm.id].online = User.query.filter(User.added_by == adm.id).filter(func.DATE(User.last_online) == today).count()
+        daily_usage[adm.id].online = db.session.query(User).filter(User.added_by == adm.id).filter(func.DATE(User.last_online) == today).count()
     if changes:
         db.session.commit()
     _reset_priodic_usage()
@@ -155,7 +155,7 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
         if uuid in res:
             continue
 
-        user = User.query.filter(User.uuid == uuid).first()
+        user = db.session.query(User).filter(User.uuid == uuid).first()
         if not user:
             user_driver.remove_client(User(uuid=uuid))
         elif not user.is_active:
@@ -178,6 +178,7 @@ def send_bot_message(user):
         return
     if not user.telegram_id:
         return
+    from flask_babel import lazy_gettext as _
     from hiddifypanel.panel.commercial.telegrambot import bot, Usage
     try:
         msg = Usage.get_usage_msg(user.uuid)

hiddifypanel/panel/user/templates/base_singbox_config.json.j2

@@ -1,5 +1,6 @@
 {% set V1_7= g.user_agent['is_singbox'] and g.user_agent['singbox_version'][0]==1 and g.user_agent['singbox_version'][1]<8 %}
 {% set V1_9= g.user_agent['is_singbox'] and g.user_agent['singbox_version'][0]==1 and g.user_agent['singbox_version'][1]<10 %}
+
 {
     "outbounds": [
         {
@@ -26,46 +27,30 @@
         {% if V1_7 %}
         "geoip": {
                "download_url": "https://github.com/SagerNet/sing-geoip/releases/latest/download/geoip.db",
-               "download_detour": {% if hconfig(ConfigEnum.country)=='cn' %}"Select" {%else%}"bypass"{%endif%} 
+               "download_detour": {% if hconfig(ConfigEnum.country)=='zh' %}"Select" {%else%}"bypass"{%endif%} 
             },
         "geosite": {
             "download_url": "https://github.com/SagerNet/sing-geosite/releases/latest/download/geosite.db",
-            "download_detour": {% if hconfig(ConfigEnum.country)=='cn' %}"Select" {%else%}"bypass"{%endif%} 
+            "download_detour": {% if hconfig(ConfigEnum.country)=='zh' %}"Select" {%else%}"bypass"{%endif%} 
         }, 
         {%else%}
         "rule_set": [
-            {%if hconfig(ConfigEnum.country)=="ir"%}
+            {%if hconfig(ConfigEnum.country) in ["ir","zh","ru"]%}
             {
-                "tag": "geosite-ir",
+                "tag": "geosite-{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}",
                 "type": "remote",
                 "format": "binary",
-                "url": "https:\/\/raw.githubusercontent.com\/Chocolate4U\/Iran-sing-box-rules\/rule-set\/geosite-ir.srs",
-                "download_detour": "bypass" 
+                "url": "https:\/\/github.com\/hiddify\/hiddify-geo\/raw\/rule-set\/country\/geosite-{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}.srs",
+                "download_detour": {% if hconfig(ConfigEnum.country)=='zh' %}"Select" {%else%}"bypass"{%endif%}
             },
             {
-            "tag": "geoip-ir",
+            "tag": "geoip-{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}",
             "type": "remote",
             "format": "binary",
-            "url": "https:\/\/raw.githubusercontent.com\/Chocolate4U\/Iran-sing-box-rules\/rule-set\/geoip-ir.srs",
-            "download_detour": "bypass"
+            "url": "https:\/\/github.com\/hiddify\/hiddify-geo\/raw\/rule-set\/country\/geoip-{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}.srs",
+            "download_detour": {% if hconfig(ConfigEnum.country)=='zh' %}"Select" {%else%}"bypass"{%endif%} 
             }
-            {%endif%}
-            {%if hconfig(ConfigEnum.country)=="ru"%}
-            {
-                "tag": "geosite-ru",
-                "type": "remote",
-                "format": "binary",
-                "url": "https:\/\/github.com\/SagerNet\/sing-geosite\/raw\/rule-set\/geosite-category-ru.srs",
-                "download_detour": "bypass" 
-            },
-            {
-            "tag": "geoip-ru",
-            "type": "remote",
-            "format": "binary",
-            "url": "https:\/\/github.com\/SagerNet\/sing-geoip\/raw\/rule-set\/geoip-ru.srs",
-            "download_detour": "bypass"
-            }
-            {%endif%}
+            {%endif%}               
             {# {
                 "tag": "geosite-category-ads-all",
                 "type": "remote",
@@ -88,10 +73,10 @@
                 ],
                 "outbound": "dns-out"
             },
-            {%if hconfig(ConfigEnum.country) in ["ir","cn","ru"]%}
+            {%if hconfig(ConfigEnum.country)in ["ir","zh","ru"]%}
             {
                 "domain_suffix": [
-                    "{{hconfig(ConfigEnum.country)}}"
+                    "{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}"
                 ],
                 "outbound": "bypass"
             },
@@ -105,19 +90,19 @@
                 {%endif%}
                 "outbound": "block"
             }, #}
-            {%if hconfig(ConfigEnum.country) in ["ir","cn","ru"]%}
+            {%if hconfig(ConfigEnum.country) in ["ir","zh","ru"]%}
             {% if V1_7 %}
             {
-                "geoip": ["{{hconfig(ConfigEnum.country)}}"],
+                "geoip": ["{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}"],
                 "outbound": "bypass"
             },
             {%else%}
             {
-                "rule_set": "geoip-{{hconfig(ConfigEnum.country)}}",
+                "rule_set": "geoip-{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}",
                 "outbound": "bypass"
             },
             {
-                "rule_set": "geosite-{{hconfig(ConfigEnum.country)}}",
+                "rule_set": "geosite-{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}",
                 "outbound": "bypass"
             },
             {%endif%}
@@ -192,10 +177,10 @@
                 ],
                 "server": "dns-local"
             },
-            {%if hconfig(ConfigEnum.country)in ["ir","cn","ru"]%}
+            {%if hconfig(ConfigEnum.country)in ["ir","zh","ru"]%}
             {
                 "domain_suffix": [
-                    "{{hconfig(ConfigEnum.country)}}"
+                    "{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}"
                 ],
                 "server": "dns-local"
             },

hiddifypanel/panel/user/templates/base_xray_config.json.j2

@@ -98,7 +98,8 @@
         "outboundTag": "direct",
         "domain": [
           "domain:ir",
-          "geosite:cn"
+          "geosite:cn",
+          "geosite:category-ru"
         ],
         "enabled": true
       },
@@ -109,7 +110,8 @@
         "ip": [
           "geoip:private",
           "geoip:cn",
-          "geoip:ir"
+          "geoip:ir",
+          "geoip:ru"
         ],
         "enabled": true
       },

hiddifypanel/panel/user/templates/clash_config.yml

@@ -135,7 +135,33 @@ proxy-groups:
 #   %endfor
 #   %endfor
 rule-providers:
-
+{% if hconfig(ConfigEnum.country) in ["ir","zh","ru"] %}
+  geoip_{{hconfig(ConfigEnum.country)}}:
+    type: http
+    behavior: classical
+    url: "https://github.com/MetaCubeX/meta-rules-dat/raw/meta/geo/geoip/classical/{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}}.yaml"
+    path: ./geoip/{{hconfig(ConfigEnum.country)}}.yaml
+    interval: 432000
+    
+{% endif %}
+{% if hconfig(ConfigEnum.country)=="zh" %}
+  geosite_cn:
+    type: http
+    behavior: classical
+    url: "https://github.com/MetaCubeX/meta-rules-dat/raw/meta/geo-lite/geosite/classical/cn.yaml"
+    path: ./geosite/zh.yaml
+    interval: 86400
+    
+{% endif %}
+{% if hconfig(ConfigEnum.country) in ["ir","ru"] %}
+  geosite_{{hconfig(ConfigEnum.country)}}:
+    type: http
+    behavior: classical
+    url: "https://github.com/MetaCubeX/meta-rules-dat/raw/meta/geo/geosite/classical/category-{{hconfig(ConfigEnum.country)}}.yaml"
+    path: ./geosite/{{hconfig(ConfigEnum.country)}}.yaml
+    interval: 86400
+    
+{% endif %}
   blocked:
     type: http
     behavior: classical
@@ -175,9 +201,13 @@ rules:
   # - IP-CIDR,10.10.34.0/24,{{OnProxyIssue}}
   # - RULE-SET,tmpblocked,{{OnProxyIssue}}
   # - RULE-SET,blocked,{{OnProxyIssue}}
-  - GEOIP,IR,{{OnIranSites}}
-  - DOMAIN-SUFFIX,.ir,{{OnIranSites}}
+{% if hconfig(ConfigEnum.country) in ["ir","zh","ru"] %}
+  - RULE-SET,geoip_{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}},DIRECT
+  - RULE-SET,geosite_{{hconfig(ConfigEnum.country)|replace('zh', 'cn')}},DIRECT
+{% endif %}
+{% if hconfig(ConfigEnum.country)=="ir" %}
   - RULE-SET,open,{{OnIranSites}}
+{% endif %}
   # - RULE-SET,ads,REJECT
   - MATCH,{{OnNotFilteredSites}}