| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403 |
- """Clipboard image extraction and text write for macOS, Windows, Linux, and WSL2.
- No Python deps — only OS-level CLI tools: macOS osascript (always present) / pngpaste (optional)
- plus a file-url fallback for Finder copies; Windows and WSL2 PowerShell via WinForms,
- Get-Clipboard, then a file-drop fallback; Linux wl-paste (Wayland), xclip (X11).
- """
- import base64
- import logging
- import os
- import shutil
- import subprocess
- import sys
- from pathlib import Path
- from hermes_constants import is_wsl as _is_wsl
- logger = logging.getLogger(__name__)
- _PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
- _TEXT = dict(capture_output=True, text=True, encoding='utf-8', errors='replace', stdin=subprocess.DEVNULL)
- _PS_FLAGS = ("-NoProfile", "-NonInteractive")
- _FILE_IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".tif"}
- def _nonempty(path: Path) -> bool:
- return path.exists() and path.stat().st_size > 0
- def _probe(argv: list, timeout: int, ok, *, missing: str | None = None) -> bool:
- """Run a text-mode probe; True when it ran and ``ok(result)`` holds.
- A missing executable logs *missing* (when given); every other failure is silent."""
- try:
- return bool(ok(subprocess.run(argv, timeout=timeout, **_TEXT, check=False)))
- except FileNotFoundError:
- if missing:
- logger.debug(missing)
- except Exception:
- pass
- return False
- def _pipe_to_file(argv: list, dest: Path) -> bool:
- """Run *argv* with stdout redirected into *dest*; True when a non-empty file resulted."""
- with open(dest, "wb") as f:
- subprocess.run(argv, stdin=subprocess.DEVNULL, stdout=f, stderr=subprocess.DEVNULL, timeout=5, check=True)
- return _nonempty(dest)
- def _linux_backends():
- """(enabled, has_image, save) in Linux fallthrough order: WSL → Wayland → X11
- (a failed WSL probe falls through — WSLg might have wl-paste or xclip working)."""
- return (
- (_is_wsl(), _wsl_has_image, _wsl_save),
- (bool(os.environ.get("WAYLAND_DISPLAY")), _wayland_has_image, _wayland_save),
- (True, _xclip_has_image, _xclip_save))
- def save_clipboard_image(dest: Path) -> bool:
- """Save the clipboard image to *dest* as PNG; True when an image was found and written."""
- dest.parent.mkdir(parents=True, exist_ok=True)
- if sys.platform == "darwin":
- # pngpaste first (fast, handles more formats); osascript is the always-present fallback.
- return _macos_pngpaste(dest) or _macos_osascript(dest)
- return (_windows_save if sys.platform == "win32" else _linux_save)(dest)
- def has_clipboard_image() -> bool:
- """Quick check: does the clipboard currently contain an image?"""
- if sys.platform == "darwin":
- return _macos_has_image()
- if sys.platform == "win32":
- return _windows_has_image()
- return any(enabled and has() for enabled, has, _ in _linux_backends())
- # ── Text write (native tools, mirrors ui-tui/src/lib/clipboard.ts) ──────
- def _write_clipboard_commands(data: bytes) -> list:
- """(argv, run_kwargs) candidates for writing *data*, in platform fallback order."""
- # PowerShell decodes piped stdin with the system ANSI code page (e.g. CP936), not UTF-8, so
- # stdin-based writes mangle CJK/emoji. Base64 the UTF-8 bytes and decode inside PowerShell
- # instead (same approach as the TUI's writeClipboardText).
- b64 = base64.b64encode(data).decode("ascii")
- ps_argv = [*_PS_FLAGS, "-Command", "Set-Clipboard -Value ([System.Text.Encoding]::UTF8"
- f".GetString([System.Convert]::FromBase64String('{b64}')))"]
- ps_kw, pipe = {"stdin": subprocess.DEVNULL}, {"input": data}
- linux = sys.platform not in ("darwin", "win32")
- return [(argv, kw) for enabled, argv, kw in (
- (sys.platform == "darwin", ["pbcopy"], pipe),
- (sys.platform == "win32", ["powershell", *ps_argv], ps_kw),
- (linux and _is_wsl(), ["powershell.exe", *ps_argv], ps_kw),
- (linux and os.environ.get("WAYLAND_DISPLAY"), ["wl-copy", "--type", "text/plain"], pipe),
- (linux, ["xclip", "-selection", "clipboard", "-in"], pipe),
- (linux, ["xsel", "--clipboard", "--input"], pipe),
- ) if enabled]
- def is_remote_shell_session(env=None) -> bool:
- """True inside an SSH session (mirrors ui-tui/src/lib/terminalSetup.ts). Over SSH, native
- clipboard tools write the REMOTE machine's clipboard (or an X-forwarded one), which is almost
- never what the user wants — OSC 52 reaches the LOCAL terminal instead."""
- e = os.environ if env is None else env
- return bool(e.get("SSH_CONNECTION") or e.get("SSH_TTY") or e.get("SSH_CLIENT"))
- def write_clipboard_text(text: str) -> bool:
- """Write *text* to the clipboard via native tools; fallback order matches the TUI: pbcopy →
- Windows/WSL PowerShell Set-Clipboard → wl-copy → xclip → xsel. Returns True if any backend
- succeeded; callers fall back to OSC 52 on False."""
- for argv, kw in _write_clipboard_commands(text.encode("utf-8")):
- try:
- if subprocess.run(argv, timeout=10, stdout=subprocess.DEVNULL,
- stderr=subprocess.DEVNULL, **kw, check=False).returncode == 0:
- return True
- except (OSError, subprocess.SubprocessError):
- continue
- return False
- # ── macOS ────────────────────────────────────────────────────────────────
- def _osascript(expr: str, timeout: int = 3) -> str:
- """stdout of an osascript expression; "" on any failure."""
- try:
- r = subprocess.run(["osascript", "-e", expr], timeout=timeout, **_TEXT, check=False)
- return r.stdout if r.returncode == 0 else ""
- except Exception as e:
- logger.debug("osascript probe failed: %s", e)
- return ""
- def _macos_has_bitmap(info: str) -> bool:
- return "«class PNGf»" in info or "«class TIFF»" in info
- def _macos_clipboard_file_image() -> Path | None:
- """Local image path when the clipboard holds a Finder file-url: Cmd+C on a file puts
- «class furl» (no bitmap) on the pasteboard, yet other apps paste it as an image."""
- path = Path(_osascript("POSIX path of (the clipboard as «class furl»)").strip())
- return path if path.suffix.lower() in _FILE_IMAGE_EXTS and os.path.isfile(path) else None
- def _macos_has_image() -> bool:
- info = _osascript("clipboard info")
- return _macos_has_bitmap(info) or (
- "«class furl»" in info and _macos_clipboard_file_image() is not None)
- def _macos_save_file_image(dest: Path) -> bool:
- src = _macos_clipboard_file_image()
- if src is None:
- return False
- try:
- shutil.copyfile(src, dest)
- if _is_png_file(dest) or (_convert_to_png(dest) and _is_png_file(dest)):
- return True
- except OSError as e:
- logger.debug("clipboard file-url extract failed: %s", e)
- dest.unlink(missing_ok=True)
- return False
- def _macos_pngpaste(dest: Path) -> bool:
- """pngpaste (brew install pngpaste) — fastest, cleanest."""
- try:
- r = subprocess.run(["pngpaste", str(dest)], stdin=subprocess.DEVNULL, capture_output=True, timeout=3, check=False)
- return r.returncode == 0 and _nonempty(dest)
- except FileNotFoundError:
- pass # pngpaste not installed
- except Exception as e:
- logger.debug("pngpaste failed: %s", e)
- return False
- def _macos_osascript(dest: Path) -> bool:
- """osascript extraction (always available): bitmap PNGf, else a Finder file-url. One
- `clipboard info` listing gates both — the furl read is a pasteboard *content* access."""
- info = _osascript("clipboard info")
- if not _macos_has_bitmap(info):
- return "«class furl»" in info and _macos_save_file_image(dest)
- script = f'''try
- set imgData to the clipboard as «class PNGf»
- set f to open for access POSIX file "{dest}" with write permission
- write imgData to f
- close access f
- on error
- return "fail"
- end try
- '''
- try:
- r = subprocess.run(["osascript", "-e", script], timeout=5, **_TEXT, check=False)
- return r.returncode == 0 and "fail" not in r.stdout and _nonempty(dest)
- except Exception as e:
- logger.debug("osascript clipboard extract failed: %s", e)
- return False
- # ── PowerShell (native Windows powershell/pwsh + WSL2 powershell.exe) ─────
- _FILEDROP_IMAGE_EXTS = ",".join(f"'{e}'" for e in sorted(_FILE_IMAGE_EXTS))
- _PS_FILEDROP_HIT = (
- "try { "
- "$files = Get-Clipboard -Format FileDropList -ErrorAction Stop;"
- f"$exts = @({_FILEDROP_IMAGE_EXTS});"
- "$hit = $files | Where-Object { $exts -contains ([System.IO.Path]::GetExtension($_).ToLowerInvariant()) } | Select-Object -First 1;"
- )
- # (has_image, extract-as-base64-PNG) script pairs, tried in order.
- _PS_IMAGE_STRATEGIES = (
- ( # .NET System.Windows.Forms.Clipboard
- "Add-Type -AssemblyName System.Windows.Forms;"
- "[System.Windows.Forms.Clipboard]::ContainsImage()",
- "Add-Type -AssemblyName System.Windows.Forms;"
- "Add-Type -AssemblyName System.Drawing;"
- "$img = [System.Windows.Forms.Clipboard]::GetImage();"
- "if ($null -eq $img) { exit 1 }"
- "$ms = New-Object System.IO.MemoryStream;"
- "$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png);"
- "[System.Convert]::ToBase64String($ms.ToArray())"),
- ( # Get-Clipboard -Format Image (System.Drawing.Image or WPF BitmapSource)
- "try { "
- "$img = Get-Clipboard -Format Image -ErrorAction Stop;"
- "if ($null -ne $img) { 'True' } else { 'False' }"
- "} catch { 'False' }",
- "try { "
- "Add-Type -AssemblyName System.Drawing;"
- "Add-Type -AssemblyName PresentationCore;"
- "Add-Type -AssemblyName WindowsBase;"
- "$img = Get-Clipboard -Format Image -ErrorAction Stop;"
- "if ($null -eq $img) { exit 1 }"
- "$ms = New-Object System.IO.MemoryStream;"
- "if ($img -is [System.Drawing.Image]) {"
- "$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)"
- "} elseif ($img -is [System.Windows.Media.Imaging.BitmapSource]) {"
- "$enc = New-Object System.Windows.Media.Imaging.PngBitmapEncoder;"
- "$enc.Frames.Add([System.Windows.Media.Imaging.BitmapFrame]::Create($img));"
- "$enc.Save($ms)"
- "} else { exit 2 }"
- "[System.Convert]::ToBase64String($ms.ToArray())"
- "} catch { exit 1 }"),
- ( # copied image *file* (Explorer file drop)
- _PS_FILEDROP_HIT
- + "if ($null -ne $hit) { 'True' } else { 'False' }"
- "} catch { 'False' }",
- _PS_FILEDROP_HIT
- + "if ($null -eq $hit) { exit 1 }"
- "[System.Convert]::ToBase64String([System.IO.File]::ReadAllBytes($hit))"
- "} catch { exit 1 }"))
- def _ps_clipboard(exe: str, timeout: int, label: str, dest: Path | None = None) -> bool:
- """Probe (*dest* None) or extract (base64 PNG → *dest*) the Windows clipboard image via *exe*.
- A missing *exe* ends the whole chain (every script needs the same binary); any other failure
- logs (and drops a partial *dest*) then tries the next strategy."""
- for check, extract in _PS_IMAGE_STRATEGIES:
- try:
- argv = [exe, *_PS_FLAGS, "-Command", check if dest is None else extract]
- r = subprocess.run(argv, timeout=timeout, **_TEXT, check=False)
- if dest is None:
- if r.returncode == 0 and "True" in r.stdout:
- return True
- elif r.returncode == 0 and r.stdout.strip():
- dest.write_bytes(base64.b64decode(r.stdout.strip(), validate=True))
- if _nonempty(dest):
- return True
- except FileNotFoundError:
- logger.debug("%s not found — clipboard unavailable", exe)
- return False
- except Exception as e:
- logger.debug("%s clipboard image %s failed: %s", label,
- "check" if dest is None else "extraction", e)
- if dest is not None:
- dest.unlink(missing_ok=True)
- return False
- _ps_exe: str | None | bool = False # resolved PowerShell executable; False = not yet checked
- def _get_ps_exe() -> str | None:
- """First working PowerShell — ``powershell`` (5.1, always present) or ``pwsh`` (7+,
- optional) — cached per process; None when neither runs."""
- global _ps_exe
- if _ps_exe is False:
- _ps_exe = next((name for name in ("powershell", "pwsh") if _probe(
- [name, *_PS_FLAGS, "-Command", "echo ok"], 5,
- lambda r: r.returncode == 0 and "ok" in r.stdout)), None)
- return _ps_exe
- def _windows_has_image() -> bool:
- ps = _get_ps_exe()
- return ps is not None and _ps_clipboard(ps, 5, "Windows")
- def _windows_save(dest: Path) -> bool:
- ps = _get_ps_exe()
- if ps is None:
- logger.debug("No PowerShell found — Windows clipboard image paste unavailable")
- return False
- return _ps_clipboard(ps, 15, "Windows", dest)
- # ── Linux: WSL (powershell.exe) → Wayland (wl-paste) → X11 (xclip) ───────
- def _linux_save(dest: Path) -> bool:
- return any(enabled and save(dest) for enabled, _, save in _linux_backends())
- def _wsl_has_image() -> bool:
- return _ps_clipboard("powershell.exe", 8, "WSL")
- def _wsl_save(dest: Path) -> bool:
- return _ps_clipboard("powershell.exe", 15, "WSL", dest)
- _WAYLAND_MIME_PREFERENCE = ("image/png", "image/jpeg", "image/bmp", "image/gif", "image/webp")
- _WL_LIST_TYPES = ["wl-paste", "--list-types"]
- _WL_MISSING = "wl-paste not installed — Wayland clipboard unavailable"
- def _wayland_has_image() -> bool:
- return _probe(_WL_LIST_TYPES, 3, lambda r: r.returncode == 0 and any(
- t.startswith("image/") for t in r.stdout.splitlines()), missing=_WL_MISSING)
- def _wayland_save(dest: Path) -> bool:
- try:
- types_r = subprocess.run(_WL_LIST_TYPES, timeout=3, **_TEXT, check=False)
- types = types_r.stdout.splitlines() if types_r.returncode == 0 else ()
- mime = next((m for m in _WAYLAND_MIME_PREFERENCE if m in types), None) # PNG preferred
- if not mime:
- return False
- # save_clipboard_image() promises a PNG. Wayland can offer JPEG/GIF/WebP/BMP payloads,
- # so every non-PNG result is normalized (and re-verified) before reporting success.
- if _pipe_to_file(["wl-paste", "--type", mime], dest) and (
- mime == "image/png" or (_convert_to_png(dest) and _is_png_file(dest))):
- return True
- dest.unlink(missing_ok=True)
- except FileNotFoundError:
- logger.debug(_WL_MISSING)
- except Exception as e:
- logger.debug("wl-paste clipboard extraction failed: %s", e)
- dest.unlink(missing_ok=True)
- return False
- def _convert_to_png(path: Path) -> bool:
- """Convert an image file to PNG in-place: Pillow first (likely in the venv), then ImageMagick.
- When neither works the file is left as-is — BMP is still usable for most APIs."""
- try:
- from PIL import Image
- Image.open(path).save(path, "PNG")
- return True
- except ImportError:
- pass
- except Exception as e:
- logger.debug("Pillow BMP→PNG conversion failed: %s", e)
- tmp = path.with_suffix(".bmp")
- try:
- path.rename(tmp)
- r = subprocess.run(["convert", str(tmp), "png:" + str(path)], stdin=subprocess.DEVNULL, capture_output=True,
- timeout=5, check=False)
- if r.returncode == 0 and _nonempty(path):
- tmp.unlink(missing_ok=True)
- return True
- tmp.rename(path) # convert failed — restore the original file
- except Exception as e:
- if isinstance(e, FileNotFoundError):
- logger.debug("ImageMagick not installed — cannot convert BMP to PNG")
- else:
- logger.debug("ImageMagick BMP→PNG conversion failed: %s", e)
- if tmp.exists() and not path.exists():
- tmp.rename(path)
- return _nonempty(path)
- def _is_png_file(path: Path) -> bool:
- try:
- with path.open("rb") as f:
- return f.read(len(_PNG_SIGNATURE)) == _PNG_SIGNATURE
- except OSError:
- return False
- _XCLIP_TARGETS = ["xclip", "-selection", "clipboard", "-t", "TARGETS", "-o"]
- def _xclip_has_image() -> bool:
- return _probe(_XCLIP_TARGETS, 3, lambda r: r.returncode == 0 and "image/png" in r.stdout)
- def _xclip_save(dest: Path) -> bool:
- if not _probe(_XCLIP_TARGETS, 3, lambda r: "image/png" in r.stdout,
- missing="xclip not installed — X11 clipboard image paste unavailable"):
- return False
- try:
- return _pipe_to_file(["xclip", "-selection", "clipboard", "-t", "image/png", "-o"], dest)
- except Exception as e:
- logger.debug("xclip image extraction failed: %s", e)
- dest.unlink(missing_ok=True)
- return False
|