klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/ui/terminal/__init__.py

@@ -1 +1,56 @@
 # Terminal utilities
+import os
+from functools import lru_cache
+
+
+@lru_cache(maxsize=1)
+def supports_osc8_hyperlinks() -> bool:
+    """Check if the current terminal supports OSC 8 hyperlinks.
+
+    Based on known terminal support. Returns False for unknown terminals.
+    """
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+    term = os.environ.get("TERM", "").lower()
+
+    # Known terminals that do NOT support OSC 8
+    unsupported = ("warp", "apple_terminal")
+    if any(t in term_program for t in unsupported):
+        return False
+
+    # Known terminals that support OSC 8
+    supported = (
+        "iterm.app",
+        "ghostty",
+        "wezterm",
+        "kitty",
+        "alacritty",
+        "hyper",
+        "contour",
+        "vscode",
+    )
+    if any(t in term_program for t in supported):
+        return True
+
+    # Kitty sets TERM to xterm-kitty
+    if "kitty" in term:
+        return True
+
+    # Ghostty sets TERM to xterm-ghostty
+    if "ghostty" in term:
+        return True
+
+    # Windows Terminal
+    if os.environ.get("WT_SESSION"):
+        return True
+
+    # VTE-based terminals (GNOME Terminal, etc.) version 0.50+
+    vte_version = os.environ.get("VTE_VERSION", "")
+    if vte_version:
+        try:
+            if int(vte_version) >= 5000:
+                return True
+        except ValueError:
+            pass
+
+    # Default to False for unknown terminals
+    return False

klaude_code/ui/terminal/color.py

@@ -182,7 +182,7 @@ def _parse_osc_color_response(data: bytes) -> tuple[int, int, int] | None:
 
     try:
         text = data.decode("ascii", errors="ignore")
-    except Exception:
+    except LookupError:  # encoding lookup failure (should not happen with "ascii")
         return None
 
     match = _OSC_BG_REGEX.search(text)

klaude_code/ui/terminal/control.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import os
 import select
 import signal
@@ -38,7 +39,7 @@ def start_esc_interrupt_monitor(
     # Fallback for non-interactive or non-POSIX environments.
     if not sys.stdin.isatty() or os.name != "posix":
 
-        async def _noop() -> None:  # type: ignore[return-type]
+        async def _noop() -> None:
             return None
 
         return stop_event, asyncio.create_task(_noop())
@@ -47,7 +48,7 @@ def start_esc_interrupt_monitor(
         try:
             fd = sys.stdin.fileno()
             old = termios.tcgetattr(fd)
-        except Exception as exc:  # pragma: no cover - environment dependent
+        except OSError as exc:  # pragma: no cover - environment dependent
             log((f"esc monitor init error: {exc}", "r red"))
             return
 
@@ -59,7 +60,7 @@ def start_esc_interrupt_monitor(
                     continue
                 try:
                     ch = os.read(fd, 1).decode(errors="ignore")
-                except Exception:
+                except OSError:
                     continue
                 if ch != "\x1b":
                     continue
@@ -70,24 +71,20 @@ def start_esc_interrupt_monitor(
                 while r2:
                     try:
                         seq += os.read(fd, 1).decode(errors="ignore")
-                    except Exception:
+                    except OSError:
                         break
                     r2, _, _ = select.select([sys.stdin], [], [], 0.0)
 
                 if seq == "":
-                    try:
+                    # Best-effort only; failures here should not crash the UI.
+                    with contextlib.suppress(Exception):
                         asyncio.run_coroutine_threadsafe(on_interrupt(), loop)
-                    except Exception:
-                        # Best-effort only; failures here should not crash the UI.
-                        pass
                     stop.set()
         except Exception as exc:  # pragma: no cover - environment dependent
             log((f"esc monitor error: {exc}", "r red"))
         finally:
-            try:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old)  # type: ignore[name-defined]
-            except Exception:
-                pass
+            with contextlib.suppress(Exception):
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
 
     esc_task: asyncio.Task[None] = asyncio.create_task(asyncio.to_thread(_esc_monitor, stop_event))
     return stop_event, esc_task
@@ -119,29 +116,23 @@ def install_sigint_double_press_exit(
         now = time.monotonic()
         if now - last_sigint_time <= window_seconds:
             # Second press within window: hide progress UI and exit.
-            try:
+            with contextlib.suppress(Exception):
                 hide_progress()
-            except Exception:
-                pass
             raise KeyboardInterrupt
 
         # First press: remember timestamp and show toast.
         last_sigint_time = now
-        try:
+        with contextlib.suppress(Exception):
             show_toast()
-        except Exception:
-            pass
 
     try:
         signal.signal(signal.SIGINT, _handler)
-    except Exception:  # pragma: no cover - platform dependent
+    except (OSError, ValueError):  # pragma: no cover - platform dependent
         # If installing the handler fails, restore() will be a no-op.
         return lambda: None
 
     def restore() -> None:
-        try:
+        with contextlib.suppress(Exception):
             signal.signal(signal.SIGINT, original_handler)
-        except Exception:
-            pass
 
     return restore

klaude_code/ui/terminal/notifier.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import subprocess
 import sys
 from dataclasses import dataclass
 from enum import Enum
@@ -8,6 +9,9 @@ from typing import TextIO, cast
 
 from klaude_code.trace import DebugType, log_debug
 
+# Environment variable for tmux test signal channel
+TMUX_SIGNAL_ENV = "KLAUDE_TEST_SIGNAL"
+
 ST = "\033\\"
 BEL = "\a"
 
@@ -39,7 +43,7 @@ class TerminalNotifierConfig:
     stream: TextIO | None = None
 
     @classmethod
-    def from_env(cls) -> "TerminalNotifierConfig":
+    def from_env(cls) -> TerminalNotifierConfig:
         env = os.getenv("KLAUDE_NOTIFY", "").strip().lower()
         if env in {"0", "off", "false", "disable", "disabled"}:
             return cls(enabled=False)
@@ -95,9 +99,7 @@ class TerminalNotifier:
         if not getattr(stream, "isatty", lambda: False)():
             return False
         term = os.getenv("TERM", "")
-        if term.lower() in {"", "dumb"}:
-            return False
-        return True
+        return term.lower() not in {"", "dumb"}
 
 
 def _compact(text: str, limit: int = 160) -> str:
@@ -105,3 +107,41 @@ def _compact(text: str, limit: int = 160) -> str:
     if len(squashed) > limit:
         return squashed[: limit - 3] + "…"
     return squashed
+
+
+def emit_tmux_signal(channel: str | None = None) -> bool:
+    """Send a tmux wait-for signal when a task completes.
+
+    This enables synchronous testing by allowing external scripts to block
+    until a task finishes, eliminating the need for polling or sleep.
+
+    Usage:
+        KLAUDE_TEST_SIGNAL=done klaude  # In tmux session
+        tmux wait-for done              # Blocks until task completes
+
+    Args:
+        channel: Signal channel name. If None, reads from KLAUDE_TEST_SIGNAL env var.
+
+    Returns:
+        True if signal was sent successfully, False otherwise.
+    """
+    channel = channel or os.getenv(TMUX_SIGNAL_ENV)
+    if not channel:
+        return False
+
+    # Check if we're in a tmux session
+    if not os.getenv("TMUX"):
+        log_debug("tmux signal skipped: not in tmux session", debug_type=DebugType.TERMINAL)
+        return False
+
+    try:
+        subprocess.run(
+            ["tmux", "wait-for", "-S", channel],
+            check=True,
+            capture_output=True,
+        )
+        log_debug(f"tmux signal sent: {channel}", debug_type=DebugType.TERMINAL)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        log_debug(f"tmux signal failed: {e}", debug_type=DebugType.TERMINAL)
+        return False