hiddifypanel 10.85.0b20__py3-none-any.whl → 10.86.0b1__py3-none-any.whl

hiddifypanel/hutils/proxy/xrayjson.py

@@ -87,8 +87,7 @@ def configs_as_json(domains: list[Domain], user: User, expire_days: int, remarks
     if not all_configs:
         return ''
 
-    json_configs = json.dumps(all_configs, indent=2,
-                              cls=hutils.proxy.ProxyJsonEncoder)
+    json_configs = json.dumps(all_configs, indent=2, cls=hutils.proxy.ProxyJsonEncoder)
     return json_configs
 
 
@@ -162,7 +161,7 @@ def add_vless_settings(base: dict, proxy: dict):
                     'id': proxy['uuid'],
                     'encryption': 'none',
                     # 'security': 'auto',
-                    'flow': 'xtls-rprx-vision' if (proxy['transport'] == ProxyTransport.XTLS or base['streamSettings']['security'] == 'reality') else '',
+                    'flow': proxy.get('flow',''),
                     'level': OUTBOUND_LEVEL
                 }
             ]
@@ -216,14 +215,17 @@ def add_shadowsocks_settings(base: dict, proxy: dict):
 
 # region stream settings
 
-def add_stream_settings(base: dict, proxy: dict):
-    ss = base['streamSettings']
+def _add_security(base_dict, proxy, tls_info=None):
+    if not tls_info:
+        tls_info = proxy
+
+    ss = base_dict
     ss['security'] = 'none'  # default
 
     # security
-    if proxy['l3'] == ProxyL3.reality:
+    if 'reality' in tls_info['mode']:
         ss['security'] = 'reality'
-    elif proxy['l3'] in [ProxyL3.tls, ProxyL3.tls_h2, ProxyL3.tls_h2_h1, ProxyL3.h3_quic]:
+    elif proxy['l3'] in [ProxyL3.tls, ProxyL3.tls_h2, ProxyL3.tls_h2_h1, ProxyL3.h3_quic, ProxyL3.reality]:
         ss['security'] = 'tls'
 
     # network and transport settings
@@ -231,15 +233,14 @@ def add_stream_settings(base: dict, proxy: dict):
     # ss['security'] == 'tls' or 'xtls' -----> ss['security'] in ['tls','xtls']
     # TODO: FIX THE CONDITION AND TEST CONFIGS ON THE CLIENT SIDE
     if ss['security'] == 'reality':
-        ss['network'] = proxy['transport']
-        add_reality_stream(ss, proxy)
+        # ss['network'] = proxy['transport']
+        add_reality_stream(ss, proxy, tls_info)
     elif ss['security'] in ['tls', "xtls"] and proxy['proto'] != ProxyProto.ss:
-
         ss['tlsSettings'] = {
-            'serverName': proxy['sni'],
-            'allowInsecure': proxy['allow_insecure'],
+            'serverName': tls_info['sni'],
+            'allowInsecure': tls_info['allow_insecure'],
             'fingerprint': proxy['fingerprint'],
-            'alpn': [proxy['alpn']],
+            'alpn': [tls_info['alpn']],
             # 'minVersion': '1.2',
             # 'disableSystemRoot': '',
             # 'enableSessionResumption': '',
@@ -250,6 +251,11 @@ def add_stream_settings(base: dict, proxy: dict):
             # 'rejectUnknownSni': '', # default is false
         }
 
+
+def add_stream_settings(base: dict, proxy: dict):
+    ss = base['streamSettings']
+
+    _add_security(ss, proxy, proxy)
     if proxy['l3'] == ProxyL3.kcp:
         ss['network'] = 'kcp'
         add_kcp_stream(ss, proxy)
@@ -299,7 +305,7 @@ def add_tcp_stream(ss: dict, proxy: dict):
                         "Connection": "keep-alive",
                         "Pragma": "no-cache"
                     },
-                    
+
                 }
             }
         }
@@ -358,23 +364,37 @@ def add_httpupgrade_stream(ss: dict, proxy: dict):
 
 
 def add_xhttp_stream(ss: dict, proxy: dict):
-    if ss['transport'] == "xhttp" and not hutils.flask.is_client_version(hutils.flask.ClientVersion.hiddify_next, 3, 0, 0):
+    if ss['transport'] == "xhttp" and g.user_agent.get(hutils.flask.ClientVersion.hiddify_next) and not hutils.flask.is_client_version(hutils.flask.ClientVersion.hiddify_next, 3, 0, 0):
         ss['transport'] = "splithttp"
         ss['splithttpSettings'] = {
             'path': proxy['path'],
             'host': proxy['host'],
-            "headers": {
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
-            }
+            "headers": proxy['params'].get('headers', {})
         }
     else:
-        ss['xhttpSettings'] = {
-            'path': proxy['path'],
-            'host': proxy['host'],
-            "headers": {
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
-            }
+        _add_xhttp_details(ss, proxy)
+
+        
+
+
+def _add_xhttp_details(ss: dict, proxy: dict):
+    ss['network'] = "xhttp"
+    ss['xhttpSettings'] = {
+        'path': proxy['path'],
+        'host': proxy['host'],
+        'mode':proxy['xhttp_mode'],
+        "extra": {
+            "headers": proxy['params'].get('headers', {})
         }
+    }
+    if proxy.get("download"):
+        ss['xhttpSettings']['extra']['downloadSettings'] = {
+            "address": proxy['download'].get("server"),
+            "port": proxy['port'],
+        }
+
+        _add_xhttp_details(ss['xhttpSettings']['extra']['downloadSettings'], proxy['download'])
+        _add_security(ss['xhttpSettings']['extra']['downloadSettings'], proxy, proxy['download'])
 
 
 def add_kcp_stream(ss: dict, proxy: dict):
@@ -409,12 +429,12 @@ def add_quic_stream(ss: dict, proxy: dict):
     }
 
 
-def add_reality_stream(ss: dict, proxy: dict):
+def add_reality_stream(ss: dict, proxy: dict, domain_info: dict):
     ss['realitySettings'] = {
-        'serverName': proxy['sni'],
+        'serverName': domain_info['sni'],
         'fingerprint': proxy['fingerprint'],
-        'shortId': proxy['reality_short_id'],
-        'publicKey': proxy['reality_pbk'],
+        'shortId': domain_info['reality_short_id'],
+        'publicKey': domain_info['reality_pbk'],
         'show': False,
     }
 

hiddifypanel/models/config.py

@@ -80,7 +80,7 @@ def hconfig(key: ConfigEnum, child_id: Optional[int] = None):  # -> str | int |
     except BaseException:
         logger.exception(f'{key} error!')
         raise
-    if value != None:
+    if value is not None:
         if key.type == int:
             return int(value)
         elif hasattr(key.type, 'from_str'):

hiddifypanel/models/config_enum.py

@@ -128,6 +128,7 @@ class ConfigEnum(metaclass=FastEnum):
     reality_private_key = _StrConfigDscr(ConfigCategory.reality, ApplyMode.apply_config, hide_in_virtual_child=True)
     reality_public_key = _StrConfigDscr(ConfigCategory.reality, ApplyMode.apply_config, hide_in_virtual_child=True)
     reality_port = _StrConfigDscr(ConfigCategory.reality, ApplyMode.apply_config, hide_in_virtual_child=True)
+    special_port = _StrConfigDscr(ConfigCategory.reality, ApplyMode.apply_config, hide_in_virtual_child=True)
 
     restls1_2_domain = _StrConfigDscr(ConfigCategory.hidden)
     restls1_3_domain = _StrConfigDscr(ConfigCategory.hidden)
@@ -161,6 +162,8 @@ class ConfigEnum(metaclass=FastEnum):
     admin_lang = _TypedConfigDscr(Lang, ConfigCategory.admin)
     admin_secret = _StrConfigDscr(ConfigCategory.hidden)  # removed
 
+    default_useragent_string = _StrConfigDscr(ConfigCategory.general)    
+    use_ip_in_config=_BoolConfigDscr(ConfigCategory.general)
     # tls
     tls_ports = _StrConfigDscr(ConfigCategory.tls, ApplyMode.apply_config)
 
@@ -291,6 +294,7 @@ class ConfigEnum(metaclass=FastEnum):
     ssh_host_dsa_pub = _StrConfigDscr(ConfigCategory.hidden)
     
     
+    
 
     hiddifycli_enable = _BoolConfigDscr(ConfigCategory.hidden, ApplyMode.reinstall)
 

hiddifypanel/models/domain.py

@@ -8,7 +8,6 @@ from sqlalchemy.orm import backref
 from strenum import StrEnum
 
 
-
 from hiddifypanel.database import db
 from hiddifypanel.models.config import hconfig
 from .child import Child
@@ -21,11 +20,16 @@ class DomainType(StrEnum):
     cdn = auto()
     auto_cdn_ip = auto()
     relay = auto()
-    reality = auto()
-    old_xtls_direct = auto()
     worker = auto()
     fake = auto()
 
+    reality = auto() #deprecated
+    special_reality_tcp = auto()
+    special_reality_xhttp = auto()
+    special_reality_grpc = auto()
+    old_xtls_direct = auto() #deprecated
+    # special_shadowtls = auto()
+
     # fake_cdn = "fake_cdn"
     # telegram_faketls = "telegram_faketls"
     # ss_faketls = "ss_faketls"
@@ -37,6 +41,7 @@ ShowDomain = db.Table('show_domain',
                       )
 
 
+
 class Domain(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0)
@@ -54,6 +59,8 @@ class Domain(db.Model):
                                    secondaryjoin=id == ShowDomain.c.related_id,
                                    backref=backref('showed_by_domains', lazy='dynamic')
                                    )
+    download_domain_id= db.Column(db.Integer, db.ForeignKey('domain.id', ondelete='SET NULL'), default=None,nullable=True)
+    download_domain = db.relationship('Domain',remote_side=[id],    foreign_keys=[download_domain_id])
     extra_params = db.Column(db.String(200), nullable=True, default='')
 
     def __repr__(self):
@@ -79,6 +86,7 @@ class Domain(db.Model):
             'cdn_ip': self.cdn_ip,
             'servernames': self.servernames,
             'grpc': self.grpc,
+            'download_domain':self.download_domain.domain if self.download_domain else "",
             'show_domains': [dd.domain for dd in self.show_domains],  # type: ignore
         }
         if dump_child_id:
@@ -86,7 +94,7 @@ class Domain(db.Model):
         if dump_ports:
             data["internal_port_hysteria2"] = self.internal_port_hysteria2
             data["internal_port_tuic"] = self.internal_port_tuic
-            data["internal_port_reality"] = self.internal_port_reality
+            data["internal_port_special"] = self.internal_port_special
             data["need_valid_ssl"] = self.need_valid_ssl
 
         return data
@@ -100,6 +108,13 @@ class Domain(db.Model):
         from hiddifypanel.panel.commercial.restapi.v2.parent.schema import DomainSchema
         return DomainSchema().load(domain_dict)
 
+
+    def auto_cdn_ip(self):
+        from hiddifypanel import hutils
+        if self.cdn_ip:
+            return hutils.network.auto_ip_selector.get_clean_ip(self.cdn_ip)
+        return None
+
     @property
     def need_valid_ssl(self):
         return self.mode in [DomainType.direct, DomainType.cdn, DomainType.worker, DomainType.relay, DomainType.auto_cdn_ip, DomainType.old_xtls_direct, DomainType.sub_link_only]
@@ -124,11 +139,11 @@ class Domain(db.Model):
         return int(hconfig(ConfigEnum.tuic_port, self.child_id)) + self.port_index
 
     @property
-    def internal_port_reality(self):
-        if self.mode != DomainType.reality:
+    def internal_port_special(self):
+        if self.mode != DomainType.reality and "special" not in self.mode.value:
             return 0
         # TODO: check validity of the range of the port
-        return int(hconfig(ConfigEnum.reality_port, self.child_id)) + self.port_index
+        return int(hconfig(ConfigEnum.special_port, self.child_id)) + self.port_index
 
     @classmethod
     def by_mode(cls, mode: DomainType) -> List['Domain']:
@@ -163,7 +178,7 @@ class Domain(db.Model):
         domains = []
         domains = db.session.query(Domain).filter(Domain.mode == DomainType.sub_link_only, Domain.child_id == Child.current().id).all()
         if not len(domains) or always_add_all_domains:
-            domains = db.session.query(Domain).filter(Domain.mode.notin_([DomainType.fake, DomainType.reality])).all()
+            domains = db.session.query(Domain).filter(Domain.mode.notin_([DomainType.fake, DomainType.reality,DomainType.special_reality_tcp,DomainType.special_reality_xhttp,DomainType.special_reality_grpc])).all()
 
         if len(domains) == 0 and request:
             domains = [Domain(domain=request.host)]  # type: ignore
@@ -188,6 +203,16 @@ class Domain(db.Model):
         dbdomain.servernames = domain.get('servernames', '')
         show_domains = domain.get('show_domains', [])
         dbdomain.show_domains = Domain.query.filter(Domain.domain.in_(show_domains)).all()
+        dl_domain=domain.get("download_domain")
+        if dl_domain:
+            dbdldomain = Domain.query.filter(Domain.domain == dl_domain).first()
+            if not dbdldomain:
+                dbdldomain = Domain(domain=dl_domain)  # type: ignore
+                db.session.add(dbdldomain)
+                db.session.commit()
+                dbdldomain=Domain.query.filter(Domain.domain == dl_domain).first()
+            assert dbdldomain
+            dbdomain.download_domain_id=dbdldomain.id
         if commit:
             db.session.commit()
 

hiddifypanel/models/proxy.py

@@ -5,12 +5,13 @@ from sqlalchemy import Column, String, Integer, Boolean, Enum, ForeignKey
 
 from hiddifypanel.database import db
 
+from sqlalchemy.types import JSON
 
 
 class ProxyTransport(StrEnum):
     h2 = auto()
     grpc = auto()
-    XTLS = auto()
+    # XTLS = auto()
     faketls = auto()
     shadowtls = auto()
     restls1_2 = auto()
@@ -68,6 +69,7 @@ class Proxy(db.Model):  # type: ignore
     l3 = Column(Enum(ProxyL3), nullable=False)
     transport = Column(Enum(ProxyTransport), nullable=False)
     cdn = Column(Enum(ProxyCDN), nullable=False)
+    params = Column(JSON,default={})
 
     @property
     def enabled(self):
@@ -81,7 +83,8 @@ class Proxy(db.Model):  # type: ignore
             'l3': self.l3,
             'transport': self.transport,
             'cdn': self.cdn,
-            'child_unique_id': self.child.unique_id if self.child else ''
+            'child_unique_id': self.child.unique_id if self.child else '',
+            'params': self.params
         }
 
     def __str__(self):
@@ -101,6 +104,7 @@ class Proxy(db.Model):  # type: ignore
         dbproxy.transport = proxy['transport']
         dbproxy.cdn = proxy['cdn']
         dbproxy.l3 = proxy['l3']
+        dbproxy.params=proxy['params']
         dbproxy.child_id = child_id
         if commit:
             db.session.commit()  # type: ignore

hiddifypanel/panel/admin/DomainAdmin.py

@@ -46,39 +46,31 @@ class DomainAdmin(AdminLTEModelView):
         domain=_("domain.description"),
         mode=_("Direct mode means you want to use your server directly (for usual use), CDN means that you use your server on behind of a CDN provider."),
         cdn_ip=_("config.cdn_forced_host.description"),
-        show_domains=_(
-            'domain.show_domains_description'),
+        show_domains=_('domain.show_domains_description'),
         alias=_('The name shown in the configs for this domain.'),
         servernames=_('config.reality_server_names.description'),
         sub_link_only=_('This can be used for giving your users a permanent non blockable links.'),
-        grpc=_('grpc-proxy.description'))
-
+        grpc=_('grpc-proxy.description'),
+        download_domain=_('download_domain.description')
+    )
     # create_modal = True
     can_export = False
-    form_widget_args = {'show_domains': {'class': 'form-control ltr'}}
+    form_widget_args = {'show_domains': {'class': 'form-control ltr'},'download_domain': {'class': 'form-control ltr'}}
+
     form_args = {
-        'mode': {
-            'enum': DomainType},
+        'mode': {'enum': DomainType},
         'show_domains': {
-            'query_factory': lambda: Domain.query.filter(
-                Domain.sub_link_only == False),
+            'query_factory': lambda: Domain.query.filter(     Domain.sub_link_only == False),
         },
         'domain': {
             'validators': [
-                Regexp(
-                    r'^(\*\.)?([A-Za-z0-9\-\.]+\.[a-zA-Z]{2,})$|^$',
-                    message=__("Should be a valid domain"))]},
+                Regexp(r'^(\*\.)?([A-Za-z0-9\-\.]+\.[a-zA-Z]{2,})$|^$',message=__("Should be a valid domain"))]},
         "cdn_ip": {
             'validators': [
-                Regexp(
-                    r"(((((25[0-5]|(2[0-4]|1\d|[1-9]|)\d).){3}(25[0-5]|(2[0-4]|1\d|[1-9]|)\d))|^([A-Za-z0-9\-\.]+\.[a-zA-Z]{2,}))[ \t\n,;]*\w{3}[ \t\n,;]*)*",
-                    message=__("Invalid IP or domain"))]},
+                Regexp(r"(((((25[0-5]|(2[0-4]|1\d|[1-9]|)\d).){3}(25[0-5]|(2[0-4]|1\d|[1-9]|)\d))|^([A-Za-z0-9\-\.]+\.[a-zA-Z]{2,}))[ \t\n,;]*\w{3}[ \t\n,;]*)*",message=__("Invalid IP or domain"))]},
         "servernames": {
             'validators': [
-                Regexp(
-                    r"^([\w-]+\.)+[\w-]+(,\s*([\w-]+\.)+[\w-]+)*$",
-                    re.IGNORECASE,
-                    _("Invalid REALITY hostnames"))]}}
+                Regexp(r"^([\w-]+\.)+[\w-]+(,\s*([\w-]+\.)+[\w-]+)*$",re.IGNORECASE,_("Invalid REALITY hostnames"))]}}
     column_list = ["domain", "alias", "mode", "domain_ip", "show_domains"]
     column_editable_list = ["alias"]
     # column_filters=["domain","mode"]
@@ -93,10 +85,11 @@ class DomainAdmin(AdminLTEModelView):
         'servernames': _('config.reality_server_names.label'),
         'show_domains': _('Show Domains'),
         'alias': _('Alias'),
-        'grpc': _('gRPC')
+        'grpc': _('gRPC'),
+        "download_domain":_('Download Domain')
     }
 
-    form_columns = ['mode', 'domain', 'alias', 'servernames', 'grpc', 'cdn_ip', 'show_domains']
+    form_columns = ['mode', 'domain','download_domain', 'alias', 'servernames', 'cdn_ip', 'show_domains']
 
     def _domain_admin_link(view, context, model, name):
         if model.mode == DomainType.fake:
@@ -155,7 +148,9 @@ class DomainAdmin(AdminLTEModelView):
     def on_model_change(self, form, model, is_created):
         # Sanitize domain input
         model.domain = (model.domain or '').lower().strip()
-        
+        if model.domain==model.download_domain.domain:
+            model.download_domain_id=None
+            model.download_domain=None
         # Basic validation
         if model.domain == '' and model.mode != DomainType.fake:
             raise ValidationError(_("domain.empty.allowed_for_fake_only"))
@@ -199,7 +194,7 @@ class DomainAdmin(AdminLTEModelView):
         if model.mode == DomainType.old_xtls_direct and not hconfig(ConfigEnum.xtls_enable):
             set_hconfig(ConfigEnum.xtls_enable, True)
             hutils.proxy.get_proxies().invalidate_all()
-        elif model.mode == DomainType.reality:
+        elif "reality" in  model.mode:
             self._validate_reality_settings(model, server_ips)
                 
             # Signal config update if needed
@@ -267,7 +262,7 @@ class DomainAdmin(AdminLTEModelView):
                 if model.domain == configs[c]:
                     raise ValidationError(_("You have used this domain in: ") + _(f"config.{c}.label"))
 
-        for td in Domain.query.filter(Domain.mode == DomainType.reality, Domain.domain != model.domain).all():
+        for td in Domain.query.filter(Domain.mode._in([DomainType.reality,DomainType.special_reality_xhttp,DomainType.special_reality_grpc,DomainType.special_reality_tcp]) == DomainType.reality, Domain.domain != model.domain).all():
             # print(td)
             if td.servernames and (model.domain in td.servernames.split(",")):
                 raise ValidationError(_("You have used this domain in: ") + _(f"config.reality_server_names.label") + td.domain)
@@ -283,6 +278,8 @@ class DomainAdmin(AdminLTEModelView):
             return True
         if model.mode in [DomainType.fake, DomainType.reality, DomainType.relay]:
             return True
+        if "special" in model.mode:
+            return True
         # Resolve domain IPs with timeout
         try:
             dips = hutils.network.get_domain_ips(model.domain)
@@ -319,7 +316,7 @@ class DomainAdmin(AdminLTEModelView):
     def on_model_delete(self, model):
         if len(Domain.query.all()) <= 1:
             raise ValidationError(f"at least one domain should exist")
-        if hconfig(ConfigEnum.cloudflare) and model.mode not in [DomainType.fake, DomainType.reality, DomainType.relay]:
+        if hconfig(ConfigEnum.cloudflare) and model.mode not in [DomainType.fake, DomainType.reality, DomainType.relay] and "special" not in model.mode:
             if not hutils.network.cf_api.delete_dns_record(model.domain):
                 hutils.flask.flash(_('cf-delete.failed'), 'warning')  # type: ignore
         model.showed_by_domains = []

hiddifypanel/panel/commercial/ProxyDetailsAdmin.py

@@ -8,11 +8,13 @@ from hiddifypanel.auth import login_required
 from flask_admin.actions import action
 from flask_admin.contrib.sqla import form, filters as sqla_filters, tools
 from flask_admin import expose
-
+from hiddifypanel.panel import  custom_widgets
 
 # Define a custom field type for the related domains
 from hiddifypanel import hutils
 
+from wtforms.widgets import TextArea
+import json
 
 class ProxyDetailsAdmin(AdminLTEModelView):
     list_template = 'model/proxydetail_list.html'
@@ -22,7 +24,12 @@ class ProxyDetailsAdmin(AdminLTEModelView):
     column_exclude_list = ['child']
     column_searchable_list = ['name', 'proto', 'transport', 'l3', 'cdn']
     column_editable_list = ['name']
-
+    form_extra_fields = {
+        'params': custom_widgets.JSONField(label='Proxy Params')
+    }
+    form_overrides={
+          'params': custom_widgets.JSONField
+    }
     @expose('reset_proxies')
     def reset_proxies(self):
         from hiddifypanel.panel.init_db import get_proxy_rows_v1
@@ -70,7 +77,8 @@ class ProxyDetailsAdmin(AdminLTEModelView):
         if login_required(roles={Role.super_admin, Role.admin})(lambda: True)() != True:
             return False
         return True
-
+    def _params_formatter(view, context, model, name):
+        return str(model.params)
     def _enable_formatter(view, context, model, name):
         if model.enable:
             link = '<i class="fa-solid fa-circle-check text-success"></i> '
@@ -79,5 +87,6 @@ class ProxyDetailsAdmin(AdminLTEModelView):
         return Markup(link)
     column_formatters = {
 
-        "enable": _enable_formatter
+        "enable": _enable_formatter,
+        "params": _params_formatter
     }

hiddifypanel/panel/commercial/restapi/v2/user/configs_api.py

@@ -130,7 +130,7 @@ class AllConfigsAPI(MethodView):
             items.append(
                 create_item(
                     pinfo["name"].replace("_", " "),
-                    f"{'Auto ' if pinfo['dbdomain'].has_auto_ip else ''}{pinfo['mode']}",
+                    f"{pinfo['mode']}",
                     pinfo['server'],
                     pinfo['proto'],
                     pinfo['transport'],

hiddifypanel/panel/custom_widgets.py

@@ -6,6 +6,11 @@ from wtforms import TextAreaField
 from wtforms.fields import IntegerField, SelectField, DecimalField
 from wtforms.widgets import TextArea
 
+from wtforms import Field
+from wtforms.validators import ValidationError
+from wtforms.widgets import TextArea
+import json
+
 from hiddifypanel.models import *
 
 
@@ -89,3 +94,43 @@ class UsageField(DecimalField):
             self.data = int(float(valuelist[0]) * ONE_GIG)
         else:
             self.data = None
+
+
+
+
+
+
+
+class JSONWidget(TextArea):
+    def __call__(self, field, **kwargs):
+        if isinstance(field.data, dict):
+            try:
+                field.data = json.dumps(field.data, indent=2)
+            except Exception:
+                pass
+        if kwargs.get('class'):
+            kwargs['class'] += ' ltr json-editor'
+        else:
+            kwargs.setdefault('class', 'ltr json-editor')
+        
+        return super().__call__(field, **kwargs)
+
+class JSONField(Field):
+    widget = JSONWidget()
+
+    def _value(self):
+        if self.data is None:
+            return ''
+        if isinstance(self.data, str):
+            return self.data
+        try:
+            return json.dumps(self.data, indent=2)
+        except Exception:
+            return str(self.data)
+
+    def process_formdata(self, valuelist):
+        if valuelist:
+            try:
+                self.data = json.loads(valuelist[0])
+            except Exception as e:
+                raise ValidationError(f'Invalid JSON: {e}')