hiddifypanel 10.14.0__py3-none-any.whl → 10.15.0.dev0__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.14.0
+10.15.0.dev0

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='10.14.0'
+__version__='10.15.0.dev0'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-03-25','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-04-05','%Y-%m-%d')

hiddifypanel/auth.py

@@ -4,7 +4,7 @@ from hiddifypanel.hutils.flask import hurl_for
 from flask_login.utils import _get_user
 from functools import wraps
 from hiddifypanel.models import *
-
+from apiflask import abort as json_abort
 from hiddifypanel import hutils
 from werkzeug.local import LocalProxy
 current_account: "BaseAccount" = LocalProxy(lambda: _get_user())
@@ -97,14 +97,17 @@ def login_user(user: AdminUser | User, remember=False, duration=None, force=Fals
     return True
 
 
-def login_required(roles: set[Role] | None = None):
+def login_required(roles: set[Role] | None = None, node_auth: bool = False):
+    '''When both roles and node_auth is set, means authentication can be done by either uuid or unique_id'''
     def wrapper(fn):
         @wraps(fn)
         def decorated_view(*args, **kwargs):
             # print('xxxx', current_account)
-            if not current_account:
+            if node_auth and not Child.node and not roles:
+                json_abort(403, 'Unauthorized node')
+            if not current_account and not node_auth:
                 return redirect_to_login()  # type: ignore
-            if roles:
+            if roles and not Child.node:
                 account_role = current_account.role
                 if account_role not in roles:
                     return redirect_to_login()  # type: ignore
@@ -151,6 +154,12 @@ def auth_before_request():
 
     elif apikey := request.headers.get("Hiddify-API-Key"):
         account = get_account_by_api_key(apikey, is_admin_path)
+        if not account:
+            # when parent/child panel needs to call another parent/child api, it will pass its unique id in the header as apikey
+            if node := Child.by_unique_id(apikey):
+                g.node = node
+                return
+
         if not account:
             return logout_redirect()
     elif request.authorization:
@@ -201,6 +210,8 @@ def logout_redirect():
 
 
 def redirect_to_login():
+    if hutils.flask.is_api_call(request.path):
+        json_abort(403, 'Unathorized')
     # if g.user_agent['is_browser']:
     # return redirect(hurl_for('common_bp.LoginView:basic_0', force=1, next=request.path))
     return redirect(hurl_for('common_bp.LoginView:index', force=1, next=request.path))

hiddifypanel/base.py

@@ -14,7 +14,7 @@ import os
 import sys
 from apiflask import APIFlask
 from werkzeug.middleware.proxy_fix import ProxyFix
-
+from loguru import logger
 from hiddifypanel.panel.init_db import init_db
 
 
@@ -23,6 +23,7 @@ def create_app(*args, cli=False, **config):
     app = APIFlask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True, version='2.0.0', title="Hiddify API",
                    openapi_blueprint_url_prefix="/<proxy_path>/api", docs_ui='elements', json_errors=False, enable_openapi=not cli)
     # app = Flask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True)
+
     if not cli:
         from hiddifypanel.cache import redis_client
         from hiddifypanel import auth
@@ -55,6 +56,7 @@ def create_app(*args, cli=False, **config):
         app.config['SESSION_PERMANENT'] = True
         app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=10)
         Session(app)
+
         app.jinja_env.line_statement_prefix = '%'
         from hiddifypanel import hutils
         app.jinja_env.filters['b64encode'] = hutils.encode.do_base_64
@@ -72,13 +74,19 @@ def create_app(*args, cli=False, **config):
     hiddifypanel.database.init_app(app)
     with app.app_context():
         init_db()
- # flaskbabel = FlaskBabel(app)
 
+        # configure logger
+        from hiddifypanel.models import ConfigEnum, hconfig
+        logger.remove()
+        log_format = '<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level> | <level>{extra}</level>'
+        logger.add(sys.stderr, format=log_format, level=hconfig(ConfigEnum.log_level), colorize=True, catch=True, enqueue=True, diagnose=False, backtrace=True)
+
+    # flaskbabel = FlaskBabel(app)
     # @babel.localeselector
+
     def get_locale():
         # Put your logic here. Application can store locale in
         # user profile, cookie, session, etc.
-        from hiddifypanel.models import ConfigEnum, hconfig
         if "admin" in request.base_url:
             g.locale = auth.current_account.lang or hconfig(ConfigEnum.admin_lang) or 'fa'
         else:

hiddifypanel/cache.py

@@ -1,47 +1,65 @@
-from redis_cache import RedisCache
-from functools import wraps
+from redis_cache import RedisCache, CacheDecorator, compact_dump, chunks
+from redis_cache import loads as redis_cache_loads
 import redis
 from pickle import dumps, loads
+from loguru import logger
+
 redis_client = redis.from_url('unix:///opt/hiddify-manager/other/redis/run.sock?db=0')
 
 
-def exception_handler(e, original_fn, args, kwargs):
-    print("cache exception occur", e, original_fn, args, kwargs)
-    return original_fn(*args, **kwargs)
-    pass
+class CustomRedisCache(RedisCache):
+
+    def invalidate_all_cached_functions(self):
+        try:
+            logger.info("Invalidating all cached functions")
+            chunks_gen = chunks(f'{self.prefix}*', 500)
+            for keys in chunks_gen:
+                self.client.delete(*keys)
+            logger.success("Successfully invalidated all cached functions")
+            return True
+        except Exception as err:
+            with logger.contextualize(error=err):
+                logger.error("Failed to invalidate all cached functions")
+            return False
+
+
+cache = CustomRedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)
 
 
 # cache = RedisCache(redis_client=redis_client, exception_handler=exception_handler)
 # cache = RedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads, exception_handler=exception_handler)
-cache = RedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)
 
+# def exception_handler(e, original_fn, args, kwargs):
+#     print("cache exception occur", e, original_fn, args, kwargs)
+#     return original_fn(*args, **kwargs)
+#     pass
 
-class CacheDecorator:
-    def __init__(self, *args, **kwargs):
-        pass
+# class CacheDecorator:
+#     def __init__(self, *args, **kwargs):
+#         pass
 
-    def __call__(self, fn):
-        @wraps(fn)
-        def inner(*args, **kwargs):
+#     def __call__(self, fn):
+#         @wraps(fn)
+#         def inner(*args, **kwargs):
 
-            parsed_result = fn(*args, **kwargs)
+#             parsed_result = fn(*args, **kwargs)
 
-            return parsed_result
+#             return parsed_result
 
-        inner.invalidate = self.invalidate
-        inner.invalidate_all = self.invalidate_all
-        inner.instance = self
-        return inner
+#         inner.invalidate = self.invalidate
+#         inner.invalidate_all = self.invalidate_all
+#         inner.instance = self
+#         return inner
 
-    def invalidate(self, *args, **kwargs):
-        pass
+#     def invalidate(self, *args, **kwargs):
+#         pass
 
-    def invalidate_all(self, *args, **kwargs):
-        pass
+#     def invalidate_all(self, *args, **kwargs):
+#         pass
 
 
-class DisableCache:
-    cache = CacheDecorator
+# class DisableCache:
+#     cache = CacheDecorator
 
 
 # cache = DisableCache()

hiddifypanel/database.py

@@ -2,6 +2,8 @@ from flask_sqlalchemy import SQLAlchemy
 from sqlalchemy_utils import UUIDType
 import re
 import os
+from sqlalchemy import text
+
 
 db: SQLAlchemy = SQLAlchemy()
 db.UUID = UUIDType  # type: ignore
@@ -10,3 +12,10 @@ db.UUID = UUIDType  # type: ignore
 def init_app(app):
     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
     db.init_app(app)
+
+
+def db_execute(query: str, **params: dict):
+    with db.engine.connect() as connection:
+        res = connection.execute(text(query), params)
+        connection.commit()
+        return res

hiddifypanel/drivers/singbox_api.py

@@ -10,23 +10,15 @@ class SingboxApi(DriverABS):
     def is_enabled(self) -> bool: return True
 
     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
         config_dir = current_app.config['HIDDIFY_CONFIG_PATH']
         with open(f"{config_dir}/singbox/configs/01_api.json") as f:
             json_data = json.load(f)
             return {u.split("@")[0]: 1 for u in json_data['experimental']['v2ray_api']['stats']['users']}
-        # raise NotImplementedError()
-#
 
     def get_inbound_tags(self):
-        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')]
@@ -37,14 +29,10 @@ class SingboxApi(DriverABS):
         return list(set(inbounds))
 
     def add_client(self, user):
-        if hconfig(ConfigEnum.is_parent):
-            return
-        # raise NotImplementedError()
+        pass
 
     def remove_client(self, user):
-        if hconfig(ConfigEnum.is_parent):
-            return
-        # raise NotImplementedError()
+        pass
 
     def get_all_usage(self, users):
         xray_client = self.get_singbox_client()

hiddifypanel/drivers/xray_api.py

@@ -41,10 +41,6 @@ class XrayApi(DriverABS):
         return list(set(inbounds))
 
     def add_client(self, user):
-        if hconfig(ConfigEnum.is_parent):
-            return
-        if hconfig(ConfigEnum.core_type) != "xray":
-            return
         uuid = user.uuid
         xray_client = self.get_xray_client()
         tags = self.get_inbound_tags()

hiddifypanel/hutils/__init__.py

@@ -11,3 +11,4 @@ from . import utils
 from . import model
 from . import crypto
 from . import proxy
+from . import node

hiddifypanel/hutils/convert.py

@@ -38,13 +38,24 @@ def json_to_date(date_str: str) -> datetime | str:
 
 
 def time_to_json(d: datetime) -> str | None:
+    return __fix_time_format(d.strftime("%Y-%m-%d %H:%M:%S")) if d else None
 
-    return d.strftime("%Y-%m-%d %H:%M:%S") if d else None
+
+def __fix_time_format(time_str):
+    'Convert "1-00-00 00:00:00" to "0001-00-00 00:00:00"'
+    t = time_str
+    char_index = t.find('-')
+    year_part = t[:char_index]
+
+    if len(year_part) < 4:
+        t = year_part.zfill(4) + t[char_index:]
+
+    return t
 
 
 def json_to_time(time_str: str) -> datetime | str:
     try:
-        return datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S")
+        return datetime.strptime(__fix_time_format(time_str), "%Y-%m-%d %H:%M:%S")
     except BaseException:
         return time_str
 

hiddifypanel/hutils/crypto.py

@@ -1,9 +1,9 @@
 import subprocess
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import x25519, ed25519
 
 
 def get_ed25519_private_public_pair():
-    from cryptography.hazmat.primitives.asymmetric import ed25519
-    from cryptography.hazmat.primitives import serialization
     privkey = ed25519.Ed25519PrivateKey.generate()
     pubkey = privkey.public_key()
     priv_bytes = privkey.private_bytes(
@@ -27,3 +27,22 @@ def get_wg_private_public_psk_pair():
     except subprocess.CalledProcessError as e:
         print(f"Error: {e}")
         return None, None, None
+
+
+def generate_x25519_keys():
+    priv = x25519.X25519PrivateKey.generate()
+    pub = priv.public_key()
+    priv_bytes = priv.private_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PrivateFormat.Raw,
+        encryption_algorithm=serialization.NoEncryption()
+    )
+    pub_bytes = pub.public_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PublicFormat.Raw
+    )
+    import base64
+    pub_str = base64.urlsafe_b64encode(pub_bytes).decode()[:-1]
+    priv_str = base64.urlsafe_b64encode(priv_bytes).decode()[:-1]
+
+    return {'private_key': priv_str, 'public_key': pub_str}

hiddifypanel/hutils/flask.py

@@ -1,10 +1,12 @@
-from typing import List
+from typing import List, Tuple
 from flask import current_app, flash as flask_flash, g, request
 from wtforms.validators import ValidationError
 from apiflask import abort as apiflask_abort
 from flask_babel import lazy_gettext as _
-from flask import url_for, Markup  # type: ignore
+from flask import url_for  # type: ignore
 from urllib.parse import urlparse
+from markupsafe import Markup
+
 import user_agents
 import re
 import os
@@ -15,7 +17,6 @@ from hiddifypanel import hutils
 
 
 def flash(message: str, category: str = "message"):
-    # print(message)
     return flask_flash(Markup(message), category)
 
 
@@ -35,7 +36,7 @@ def static_url_for(**values):
 
 
 def hurl_for(endpoint, **values):
-    if Child.current.id != 0:
+    if Child.current().id != 0:
 
         new_endpoint = "child_" + endpoint
         if new_endpoint in current_app.view_functions:
@@ -237,6 +238,19 @@ def get_proxy_stats_url():
     proxy_stats_url = f'{request.host_url}{g.proxy_path}/proxy-stats/'
     params = f'hostname={proxy_stats_url}api/&port=443&secret=hiddify'
     return f'{proxy_stats_url}?{params}/'
+
+
+def extract_parent_info_from_url(url) -> Tuple[str | None, str | None, str | None]:
+    pattern = r'^https?://([^/]+)/([^/]+)/([^/]+)/.*$'
+    match = re.match(pattern, url)
+
+    if match:
+        domain = match.group(1)
+        proxy_path = match.group(2)
+        admin_uuid = match.group(3)
+        return domain, proxy_path, admin_uuid
+    else:
+        return None, None, None
 # region not used
 
 

hiddifypanel/hutils/importer/xui.py

@@ -6,15 +6,18 @@ from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from hiddifypanel import hutils
 from hiddifypanel.models import *
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute
 import os
+from sqlalchemy import text
 
 
 def __query_fetch_json(db, query: str, args: Tuple = ()) -> List[Dict[str, Any]]:
     try:
-        db.execute(query, args) if args else db.execute(query)
+
+        db_execute(query, args)
         r = [dict((db.description[i][0], value)
                   for i, value in enumerate(row)) for row in db.fetchall()]
+        connection.close()
         return r
     except Exception as err:
         raise err

hiddifypanel/hutils/node/__init__.py

@@ -0,0 +1,3 @@
+from .shared import *
+from . import child
+from . import parent

hiddifypanel/hutils/node/api_client.py

@@ -0,0 +1,76 @@
+from typing import Optional, Union, Type
+from apiflask import Schema, fields
+import traceback
+import requests
+from loguru import logger
+from hiddifypanel.models import hconfig, ConfigEnum
+
+
+class NodeApiErrorSchema(Schema):
+    msg = fields.String(required=True)
+    stacktrace = fields.String(required=True)
+    code = fields.Integer(required=True)
+    reason = fields.String(required=True)
+
+
+class NodeApiClient():
+    def __init__(self, base_url: str, apikey: Optional[str] = None, max_retry: int = 3):
+        self.base_url = base_url if base_url.endswith('/') else base_url+'/'
+        self.max_retry = max_retry
+        self.headers = {'Hiddify-API-Key': apikey or hconfig(ConfigEnum.unique_id)}
+
+    def __call(self, method: str, path: str, payload: Optional[Schema], output_schema: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:  # type: ignore
+        retry_count = 1
+        full_url = self.base_url + path.removeprefix('/')
+        while 1:
+            try:
+                # TODO: implement it with aiohttp
+
+                logger.trace(f"Attempting {method} request to node at {full_url}")
+
+                # send request
+                if payload:
+                    response = requests.request(method, full_url, json=payload.dump(payload), headers=self.headers)
+                else:
+                    response = requests.request(method, full_url, headers=self.headers)
+
+                # parse response
+                response.raise_for_status()
+                resp = response.json()
+                if not resp:
+                    err = NodeApiErrorSchema()
+                    err.msg = 'Empty response'  # type: ignore
+                    err.stacktrace = ''  # type: ignore
+                    err.code = response.status_code  # type: ignore
+                    err.reason = response.reason  # type: ignore
+                    with logger.contextualize(payload=payload):
+                        logger.warning(f"Received empty response from {full_url} with method {method}")
+                    return err
+
+                logger.trace(f"Successfully received response from {full_url}")
+                return resp if isinstance(output_schema, type(dict)) else output_schema().load(resp)  # type: ignore
+
+            except requests.HTTPError as e:
+                if retry_count >= self.max_retry:
+                    stack_trace = traceback.format_exc()
+                    err = NodeApiErrorSchema()
+                    err.msg = str(e)  # type: ignore
+                    err.stacktrace = stack_trace  # type: ignore
+                    err.code = response.status_code  # type: ignore
+                    err.reason = response.reason  # type: ignore
+                    with logger.contextualize(status_code=err.code, reason=err.reason, stack_trace=stack_trace, payload=payload):
+                        logger.error(f"HTTP error after {self.max_retry} retries")
+                        logger.exception(e)
+                    return err
+
+                logger.warning(f"Error occurred: {e} from {full_url} with method {method}, retrying... ({retry_count}/{self.max_retry})")
+                retry_count += 1
+
+    def get(self, path: str, output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("GET", path, None, output)
+
+    def post(self, path: str, payload: Optional[Schema], output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("POST", path, payload, output)
+
+    def put(self, path: str, payload: Optional[Schema], output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("PUT", path, payload, output)

hiddifypanel/hutils/node/child.py

@@ -0,0 +1,147 @@
+from loguru import logger
+import socket
+
+from hiddifypanel.models import AdminUser, User, hconfig, ConfigEnum, ChildMode, set_hconfig, Domain, Proxy, StrConfig, BoolConfig, Child, ChildMode
+from hiddifypanel import hutils
+from hiddifypanel.panel import hiddify
+from hiddifypanel.panel import usage
+from hiddifypanel.database import db
+from hiddifypanel.cache import cache
+
+# import schmeas
+from hiddifypanel.panel.commercial.restapi.v2.parent.schema import *
+from hiddifypanel.panel.commercial.restapi.v2.child.schema import *
+
+from .api_client import NodeApiClient, NodeApiErrorSchema
+# region private
+
+
+def __get_register_data_for_api(name: str, mode: ChildMode) -> RegisterInputSchema:
+
+    register_data = RegisterInputSchema()
+    register_data.unique_id = hconfig(ConfigEnum.unique_id)
+    register_data.name = name  # type: ignore
+    register_data.mode = mode  # type: ignore
+
+    panel_data = RegisterDataSchema()  # type: ignore
+    panel_data.admin_users = [admin_user.to_schema() for admin_user in AdminUser.query.all()]  # type: ignore
+    panel_data.users = [user.to_schema() for user in User.query.all()]  # type: ignore
+    panel_data.domains = [domain.to_schema() for domain in Domain.query.all()]  # type: ignore
+    panel_data.proxies = [proxy.to_schema() for proxy in Proxy.query.all()]  # type: ignore
+    panel_data.hconfigs = [*[u.to_schema() for u in StrConfig.query.all()], *[u.to_schema() for u in BoolConfig.query.all()]]  # type: ignore
+    register_data.panel_data = panel_data
+
+    return register_data
+
+
+def __get_sync_data_for_api() -> SyncInputSchema:
+    sync_data = SyncInputSchema()
+    sync_data.domains = [domain.to_schema() for domain in Domain.query.all()]  # type: ignore
+    sync_data.proxies = [proxy.to_schema() for proxy in Proxy.query.all()]  # type: ignore
+    sync_data.hconfigs = [*[u.to_schema() for u in StrConfig.query.all()], *[u.to_schema() for u in BoolConfig.query.all()]]  # type: ignore
+
+    return sync_data
+
+
+def __get_parent_panel_url() -> str:
+    url = 'https://' + f"{hconfig(ConfigEnum.parent_domain).removesuffix('/')}/{hconfig(ConfigEnum.parent_admin_proxy_path).removesuffix('/')}"
+    return url
+
+# endregion
+
+
+def is_registered() -> bool:
+    '''Checks if the current parent registered as a child'''
+    try:
+        logger.debug("Checking if current panel is registered with parent")
+        base_url = __get_parent_panel_url()
+        if not base_url:
+            return False
+        payload = ChildStatusInputSchema()
+        payload.child_unique_id = hconfig(ConfigEnum.unique_id)
+
+        res = NodeApiClient(base_url).post('/api/v2/parent/status/', payload, ChildStatusOutputSchema)
+        if isinstance(res, NodeApiErrorSchema):
+            logger.error(f"Error while checking if current panel is registered with parent: {res.msg}")
+            return False
+
+        if res['existance']:
+            return True
+        return False
+    except Exception as e:
+        logger.error(f"Error while checking if current panel is registered with parent")
+        logger.exception(e)
+        return False
+
+
+def register_to_parent(name: str, apikey: str, mode: ChildMode = ChildMode.remote) -> bool:
+    # get parent link its format is "https://panel.hiddify.com/<admin_proxy_path>/"
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Parent url is empty")
+        return False
+
+    payload = __get_register_data_for_api(name, mode)
+    res = NodeApiClient(p_url, apikey).put('/api/v2/parent/register/', payload, RegisterOutputSchema)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while registering to parent: {res.msg}")
+        return False
+
+    # TODO: change the bulk_register and such methods to accept models instead of dict
+    AdminUser.bulk_register(res['admin_users'], commit=False)
+    User.bulk_register(res['users'], commit=False)
+
+    # add new child as parent
+    db.session.add(  # type: ignore
+        Child(unique_id=res['parent_unique_id'], name=socket.gethostname() or res['parent_unique_id'], mode=ChildMode.parent)
+    )
+
+    db.session.commit()  # type: ignore
+
+    logger.success("Successfully registered to parent")
+    cache.invalidate_all_cached_functions()
+    return True
+
+
+def sync_with_parent() -> bool:
+    # sync usage first
+    if not sync_users_usage_with_parent():
+        logger.error("Error while syncing with parent: Failed to sync users usage")
+        return False
+
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Error while syncing with parent: Parent url is empty")
+        return False
+    payload = __get_sync_data_for_api()
+    res = NodeApiClient(p_url).put('/api/v2/parent/sync/', payload, SyncOutputSchema)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while syncing with parent: {res.msg}")
+        return False
+    AdminUser.bulk_register(res['admin_users'], commit=False, remove=True)
+    User.bulk_register(res['users'], commit=False, remove=True)
+    db.session.commit()  # type: ignore
+    logger.success("Successfully synced with parent")
+    cache.invalidate_all_cached_functions()
+    return True
+
+
+def sync_users_usage_with_parent() -> bool:
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Parent url is empty")
+        return False
+
+    payload = hutils.node.get_users_usage_data_for_api()
+    if payload:
+        res = NodeApiClient(p_url).put('/api/v2/parent/usage/', payload, UsageInputOutputSchema)  # type: ignore
+        if isinstance(res, NodeApiErrorSchema):
+            logger.error(f"Error while syncing users usage with parent: {res.msg}")
+            return False
+
+        # parse usages data
+        res = hutils.node.convert_usage_api_response_to_dict(res)  # type: ignore
+        usage.add_users_usage_uuid(res, hiddify.get_child(None), True)
+        logger.success(f"Successfully synced users usage with parent: {res}")
+
+    return True