3.2.0 (#153)

* change version

* Add `pyproject.toml` for the Linux desktop python package (#116)

* Add files via upload

* Update main.py

* Update pyproject.toml

* handle platform-specific dependencies with sys_platform markers

* change clipboard tray icon from issue#139

#139
Author - https://github.com/bammerlaan

* feat(macos): hide dock icon and add startup error dialog (#141)

- Add PyInstaller spec file with LSUIElement to hide dock icon
- Use NSApplicationActivationPolicyAccessory to fully hide dock icon
- Add native macOS error dialog using osascript for startup crashes
- Add tkinter and pyinstaller to requirements_mac.txt
- Update .gitignore with build artifacts

Co-authored-by: Sathvik Rao Poladi <36164509+Sathvik-Rao@users.noreply.github.com>

* clean up

* add windows PyInstaller build spec

* Fix window centering on primary monitor

* color change for config label

* clean up

* Fix negative peer counter; add macOS pasteboard lock; add Linux wl-watch support

* fix -ve peers and peers disconnect after system sleep

* increase wl-clipboard timeout

* add linux kwargs flags gui, xmode, polling

* remove tab focus from checkboxes

* add login UI tooltips

* add custom ssl ca field in login and update tray icon for download

* show ssl ca at the end of cli version

* cli continue retry if ssl ca has invalid path

* refurbish p2p logic in desktop and mobile

* fix race condition

* cleanup

* android remove escape sequence from msg

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* version update

---------

Co-authored-by: Harshith Goka <harshith9399@gmail.com>
Co-authored-by: Olamshin <olamide_kolawole@yahoo.com>

Author: 3 people

.gitignore

@@ -1,2 +1,4 @@
 private/
 screenshots/
+.DS_Store
+.vscode/

ClipCascade_Desktop/src/.gitignore

@@ -1,3 +1,7 @@
 **/__pycache__/
 *.log
 DATA
+build/
+dist/
+*.spec.bak
+.venv/

ClipCascade_Desktop/src/ClipCascade_macos.spec

@@ -0,0 +1,49 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+import certifi
+
+a = Analysis(
+    ['main.py'],
+    pathex=[],
+    binaries=[],
+    datas=[(certifi.where(), 'certifi')],
+    hiddenimports=['tkinter'],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='ClipCascade',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon=['../../logo/logo.icns'],
+)
+app = BUNDLE(
+    exe,
+    name='ClipCascade.app',
+    icon='../../logo/logo.icns',
+    bundle_identifier=None,
+    info_plist={
+        'LSUIElement': True,
+    },
+)

ClipCascade_Desktop/src/ClipCascade_win.spec

@@ -0,0 +1,38 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+
+a = Analysis(
+    ['main.py'],
+    pathex=[],
+    binaries=[],
+    datas=[],
+    hiddenimports=['plyer.platforms.win.notification'],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='ClipCascade',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon=['../../logo/logo.ico'],
+)

ClipCascade_Desktop/src/cli/login.py

@@ -1,4 +1,5 @@
 import getpass
+import os
 import re
 
 from core.config import Config
@@ -13,7 +14,6 @@ def __init__(
         on_login_callback=None,
         on_quit_callback=None,
     ):
-        super().__init__()
         self.config = config
         self.on_login_callback = on_login_callback
         self.on_quit_callback = on_quit_callback
@@ -186,6 +186,25 @@ def mainloop(self):
             )
             break
 
+        while True:
+            ssl_ca_bundle = (
+                input(
+                    f"ssl ca bundle path (optional) [{self.config.data.get('ssl_ca_bundle') or ''}]: "
+                )
+                or (self.config.data.get("ssl_ca_bundle") or "")
+            ).strip()
+            if ssl_ca_bundle == "":
+                self.config.data["ssl_ca_bundle"] = ""
+                break
+            if not os.path.isfile(ssl_ca_bundle):
+                CustomDialog(
+                    "Invalid Input\nSSL CA bundle path is not a file or does not exist.",
+                    msg_type="error",
+                ).mainloop()
+                continue
+            self.config.data["ssl_ca_bundle"] = ssl_ca_bundle
+            break
+
         CustomDialog("Logging in...").mainloop()
 
     def on_quit(self):

ClipCascade_Desktop/src/clipboard/clipboard_manager.py

@@ -10,7 +10,7 @@
 from core.constants import *
 from core.config import Config
 
-if PLATFORM.startswith(LINUX) and not XMODE:
+if PLATFORM.startswith(LINUX) and LINUX_USE_CLI_UI:
     from cli.tray import TaskbarPanel
 else:
     from gui.tray import TaskbarPanel
@@ -250,8 +250,7 @@ def paste(self, payload: any, payload_type: str = "text"):
                         tiff_data = output.getvalue()
 
                     clipboard_monitor.enable_block_image_once()  # Block image copy to prevent deadlock
-                    pb_image = pasteboard.Pasteboard()
-                    pb_image.set_contents(tiff_data, pasteboard.TIFF)
+                    clipboard_monitor.write_to_pasteboard(tiff_data, pasteboard.TIFF)
                 elif PLATFORM.startswith(LINUX):
                     # Save the image to a binary buffer in PNG format
                     with io.BytesIO() as output:

ClipCascade_Desktop/src/clipboard/clipboard_monitor_linux.py

@@ -13,6 +13,7 @@
 
 _is_gdk_running = False
 _run_poll = threading.Event()
+_wl_watch_proc = None
 
 
 def _on_clipboard_changed(
@@ -64,10 +65,13 @@ def _monitor_x_wl_clipboard(
         r"no suitable type of content copied",  # wl-clipboard pattern
     ]
 
-    if x_mode:
+    if LINUX_CLIPBOARD_POLL_INTERVAL_SEC is not None:
+        timeout = LINUX_CLIPBOARD_POLL_INTERVAL_SEC
+        logging.info(f"Clipboard polling interval (--polling): {timeout}s")
+    elif x_mode:
         timeout = 0.3  # xclip seconds
     else:
-        timeout = 1  # wl-clipboard seconds
+        timeout = 3  # wl-clipboard seconds
 
     while _run_poll.is_set():
         if x_mode:
@@ -179,6 +183,148 @@ def _monitor_x_wl_clipboard(
         time.sleep(timeout)
 
 
+def _monitor_wl_watch(enable_image_monitoring=False, enable_file_monitoring=False):
+    """Event-driven Wayland clipboard monitoring using wl-paste --watch.
+    Uses the wlr-data-control-v1 protocol which does not create visible
+    surfaces or steal focus. Supported by wlroots-based compositors
+    (Sway, Hyprland, etc.) and KDE Plasma on Wayland.
+    Returns True if watch mode ran successfully, False to fall back to polling."""
+    global _block_image_once, _wl_watch_proc
+
+    last_error = None
+    previous_clipboard = None
+    ignore_patterns = [
+        r"target .+ not available",
+        r"no suitable type of content copied",
+    ]
+
+    try:
+        _wl_watch_proc = subprocess.Popen(
+            ["wl-paste", "--watch", "echo"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        time.sleep(0.5)
+        if _wl_watch_proc.poll() is not None:
+            stderr_out = _wl_watch_proc.stderr.read().decode("utf-8", errors="ignore")
+            logging.warning(
+                f"wl-paste --watch exited immediately: {stderr_out.strip()}"
+            )
+            _wl_watch_proc = None
+            return False
+
+        logging.info(
+            "Using wl-paste --watch for clipboard monitoring (no focus stealing)"
+        )
+
+        while _run_poll.is_set():
+            line = _wl_watch_proc.stdout.readline()
+            if not line:
+                break
+            if not _run_poll.is_set():
+                break
+
+            success, mime_output = execute_command("wl-paste", "-l")
+            if not success:
+                error_msg = f"Failed to retrieve MIME types: {mime_output}"
+                if error_msg != last_error:
+                    logging.error(error_msg)
+                    last_error = error_msg
+                continue
+
+            mime_list = mime_output.decode("utf-8")
+            mime_list = mime_list.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+            mime_list = [m.strip() for m in mime_list if len(m.strip()) > 0]
+            type_ = convert_mime_to_generic_type(mime_list)
+
+            # Text
+            if type_ == "text":
+                success, text = execute_command("wl-paste", "-n")
+                if success:
+                    text = text.decode("utf-8")
+                    if len(text) > 0 and text != previous_clipboard:
+                        previous_clipboard = text
+                        if _callback_update:
+                            _callback_update("text", text)
+                else:
+                    error_msg = (
+                        f"Failed to retrieve text content from clipboard. {text}"
+                    )
+                    if error_msg != last_error:
+                        if not any(
+                            re.search(pattern, error_msg.lower())
+                            for pattern in ignore_patterns
+                        ):
+                            logging.error(error_msg)
+                        last_error = error_msg
+
+            # Image
+            elif type_ == "image" and enable_image_monitoring:
+                success, image = execute_command("wl-paste", "-t", "image/png")
+                if success:
+                    if image != previous_clipboard:
+                        previous_clipboard = image
+                        if _callback_update and not _block_image_once:
+                            _callback_update("image", image)
+                        else:
+                            _block_image_once = False
+                else:
+                    error_msg = (
+                        f"Failed to retrieve image content from clipboard. {image}"
+                    )
+                    if error_msg != last_error:
+                        if not any(
+                            re.search(pattern, error_msg.lower())
+                            for pattern in ignore_patterns
+                        ):
+                            logging.error(error_msg)
+                        last_error = error_msg
+
+            # Files
+            elif type_ == "files" and enable_file_monitoring:
+                success, files = execute_command(
+                    "wl-paste", "-t", "text/uri-list", "-n"
+                )
+                if success:
+                    files = files.decode("utf-8")
+                    files = (
+                        files.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+                    )
+                    files = [f.strip() for f in files if len(f.strip()) > 0]
+                    if files != previous_clipboard:
+                        previous_clipboard = files
+                        if _callback_update:
+                            _callback_update("files", files)
+                else:
+                    error_msg = (
+                        f"Failed to retrieve files content from clipboard. {files}"
+                    )
+                    if error_msg != last_error:
+                        if not any(
+                            re.search(pattern, error_msg.lower())
+                            for pattern in ignore_patterns
+                        ):
+                            logging.error(error_msg)
+                        last_error = error_msg
+
+        return True
+    except FileNotFoundError:
+        logging.warning("wl-paste not found, cannot use --watch mode")
+        return False
+    except Exception as e:
+        logging.warning(f"wl-paste --watch failed: {e}")
+        return False
+    finally:
+        if _wl_watch_proc is not None:
+            _wl_watch_proc.terminate()
+            try:
+                _wl_watch_proc.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                _wl_watch_proc.kill()
+            _wl_watch_proc = None
+
+
 def convert_mime_to_generic_type(mime_list):
     if "text/uri-list" in mime_list:
         return "files"
@@ -242,15 +388,23 @@ def _start_clipboard_polling(enable_image_monitoring, enable_file_monitoring):
             enable_file_monitoring=enable_file_monitoring,
         )
     else:
-        _monitor_x_wl_clipboard(
-            x_mode=XMODE,
+        if not _monitor_wl_watch(
             enable_image_monitoring=enable_image_monitoring,
             enable_file_monitoring=enable_file_monitoring,
-        )
+        ):
+            logging.info(
+                "Falling back to wl-paste polling mode for clipboard monitoring"
+            )
+            _monitor_x_wl_clipboard(
+                x_mode=False,
+                enable_image_monitoring=enable_image_monitoring,
+                enable_file_monitoring=enable_file_monitoring,
+            )
 
 
 def _runner(enable_image_monitoring=False, enable_file_monitoring=False):
     global _is_gdk_running, _run_poll
+    logging.info(f"XMODE: {XMODE}")
     try:
         _run_poll.set()
         import gi
@@ -260,6 +414,7 @@ def _runner(enable_image_monitoring=False, enable_file_monitoring=False):
         from gi.repository import Gtk, Gdk
 
         if "x11" in str(type(Gdk.Display.get_default())).lower():  # X11
+            logging.info("Starting GTK clipboard monitoring for X11 display server.")
             clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
             clipboard.connect(
                 "owner-change",
@@ -293,7 +448,7 @@ def _start(enable_image_monitoring=False, enable_file_monitoring=False):
 
 
 def stop():
-    global _clipboard_thread, _callback_update, _block_image_once, _run_poll, _is_gdk_running
+    global _clipboard_thread, _callback_update, _block_image_once, _run_poll, _is_gdk_running, _wl_watch_proc
     if _clipboard_thread:
         if _is_gdk_running:
             import gi
@@ -304,10 +459,13 @@ def stop():
             Gtk.main_quit()
             _is_gdk_running = False
         _run_poll.clear()
+        if _wl_watch_proc is not None:
+            _wl_watch_proc.terminate()
         _clipboard_thread.join()  # Wait for the thread to finish
         _clipboard_thread = None
         _callback_update = None
         _block_image_once = False
+        _wl_watch_proc = None
         logging.info("Clipboard monitor stopped")