clipboard_handler 0.1.0__tar.gz

clipboard_handler-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: clipboard_handler
+Version: 0.1.0
+Summary: Clipboard handler server
+Author-email: Daniel-Adepoju <dannymay116@gmail.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+<!-- uv init -->
+<!-- uv build -->

clipboard_handler-0.1.0/README.md

@@ -0,0 +1,2 @@
+<!-- uv init -->
+<!-- uv build -->

clipboard_handler-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "clipboard_handler"
+version = "0.1.0"
+description = "Clipboard handler server"
+readme = "README.md"
+authors = [
+    { name = "Daniel-Adepoju", email = "dannymay116@gmail.com" }
+]
+requires-python = ">=3.14"
+dependencies = []
+
+[build-system]
+requires = ["setuptools>42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tools.setuptools.packages.find]
+where = ["src"]
+
+[project.scripts]
+clipboard_handler = "clipboard_handler.main:main"
+ 

clipboard_handler-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

clipboard_handler-0.1.0/src/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from prod-mcp-test!")

clipboard_handler-0.1.0/src/clipboard_handler/main.py

@@ -0,0 +1,5 @@
+from clipboard_handlerv .tools import mcp
+
+def main():
+    mcp.run(transport="stdio")
+    # print(mcp)

clipboard_handler-0.1.0/src/clipboard_handler/tools.py

@@ -0,0 +1,306 @@
+
+"""
+Clipboard History MCP Server (FastMCP)
+
+Tools:
+  - get_clipboard          : current clipboard text
+  - set_clipboard          : set clipboard text (also pushed to history)
+  - list_history           : list recent clipboard entries
+  - get_history_item       : get one history entry by index
+  - copy_from_history      : copy a history entry back to the clipboard
+  - clear_history          : wipe stored history
+  - search_history         : search history by substring
+
+Requires: pip install fastmcp pyperclip
+Optional (better Windows support): pip install pywin32
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+import time
+from collections import deque
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from fastmcp import FastMCP
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+MAX_HISTORY = 50
+HISTORY_FILE = Path.home() / ".clipboard_mcp_history.json"
+POLL_INTERVAL_SEC = 0.8  # background watcher interval
+
+# ---------------------------------------------------------------------------
+# Clipboard backend
+# ---------------------------------------------------------------------------
+
+def _get_clipboard() -> str:
+    try:
+        import pyperclip
+        return pyperclip.paste() or ""
+    except Exception as e:
+        return f"[clipboard error: {e}]"
+
+
+def _set_clipboard(text: str) -> None:
+    import pyperclip
+    pyperclip.copy(text)
+
+
+# ---------------------------------------------------------------------------
+# History store
+# ---------------------------------------------------------------------------
+
+@dataclass
+class HistoryEntry:
+    id: int
+    text: str
+    timestamp: str  # ISO-8601 UTC
+    source: str = "watch"  # "watch" | "set" | "restore"
+
+
+class ClipboardHistory:
+    def __init__(self, max_size: int = MAX_HISTORY, path: Path = HISTORY_FILE):
+        self.max_size = max_size
+        self.path = path
+        self._lock = threading.Lock()
+        self._entries: deque[HistoryEntry] = deque(maxlen=max_size)
+        self._next_id = 1
+        self._last_seen = ""
+        self._load()
+
+    def _load(self) -> None:
+        if not self.path.exists():
+            return
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+            self._next_id = data.get("next_id", 1)
+            for item in data.get("entries", []):
+                self._entries.append(HistoryEntry(**item))
+            if self._entries:
+                self._last_seen = self._entries[-1].text
+        except Exception:
+            pass
+
+    def _save(self) -> None:
+        try:
+            payload = {
+                "next_id": self._next_id,
+                "entries": [asdict(e) for e in self._entries],
+            }
+            self.path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        except Exception:
+            pass
+
+    def push(self, text: str, source: str = "watch") -> HistoryEntry | None:
+        text = (text or "").strip("\x00")  # strip nulls
+        if not text:
+            return None
+        with self._lock:
+            # Deduplicate consecutive identical entries
+            if self._entries and self._entries[-1].text == text:
+                return None
+            entry = HistoryEntry(
+                id=self._next_id,
+                text=text,
+                timestamp=datetime.now(timezone.utc).isoformat(),
+                source=source,
+            )
+            self._next_id += 1
+            self._entries.append(entry)
+            self._last_seen = text
+            self._save()
+            return entry
+
+    def list(self, limit: int = 20) -> list[dict[str, Any]]:
+        with self._lock:
+            items = list(self._entries)[-limit:]
+            # newest first
+            items = list(reversed(items))
+            return [
+                {
+                    "id": e.id,
+                    "preview": e.text[:120] + ("…" if len(e.text) > 120 else ""),
+                    "length": len(e.text),
+                    "timestamp": e.timestamp,
+                    "source": e.source,
+                }
+                for e in items
+            ]
+
+    def get(self, index: int = 0) -> HistoryEntry | None:
+        """index 0 = newest, 1 = previous, …"""
+        with self._lock:
+            if not self._entries:
+                return None
+            items = list(reversed(self._entries))
+            if index < 0 or index >= len(items):
+                return None
+            return items[index]
+
+    def get_by_id(self, entry_id: int) -> HistoryEntry | None:
+        with self._lock:
+            for e in self._entries:
+                if e.id == entry_id:
+                    return e
+            return None
+
+    def search(self, query: str, limit: int = 20) -> list[dict[str, Any]]:
+        q = query.lower()
+        with self._lock:
+            hits = [e for e in reversed(self._entries) if q in e.text.lower()]
+            hits = hits[:limit]
+            return [
+                {
+                    "id": e.id,
+                    "preview": e.text[:120] + ("…" if len(e.text) > 120 else ""),
+                    "length": len(e.text),
+                    "timestamp": e.timestamp,
+                }
+                for e in hits
+            ]
+
+    def clear(self) -> int:
+        with self._lock:
+            n = len(self._entries)
+            self._entries.clear()
+            self._save()
+            return n
+
+    def watch_once(self) -> None:
+        """Poll clipboard once and push if changed."""
+        current = _get_clipboard()
+        if current and current != self._last_seen:
+            self.push(current, source="watch")
+
+
+history = ClipboardHistory()
+
+
+def _start_watcher() -> None:
+    def loop() -> None:
+        while True:
+            try:
+                history.watch_once()
+            except Exception:
+                pass
+            time.sleep(POLL_INTERVAL_SEC)
+
+    t = threading.Thread(target=loop, daemon=True, name="clipboard-watcher")
+    t.start()
+
+
+_start_watcher()
+
+# ---------------------------------------------------------------------------
+# FastMCP server
+# ---------------------------------------------------------------------------
+
+mcp = FastMCP(
+    name="Clipboard History",
+    instructions=(
+        "Clipboard history tools. The server continuously watches the system "
+        "clipboard and keeps the last 50 unique entries. Use list_history / "
+        "search_history to find past clips, then copy_from_history to restore one."
+    ),
+)
+
+
+@mcp.tool()
+def get_clipboard() -> str:
+    """Return the current system clipboard text."""
+    return _get_clipboard()
+
+
+@mcp.tool()
+def set_clipboard(text: str) -> str:
+    """
+    Set the system clipboard to the given text.
+    The text is also added to clipboard history.
+    """
+    _set_clipboard(text)
+    entry = history.push(text, source="set")
+    if entry:
+        return f"Clipboard set (history id={entry.id}, {len(text)} chars)"
+    return f"Clipboard set ({len(text)} chars, duplicate ignored)"
+
+
+@mcp.tool()
+def list_history(limit: int = 20) -> list[dict[str, Any]]:
+    """
+    List recent clipboard history entries (newest first).
+
+    Args:
+        limit: Max number of entries to return (default 20, max 50).
+    """
+    limit = max(1, min(limit, MAX_HISTORY))
+    return history.list(limit=limit)
+
+
+@mcp.tool()
+def get_history_item(index: int = 0) -> dict[str, Any]:
+    """
+    Get full text of a history entry by position.
+
+    Args:
+        index: 0 = newest, 1 = previous, 2 = older, …
+    """
+    entry = history.get(index)
+    if not entry:
+        return {"error": f"No history entry at index {index}"}
+    return {
+        "id": entry.id,
+        "text": entry.text,
+        "timestamp": entry.timestamp,
+        "source": entry.source,
+        "length": len(entry.text),
+    }
+
+
+@mcp.tool()
+def copy_from_history(index: int = 0) -> str:
+    """
+    Copy a history entry back onto the system clipboard.
+
+    Args:
+        index: 0 = newest, 1 = previous, …
+    """
+    entry = history.get(index)
+    if not entry:
+        return f"No history entry at index {index}"
+    _set_clipboard(entry.text)
+    history.push(entry.text, source="restore")
+    preview = entry.text[:80] + ("…" if len(entry.text) > 80 else "")
+    return f"Restored to clipboard (id={entry.id}): {preview}"
+
+
+@mcp.tool()
+def search_history(query: str, limit: int = 20) -> list[dict[str, Any]]:
+    """
+    Search clipboard history for entries containing the query (case-insensitive).
+
+    Args:
+        query: Substring to search for.
+        limit: Max results (default 20).
+    """
+    if not query.strip():
+        return []
+    return history.search(query, limit=limit)
+
+
+@mcp.tool()
+def clear_history() -> str:
+    """Clear all stored clipboard history (does not change the current clipboard)."""
+    n = history.clear()
+    return f"Cleared {n} history entries"
+
+
+# if __name__ == "__main__":
+#     # stdio is the default for MCP subprocess servers
+#     mcp.run()

clipboard_handler-0.1.0/src/clipboard_handler.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: clipboard_handler
+Version: 0.1.0
+Summary: Clipboard handler server
+Author-email: Daniel-Adepoju <dannymay116@gmail.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+<!-- uv init -->
+<!-- uv build -->

clipboard_handler-0.1.0/src/clipboard_handler.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/__init__.py
+src/clipboard_handler/__init__.py
+src/clipboard_handler/main.py
+src/clipboard_handler/tools.py
+src/clipboard_handler.egg-info/PKG-INFO
+src/clipboard_handler.egg-info/SOURCES.txt
+src/clipboard_handler.egg-info/dependency_links.txt
+src/clipboard_handler.egg-info/entry_points.txt
+src/clipboard_handler.egg-info/top_level.txt

clipboard_handler-0.1.0/src/clipboard_handler.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clipboard_handler-0.1.0/src/clipboard_handler.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clipboard_handler = clipboard_handler.main:main

clipboard_handler-0.1.0/src/clipboard_handler.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+clipboard_handler