@danhachuel/thunderbolt 0.7.52 → 0.7.54

package/app/main.py

@@ -3326,16 +3326,33 @@ def render_channels():
     channels = [channel for channel in read_json("channels.json", []) if is_youtube_channel_record(channel)]
     st.divider()
     st.subheader(f"Canais Youtube cadastrados ({len(channels)})")
-    youtube_channel_search = st.text_input(
-        "Pesquisar nomes dos canais YouTube",
-        key="youtube_registered_channels_search",
-        placeholder="Digite o nome do canal",
-    )
+    filter_cols = st.columns([1, 1], gap="small")
+    with filter_cols[0]:
+        youtube_channel_search = st.text_input(
+            "Pesquisar nomes dos canais YouTube",
+            key="youtube_registered_channels_search",
+            placeholder="Digite o nome do canal",
+        )
+    with filter_cols[1]:
+        youtube_country_options = [""] + list(COUNTRY_OPTIONS)
+        youtube_country_filter = st.selectbox(
+            "Filtrar por País",
+            youtube_country_options,
+            format_func=lambda value: value or "Todos os países",
+            key="youtube_registered_country_filter",
+        )
+        if st.button("Filtrar", type="primary", width="content", key="youtube_registered_country_filter_apply"):
+            st.session_state["youtube_registered_country_filter_applied"] = youtube_country_filter
+    applied_country = str(st.session_state.get("youtube_registered_country_filter_applied") or "").strip()
     visible_registered_channels = [
         channel for channel in channels
         if not youtube_channel_search.strip()
         or youtube_channel_search.strip().casefold() in str(channel.get("name") or "").casefold()
     ]
+    visible_registered_channels = [
+        channel for channel in visible_registered_channels
+        if not applied_country or str(channel.get("country") or "").strip() == applied_country
+    ]
     if not channels:
         st.info("Nenhum canal YouTube cadastrado.")
         return
@@ -6480,7 +6497,24 @@ def render_automation():
     if not channels:
         st.info("Nenhum canal cadastrado para configurar.")
     with st.expander("Canais cadastrados", expanded=False):
-        for channel in channels:
+        automation_country_options = [""] + list(COUNTRY_OPTIONS)
+        automation_filter_cols = st.columns([1, 1], gap="small")
+        with automation_filter_cols[0]:
+            automation_country_filter = st.selectbox(
+                "Filtrar por País",
+                automation_country_options,
+                format_func=lambda value: value or "Todos os países",
+                key="youtube_automation_country_filter",
+            )
+        with automation_filter_cols[1]:
+            if st.button("Filtrar", type="primary", width="content", key="youtube_automation_country_filter_apply"):
+                st.session_state["youtube_automation_country_filter_applied"] = automation_country_filter
+        applied_automation_country = str(st.session_state.get("youtube_automation_country_filter_applied") or "").strip()
+        filtered_automation_channels = [
+            channel for channel in channels
+            if not applied_automation_country or str(channel.get("country") or "").strip() == applied_automation_country
+        ]
+        for channel in filtered_automation_channels:
             channel_id = channel["id"]
             with st.container(border=True):
                 blueprint_ids, blueprint_labels, current_blueprint, voice_options, current_voice = channel_default_options(channel)
@@ -6497,6 +6531,7 @@ def render_automation():
                 with header_cols[1]:
                     st.write(f"**{channel.get('name', 'Sem nome')}**")
                     st.caption(channel.get("handle") or channel.get("url") or "sem URL")
+                    st.caption(f"País: {channel.get('country') or 'Não definido'}")
                     channel_url = str(channel.get("url") or "").strip()
                     if not channel_url:
                         channel_id_or_handle = str(channel.get("youtube_channel_id") or channel.get("youtube_id") or channel.get("handle") or "").strip()

package/hermes_ui/storage.py

@@ -5,6 +5,7 @@ import os
 import shutil
 import tempfile
 import time
+from threading import RLock
 from contextlib import contextmanager
 from copy import deepcopy
 from datetime import datetime, timezone
@@ -24,6 +25,9 @@ SEED_BLUEPRINTS = ROOT / "seed" / "blueprints"
 SEED_THUMBNAIL_BLUEPRINTS = SEED_BLUEPRINTS / "thumbnails"
 SEED_TIKTOK_PROMPT_MASTERS = ROOT / "seed" / "prompt_masters"
 
+_READ_CACHE_LOCK = RLock()
+_READ_CACHE: dict[str, tuple[tuple[int, int], Any]] = {}
+
 DEFAULTS: dict[str, Any] = {
         "channels.json": [],
         "channel_videos.json": [],
@@ -720,6 +724,19 @@ def _load_json_unlocked(path: Path) -> Any:
         return json.load(handle)
 
 
+def _read_fingerprint(path: Path) -> tuple[int, int] | None:
+    try:
+        stat = path.stat()
+    except OSError:
+        return None
+    return stat.st_mtime_ns, stat.st_size
+
+
+def _invalidate_read_cache(path: Path) -> None:
+    with _READ_CACHE_LOCK:
+        _READ_CACHE.pop(str(path), None)
+
+
 def _recover_json_unlocked(name: str, path: Path, default: Any | None) -> Any:
     backup = _corrupt_backup(path)
     if name in _PROTECTED_STATE_FILES:
@@ -743,6 +760,13 @@ def _recover_json_unlocked(name: str, path: Path, default: Any | None) -> Any:
 def read_json(name: str, default: Any | None = None) -> Any:
     ensure_storage()
     path = STATE / name
+    fingerprint = _read_fingerprint(path)
+    cache_key = str(path)
+    if fingerprint is not None:
+        with _READ_CACHE_LOCK:
+            cached = _READ_CACHE.get(cache_key)
+        if cached is not None and cached[0] == fingerprint:
+            return deepcopy(cached[1])
     with _state_lock(path, read_only=True):
         try:
             data = _load_json_unlocked(path)
@@ -753,7 +777,12 @@ def read_json(name: str, default: Any | None = None) -> Any:
         migrated, changed = _migrate_settings(data)
         if changed:
             _atomic_write_unlocked(path, migrated)
-        return migrated
+        result = migrated
+        current_fingerprint = _read_fingerprint(path)
+        if current_fingerprint is not None:
+            with _READ_CACHE_LOCK:
+                _READ_CACHE[cache_key] = (current_fingerprint, deepcopy(result))
+        return deepcopy(result)
 
 
 def update_json(name: str, default: Any, mutator: Callable[[Any], Any]) -> Any:
@@ -767,6 +796,7 @@ def update_json(name: str, default: Any, mutator: Callable[[Any], Any]) -> Any:
             current = _recover_json_unlocked(name, path, default)
         result = mutator(current)
         _atomic_write_unlocked(path, current)
+        _invalidate_read_cache(path)
         return result
 
 
@@ -774,6 +804,7 @@ def write_json(name: str, data: Any) -> None:
     """Persist a state JSON file using :func:`atomic_write`."""
     ensure_storage()
     atomic_write(STATE / name, data)
+    _invalidate_read_cache(STATE / name)
 
 
 def append_json(name: str, item: dict[str, Any]) -> dict[str, Any]:

package/package.json

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

package/scripts/cli.mjs

@@ -262,16 +262,19 @@ const proxy = http.createServer((request, response) => {
     headers: { ...request.headers, host: `127.0.0.1:${backendPort}`, "accept-encoding": "identity" },
   }, (upstreamResponse) => {
     const responseHeaders = { ...upstreamResponse.headers };
-    // Streamlit entrega HTML/JS de uma instância local que pode mudar após
-    // uma atualização via npx. Não permitir que o browser reaproveite uma
-    // página ou bundle da instância anterior.
-    delete responseHeaders.etag;
-    delete responseHeaders["last-modified"];
-    responseHeaders["cache-control"] = "no-store, no-cache, must-revalidate, max-age=0";
-    responseHeaders.pragma = "no-cache";
-    responseHeaders.expires = "0";
     const contentType = String(responseHeaders["content-type"] || "").toLowerCase();
     const isHtml = contentType.includes("text/html") && !responseHeaders["content-encoding"];
+    // O documento HTML contém o estado da sessão e pode mudar após uma
+    // actualização via npx; os bundles estáticos do Streamlit, por outro lado,
+    // devem ser reutilizados pelo browser. Desactivar cache em todos os
+    // recursos tornava cada aba muito mais pesada e multiplicava downloads.
+    if (isHtml) {
+      delete responseHeaders.etag;
+      delete responseHeaders["last-modified"];
+      responseHeaders["cache-control"] = "no-store, no-cache, must-revalidate, max-age=0";
+      responseHeaders.pragma = "no-cache";
+      responseHeaders.expires = "0";
+    }
     if (!isHtml) {
       response.writeHead(upstreamResponse.statusCode || 502, responseHeaders);
       upstreamResponse.pipe(response);