clipsy 1.7.0__tar.gz → 1.8.0__tar.gz

{clipsy-1.7.0/src/clipsy.egg-info → clipsy-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clipsy
-Version: 1.7.0
+Version: 1.8.0
 Summary: Lightweight clipboard history manager for macOS
 Author-email: Brendan Conrad <brendan.conrad@gmail.com>
 License: MIT
@@ -59,7 +59,14 @@ A lightweight clipboard history manager for macOS. Runs as a menu bar icon — n
 
 ## Installation
 
-### Via pipx (recommended)
+### Via Homebrew (recommended)
+
+```bash
+brew install brencon/clipsy/clipsy
+clipsy
+```
+
+### Via pipx
 
 ```bash
 brew install pipx

{clipsy-1.7.0 → clipsy-1.8.0}/README.md

@@ -28,7 +28,14 @@ A lightweight clipboard history manager for macOS. Runs as a menu bar icon — n
 
 ## Installation
 
-### Via pipx (recommended)
+### Via Homebrew (recommended)
+
+```bash
+brew install brencon/clipsy/clipsy
+clipsy
+```
+
+### Via pipx
 
 ```bash
 brew install pipx

{clipsy-1.7.0 → clipsy-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clipsy"
-version = "1.7.0"
+version = "1.8.0"
 description = "Lightweight clipboard history manager for macOS"
 readme = "README.md"
 license = {text = "MIT"}

{clipsy-1.7.0 → clipsy-1.8.0}/src/clipsy/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "1.7.0"
+__version__ = "1.8.0"
 __app_name__ = "Clipsy"

{clipsy-1.7.0 → clipsy-1.8.0}/src/clipsy/__main__.py

@@ -37,6 +37,7 @@ def create_plist(clipsy_path: str) -> str:
     <key>ProgramArguments</key>
     <array>
         <string>{clipsy_path}</string>
+        <string>run</string>
     </array>
     <key>RunAtLoad</key>
     <true/>

{clipsy-1.7.0 → clipsy-1.8.0}/src/clipsy/app.py

@@ -120,6 +120,7 @@ class ClipsyApp(rumps.App):
 
         try:
             from AppKit import NSPasteboard, NSPasteboardTypePNG, NSPasteboardTypeString
+            from Foundation import NSData
 
             pb = NSPasteboard.generalPasteboard()
 
@@ -128,11 +129,18 @@ class ClipsyApp(rumps.App):
             if entry.content_type == ContentType.TEXT and entry.text_content:
                 pb.clearContents()
                 pb.setString_forType_(entry.text_content, NSPasteboardTypeString)
+                if entry.rtf_data:
+                    rtf_ns_data = NSData.dataWithBytes_length_(entry.rtf_data, len(entry.rtf_data))
+                    if rtf_ns_data:
+                        pb.setData_forType_(rtf_ns_data, "public.rtf")
+                if entry.html_data:
+                    html_ns_data = NSData.dataWithBytes_length_(entry.html_data, len(entry.html_data))
+                    if html_ns_data:
+                        pb.setData_forType_(html_ns_data, "public.html")
                 self._monitor.sync_change_count()
                 copied = True
 
             elif entry.content_type == ContentType.IMAGE and entry.image_path:
-                from Foundation import NSData
                 img_data = NSData.dataWithContentsOfFile_(entry.image_path)
                 if img_data:
                     pb.clearContents()

{clipsy-1.7.0 → clipsy-1.8.0}/src/clipsy/config.py

@@ -11,6 +11,17 @@ MAX_ENTRIES = 500  # auto-purge threshold
 MAX_TEXT_SIZE = 1_000_000  # 1MB text limit
 MAX_IMAGE_SIZE = 10_000_000  # 10MB image limit
 PREVIEW_LENGTH = 60  # characters shown in menu item
-MENU_DISPLAY_COUNT = 10  # items shown in dropdown
+def _parse_menu_display_count() -> int:
+    raw = os.environ.get("CLIPSY_MENU_DISPLAY_COUNT")
+    if raw is None:
+        return 10
+    try:
+        value = int(raw)
+    except ValueError:
+        return 10
+    return max(5, min(50, value))
+
+
+MENU_DISPLAY_COUNT = _parse_menu_display_count()
 THUMBNAIL_SIZE = (32, 32)  # pixels, for menu icon display
 REDACT_SENSITIVE = True  # mask sensitive data in preview (API keys, passwords, etc.)

{clipsy-1.7.0 → clipsy-1.8.0}/src/clipsy/models.py

@@ -24,3 +24,5 @@ class ClipboardEntry:
     thumbnail_path: str | None = None
     is_sensitive: bool = False
     masked_preview: str | None = None
+    rtf_data: bytes | None = None
+    html_data: bytes | None = None

clipsy-1.8.0/src/clipsy/monitor.py

@@ -0,0 +1,201 @@
+import logging
+from collections.abc import Callable
+from datetime import datetime
+from pathlib import Path
+
+from AppKit import NSPasteboard, NSPasteboardTypePNG, NSPasteboardTypeTIFF, NSPasteboardTypeString, NSFilenamesPboardType
+
+try:
+    from AppKit import NSPasteboardTypeRTF
+except ImportError:
+    NSPasteboardTypeRTF = "public.rtf"
+
+try:
+    from AppKit import NSPasteboardTypeHTML
+except ImportError:
+    NSPasteboardTypeHTML = "public.html"
+
+from clipsy.config import IMAGE_DIR, MAX_IMAGE_SIZE, MAX_TEXT_SIZE, PREVIEW_LENGTH, REDACT_SENSITIVE, THUMBNAIL_SIZE
+from clipsy.models import ClipboardEntry, ContentType
+from clipsy.redact import detect_sensitive, mask_text
+from clipsy.storage import StorageManager
+from clipsy.utils import compute_hash, create_thumbnail, ensure_dirs, get_image_dimensions, truncate_text
+
+logger = logging.getLogger(__name__)
+
+
+class ClipboardMonitor:
+    def __init__(self, storage: StorageManager, on_change: Callable[[], None] | None = None):
+        self._storage = storage
+        self._on_change = on_change
+        self._pasteboard = NSPasteboard.generalPasteboard()
+        self._last_change_count = self._pasteboard.changeCount()
+        ensure_dirs()
+
+    def check_clipboard(self) -> bool:
+        current_count = self._pasteboard.changeCount()
+        if current_count == self._last_change_count:
+            return False
+
+        self._last_change_count = current_count
+
+        try:
+            entry = self._read_clipboard()
+            if entry is None:
+                return False
+
+            existing = self._storage.find_by_hash(entry.content_hash)
+            if existing:
+                self._storage.update_timestamp(existing.id)
+            else:
+                self._storage.add_entry(entry)
+                self._storage.purge_old()
+
+            if self._on_change:
+                self._on_change()
+            return True
+        except Exception:
+            logger.exception("Error reading clipboard")
+            return False
+
+    def sync_change_count(self) -> None:
+        self._last_change_count = self._pasteboard.changeCount()
+
+    def _read_clipboard(self) -> ClipboardEntry | None:
+        types = self._pasteboard.types()
+        if types is None:
+            return None
+
+        if NSPasteboardTypeString in types:
+            entry = self._read_text()
+            if entry:
+                return entry
+
+        for img_type in (NSPasteboardTypePNG, NSPasteboardTypeTIFF):
+            if img_type in types:
+                entry = self._read_image(img_type)
+                if entry:
+                    return entry
+
+        if NSFilenamesPboardType in types:
+            return self._read_files()
+
+        return None
+
+    def _read_text(self) -> ClipboardEntry | None:
+        text = self._pasteboard.stringForType_(NSPasteboardTypeString)
+        if not text:
+            return None
+
+        text_bytes = text.encode("utf-8")
+        if len(text_bytes) > MAX_TEXT_SIZE:
+            return None
+
+        content_hash = compute_hash(text_bytes)
+        preview = truncate_text(text, PREVIEW_LENGTH)
+
+        rtf_data = None
+        html_data = None
+        types = self._pasteboard.types()
+        if types:
+            if NSPasteboardTypeRTF in types:
+                data = self._pasteboard.dataForType_(NSPasteboardTypeRTF)
+                if data:
+                    rtf_data = bytes(data)
+            if NSPasteboardTypeHTML in types:
+                data = self._pasteboard.dataForType_(NSPasteboardTypeHTML)
+                if data:
+                    html_data = bytes(data)
+
+        is_sensitive = False
+        masked_preview = None
+        if REDACT_SENSITIVE:
+            matches = detect_sensitive(text)
+            if matches:
+                is_sensitive = True
+                masked_preview = truncate_text(mask_text(text, matches), PREVIEW_LENGTH)
+
+        return ClipboardEntry(
+            id=None,
+            content_type=ContentType.TEXT,
+            text_content=text,
+            image_path=None,
+            preview=preview,
+            content_hash=content_hash,
+            byte_size=len(text_bytes),
+            created_at=datetime.now(),
+            is_sensitive=is_sensitive,
+            masked_preview=masked_preview,
+            rtf_data=rtf_data,
+            html_data=html_data,
+        )
+
+    def _read_image(self, img_type) -> ClipboardEntry | None:
+        data = self._pasteboard.dataForType_(img_type)
+        if data is None:
+            return None
+
+        img_bytes = bytes(data)
+        if len(img_bytes) > MAX_IMAGE_SIZE:
+            logger.warning("Image too large (%d bytes), skipping", len(img_bytes))
+            return None
+
+        content_hash = compute_hash(img_bytes)
+        is_png = img_type == NSPasteboardTypePNG
+        image_path, thumbnail_path = self._save_image(img_bytes, content_hash, is_png)
+        width, height = get_image_dimensions(img_bytes)
+        preview = f"[Image: {width}x{height}]" if width > 0 else "[Image]"
+
+        return ClipboardEntry(
+            id=None,
+            content_type=ContentType.IMAGE,
+            text_content=None,
+            image_path=str(image_path),
+            preview=preview,
+            content_hash=content_hash,
+            byte_size=len(img_bytes),
+            created_at=datetime.now(),
+            thumbnail_path=str(thumbnail_path) if thumbnail_path else None,
+        )
+
+    def _read_files(self) -> ClipboardEntry | None:
+        filenames = self._pasteboard.propertyListForType_(NSFilenamesPboardType)
+        if not filenames:
+            return None
+
+        file_list = list(filenames)
+        text = "\n".join(file_list)
+        content_hash = compute_hash(text)
+
+        if len(file_list) == 1:
+            preview = truncate_text(Path(file_list[0]).name, PREVIEW_LENGTH)
+        else:
+            preview = truncate_text(f"{len(file_list)} files: {Path(file_list[0]).name}, ...", PREVIEW_LENGTH)
+
+        return ClipboardEntry(
+            id=None,
+            content_type=ContentType.FILE,
+            text_content=text,
+            image_path=None,
+            preview=preview,
+            content_hash=content_hash,
+            byte_size=len(text.encode("utf-8")),
+            created_at=datetime.now(),
+        )
+
+    def _save_image(self, img_bytes: bytes, content_hash: str, is_png: bool) -> tuple[Path, Path | None]:
+        ext = ".png" if is_png else ".tiff"
+        filename = content_hash[:12] + ext
+        path = IMAGE_DIR / filename
+        if not path.exists():
+            path.write_bytes(img_bytes)
+
+        # Generate thumbnail
+        thumb_filename = content_hash[:12] + "_thumb.png"
+        thumb_path = IMAGE_DIR / thumb_filename
+        if not thumb_path.exists():
+            if create_thumbnail(str(path), str(thumb_path), THUMBNAIL_SIZE):
+                return path, thumb_path
+            else:
+                return path, None
+        return path, thumb_path

{clipsy-1.7.0 → clipsy-1.8.0}/src/clipsy/storage.py

@@ -20,7 +20,9 @@ CREATE TABLE IF NOT EXISTS clipboard_entries (
     source_app     TEXT,
     thumbnail_path TEXT,
     is_sensitive   INTEGER NOT NULL DEFAULT 0,
-    masked_preview TEXT
+    masked_preview TEXT,
+    rtf_data       BLOB,
+    html_data      BLOB
 );
 
 CREATE INDEX IF NOT EXISTS idx_created_at ON clipboard_entries(created_at DESC);
@@ -70,12 +72,24 @@ class StorageManager:
             self._conn.execute("ALTER TABLE clipboard_entries ADD COLUMN is_sensitive INTEGER NOT NULL DEFAULT 0")
         if "masked_preview" not in columns:
             self._conn.execute("ALTER TABLE clipboard_entries ADD COLUMN masked_preview TEXT")
+        if "rtf_data" not in columns:
+            self._conn.execute("ALTER TABLE clipboard_entries ADD COLUMN rtf_data BLOB")
+        if "html_data" not in columns:
+            self._conn.execute("ALTER TABLE clipboard_entries ADD COLUMN html_data BLOB")
+
+    @staticmethod
+    def _delete_files(image_path: str | None, thumbnail_path: str | None) -> None:
+        for file_path in (image_path, thumbnail_path):
+            if file_path:
+                p = Path(file_path)
+                if p.exists():
+                    p.unlink()
 
     def add_entry(self, entry: ClipboardEntry) -> int:
         cursor = self._conn.execute(
             """INSERT INTO clipboard_entries
-               (content_type, text_content, image_path, preview, content_hash, byte_size, created_at, pinned, source_app, thumbnail_path, is_sensitive, masked_preview)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+               (content_type, text_content, image_path, preview, content_hash, byte_size, created_at, pinned, source_app, thumbnail_path, is_sensitive, masked_preview, rtf_data, html_data)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
             (
                 entry.content_type.value,
                 entry.text_content,
@@ -89,6 +103,8 @@ class StorageManager:
                 entry.thumbnail_path,
                 int(entry.is_sensitive),
                 entry.masked_preview,
+                entry.rtf_data,
+                entry.html_data,
             ),
         )
         self._conn.commit()
@@ -124,14 +140,7 @@ class StorageManager:
     def delete_entry(self, entry_id: int) -> None:
         entry = self.get_entry(entry_id)
         if entry:
-            if entry.image_path:
-                path = Path(entry.image_path)
-                if path.exists():
-                    path.unlink()
-            if entry.thumbnail_path:
-                thumb = Path(entry.thumbnail_path)
-                if thumb.exists():
-                    thumb.unlink()
+            self._delete_files(entry.image_path, entry.thumbnail_path)
         self._conn.execute("DELETE FROM clipboard_entries WHERE id = ?", (entry_id,))
         self._conn.commit()
 
@@ -169,14 +178,7 @@ class StorageManager:
 
         deleted = 0
         for row in rows:
-            if row["image_path"]:
-                path = Path(row["image_path"])
-                if path.exists():
-                    path.unlink()
-            if row["thumbnail_path"]:
-                thumb = Path(row["thumbnail_path"])
-                if thumb.exists():
-                    thumb.unlink()
+            self._delete_files(row["image_path"], row["thumbnail_path"])
             self._conn.execute("DELETE FROM clipboard_entries WHERE id = ?", (row["id"],))
             deleted += 1
 
@@ -201,14 +203,7 @@ class StorageManager:
             "SELECT image_path, thumbnail_path FROM clipboard_entries WHERE image_path IS NOT NULL OR thumbnail_path IS NOT NULL"
         ).fetchall()
         for row in rows:
-            if row["image_path"]:
-                path = Path(row["image_path"])
-                if path.exists():
-                    path.unlink()
-            if row["thumbnail_path"]:
-                thumb = Path(row["thumbnail_path"])
-                if thumb.exists():
-                    thumb.unlink()
+            self._delete_files(row["image_path"], row["thumbnail_path"])
         self._conn.execute("DELETE FROM clipboard_entries")
         self._conn.commit()
 
@@ -241,6 +236,8 @@ class StorageManager:
         thumbnail_path = row["thumbnail_path"] if "thumbnail_path" in keys else None
         is_sensitive = bool(row["is_sensitive"]) if "is_sensitive" in keys else False
         masked_preview = row["masked_preview"] if "masked_preview" in keys else None
+        rtf_data = bytes(row["rtf_data"]) if "rtf_data" in keys and row["rtf_data"] is not None else None
+        html_data = bytes(row["html_data"]) if "html_data" in keys and row["html_data"] is not None else None
         return ClipboardEntry(
             id=row["id"],
             content_type=ContentType(row["content_type"]),
@@ -255,4 +252,6 @@ class StorageManager:
             thumbnail_path=thumbnail_path,
             is_sensitive=is_sensitive,
             masked_preview=masked_preview,
+            rtf_data=rtf_data,
+            html_data=html_data,
         )

{clipsy-1.7.0 → clipsy-1.8.0/src/clipsy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clipsy
-Version: 1.7.0
+Version: 1.8.0
 Summary: Lightweight clipboard history manager for macOS
 Author-email: Brendan Conrad <brendan.conrad@gmail.com>
 License: MIT
@@ -59,7 +59,14 @@ A lightweight clipboard history manager for macOS. Runs as a menu bar icon — n
 
 ## Installation
 
-### Via pipx (recommended)
+### Via Homebrew (recommended)
+
+```bash
+brew install brencon/clipsy/clipsy
+clipsy
+```
+
+### Via pipx
 
 ```bash
 brew install pipx

{clipsy-1.7.0 → clipsy-1.8.0}/src/clipsy.egg-info/SOURCES.txt

@@ -17,6 +17,8 @@ src/clipsy.egg-info/entry_points.txt
 src/clipsy.egg-info/requires.txt
 src/clipsy.egg-info/top_level.txt
 tests/test_app.py
+tests/test_config.py
+tests/test_main.py
 tests/test_monitor.py
 tests/test_redact.py
 tests/test_storage.py

{clipsy-1.7.0 → clipsy-1.8.0}/tests/test_app.py

@@ -202,3 +202,39 @@ class TestMenuEntryMapping:
 
         assert "old_key" not in entry_ids
         assert len(entry_ids) == 1
+
+
+class TestRichTextRestoration:
+    """Test that RTF/HTML data round-trips through storage for restoration."""
+
+    def test_text_entry_with_rtf_data_available(self, storage, make_entry):
+        rtf_bytes = b"{\\rtf1\\ansi Hello \\b World\\b0}"
+        entry_id = storage.add_entry(make_entry("Hello World", rtf_data=rtf_bytes))
+        entry = storage.get_entry(entry_id)
+        assert entry.rtf_data == rtf_bytes
+        assert entry.text_content == "Hello World"
+        assert entry.content_type == ContentType.TEXT
+
+    def test_text_entry_with_html_data_available(self, storage, make_entry):
+        html_bytes = b"<p>Hello <b>World</b></p>"
+        entry_id = storage.add_entry(make_entry("Hello World", html_data=html_bytes, content_hash="html_h"))
+        entry = storage.get_entry(entry_id)
+        assert entry.html_data == html_bytes
+        assert entry.text_content == "Hello World"
+
+    def test_text_entry_with_both_formats(self, storage, make_entry):
+        rtf_bytes = b"{\\rtf1\\ansi Hello}"
+        html_bytes = b"<p>Hello</p>"
+        entry_id = storage.add_entry(
+            make_entry("Hello", rtf_data=rtf_bytes, html_data=html_bytes)
+        )
+        entry = storage.get_entry(entry_id)
+        assert entry.rtf_data == rtf_bytes
+        assert entry.html_data == html_bytes
+
+    def test_plain_text_entry_has_no_rich_data(self, storage, make_entry):
+        entry_id = storage.add_entry(make_entry("plain text"))
+        entry = storage.get_entry(entry_id)
+        assert entry.rtf_data is None
+        assert entry.html_data is None
+        assert entry.text_content == "plain text"

clipsy-1.8.0/tests/test_config.py

@@ -0,0 +1,36 @@
+import os
+from unittest.mock import patch
+
+from clipsy.config import _parse_menu_display_count
+
+
+class TestParseMenuDisplayCount:
+    def test_default_when_not_set(self):
+        env = os.environ.copy()
+        env.pop("CLIPSY_MENU_DISPLAY_COUNT", None)
+        with patch.dict("os.environ", env, clear=True):
+            assert _parse_menu_display_count() == 10
+
+    def test_valid_value(self):
+        with patch.dict("os.environ", {"CLIPSY_MENU_DISPLAY_COUNT": "20"}):
+            assert _parse_menu_display_count() == 20
+
+    def test_clamped_below_minimum(self):
+        with patch.dict("os.environ", {"CLIPSY_MENU_DISPLAY_COUNT": "2"}):
+            assert _parse_menu_display_count() == 5
+
+    def test_clamped_above_maximum(self):
+        with patch.dict("os.environ", {"CLIPSY_MENU_DISPLAY_COUNT": "100"}):
+            assert _parse_menu_display_count() == 50
+
+    def test_invalid_non_integer(self):
+        with patch.dict("os.environ", {"CLIPSY_MENU_DISPLAY_COUNT": "abc"}):
+            assert _parse_menu_display_count() == 10
+
+    def test_boundary_minimum(self):
+        with patch.dict("os.environ", {"CLIPSY_MENU_DISPLAY_COUNT": "5"}):
+            assert _parse_menu_display_count() == 5
+
+    def test_boundary_maximum(self):
+        with patch.dict("os.environ", {"CLIPSY_MENU_DISPLAY_COUNT": "50"}):
+            assert _parse_menu_display_count() == 50

clipsy-1.8.0/tests/test_main.py

@@ -0,0 +1,159 @@
+"""Tests for __main__.py CLI and LaunchAgent functions."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from clipsy.__main__ import (
+    PLIST_NAME,
+    check_status,
+    create_plist,
+    get_clipsy_path,
+    install_launchagent,
+    main,
+    uninstall_launchagent,
+)
+
+
+class TestCreatePlist:
+    def test_contains_label(self):
+        plist = create_plist("/usr/local/bin/clipsy")
+        assert "<string>com.clipsy.app</string>" in plist
+
+    def test_contains_clipsy_path(self):
+        plist = create_plist("/opt/homebrew/bin/clipsy")
+        assert "<string>/opt/homebrew/bin/clipsy</string>" in plist
+
+    def test_contains_run_argument(self):
+        plist = create_plist("/usr/local/bin/clipsy")
+        assert "<string>run</string>" in plist
+
+    def test_contains_keep_alive(self):
+        plist = create_plist("/usr/local/bin/clipsy")
+        assert "<key>KeepAlive</key>" in plist
+        assert "<true/>" in plist
+
+    def test_contains_log_path(self):
+        plist = create_plist("/usr/local/bin/clipsy")
+        assert "clipsy.log</string>" in plist
+
+    def test_valid_xml(self):
+        plist = create_plist("/usr/local/bin/clipsy")
+        assert plist.startswith("<?xml version=")
+        assert "</plist>" in plist
+
+
+class TestGetClipsyPath:
+    @patch("shutil.which", return_value="/usr/local/bin/clipsy")
+    def test_returns_which_path(self, _mock_which):
+        assert get_clipsy_path() == "/usr/local/bin/clipsy"
+
+    @patch("shutil.which", return_value=None)
+    def test_falls_back_to_python_module(self, _mock_which):
+        path = get_clipsy_path()
+        assert "-m clipsy" in path
+
+
+class TestInstallLaunchAgent:
+    @patch("clipsy.__main__.subprocess.run")
+    @patch("clipsy.__main__.PLIST_PATH")
+    @patch("clipsy.__main__.LAUNCHAGENT_DIR")
+    @patch("clipsy.__main__.ensure_dirs")
+    @patch("clipsy.__main__.get_clipsy_path", return_value="/usr/local/bin/clipsy")
+    def test_install_success(self, _mock_path, _mock_dirs, mock_la_dir, mock_plist, mock_run):
+        mock_plist.exists.return_value = False
+        mock_run.return_value = MagicMock(returncode=0)
+        assert install_launchagent() == 0
+
+    @patch("clipsy.__main__.subprocess.run")
+    @patch("clipsy.__main__.PLIST_PATH")
+    @patch("clipsy.__main__.LAUNCHAGENT_DIR")
+    @patch("clipsy.__main__.ensure_dirs")
+    @patch("clipsy.__main__.get_clipsy_path", return_value="/usr/local/bin/clipsy")
+    def test_install_failure(self, _mock_path, _mock_dirs, mock_la_dir, mock_plist, mock_run):
+        mock_plist.exists.return_value = False
+        mock_run.return_value = MagicMock(returncode=1, stderr="load failed")
+        assert install_launchagent() == 1
+
+    @patch("clipsy.__main__.subprocess.run")
+    @patch("clipsy.__main__.PLIST_PATH")
+    @patch("clipsy.__main__.LAUNCHAGENT_DIR")
+    @patch("clipsy.__main__.ensure_dirs")
+    @patch("clipsy.__main__.get_clipsy_path", return_value="/usr/local/bin/clipsy")
+    def test_install_unloads_existing(self, _mock_path, _mock_dirs, mock_la_dir, mock_plist, mock_run):
+        mock_plist.exists.return_value = True
+        mock_run.return_value = MagicMock(returncode=0)
+        install_launchagent()
+        # First call should be unload, second should be load
+        assert mock_run.call_count == 2
+
+
+class TestUninstallLaunchAgent:
+    @patch("clipsy.__main__.subprocess.run")
+    @patch("clipsy.__main__.PLIST_PATH")
+    def test_uninstall_not_installed(self, mock_plist, _mock_run):
+        mock_plist.exists.return_value = False
+        assert uninstall_launchagent() == 0
+
+    @patch("clipsy.__main__.subprocess.run")
+    @patch("clipsy.__main__.PLIST_PATH")
+    def test_uninstall_success(self, mock_plist, mock_run):
+        mock_plist.exists.return_value = True
+        mock_run.return_value = MagicMock(returncode=0)
+        assert uninstall_launchagent() == 0
+        mock_plist.unlink.assert_called_once()
+
+
+class TestCheckStatus:
+    @patch("clipsy.__main__.subprocess.run")
+    @patch("clipsy.__main__.PLIST_PATH")
+    def test_running(self, mock_plist, mock_run):
+        mock_plist.exists.return_value = True
+        mock_run.return_value = MagicMock(returncode=0)
+        assert check_status() == 0
+
+    @patch("clipsy.__main__.subprocess.run")
+    @patch("clipsy.__main__.PLIST_PATH")
+    def test_not_running_installed(self, mock_plist, mock_run):
+        mock_plist.exists.return_value = True
+        mock_run.return_value = MagicMock(returncode=1)
+        assert check_status() == 1
+
+    @patch("clipsy.__main__.subprocess.run")
+    @patch("clipsy.__main__.PLIST_PATH")
+    def test_not_running_not_installed(self, mock_plist, mock_run):
+        mock_plist.exists.return_value = False
+        mock_run.return_value = MagicMock(returncode=1)
+        assert check_status() == 1
+
+
+class TestCLIParsing:
+    @patch("clipsy.__main__.install_launchagent", return_value=0)
+    def test_default_installs(self, mock_install):
+        with patch("sys.argv", ["clipsy"]):
+            with pytest.raises(SystemExit) as exc:
+                main()
+            assert exc.value.code == 0
+            mock_install.assert_called_once()
+
+    @patch("clipsy.__main__.uninstall_launchagent", return_value=0)
+    def test_uninstall_command(self, mock_uninstall):
+        with patch("sys.argv", ["clipsy", "uninstall"]):
+            with pytest.raises(SystemExit) as exc:
+                main()
+            assert exc.value.code == 0
+            mock_uninstall.assert_called_once()
+
+    @patch("clipsy.__main__.check_status", return_value=0)
+    def test_status_command(self, mock_status):
+        with patch("sys.argv", ["clipsy", "status"]):
+            with pytest.raises(SystemExit) as exc:
+                main()
+            assert exc.value.code == 0
+            mock_status.assert_called_once()
+
+    @patch("clipsy.__main__.run_app")
+    def test_run_command(self, mock_run):
+        with patch("sys.argv", ["clipsy", "run"]):
+            main()
+            mock_run.assert_called_once()

{clipsy-1.7.0 → clipsy-1.8.0}/tests/test_monitor.py

@@ -369,3 +369,104 @@ class TestThumbnailGeneration:
         entries = storage.get_recent()
         assert len(entries) == 1
         assert entries[0].thumbnail_path == str(thumb_path)
+
+
+class TestRichTextClipboard:
+    def test_rtf_data_captured(self, monitor, mock_pasteboard, storage):
+        rtf_bytes = b"{\\rtf1\\ansi Hello \\b World\\b0}"
+        mock_pasteboard.changeCount.return_value = 1
+        mock_pasteboard.types.return_value = ["public.utf8-plain-text", "public.rtf"]
+        mock_pasteboard.stringForType_.return_value = "Hello World"
+        mock_pasteboard.dataForType_.return_value = rtf_bytes
+
+        with (
+            patch("clipsy.monitor.NSPasteboardTypeString", "public.utf8-plain-text"),
+            patch("clipsy.monitor.NSPasteboardTypeRTF", "public.rtf"),
+            patch("clipsy.monitor.NSPasteboardTypeHTML", "public.html"),
+        ):
+            assert monitor.check_clipboard() is True
+
+        entries = storage.get_recent()
+        assert len(entries) == 1
+        assert entries[0].text_content == "Hello World"
+        assert entries[0].rtf_data == rtf_bytes
+
+    def test_html_data_captured(self, monitor, mock_pasteboard, storage):
+        html_bytes = b"<p>Hello <b>World</b></p>"
+        mock_pasteboard.changeCount.return_value = 1
+        mock_pasteboard.types.return_value = ["public.utf8-plain-text", "public.html"]
+        mock_pasteboard.stringForType_.return_value = "Hello World"
+        mock_pasteboard.dataForType_.return_value = html_bytes
+
+        with (
+            patch("clipsy.monitor.NSPasteboardTypeString", "public.utf8-plain-text"),
+            patch("clipsy.monitor.NSPasteboardTypeRTF", "public.rtf"),
+            patch("clipsy.monitor.NSPasteboardTypeHTML", "public.html"),
+        ):
+            assert monitor.check_clipboard() is True
+
+        entries = storage.get_recent()
+        assert len(entries) == 1
+        assert entries[0].html_data == html_bytes
+
+    def test_both_rtf_and_html_captured(self, monitor, mock_pasteboard, storage):
+        rtf_bytes = b"{\\rtf1\\ansi Hello}"
+        html_bytes = b"<p>Hello</p>"
+        mock_pasteboard.changeCount.return_value = 1
+        mock_pasteboard.types.return_value = ["public.utf8-plain-text", "public.rtf", "public.html"]
+        mock_pasteboard.stringForType_.return_value = "Hello"
+
+        def data_for_type(type_str):
+            if type_str == "public.rtf":
+                return rtf_bytes
+            if type_str == "public.html":
+                return html_bytes
+            return None
+
+        mock_pasteboard.dataForType_ = data_for_type
+
+        with (
+            patch("clipsy.monitor.NSPasteboardTypeString", "public.utf8-plain-text"),
+            patch("clipsy.monitor.NSPasteboardTypeRTF", "public.rtf"),
+            patch("clipsy.monitor.NSPasteboardTypeHTML", "public.html"),
+        ):
+            assert monitor.check_clipboard() is True
+
+        entries = storage.get_recent()
+        assert len(entries) == 1
+        assert entries[0].rtf_data == rtf_bytes
+        assert entries[0].html_data == html_bytes
+
+    def test_plain_text_without_rtf(self, monitor, mock_pasteboard, storage):
+        mock_pasteboard.changeCount.return_value = 1
+        mock_pasteboard.types.return_value = ["public.utf8-plain-text"]
+        mock_pasteboard.stringForType_.return_value = "plain text"
+
+        with (
+            patch("clipsy.monitor.NSPasteboardTypeString", "public.utf8-plain-text"),
+            patch("clipsy.monitor.NSPasteboardTypeRTF", "public.rtf"),
+            patch("clipsy.monitor.NSPasteboardTypeHTML", "public.html"),
+        ):
+            assert monitor.check_clipboard() is True
+
+        entries = storage.get_recent()
+        assert len(entries) == 1
+        assert entries[0].rtf_data is None
+        assert entries[0].html_data is None
+
+    def test_rtf_data_for_type_returns_none(self, monitor, mock_pasteboard, storage):
+        mock_pasteboard.changeCount.return_value = 1
+        mock_pasteboard.types.return_value = ["public.utf8-plain-text", "public.rtf"]
+        mock_pasteboard.stringForType_.return_value = "Hello"
+        mock_pasteboard.dataForType_.return_value = None
+
+        with (
+            patch("clipsy.monitor.NSPasteboardTypeString", "public.utf8-plain-text"),
+            patch("clipsy.monitor.NSPasteboardTypeRTF", "public.rtf"),
+            patch("clipsy.monitor.NSPasteboardTypeHTML", "public.html"),
+        ):
+            assert monitor.check_clipboard() is True
+
+        entries = storage.get_recent()
+        assert len(entries) == 1
+        assert entries[0].rtf_data is None

{clipsy-1.7.0 → clipsy-1.8.0}/tests/test_storage.py

@@ -346,3 +346,82 @@ class TestFileCleanup:
         # Check that old files were deleted
         remaining_files = list(tmp_path.glob("*.png"))
         assert len(remaining_files) == 4  # 2 images + 2 thumbnails
+
+
+class TestRichTextEntries:
+    def test_store_and_retrieve_rtf_data(self, storage, make_entry):
+        rtf_bytes = b"{\\rtf1\\ansi Hello \\b World\\b0}"
+        entry = make_entry("Hello World", rtf_data=rtf_bytes)
+        entry_id = storage.add_entry(entry)
+        retrieved = storage.get_entry(entry_id)
+        assert retrieved.rtf_data == rtf_bytes
+        assert retrieved.text_content == "Hello World"
+
+    def test_store_and_retrieve_html_data(self, storage, make_entry):
+        html_bytes = b"<p>Hello <b>World</b></p>"
+        entry = make_entry("Hello World", html_data=html_bytes, content_hash="html_hash")
+        entry_id = storage.add_entry(entry)
+        retrieved = storage.get_entry(entry_id)
+        assert retrieved.html_data == html_bytes
+
+    def test_store_both_rtf_and_html(self, storage, make_entry):
+        rtf_bytes = b"{\\rtf1\\ansi Hello \\b World\\b0}"
+        html_bytes = b"<p>Hello <b>World</b></p>"
+        entry = make_entry("Hello World", rtf_data=rtf_bytes, html_data=html_bytes)
+        entry_id = storage.add_entry(entry)
+        retrieved = storage.get_entry(entry_id)
+        assert retrieved.rtf_data == rtf_bytes
+        assert retrieved.html_data == html_bytes
+
+    def test_entry_without_rtf_data(self, storage, make_entry):
+        entry = make_entry("plain text only")
+        entry_id = storage.add_entry(entry)
+        retrieved = storage.get_entry(entry_id)
+        assert retrieved.rtf_data is None
+        assert retrieved.html_data is None
+
+    def test_search_still_uses_text_content(self, storage, make_entry):
+        rtf_bytes = b"{\\rtf1\\ansi Hello}"
+        entry = make_entry("Hello World", rtf_data=rtf_bytes)
+        storage.add_entry(entry)
+        results = storage.search("Hello")
+        assert len(results) == 1
+        assert results[0].rtf_data == rtf_bytes
+
+
+class TestRichTextMigration:
+    def test_migrate_adds_rtf_and_html_columns(self, tmp_path):
+        """Test that migration adds rtf_data and html_data to old databases."""
+        import sqlite3
+        from clipsy.storage import StorageManager
+
+        db_file = tmp_path / "old_db_no_rtf.sqlite"
+        conn = sqlite3.connect(str(db_file))
+        conn.executescript("""
+            CREATE TABLE clipboard_entries (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                content_type TEXT NOT NULL,
+                text_content TEXT,
+                image_path TEXT,
+                preview TEXT NOT NULL,
+                content_hash TEXT NOT NULL,
+                byte_size INTEGER NOT NULL DEFAULT 0,
+                created_at TEXT NOT NULL,
+                pinned INTEGER NOT NULL DEFAULT 0,
+                source_app TEXT,
+                thumbnail_path TEXT,
+                is_sensitive INTEGER NOT NULL DEFAULT 0,
+                masked_preview TEXT
+            );
+        """)
+        conn.commit()
+        conn.close()
+
+        mgr = StorageManager(db_path=str(db_file))
+
+        cursor = mgr._conn.execute("PRAGMA table_info(clipboard_entries)")
+        columns = {row[1] for row in cursor.fetchall()}
+        assert "rtf_data" in columns
+        assert "html_data" in columns
+
+        mgr.close()

clipsy-1.7.0/src/clipsy/monitor.py

@@ -1,153 +0,0 @@
-import logging
-from collections.abc import Callable
-from datetime import datetime
-from pathlib import Path
-
-from AppKit import NSPasteboard, NSPasteboardTypePNG, NSPasteboardTypeTIFF, NSPasteboardTypeString, NSFilenamesPboardType
-
-from clipsy.config import IMAGE_DIR, MAX_IMAGE_SIZE, MAX_TEXT_SIZE, PREVIEW_LENGTH, REDACT_SENSITIVE, THUMBNAIL_SIZE
-from clipsy.models import ClipboardEntry, ContentType
-from clipsy.redact import detect_sensitive, mask_text
-from clipsy.storage import StorageManager
-from clipsy.utils import compute_hash, create_thumbnail, ensure_dirs, get_image_dimensions, truncate_text
-
-logger = logging.getLogger(__name__)
-
-
-class ClipboardMonitor:
-    def __init__(self, storage: StorageManager, on_change: Callable[[], None] | None = None):
-        self._storage = storage
-        self._on_change = on_change
-        self._pasteboard = NSPasteboard.generalPasteboard()
-        self._last_change_count = self._pasteboard.changeCount()
-        ensure_dirs()
-
-    def check_clipboard(self) -> bool:
-        current_count = self._pasteboard.changeCount()
-        if current_count == self._last_change_count:
-            return False
-
-        self._last_change_count = current_count
-
-        try:
-            entry = self._read_clipboard()
-            if entry is None:
-                return False
-
-            existing = self._storage.find_by_hash(entry.content_hash)
-            if existing:
-                self._storage.update_timestamp(existing.id)
-            else:
-                self._storage.add_entry(entry)
-                self._storage.purge_old()
-
-            if self._on_change:
-                self._on_change()
-            return True
-        except Exception:
-            logger.exception("Error reading clipboard")
-            return False
-
-    def sync_change_count(self) -> None:
-        self._last_change_count = self._pasteboard.changeCount()
-
-    def _read_clipboard(self) -> ClipboardEntry | None:
-        types = self._pasteboard.types()
-        if types is None:
-            return None
-
-        if NSPasteboardTypeString in types:
-            text = self._pasteboard.stringForType_(NSPasteboardTypeString)
-            if text:
-                text_bytes = text.encode("utf-8")
-                if len(text_bytes) <= MAX_TEXT_SIZE:
-                    content_hash = compute_hash(text_bytes)
-                    preview = truncate_text(text, PREVIEW_LENGTH)
-
-                    # Detect sensitive data
-                    is_sensitive = False
-                    masked_preview = None
-                    if REDACT_SENSITIVE:
-                        matches = detect_sensitive(text)
-                        if matches:
-                            is_sensitive = True
-                            masked_preview = truncate_text(mask_text(text, matches), PREVIEW_LENGTH)
-
-                    return ClipboardEntry(
-                        id=None,
-                        content_type=ContentType.TEXT,
-                        text_content=text,
-                        image_path=None,
-                        preview=preview,
-                        content_hash=content_hash,
-                        byte_size=len(text_bytes),
-                        created_at=datetime.now(),
-                        is_sensitive=is_sensitive,
-                        masked_preview=masked_preview,
-                    )
-
-        for img_type in (NSPasteboardTypePNG, NSPasteboardTypeTIFF):
-            if img_type in types:
-                data = self._pasteboard.dataForType_(img_type)
-                if data is None:
-                    continue
-                img_bytes = bytes(data)
-                if len(img_bytes) > MAX_IMAGE_SIZE:
-                    logger.warning("Image too large (%d bytes), skipping", len(img_bytes))
-                    return None
-                content_hash = compute_hash(img_bytes)
-                is_png = img_type == NSPasteboardTypePNG
-                image_path, thumbnail_path = self._save_image(img_bytes, content_hash, is_png)
-                width, height = get_image_dimensions(img_bytes)
-                preview = f"[Image: {width}x{height}]" if width > 0 else "[Image]"
-                return ClipboardEntry(
-                    id=None,
-                    content_type=ContentType.IMAGE,
-                    text_content=None,
-                    image_path=str(image_path),
-                    preview=preview,
-                    content_hash=content_hash,
-                    byte_size=len(img_bytes),
-                    created_at=datetime.now(),
-                    thumbnail_path=str(thumbnail_path) if thumbnail_path else None,
-                )
-
-        if NSFilenamesPboardType in types:
-            filenames = self._pasteboard.propertyListForType_(NSFilenamesPboardType)
-            if filenames:
-                file_list = list(filenames)
-                text = "\n".join(file_list)
-                content_hash = compute_hash(text)
-                if len(file_list) == 1:
-                    preview = truncate_text(Path(file_list[0]).name, PREVIEW_LENGTH)
-                else:
-                    preview = truncate_text(f"{len(file_list)} files: {Path(file_list[0]).name}, ...", PREVIEW_LENGTH)
-                return ClipboardEntry(
-                    id=None,
-                    content_type=ContentType.FILE,
-                    text_content=text,
-                    image_path=None,
-                    preview=preview,
-                    content_hash=content_hash,
-                    byte_size=len(text.encode("utf-8")),
-                    created_at=datetime.now(),
-                )
-
-        return None
-
-    def _save_image(self, img_bytes: bytes, content_hash: str, is_png: bool) -> tuple[Path, Path | None]:
-        ext = ".png" if is_png else ".tiff"
-        filename = content_hash[:12] + ext
-        path = IMAGE_DIR / filename
-        if not path.exists():
-            path.write_bytes(img_bytes)
-
-        # Generate thumbnail
-        thumb_filename = content_hash[:12] + "_thumb.png"
-        thumb_path = IMAGE_DIR / thumb_filename
-        if not thumb_path.exists():
-            if create_thumbnail(str(path), str(thumb_path), THUMBNAIL_SIZE):
-                return path, thumb_path
-            else:
-                return path, None
-        return path, thumb_path