ai-devsec-gateway 1.2.1__py3-none-any.whl

ai_blocker/__init__.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# ruff: noqa: F401
+__version__ = "1.2.1"
+APP_VERSION = __version__
+
+# Expose everything to maintain backwards compatibility and test stability
+from ai_blocker.block_actions import activate_block, deactivate_block, detect_running_ai_editors, force_close_processes
+from ai_blocker.config import (
+    SENSITIVE_CONFIG_KEYS,
+    get_config_path,
+    get_windows_autostart,
+    load_config,
+    save_config,
+    set_windows_autostart,
+)
+from ai_blocker.constants import (
+    BLOCKLIST,
+    CATEGORY_ICONS,
+    COL_BASE,
+    COL_BLUE,
+    COL_GREEN,
+    COL_MAUVE,
+    COL_RED,
+    COL_SUBTEXT,
+    COL_SURFACE0,
+    COL_SURFACE1,
+    COL_TEXT,
+    COL_YELLOW,
+    COMMENT_TAG,
+    CURRENT_OS,
+    HOSTS_PATH,
+    PROCESS_LIST,
+    UI_FONT,
+    _get_ui_font,
+)
+from ai_blocker.gateway import GatewayHandler
+from ai_blocker.i18n import (
+    CATEGORY_TRANSLATIONS,
+    LANG_CODE_MAP,
+    LANG_DISPLAY_MAP,
+    STRINGS,
+    detect_system_language,
+    load_translations,
+)
+from ai_blocker.system_utils import (
+    _get_subprocess_kwargs,
+    count_total_domains,
+    flush_dns,
+    get_hosts_status,
+    is_admin,
+    relaunch_as_admin,
+)
+from ai_blocker.ui import AIBlockerApp
+
+if CURRENT_OS == "Windows":
+    from ai_blocker.tray import WindowsTrayIcon

ai_blocker/__main__.py

@@ -0,0 +1,112 @@
+import argparse
+import ctypes
+import sys
+import tkinter as tk
+from tkinter import messagebox
+
+from ai_blocker.constants import CURRENT_OS
+from ai_blocker.i18n import STRINGS, detect_system_language
+from ai_blocker.system_utils import get_hosts_status, is_admin, relaunch_as_admin
+from ai_blocker.ui import AIBlockerApp
+
+
+def acquire_single_instance_lock():
+    if CURRENT_OS == "Windows":
+        mutex_name = "Global\\AIBlocker_SingleInstance_Mutex"
+        mutex = ctypes.windll.kernel32.CreateMutexW(None, False, mutex_name)
+        if ctypes.windll.kernel32.GetLastError() == 183:  # ERROR_ALREADY_EXISTS
+            return False, None
+        return True, mutex
+    else:
+        try:
+            import fcntl
+            lock_file = "/tmp/ai_blocker.lock"
+            fp = open(lock_file, "w")
+            fcntl.lockf(fp, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            return True, fp
+        except (IOError, OSError, ImportError):
+            return False, None
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Network Blocker & DevSec Gateway CLI")
+    parser.add_argument("--block", choices=["work", "personal", "free"], help="Activate blocking for the specified profile")
+    parser.add_argument("--unblock", action="store_true", help="Deactivate all AI domain blocks")
+    parser.add_argument("--status", action="store_true", help="Show current blocking status and active editors")
+
+    args, unknown = parser.parse_known_args()
+
+    # CLI execution path
+    if args.block or args.unblock or args.status:
+        if args.status:
+            is_blocked, count = get_hosts_status()
+            print(f"Status: {'PROTECTED (Blocking active)' if is_blocked else 'EXPOSED (No protection)'}")
+            print(f"Blocked domains: {count}")
+
+            from ai_blocker.block_actions import detect_running_ai_editors
+            editors = detect_running_ai_editors()
+            if editors:
+                print(f"Active AI editors detected: {', '.join(editors)}")
+            else:
+                print("No active AI editors detected.")
+            sys.exit(0)
+
+        # For block/unblock, verify admin privileges
+        if not is_admin():
+            print("Error: Administrator/root privileges are required for this action.")
+            if CURRENT_OS == "Windows":
+                print("Requesting Administrator elevation...")
+                relaunch_as_admin()
+            sys.exit(1)
+
+        from ai_blocker.block_actions import activate_block, deactivate_block
+
+        if args.unblock:
+            ok, msg = deactivate_block("en")
+            print(msg.strip())
+            sys.exit(0 if ok else 1)
+
+        if args.block:
+            from ai_blocker.constants import BLOCKLIST
+            if args.block == "work":
+                cats = list(BLOCKLIST.keys())
+            elif args.block == "personal":
+                cats = [c for c in BLOCKLIST.keys() if "copilot" in c.lower()]
+            else: # free
+                cats = []
+
+            if not cats:
+                ok, msg = deactivate_block("en")
+            else:
+                ok, msg = activate_block("en", cats)
+            print(msg.strip())
+            sys.exit(0 if ok else 1)
+
+    # GUI execution path
+    ok, lock_ref = acquire_single_instance_lock()
+    if not ok:
+        print("AI Network Blocker is already running.")
+        sys.exit(0)
+
+    if not is_admin():
+        relaunch_as_admin()
+
+        detected_lang = detect_system_language()
+        s = STRINGS[detected_lang]
+
+        root_temp = tk.Tk()
+        root_temp.withdraw()
+        messagebox.showerror(
+            s["admin_required_title"],
+            s["admin_required_msg"]
+        )
+        root_temp.destroy()
+        sys.exit(1)
+
+    root = tk.Tk()
+    AIBlockerApp(root)
+    if "--minimized" in sys.argv and CURRENT_OS == "Windows":
+        root.withdraw()
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()

ai_blocker/block_actions.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+import os
+import subprocess
+
+from ai_blocker.constants import BLOCKLIST, COMMENT_TAG, CURRENT_OS, HOSTS_PATH, PROCESS_LIST
+from ai_blocker.i18n import STRINGS
+from ai_blocker.system_utils import _get_subprocess_kwargs, flush_dns
+
+
+def force_close_processes():
+    closed = []
+    kwargs = _get_subprocess_kwargs()
+
+    try:
+        if CURRENT_OS == "Windows":
+            args = ["taskkill", "/F"]
+            for proc in PROCESS_LIST:
+                args.extend(["/IM", proc])
+            result = subprocess.run(args, capture_output=True, text=True, **kwargs)
+            out_lower = result.stdout.lower()
+            for proc in PROCESS_LIST:
+                if f'"{proc.lower()}"' in out_lower or f'{proc.lower()}' in out_lower:
+                    closed.append(proc.replace(".exe", ""))
+        else:
+            active = detect_running_ai_editors()
+            if active:
+                args = ["killall"] + active
+                subprocess.run(args, capture_output=True, text=True, **kwargs)
+                closed = active
+    except Exception:
+        pass
+    return closed
+
+def detect_running_ai_editors():
+    running = []
+    kwargs = _get_subprocess_kwargs()
+
+    try:
+        if CURRENT_OS == "Windows":
+            result = subprocess.run(["tasklist", "/NH"], capture_output=True, text=True, **kwargs)
+            out_lower = result.stdout.lower()
+            for proc in PROCESS_LIST:
+                if proc.lower() in out_lower:
+                    running.append(proc.replace(".exe", ""))
+        else:
+            result = subprocess.run(["ps", "-A", "-o", "comm="], capture_output=True, text=True, **kwargs)
+            out_lines = result.stdout.splitlines()
+            active = set()
+            for line in out_lines:
+                active.add(os.path.basename(line.strip()).lower())
+
+            for proc in PROCESS_LIST:
+                if proc.lower() in active:
+                    running.append(proc)
+    except Exception:
+        pass
+    return running
+
+def activate_block(lang, categories_to_block=None):
+    if categories_to_block is None:
+        categories_to_block = list(BLOCKLIST.keys())
+
+    closed_list = force_close_processes()
+    s = STRINGS[lang]
+
+    try:
+        existing_lines = []
+        if os.path.exists(HOSTS_PATH):
+            with open(HOSTS_PATH, "r", encoding="utf-8") as f:
+                existing_lines = f.readlines()
+
+        cleaned_lines = [l for l in existing_lines if COMMENT_TAG not in l]
+
+        if cleaned_lines and not cleaned_lines[-1].endswith("\n"):
+            cleaned_lines[-1] += "\n"
+
+        new_entries = []
+        added_count = 0
+
+        domains_to_block = []
+        for cat in categories_to_block:
+            if cat in BLOCKLIST:
+                for domain in BLOCKLIST[cat]:
+                    if domain not in domains_to_block:
+                        domains_to_block.append(domain)
+
+        for domain in domains_to_block:
+            entry = f"127.0.0.1 {domain} {COMMENT_TAG}\n"
+            new_entries.append(entry)
+            added_count += 1
+
+        with open(HOSTS_PATH, "w", encoding="utf-8") as f:
+            f.writelines(cleaned_lines + new_entries)
+
+        flush_dns()
+
+        if closed_list:
+            process_details = f"{s['closed_processes_prefix']}{', '.join(closed_list)}"
+        else:
+            process_details = s["no_processes_detected"]
+
+        msg = s["block_success_msg"].format(
+            added_count=added_count,
+            process_details=process_details
+        )
+        return True, msg
+
+    except PermissionError:
+        return False, s["hosts_write_error_msg"]
+    except Exception as e:
+        return False, s["unexpected_error_msg"].format(error=str(e))
+
+def deactivate_block(lang):
+    s = STRINGS[lang]
+    try:
+        if not os.path.exists(HOSTS_PATH):
+            return True, s["unblock_success_msg"].format(removed=0)
+
+        with open(HOSTS_PATH, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        original_count = len(lines)
+        cleaned = [l for l in lines if COMMENT_TAG not in l]
+        removed = original_count - len(cleaned)
+
+        with open(HOSTS_PATH, "w", encoding="utf-8") as f:
+            f.writelines(cleaned)
+
+        flush_dns()
+
+        msg = s["unblock_success_msg"].format(removed=removed)
+        return True, msg
+
+    except PermissionError:
+        return False, s["hosts_write_error_msg"]
+    except Exception as e:
+        return False, s["unexpected_error_msg"].format(error=str(e))

ai_blocker/config.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+import json
+import os
+import sys
+
+from ai_blocker.constants import CURRENT_OS
+
+SENSITIVE_CONFIG_KEYS = {"openai_key"}
+
+def get_config_path():
+    if CURRENT_OS == "Windows":
+        base_dir = os.environ.get("APPDATA", os.path.expanduser("~"))
+    else:
+        base_dir = os.path.expanduser("~/.config")
+    app_dir = os.path.join(base_dir, "AI-Blocker")
+    try:
+        os.makedirs(app_dir, exist_ok=True)
+    except Exception:
+        pass
+    return os.path.join(app_dir, "config.json")
+
+def load_config():
+    path = get_config_path()
+    if os.path.exists(path):
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            for key in SENSITIVE_CONFIG_KEYS:
+                data.pop(key, None)
+            return data
+        except Exception:
+            pass
+    return {}
+
+def save_config(config_data):
+    path = get_config_path()
+    try:
+        safe_config = dict(config_data)
+        for key in SENSITIVE_CONFIG_KEYS:
+            safe_config.pop(key, None)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(safe_config, f, indent=4, ensure_ascii=False)
+    except Exception:
+        pass
+
+def set_windows_autostart(enabled=True):
+    if CURRENT_OS != "Windows":
+        return False
+    import winreg
+    key_path = r"Software\Microsoft\Windows\CurrentVersion\Run"
+    try:
+        # Determine script/executable command line
+        if getattr(sys, 'frozen', False):
+            cmd = f'"{sys.executable}" --minimized'
+        else:
+            # When modularized, the root file is still ai_blocker.py
+            # But let's check: if we are running as module, we need to run main file
+            root_file = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "ai_blocker.py"))
+            cmd = f'"{sys.executable}" "{root_file}" --minimized'
+
+        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_SET_VALUE)
+        if enabled:
+            winreg.SetValueEx(key, "AIBlocker", 0, winreg.REG_SZ, cmd)
+        else:
+            try:
+                winreg.DeleteValue(key, "AIBlocker")
+            except FileNotFoundError:
+                pass
+        winreg.CloseKey(key)
+        return True
+    except Exception:
+        return False
+
+def get_windows_autostart():
+    if CURRENT_OS != "Windows":
+        return False
+    import winreg
+    key_path = r"Software\Microsoft\Windows\CurrentVersion\Run"
+    try:
+        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_READ)
+        val, _ = winreg.QueryValueEx(key, "AIBlocker")
+        winreg.CloseKey(key)
+        return True
+    except Exception:
+        return False

ai_blocker/constants.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+import os
+import platform
+
+CURRENT_OS = platform.system()  # 'Windows', 'Linux', 'Darwin'
+
+BLOCKLIST = {
+    "OpenAI": [
+        "api.openai.com", "chatgpt.com", "chat.openai.com",
+        "platform.openai.com", "openai.com", "auth.openai.com",
+        "oaistatic.com", "oaiusercontent.com", "labs.openai.com",
+    ],
+    "Anthropic": [
+        "api.anthropic.com", "claude.ai", "anthropic.com",
+        "claudeusercontent.com",
+    ],
+    "GitHub Copilot": [
+        "api.githubcopilot.com", "copilot.github.com",
+        "githubcopilot.com", "api.individual.githubcopilot.com",
+    ],
+    "Google AI": [
+        "generativelanguage.googleapis.com", "aistudio.google.com",
+        "gemini.google.com", "ai.google.dev",
+    ],
+    "Meta AI": [
+        "meta.ai", "ai.meta.com",
+    ],
+    "Mistral AI": [
+        "api.mistral.ai", "mistral.ai",
+    ],
+    "Microsoft Copilot": [
+        "copilot.microsoft.com", "bing.com", "edgeservices.bing.com",
+    ],
+    "DeepSeek": [
+        "deepseek.com", "api.deepseek.com",
+    ],
+    "xAI": [
+        "api.x.ai", "grok.x.ai", "x.ai",
+    ],
+    "Otros": [
+        "api.perplexity.ai", "perplexity.ai",
+        "app.wordware.ai",
+    ],
+}
+
+CATEGORY_ICONS = {
+    "OpenAI": "🟢", "Anthropic": "🟠", "GitHub Copilot": "🐙",
+    "Google AI": "🔵", "Meta AI": "🔷", "Mistral AI": "🌊",
+    "Microsoft Copilot": "🟦", "DeepSeek": "🔮", "xAI": "🤖", "Otros": "📦",
+}
+
+if CURRENT_OS == "Windows":
+    PROCESS_LIST = [
+        "Code.exe", "Cursor.exe", "Windsurf.exe", "Claude.exe",
+        "Trae.exe", "Cline.exe", "Roo.exe", "Augment.exe",
+    ]
+else:
+    PROCESS_LIST = [
+        "code", "cursor", "windsurf", "claude",
+        "trae", "cline", "roo", "augment",
+    ]
+
+COMMENT_TAG = "# AI-Block"
+
+if CURRENT_OS == "Windows":
+    HOSTS_PATH = os.path.join(
+        os.environ.get("SystemRoot", r"C:\Windows"),
+        r"System32\drivers\etc\hosts",
+    )
+else:
+    HOSTS_PATH = "/etc/hosts"
+
+# Catppuccin Mocha colors
+COL_BASE      = "#1E1E2E"
+COL_SURFACE0  = "#313244"
+COL_SURFACE1  = "#45475A"
+COL_TEXT      = "#CDD6F4"
+COL_SUBTEXT   = "#A6ADC8"
+COL_RED       = "#F38BA8"
+COL_GREEN     = "#A6E3A1"
+COL_YELLOW    = "#F9E2AF"
+COL_BLUE      = "#89B4FA"
+COL_MAUVE     = "#CBA6F7"
+
+def _get_ui_font():
+    if CURRENT_OS == "Windows":
+        return "Segoe UI"
+    elif CURRENT_OS == "Darwin":
+        return "Helvetica Neue"
+    else:
+        return "DejaVu Sans"
+
+UI_FONT = _get_ui_font()

ai_blocker/gateway.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+import urllib.error
+import urllib.request
+from http.server import BaseHTTPRequestHandler
+
+
+class GatewayHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        self._proxy_request("GET")
+
+    def do_POST(self):
+        self._proxy_request("POST")
+
+    def do_OPTIONS(self):
+        self._proxy_request("OPTIONS")
+
+    def _proxy_request(self, method):
+        target = self.server.target_url.rstrip("/") + self.path
+        headers = {}
+        for k, v in self.headers.items():
+            if k.lower() not in ['host', 'accept-encoding']:
+                headers[k] = v
+
+        data = None
+        if method in ['POST', 'PUT', 'PATCH']:
+            content_length = int(self.headers.get('Content-Length', 0))
+            if content_length > 0:
+                data = self.rfile.read(content_length)
+
+        req = urllib.request.Request(target, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=30) as response:
+                self.send_response(response.status)
+                for k, v in response.headers.items():
+                    if k.lower() not in ['transfer-encoding']:
+                        self.send_header(k, v)
+                self.end_headers()
+
+                while True:
+                    chunk = response.read(1024)
+                    if not chunk:
+                        break
+                    self.wfile.write(chunk)
+                    self.wfile.flush()
+        except urllib.error.HTTPError as e:
+            self.send_response(e.code)
+            for k, v in e.headers.items():
+                if k.lower() not in ['transfer-encoding']:
+                    self.send_header(k, v)
+            self.end_headers()
+            self.wfile.write(e.read())
+        except Exception as e:
+            self.send_response(502)
+            self.end_headers()
+            self.wfile.write(f"Gateway Error: {e}".encode())

ai_blocker/i18n.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+import json
+import locale
+import os
+import sys
+
+from ai_blocker.constants import CURRENT_OS
+
+if CURRENT_OS == "Windows":
+    import ctypes
+
+LANG_DISPLAY_MAP = {
+    "English": "en",
+    "Español": "es",
+    "Português": "pt",
+    "Français": "fr",
+    "Deutsch": "de",
+    "Italiano": "it",
+    "Русский": "ru",
+    "中文 (简体)": "zh",
+    "日本語": "ja",
+    "한국어": "ko"
+}
+LANG_CODE_MAP = {v: k for k, v in LANG_DISPLAY_MAP.items()}
+
+CATEGORY_TRANSLATIONS = {}
+STRINGS = {}
+
+def load_translations():
+    global CATEGORY_TRANSLATIONS, STRINGS
+    try:
+        # Load relative to package or executable directory
+        if getattr(sys, 'frozen', False):
+            base_dir = os.path.dirname(sys.executable)
+        else:
+            base_dir = os.path.dirname(os.path.abspath(__file__))
+
+        trans_path = os.path.join(base_dir, "translations.json")
+
+        # Fallback to parent directory if in development subfolder
+        if not os.path.exists(trans_path):
+            trans_path = os.path.join(os.path.dirname(base_dir), "translations.json")
+
+        # Try PyInstaller temporary folder fallback (if bundled as data file)
+        if not os.path.exists(trans_path) and hasattr(sys, '_MEIPASS'):
+            trans_path = os.path.join(sys._MEIPASS, "translations.json")
+
+        # Fallback if still not found
+        if not os.path.exists(trans_path):
+            trans_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "translations.json")
+
+        with open(trans_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            CATEGORY_TRANSLATIONS = data["category_translations"]
+            STRINGS = data["strings"]
+    except Exception as e:
+        print(f"Warning: Failed to load translations.json: {e}")
+        # Minimal hardcoded fallback
+        CATEGORY_TRANSLATIONS = {"en": {"OpenAI": "OpenAI", "Anthropic": "Anthropic", "GitHub Copilot": "GitHub Copilot", "Google AI": "Google AI", "Meta AI": "Meta AI", "Mistral AI": "Mistral AI", "Microsoft Copilot": "Microsoft Copilot", "DeepSeek": "DeepSeek", "xAI": "xAI", "Otros": "Others"}}
+        STRINGS = {"en": {
+            "protected_title": "PROTECTED — Blocking active",
+            "protected_desc": "{count} domains redirected to 127.0.0.1",
+            "exposed_title": "EXPOSED — No protection",
+            "exposed_desc": "Your network traffic to AI is open",
+            "btn_block": "🔒  BLOCK AI",
+            "btn_unblock": "🔓  UNBLOCK AI",
+            "busy_text": "⏳  Processing...",
+            "categories_title": "Blocked Categories",
+            "domains_label": "{total} domains",
+            "running_warning": "⚠ Detected: {editors}",
+            "hosts_write_error_title": "Permission Error",
+            "hosts_write_error_msg": "Could not write to the hosts file.\nPlease run the application as Administrator.",
+            "unexpected_error_title": "Unexpected Error",
+            "unexpected_error_msg": "An error occurred:\n{error}",
+            "block_success_title": "AI Blocking Active",
+            "block_success_msg": "Block successfully activated!\n\n✓ {added_count} domains blocked in hosts file.\n{process_details}\n✓ DNS cache flushed.",
+            "unblock_success_title": "AI Blocking Disabled",
+            "unblock_success_msg": "Block successfully deactivated!\n\n✓ {removed} entries removed from hosts file.\n✓ DNS cache flushed.\n\nAll AI tools can access the network again.",
+            "closed_processes_prefix": "✓ Closed processes: ",
+            "no_processes_detected": "• No open AI editors detected.",
+            "admin_required_title": "Access Denied",
+            "admin_required_msg_windows": "Administrator privileges are required.\n\nRight-click → 'Run as administrator'.",
+            "admin_required_msg_unix": "Root privileges are required.\n\nRun with: sudo python3 ai_blocker.py",
+            "profile_work": "Work",
+            "profile_personal": "Personal",
+            "profile_free": "Free",
+            "profile_custom": "Custom"
+        }}
+
+    # Resolve platform specific strings
+    for lang in STRINGS:
+        if CURRENT_OS == "Windows":
+            STRINGS[lang]["admin_required_msg"] = STRINGS[lang].get("admin_required_msg_windows", "")
+        else:
+            STRINGS[lang]["admin_required_msg"] = STRINGS[lang].get("admin_required_msg_unix", "")
+
+def detect_system_language():
+    # 1. Environment variables
+    for env_var in ('LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LANG'):
+        val = os.environ.get(env_var)
+        if val:
+            code = val.split('_')[0].split('.')[0].lower()
+            if code in STRINGS:
+                return code
+
+    # 2. locale.getlocale()
+    try:
+        if hasattr(locale, 'getlocale'):
+            lang, _ = locale.getlocale()
+            if lang:
+                code = lang.split('_')[0].lower()
+                if code in STRINGS:
+                    return code
+    except Exception:
+        pass
+
+    # Windows LCID query
+    if CURRENT_OS == "Windows":
+        try:
+            lcid = ctypes.windll.kernel32.GetUserDefaultUILanguage()
+            lcid_map = {
+                1034: "es", 2058: "es", 3082: "es", 4106: "es", 5130: "es", 6154: "es",
+                1046: "pt", 2070: "pt",
+                1036: "fr", 2060: "fr", 3084: "fr",
+                1031: "de", 2055: "de",
+                1040: "it",
+                1049: "ru",
+                2052: "zh", 1028: "zh", 3076: "zh",
+                1041: "ja",
+                1042: "ko",
+            }
+            for k, v in lcid_map.items():
+                if lcid == k or (lcid & 0x3FF) == (k & 0x3FF):
+                    return v
+        except Exception:
+            pass
+
+    return "en"
+
+# Run initial load on import
+load_translations()