create-screenfix 0.1.0

package/python/screenfix/clipboard_watcher.py

@@ -0,0 +1,164 @@
+"""
+Clipboard watcher for detecting new screenshots.
+
+Watches the system clipboard for new image data and triggers
+a callback when detected. Use Cmd+Ctrl+Shift+4 to copy screenshot
+to clipboard (instant, no preview delay).
+"""
+
+import os
+import time
+import threading
+from pathlib import Path
+from typing import Callable, Optional
+
+from AppKit import NSPasteboard, NSPasteboardTypePNG, NSPasteboardTypeTIFF
+from Foundation import NSData
+
+
+# Temp directory for clipboard images
+CLIPBOARD_TEMP_DIR = Path("/tmp/screenfix/clipboard")
+
+
+class ClipboardWatcher:
+    """Watches clipboard for new images."""
+
+    def __init__(self, callback: Callable[[str], None], poll_interval: float = 0.3):
+        """
+        Initialize the clipboard watcher.
+
+        Args:
+            callback: Function to call when new image detected.
+                     Called with path to saved image file.
+            poll_interval: How often to check clipboard (seconds).
+        """
+        self._callback = callback
+        self._poll_interval = poll_interval
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._last_change_count = 0
+
+    def start(self):
+        """Start watching the clipboard."""
+        if self._running:
+            return
+
+        # Ensure temp directory exists
+        CLIPBOARD_TEMP_DIR.mkdir(parents=True, exist_ok=True)
+
+        # Get initial change count
+        pasteboard = NSPasteboard.generalPasteboard()
+        self._last_change_count = pasteboard.changeCount()
+
+        self._running = True
+        self._thread = threading.Thread(target=self._watch_loop, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        """Stop watching the clipboard."""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+
+    @property
+    def is_running(self) -> bool:
+        """Check if watcher is running."""
+        return self._running
+
+    def _watch_loop(self):
+        """Main watch loop running in background thread."""
+        while self._running:
+            try:
+                self._check_clipboard()
+            except Exception as e:
+                import sys
+                print(f"Clipboard watch error: {e}", file=sys.stderr)
+
+            time.sleep(self._poll_interval)
+
+    def _check_clipboard(self):
+        """Check if clipboard has new image data."""
+        pasteboard = NSPasteboard.generalPasteboard()
+        current_count = pasteboard.changeCount()
+
+        # No change
+        if current_count == self._last_change_count:
+            return
+
+        self._last_change_count = current_count
+
+        # Check for image data (PNG preferred, fallback to TIFF)
+        image_data = None
+        extension = ".png"
+
+        # Try PNG first
+        png_data = pasteboard.dataForType_(NSPasteboardTypePNG)
+        if png_data:
+            image_data = png_data
+            extension = ".png"
+        else:
+            # Try TIFF (screenshots are often TIFF on clipboard)
+            tiff_data = pasteboard.dataForType_(NSPasteboardTypeTIFF)
+            if tiff_data:
+                image_data = tiff_data
+                extension = ".tiff"
+
+        if not image_data:
+            return  # No image on clipboard
+
+        # Save to temp file
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        filename = f"clipboard_{timestamp}{extension}"
+        temp_path = CLIPBOARD_TEMP_DIR / filename
+
+        # Write the image data
+        image_data.writeToFile_atomically_(str(temp_path), True)
+
+        # Clear clipboard to prevent re-triggers
+        pasteboard.clearContents()
+
+        # Convert TIFF to PNG if needed (for consistency)
+        if extension == ".tiff":
+            png_path = temp_path.with_suffix(".png")
+            if self._convert_to_png(temp_path, png_path):
+                os.remove(temp_path)
+                temp_path = png_path
+
+        # Trigger callback
+        self._callback(str(temp_path))
+
+    def _convert_to_png(self, tiff_path: Path, png_path: Path) -> bool:
+        """Convert TIFF to PNG using CoreGraphics."""
+        try:
+            from Quartz import (
+                CGImageSourceCreateWithURL,
+                CGImageSourceCreateImageAtIndex,
+                CGImageDestinationCreateWithURL,
+                CGImageDestinationAddImage,
+                CGImageDestinationFinalize,
+                kCGImagePropertyOrientation,
+            )
+            from Foundation import NSURL
+
+            # Read TIFF
+            source_url = NSURL.fileURLWithPath_(str(tiff_path))
+            source = CGImageSourceCreateWithURL(source_url, None)
+            if not source:
+                return False
+
+            image = CGImageSourceCreateImageAtIndex(source, 0, None)
+            if not image:
+                return False
+
+            # Write PNG
+            dest_url = NSURL.fileURLWithPath_(str(png_path))
+            destination = CGImageDestinationCreateWithURL(dest_url, "public.png", 1, None)
+            if not destination:
+                return False
+
+            CGImageDestinationAddImage(destination, image, None)
+            return CGImageDestinationFinalize(destination)
+
+        except Exception:
+            return False

package/python/screenfix/config.py

@@ -0,0 +1,66 @@
+"""Configuration management for ScreenFix."""
+
+import os
+import json
+from pathlib import Path
+
+DEFAULT_CONFIG = {
+    "save_directory": "./screenfix/screenshots",
+    "tasks_file": "./screenfix/tasks/screenfix-tasks.md",
+}
+
+CONFIG_DIR = Path.home() / ".config" / "screenfix"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+class Config:
+    """Configuration manager for ScreenFix."""
+
+    def __init__(self):
+        self._config = DEFAULT_CONFIG.copy()
+        self._load()
+
+    def _load(self):
+        """Load configuration from file."""
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE, "r") as f:
+                    saved = json.load(f)
+                    self._config.update(saved)
+            except (json.JSONDecodeError, IOError):
+                pass
+
+    def save(self):
+        """Save configuration to file."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        with open(CONFIG_FILE, "w") as f:
+            json.dump(self._config, f, indent=2)
+
+    @property
+    def save_directory(self) -> str:
+        """Directory where screenshots are saved."""
+        return self._config["save_directory"]
+
+    @save_directory.setter
+    def save_directory(self, value: str):
+        self._config["save_directory"] = os.path.expanduser(value)
+        self.save()
+
+    @property
+    def tasks_file(self) -> str:
+        """Path to the tasks.md file."""
+        return self._config["tasks_file"]
+
+    @tasks_file.setter
+    def tasks_file(self, value: str):
+        self._config["tasks_file"] = os.path.expanduser(value)
+        self.save()
+
+    def ensure_directories(self):
+        """Ensure save and tasks directories exist."""
+        Path(self.save_directory).mkdir(parents=True, exist_ok=True)
+        Path(self.tasks_file).parent.mkdir(parents=True, exist_ok=True)
+
+
+# Global config instance
+config = Config()

package/python/screenfix/daemon.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""
+ScreenFix Daemon - Clipboard watcher for instant screenshot capture.
+
+Watches the clipboard for new images and shows annotation window instantly.
+Use Cmd+Ctrl+Shift+4 to capture screenshot to clipboard (no preview delay).
+
+Run with: python -m screenfix.daemon
+"""
+
+import json
+import os
+import queue
+import signal
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from AppKit import (
+    NSApplication,
+    NSApplicationActivationPolicyAccessory,
+    NSEventMaskAny,
+)
+from Foundation import NSDate, NSDefaultRunLoopMode
+
+from .config import config
+
+
+# State file for communication with MCP server
+STATE_FILE = Path.home() / ".config" / "screenfix" / "state.json"
+
+
+def update_state(listening: bool = None, last_capture: str = None):
+    """Update the state file for MCP server to read."""
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    state = {"pid": os.getpid(), "listening": False}
+
+    if STATE_FILE.exists():
+        try:
+            with open(STATE_FILE, "r") as f:
+                state = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    state["pid"] = os.getpid()
+    if listening is not None:
+        state["listening"] = listening
+    if last_capture is not None:
+        state["last_capture"] = last_capture
+        state["last_capture_time"] = datetime.now().isoformat()
+
+    with open(STATE_FILE, "w") as f:
+        json.dump(state, f, indent=2)
+
+
+def clear_state():
+    """Clear the state file on exit."""
+    if STATE_FILE.exists():
+        try:
+            os.remove(STATE_FILE)
+        except OSError:
+            pass
+
+
+class ScreenFixDaemon:
+    """Daemon that watches clipboard for screenshots."""
+
+    def __init__(self):
+        self._running = False
+        self._clipboard_watcher = None
+        self._app = None
+        self._main_thread_queue = queue.Queue()
+
+    def _on_clipboard_image(self, image_path: str):
+        """Called when a new image is detected on clipboard."""
+        print(f"Screenshot detected: {image_path}", file=sys.stderr)
+        self._main_thread_queue.put(image_path)
+
+    def _process_main_thread_queue(self):
+        """Process any pending work on the main thread."""
+        try:
+            while True:
+                image_path = self._main_thread_queue.get_nowait()
+                self._show_annotation(image_path)
+        except queue.Empty:
+            pass
+
+    def _show_annotation(self, image_path: str):
+        """Show the annotation window. Must be called from main thread."""
+        from .annotation_window import show_annotation_window
+        show_annotation_window(image_path)
+
+    def _setup_signal_handlers(self):
+        """Set up signal handlers for graceful shutdown."""
+        def handle_signal(signum, frame):
+            print(f"\nShutting down...", file=sys.stderr)
+            self.stop()
+
+        signal.signal(signal.SIGINT, handle_signal)
+        signal.signal(signal.SIGTERM, handle_signal)
+
+    def start(self):
+        """Start the daemon."""
+        if self._running:
+            return
+
+        self._running = True
+        config.ensure_directories()
+
+        # Initialize NSApplication for UI
+        self._app = NSApplication.sharedApplication()
+        self._app.setActivationPolicy_(NSApplicationActivationPolicyAccessory)
+        self._app.finishLaunching()
+
+        self._setup_signal_handlers()
+
+        print("ScreenFix daemon started", file=sys.stderr)
+        print(f"Screenshots will be saved to: {config.save_directory}", file=sys.stderr)
+        print(f"Tasks will be saved to: {config.tasks_file}", file=sys.stderr)
+        print("\nUse Cmd+Ctrl+Shift+4 to capture (INSTANT, no delay!)", file=sys.stderr)
+        print("Press Ctrl+C to stop.\n", file=sys.stderr)
+
+        # Start clipboard watcher
+        from .clipboard_watcher import ClipboardWatcher
+        self._clipboard_watcher = ClipboardWatcher(self._on_clipboard_image)
+        self._clipboard_watcher.start()
+
+        update_state(listening=True)
+
+        # Run the main loop
+        while self._running:
+            self._process_main_thread_queue()
+
+            while True:
+                event = self._app.nextEventMatchingMask_untilDate_inMode_dequeue_(
+                    NSEventMaskAny,
+                    NSDate.dateWithTimeIntervalSinceNow_(0.05),
+                    NSDefaultRunLoopMode,
+                    True
+                )
+                if event is None:
+                    break
+                self._app.sendEvent_(event)
+
+    def stop(self):
+        """Stop the daemon."""
+        self._running = False
+
+        if self._clipboard_watcher:
+            self._clipboard_watcher.stop()
+            self._clipboard_watcher = None
+
+        clear_state()
+
+        if self._app:
+            self._app.terminate_(None)
+
+
+def is_daemon_running() -> bool:
+    """Check if the daemon is already running."""
+    if not STATE_FILE.exists():
+        return False
+
+    try:
+        with open(STATE_FILE, "r") as f:
+            state = json.load(f)
+
+        pid = state.get("pid")
+        if pid:
+            try:
+                os.kill(pid, 0)
+                return True
+            except OSError:
+                clear_state()
+                return False
+    except (json.JSONDecodeError, IOError):
+        return False
+
+    return False
+
+
+def main():
+    """Main entry point."""
+    if is_daemon_running():
+        print("ScreenFix daemon is already running!", file=sys.stderr)
+        sys.exit(1)
+
+    daemon = ScreenFixDaemon()
+
+    try:
+        daemon.start()
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+    finally:
+        daemon.stop()
+
+
+if __name__ == "__main__":
+    main()