@danhachuel/thunderbolt 0.2.91 → 0.2.92

package/app/main.py

@@ -216,9 +216,20 @@ st.markdown("""
 
 
 def current_ui_language() -> str:
-    settings = read_json("settings.json", {})
-    stored = st.session_state.get("ui_language") or settings.get("ui_language") or "pt"
-    normalized = language_code(stored)
+    """Return the session language without hitting disk on every widget render."""
+    cached = st.session_state.get("ui_language")
+    if cached:
+        return language_code(cached)
+    requested = ""
+    try:
+        requested = str(st.query_params.get("lang") or "").strip()
+    except Exception:
+        requested = ""
+    if requested:
+        normalized = language_code(requested)
+    else:
+        settings = read_json("settings.json", {})
+        normalized = language_code(settings.get("ui_language") or "pt")
     st.session_state["ui_language"] = normalized
     return normalized
 
@@ -235,7 +246,7 @@ _STREAMLIT_I18N_INSTALLED = False
 def _translate_streamlit_arguments(method_name: str, args: tuple[Any, ...], kwargs: dict[str, Any]) -> tuple[tuple[Any, ...], dict[str, Any]]:
     if not args and "label" not in kwargs:
         return args, kwargs
-    selected_language = current_ui_language()
+    selected_language = str(st.session_state.get("ui_language") or current_ui_language())
     translated_args = list(args)
     if translated_args and isinstance(translated_args[0], str):
         translated_args[0] = ui_text(translated_args[0], selected_language)
@@ -339,6 +350,10 @@ def render_ui_language_picker(language: str) -> None:
         )
     if selected != current:
         save_ui_language(selected)
+        try:
+            st.query_params["lang"] = selected
+        except Exception:
+            pass
         st.rerun()
 
 

package/hermes_ui/languages.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import base64
+from functools import lru_cache
 from typing import Any
 
 
@@ -589,6 +590,22 @@ for _row in _CONTENT_TOKEN_TRANSLATION_ROWS:
         UI_TOKEN_TRANSLATIONS[_code][_source] = _translated
 
 
+@lru_cache(maxsize=16)
+def _combined_translations(language: str) -> dict[str, str]:
+    """Build the immutable-language translation index once per process."""
+    return {
+        **UI_TRANSLATIONS.get(language, {}),
+        **UI_CONTENT_TRANSLATIONS.get(language, {}),
+        **UI_TOKEN_TRANSLATIONS.get(language, {}),
+    }
+
+
+@lru_cache(maxsize=16)
+def _sorted_translations(language: str) -> tuple[tuple[str, str], ...]:
+    """Cache longest-first token replacement order for each language."""
+    return tuple(sorted(_combined_translations(language).items(), key=lambda item: len(item[0]), reverse=True))
+
+
 def translate_ui_content(value: Any, language: Any = "pt") -> Any:
     """Translate visible Streamlit content while preserving non-text values and user data markup."""
     if not isinstance(value, str):
@@ -601,12 +618,7 @@ def translate_ui_content(value: Any, language: Any = "pt") -> Any:
     if exact is not None:
         return exact
     translated = value
-    combined_translations = {
-        **UI_TRANSLATIONS.get(code, {}),
-        **UI_CONTENT_TRANSLATIONS.get(code, {}),
-        **UI_TOKEN_TRANSLATIONS.get(code, {}),
-    }
-    for source, target in sorted(combined_translations.items(), key=lambda item: len(item[0]), reverse=True):
+    for source, target in _sorted_translations(code):
         if source != target and source in translated:
             translated = translated.replace(source, target)
     return translated

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.2.91",
+  "version": "0.2.92",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",

package/scripts/cli.mjs

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import { spawn, spawnSync } from "node:child_process";
+import http from "node:http";
+import net from "node:net";
 import { existsSync, mkdirSync, readFileSync, copyFileSync, readdirSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { join, resolve } from "node:path";
@@ -150,6 +152,51 @@ if (args[0] === "pipeline-worker" || args.includes("--pipeline-worker")) {
 }
 
 const port = process.env.THUNDERBOLT_PORT || process.env.HERMES_PORT || "3030";
+const publicPort = Number.parseInt(String(port), 10);
+const backendPort = Number.isFinite(publicPort) ? publicPort + 1 : 3031;
+const supportedLanguages = new Set(["en", "zh", "de", "vi", "tr", "pt", "ru", "es", "id", "it"]);
+
+const proxy = http.createServer((request, response) => {
+  const requestUrl = new URL(request.url || "/", `http://localhost:${publicPort}`);
+  const pathParts = requestUrl.pathname.split("/").filter(Boolean);
+  const languagePrefix = pathParts.length === 1 && supportedLanguages.has(pathParts[0]) ? pathParts[0] : "";
+  if (languagePrefix) {
+    requestUrl.pathname = "/";
+    requestUrl.searchParams.set("lang", languagePrefix);
+    response.writeHead(302, { Location: `${requestUrl.pathname}?${requestUrl.searchParams.toString()}` });
+    response.end();
+    return;
+  }
+  const upstream = http.request({
+    hostname: "127.0.0.1",
+    port: backendPort,
+    method: request.method,
+    path: `${requestUrl.pathname}${requestUrl.search}`,
+    headers: { ...request.headers, host: `127.0.0.1:${backendPort}` },
+  }, (upstreamResponse) => {
+    response.writeHead(upstreamResponse.statusCode || 502, upstreamResponse.headers);
+    upstreamResponse.pipe(response);
+  });
+  upstream.on("error", (error) => {
+    response.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+    response.end(`Thunderbolt backend indisponível: ${error.message}`);
+  });
+  request.pipe(upstream);
+});
+
+proxy.on("upgrade", (request, clientSocket, head) => {
+  const upstreamSocket = net.connect(backendPort, "127.0.0.1", () => {
+    const headers = Object.entries(request.headers)
+      .map(([name, value]) => `${name}: ${Array.isArray(value) ? value.join(", ") : value}`)
+      .join("\\r\\n");
+    upstreamSocket.write(`GET ${request.url} HTTP/1.1\\r\\n${headers}\\r\\n\\r\\n`);
+    if (head.length) upstreamSocket.write(head);
+    clientSocket.pipe(upstreamSocket).pipe(clientSocket);
+  });
+  upstreamSocket.on("error", () => clientSocket.destroy());
+});
+
+proxy.listen(publicPort, "127.0.0.1");
 const worker = spawn(python, ["-m", "hermes_ui.automation_worker"], {
   cwd: root,
   stdio: "inherit",
@@ -162,7 +209,7 @@ const pipelineWorker = spawn(python, ["-m", "hermes_ui.pipeline_worker"], {
   env: runtimeEnv,
   windowsHide: false,
 });
-const child = spawn(python, ["-m", "streamlit", "run", main, "--server.port", port, "--server.address", "localhost"], {
+const child = spawn(python, ["-m", "streamlit", "run", main, "--server.port", String(backendPort), "--server.address", "127.0.0.1"], {
   cwd: root,
   stdio: "inherit",
   env: runtimeEnv,
@@ -170,6 +217,7 @@ const child = spawn(python, ["-m", "streamlit", "run", main, "--server.port", po
 });
 
 const stopWorker = () => {
+  proxy.close();
   if (!worker.killed) worker.kill();
   if (!pipelineWorker.killed) pipelineWorker.kill();
 };