Upload 11 files

antigravity_proxy.py

@@ -52,6 +52,64 @@ _cancel_event = threading.Event()
 _proxy_process: Optional[subprocess.Popen] = None
 _proxy_launch_lock = threading.Lock()
 
+# Auth browser tracking — only open the browser once per session
+_auth_browser_opened = False
+_auth_browser_lock = threading.Lock()
+
+
+def _open_auth_browser_once(proxy_url: str, log_fn=None) -> bool:
+    """Open the proxy auth URL in the browser, but only once per session.
+
+    Returns True if the browser was opened (first call), False if already opened.
+    """
+    global _auth_browser_opened
+    with _auth_browser_lock:
+        if _auth_browser_opened:
+            return False
+        _auth_browser_opened = True
+    _log = log_fn or (lambda msg: None)
+    _log(f"🔐 Antigravity: Authentication required – opening {proxy_url} in your browser...")
+    _log(f"   Please link your Google account. Glossarion will continue automatically once done.")
+    try:
+        webbrowser.open(proxy_url)
+    except Exception:
+        pass
+    return True
+
+
+def _wait_for_auth(
+    url: str,
+    payload: dict,
+    headers: dict,
+    proxy_url: str,
+    log_fn=None,
+    max_wait: int = 120,
+    poll_interval: int = 5,
+    stream: bool = False,
+):
+    """Open browser once and poll until authentication succeeds or timeout.
+
+    Returns the successful requests.Response, or None if timed out.
+    """
+    _open_auth_browser_once(proxy_url, log_fn)
+    _log = log_fn or (lambda msg: None)
+    elapsed = 0
+    while elapsed < max_wait:
+        time.sleep(poll_interval)
+        elapsed += poll_interval
+        if _cancel_event.is_set():
+            return None
+        _log(f"⏳ Waiting for authentication... ({elapsed}s / {max_wait}s)")
+        try:
+            retry_resp = requests.post(
+                url, json=payload, headers=headers, timeout=30, stream=stream
+            )
+            if retry_resp.status_code not in (401, 403):
+                return retry_resp
+        except Exception:
+            continue
+    return None
+
 
 def cancel_stream():
     """Signal any active Antigravity proxy stream to abort."""
@@ -138,6 +196,38 @@ def _find_npx() -> Optional[str]:
     return None
 
 
+def _ensure_proxy_config():
+    """Ensure the proxy config disables API key auth.
+
+    The antigravity-claude-proxy validates an ``apiKey`` on every ``/v1/*``
+    request.  Glossarion talks to the proxy on localhost, so there is no
+    need for this gate.  We write ``{"apiKey": ""}`` (skip validation) into
+    the proxy's config file so that any dummy token we send is accepted.
+    Existing settings in the file are preserved; only ``apiKey`` is touched.
+    """
+    try:
+        config_dir = os.path.join(os.path.expanduser("~"), ".config", "antigravity-proxy")
+        os.makedirs(config_dir, exist_ok=True)
+        config_path = os.path.join(config_dir, "config.json")
+
+        # Read existing config if present, otherwise start fresh
+        existing: Dict[str, Any] = {}
+        if os.path.isfile(config_path):
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    existing = json.loads(f.read())
+            except Exception:
+                existing = {}
+
+        # Only write if apiKey is not already empty
+        if existing.get("apiKey", None) != "":
+            existing["apiKey"] = ""
+            with open(config_path, "w", encoding="utf-8") as f:
+                f.write(json.dumps(existing, indent=2))
+    except Exception:
+        pass  # Non-critical – proxy may still work without this
+
+
 def ensure_proxy_running(log_fn=None) -> Dict[str, Any]:
     """Ensure the Antigravity proxy is running, auto-launching if needed.
 
@@ -152,6 +242,9 @@ def ensure_proxy_running(log_fn=None) -> Dict[str, Any]:
 
     _log = log_fn or (lambda msg: None)
 
+    # Ensure proxy config disables API key auth (localhost doesn't need it)
+    _ensure_proxy_config()
+
     # Already running?
     health = check_proxy_health()
     if health.get("healthy"):
@@ -204,6 +297,15 @@ def ensure_proxy_running(log_fn=None) -> Dict[str, Any]:
                 "stderr": subprocess.DEVNULL,
                 "stdin": subprocess.DEVNULL,
             }
+
+            # Ensure node.exe's directory is on PATH for the subprocess
+            # (npx.cmd invokes "node" and needs it resolvable)
+            npx_dir = os.path.dirname(npx_path)
+            env = os.environ.copy()
+            if npx_dir not in env.get("PATH", ""):
+                env["PATH"] = npx_dir + os.pathsep + env.get("PATH", "")
+            kwargs["env"] = env
+
             if sys.platform == "win32":
                 # CREATE_NEW_PROCESS_GROUP + DETACHED_PROCESS so it survives app close
                 CREATE_NEW_PROCESS_GROUP = 0x00000200
@@ -359,6 +461,20 @@ def send_message(
             "The model may need more time for long translations."
         )
 
+    # Handle auth failure: open browser once and wait for user to authenticate
+    if resp.status_code in (401, 403):
+        auth_resp = _wait_for_auth(
+            url, payload, headers, proxy_url, log_fn, stream=False
+        )
+        if auth_resp is not None and auth_resp.status_code == 200:
+            resp = auth_resp  # auth succeeded, continue with this response
+        else:
+            raise RuntimeError(
+                f"Antigravity: Authentication timed out.\n"
+                f"Open {proxy_url} in your browser and link your Google account,\n"
+                f"then try again."
+            )
+
     if resp.status_code != 200:
         error_body = resp.text
         try:
@@ -366,17 +482,6 @@ def send_message(
             error_msg = error_json.get("error", {}).get("message", error_body)
         except Exception:
             error_msg = error_body
-
-        # Auto-open browser for authentication if proxy returns 401/403
-        if resp.status_code in (401, 403):
-            auth_url = proxy_url  # e.g. http://localhost:8080
-            if log_fn:
-                log_fn(f"🔐 Antigravity: Authentication required – opening {auth_url} in your browser...")
-            try:
-                webbrowser.open(auth_url)
-            except Exception:
-                pass
-
         raise RuntimeError(
             f"Antigravity: {resp.status_code} - {error_msg}"
         )
@@ -477,16 +582,21 @@ def send_message_stream(
             f"Antigravity proxy streaming request timed out after {timeout}s."
         )
 
+    # Handle auth failure: open browser once and wait for user to authenticate
+    if resp.status_code in (401, 403):
+        auth_resp = _wait_for_auth(
+            url, payload, headers, proxy_url, log_fn, stream=True
+        )
+        if auth_resp is not None and auth_resp.status_code == 200:
+            resp = auth_resp  # auth succeeded, continue with this streaming response
+        else:
+            raise RuntimeError(
+                f"Antigravity: Authentication timed out.\n"
+                f"Open {proxy_url} in your browser and link your Google account,\n"
+                f"then try again."
+            )
+
     if resp.status_code != 200:
-        # Auto-open browser for authentication if proxy returns 401/403
-        if resp.status_code in (401, 403):
-            auth_url = proxy_url
-            if log_fn:
-                log_fn(f"🔐 Antigravity: Authentication required – opening {auth_url} in your browser...")
-            try:
-                webbrowser.open(auth_url)
-            except Exception:
-                pass
         raise RuntimeError(f"Antigravity: {resp.status_code} - {resp.text[:500]}")
 
     # Collect SSE events

app.py

@@ -10,6 +10,8 @@ import sys
 import json
 import tempfile
 import base64
+import threading
+import uuid
 from pathlib import Path
 
 # CRITICAL: Set API delay IMMEDIATELY at module level before any other imports
@@ -82,7 +84,7 @@ except ImportError as e:
 
 
 # Models that do not require an API key
-_NO_API_KEY_PREFIXES = ('vertex/', 'authgpt/', 'google-translate', 'deepl')
+_NO_API_KEY_PREFIXES = ('vertex/', 'authgpt/', 'antigravity/', 'google-translate', 'deepl')
 
 def _model_needs_no_api_key(model: str) -> bool:
     """Return True if the given model name does not require a user-supplied API key."""
@@ -92,6 +94,72 @@ def _model_needs_no_api_key(model: str) -> bool:
     return any(m.startswith(p) for p in _NO_API_KEY_PREFIXES)
 
 
+# ---------------------------------------------------------------------------
+# Thread-local stdout writer — isolates log output per translation thread
+# so User A's logs never leak into User B's log_callback.
+# ---------------------------------------------------------------------------
+_thread_local = threading.local()
+
+class _ThreadLocalStdoutWriter:
+    """sys.stdout replacement that routes write() to a per-thread callback.
+
+    If the current thread has a callback registered in _thread_local.log_cb,
+    output goes there.  Otherwise it falls through to the original stdout so
+    server-side console logs still work.
+    """
+    def __init__(self, original_stdout):
+        self._original = original_stdout
+
+    # --- required file-like API ---
+    def write(self, text):
+        cb = getattr(_thread_local, 'log_cb', None)
+        if cb is not None:
+            # Only forward non-empty, non-whitespace-only text
+            stripped = text.strip()
+            if stripped:
+                try:
+                    cb(stripped)
+                except Exception:
+                    pass
+            return
+        # No per-thread callback → use original stdout
+        if self._original is not None:
+            try:
+                self._original.write(text)
+            except Exception:
+                pass
+
+    def flush(self):
+        if self._original is not None:
+            try:
+                self._original.flush()
+            except Exception:
+                pass
+
+    def fileno(self):
+        if self._original is not None:
+            return self._original.fileno()
+        raise OSError("no underlying fileno")
+
+    @property
+    def encoding(self):
+        return getattr(self._original, 'encoding', 'utf-8')
+
+    def isatty(self):
+        return False
+
+    def readable(self):
+        return False
+
+    def writable(self):
+        return True
+
+# Install the thread-local writer ONCE at module load so *all* print()
+# calls are routed through it.  The original stdout is preserved inside.
+if not isinstance(sys.stdout, _ThreadLocalStdoutWriter):
+    sys.stdout = _ThreadLocalStdoutWriter(sys.stdout)
+
+
 class GlossarionWeb:
     """Web interface for Glossarion translator"""
     
@@ -211,14 +279,20 @@ class GlossarionWeb:
         print(f"🤖 Loaded {len(self.models)} models: {self.models[:5]}{'...' if len(self.models) > 5 else ''}")
         
         # Translation state management
-        import threading
+        # NOTE: These are per-instance defaults.  For a public web app each
+        # concurrent request needs its own stop flag — we use a dict keyed by
+        # a unique request_id so one user's stop doesn't affect another.
         self.is_translating = False
         self.stop_flag = threading.Event()
         self.translation_thread = None
         self.current_unified_client = None  # Track active client to allow cancellation
         self.current_translator = None     # Track active translator to allow shutdown
         
-        # Add stop flags for different translation types
+        # Per-request stop flags (keyed by request_id uuid)
+        self._stop_flags: dict[str, bool] = {}   # request_id -> True means "stop"
+        self._stop_lock = threading.Lock()
+        
+        # Legacy flags (kept for manga which still uses the old pattern)
         self.epub_translation_stop = False
         self.epub_translation_thread = None
         self.glossary_extraction_stop = False
@@ -830,9 +904,14 @@ class GlossarionWeb:
             yield None, None, None, "❌ Please select a translation profile", None, "Error", 0
             return
         
-        # Initialize logs list
+        # Initialize logs list (per-request, NOT shared)
         translation_logs = []
         
+        # Create a unique request id for per-session stop tracking
+        request_id = self._new_request_id()
+        # Also reset legacy flag
+        self.epub_translation_stop = False
+        
         try:
             # Initial status
             input_path = epub_file.name if hasattr(epub_file, 'name') else epub_file
@@ -967,28 +1046,46 @@ class GlossarionWeb:
             
             # Create a thread-safe queue for capturing logs
             import queue
-            import threading
             import time
             log_queue = queue.Queue()
             translation_complete = threading.Event()
             translation_error = [None]
             
+            # CRITICAL: Reset stop env vars so stale flags don't interfere
+            os.environ['GRACEFUL_STOP'] = '0'
+            os.environ['TRANSLATION_CANCELLED'] = '0'
+            try:
+                from TransateKRtoEN import set_stop_flag as _set_stop
+                _set_stop(False)
+            except ImportError:
+                pass
+            
             def log_callback(msg):
-                """Capture log messages"""
+                """Capture log messages — per-request, thread-safe"""
                 if msg and msg.strip():
                     log_queue.put(msg.strip())
             
+            # Stop callback that TransateKRtoEN.main() will poll
+            _rid = request_id  # capture in closure
+            def stop_callback():
+                return self._is_request_stopped(_rid) or self.epub_translation_stop
+            
             # Run translation in a separate thread
             def run_translation():
+                # Install per-thread log routing so print() inside
+                # TransateKRtoEN goes to THIS request's queue only.
+                _thread_local.log_cb = log_callback
                 try:
                     result = TransateKRtoEN.main(
                         log_callback=log_callback,
-                        stop_callback=None
+                        stop_callback=stop_callback
                     )
                     translation_error[0] = None
                 except Exception as e:
                     translation_error[0] = e
                 finally:
+                    # Remove per-thread redirect
+                    _thread_local.log_cb = None
                     translation_complete.set()
             
             translation_thread = threading.Thread(target=run_translation, daemon=True)
@@ -999,10 +1096,16 @@ class GlossarionWeb:
             progress_percent = 10
             
             while not translation_complete.is_set() or not log_queue.empty():
-                # Check if stop was requested
-                if self.epub_translation_stop:
+                # Check if stop was requested (per-request OR legacy flag)
+                if self._is_request_stopped(request_id) or self.epub_translation_stop:
                     translation_logs.append("⚠️ Stopping translation...")
-                    # Try to stop the translation thread
+                    # Signal the translation engine to stop as well
+                    try:
+                        from TransateKRtoEN import set_stop_flag as _set_stop
+                        _set_stop(True)
+                    except ImportError:
+                        pass
+                    os.environ['TRANSLATION_CANCELLED'] = '1'
                     translation_complete.set()
                     break
                     
@@ -1367,6 +1470,9 @@ class GlossarionWeb:
             error_msg = f"❌ Error during translation:\n{str(e)}\n\n{traceback.format_exc()}"
             translation_logs.append(error_msg)
             yield None, None, gr.update(visible=False), "\n".join(translation_logs), gr.update(visible=True), "Error occurred", 0
+        finally:
+            # Always clean up the per-request stop flag
+            self._cleanup_request(request_id)
     
     def translate_epub_with_stop(self, *args):
         """Wrapper for translate_epub that includes button visibility control"""
@@ -1387,6 +1493,17 @@ class GlossarionWeb:
     def stop_epub_translation(self):
         """Stop the ongoing EPUB translation"""
         self.epub_translation_stop = True
+        # Also signal the translation engine's global stop flag
+        try:
+            from TransateKRtoEN import set_stop_flag as _set_stop
+            _set_stop(True)
+        except ImportError:
+            pass
+        os.environ['TRANSLATION_CANCELLED'] = '1'
+        # Signal all active per-request stop flags for epub
+        with self._stop_lock:
+            for rid in self._stop_flags:
+                self._stop_flags[rid] = True
         if self.epub_translation_thread and self.epub_translation_thread.is_alive():
             # The thread will check the stop flag
             pass
@@ -1485,31 +1602,46 @@ class GlossarionWeb:
             
             # Create a thread-safe queue for capturing logs
             import queue
-            import threading
             import time
             log_queue = queue.Queue()
             extraction_complete = threading.Event()
             extraction_error = [None]
             extraction_result = [None]
             
+            # Per-request stop tracking for glossary extraction
+            gloss_request_id = self._new_request_id()
+            self.glossary_extraction_stop = False
+            
+            # CRITICAL: Reset stop env vars
+            os.environ['GRACEFUL_STOP'] = '0'
+            os.environ['TRANSLATION_CANCELLED'] = '0'
+            
             def log_callback(msg):
-                """Capture log messages"""
+                """Capture log messages — per-request, thread-safe"""
                 if msg and msg.strip():
                     log_queue.put(msg.strip())
             
+            _grid = gloss_request_id  # capture in closure
+            def stop_callback():
+                return self._is_request_stopped(_grid) or self.glossary_extraction_stop
+            
             # Run extraction in a separate thread
             def run_extraction():
+                # Install per-thread log routing
+                _thread_local.log_cb = log_callback
                 try:
                     result = extract_glossary_from_epub.main(
                         log_callback=log_callback,
-                        stop_callback=None
+                        stop_callback=stop_callback
                     )
                     extraction_result[0] = result
                     extraction_error[0] = None
                 except Exception as e:
                     extraction_error[0] = e
                 finally:
+                    _thread_local.log_cb = None
                     extraction_complete.set()
+                    self._cleanup_request(_grid)
             
             extraction_thread = threading.Thread(target=run_extraction, daemon=True)
             extraction_thread.start()
@@ -1519,10 +1651,10 @@ class GlossarionWeb:
             progress_percent = 40
             
             while not extraction_complete.is_set() or not log_queue.empty():
-                # Check if stop was requested
-                if self.glossary_extraction_stop:
+                # Check if stop was requested (per-request OR legacy flag)
+                if self._is_request_stopped(gloss_request_id) or self.glossary_extraction_stop:
                     extraction_logs.append("⚠️ Stopping extraction...")
-                    # Try to stop the extraction thread
+                    os.environ['TRANSLATION_CANCELLED'] = '1'
                     extraction_complete.set()
                     break
                     
@@ -1615,6 +1747,11 @@ class GlossarionWeb:
     def stop_glossary_extraction(self):
         """Stop the ongoing glossary extraction"""
         self.glossary_extraction_stop = True
+        os.environ['TRANSLATION_CANCELLED'] = '1'
+        # Signal all active per-request stop flags
+        with self._stop_lock:
+            for rid in self._stop_flags:
+                self._stop_flags[rid] = True
         if self.glossary_extraction_thread and self.glossary_extraction_thread.is_alive():
             # The thread will check the stop flag
             pass
@@ -1973,11 +2110,44 @@ class GlossarionWeb:
         else:
             print("DEBUG: stop_translation called but not translating")
     
+    # -- per-request stop helpers --------------------------------------------------
+    def _new_request_id(self) -> str:
+        """Create a fresh request ID and register its stop flag."""
+        rid = str(uuid.uuid4())
+        with self._stop_lock:
+            self._stop_flags[rid] = False
+        return rid
+
+    def _request_stop(self, rid: str):
+        """Signal stop for a given request."""
+        with self._stop_lock:
+            self._stop_flags[rid] = True
+
+    def _is_request_stopped(self, rid: str) -> bool:
+        with self._stop_lock:
+            return self._stop_flags.get(rid, False)
+
+    def _cleanup_request(self, rid: str):
+        with self._stop_lock:
+            self._stop_flags.pop(rid, None)
+
     def _reset_translation_flags(self):
         """Reset all translation flags for new translation"""
         self.is_translating = False
         self.stop_flag.clear()
         
+        # CRITICAL: Reset stop / graceful-stop env vars so stale state
+        # from a previous run does not bleed into the next one.
+        os.environ['GRACEFUL_STOP'] = '0'
+        os.environ['TRANSLATION_CANCELLED'] = '0'
+        
+        # Reset global stop flags in the translation engine
+        try:
+            from TransateKRtoEN import set_stop_flag as _set_stop
+            _set_stop(False)
+        except ImportError:
+            pass
+        
         # Reset global cancellation flags
         try:
             if MANGA_TRANSLATION_AVAILABLE:

splash_utils.py

@@ -55,7 +55,7 @@ class SplashManager(QObject):
             
             if os.path.isfile(ico_path):
                 # Set app user model ID immediately
-                ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID('Glossarion.Translator.7.8.0')
+                ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID('Glossarion.Translator.7.8.1')
                 
                 # Set app-level icon
                 if self.app:
@@ -162,7 +162,7 @@ class SplashManager(QObject):
             self._load_icon(layout)
             
             # Title
-            title_label = QLabel("Glossarion v7.8.0")
+            title_label = QLabel("Glossarion v7.8.1")
             title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
             title_font = QFont("Arial", int(max(14, 20 * self._ui_scale)), QFont.Weight.Bold)
             title_label.setFont(title_font)
@@ -320,7 +320,7 @@ class SplashManager(QObject):
                     import platform
                     if platform.system() == 'Windows':
                         # Set app user model ID
-                        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID('Glossarion.Translator.7.8.0')
+                        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID('Glossarion.Translator.7.8.1')
                         
                         # Load icon from file and set it on the window
                         hwnd = int(self.splash_window.winId())

unified_api_client.py

@@ -14882,12 +14882,10 @@ class UnifiedClient:
                         error_type="config_error"
                     )
 
-                # Authentication error – user needs to link Google account (don't retry)
-                if "401" in error_str or "403" in error_str or "api key" in error_str.lower():
+                # Authentication timed out – proxy handled the browser+polling already
+                if "authentication timed out" in error_str.lower():
                     raise UnifiedClientError(
-                        f"Antigravity proxy authentication failed.\n"
-                        f"Open http://localhost:8080 in your browser and link your Google account,\n"
-                        f"then try again.",
+                        str(exc),
                         error_type="config_error"
                     )