server.py

#!/usr/bin/env python3
"""
SnipMCP - Screenshot MCP Server

Provides a tool for Claude Code to fetch screenshots from the Desktop
using the #snip notation.
"""

import glob
import os
from pathlib import Path

from mcp.server.fastmcp import FastMCP, Image

# Initialize MCP server
mcp = FastMCP("snip")

# Desktop path - mounted from host
DESKTOP_PATH = os.environ.get("DESKTOP_PATH", "/desktop")
SCREENSHOT_PATTERN = "Screenshot*.png"


def get_screenshots_sorted() -> list[Path]:
    """Get all screenshots sorted by modification time (newest first)."""
    pattern = os.path.join(DESKTOP_PATH, SCREENSHOT_PATTERN)
    files = glob.glob(pattern)
    # Sort by modification time, newest first
    files.sort(key=lambda x: os.path.getmtime(x), reverse=True)
    return [Path(f) for f in files]


def read_image_bytes(filepath: Path) -> bytes:
    """Read an image file and return as bytes."""
    with open(filepath, "rb") as f:
        return f.read()


@mcp.tool()
def screenshot(index: str = "latest") -> list:
    """
    Fetch screenshot(s) from the Desktop.

    Args:
        index: Either "latest" for most recent, a single number like "0",
               or comma-separated indices like "0,1,2" for multiple screenshots.
               Index 0 is the oldest in the requested set.

    Returns:
        List of Image objects that Claude can view directly.
    """
    screenshots = get_screenshots_sorted()

    if not screenshots:
        return ["No screenshots found on Desktop"]

    if index == "latest":
        filepath = screenshots[0]
        image_bytes = read_image_bytes(filepath)
        return [
            f"Screenshot: {filepath.name}",
            Image(data=image_bytes, format="png")
        ]

    # Parse indices
    try:
        if "," in index:
            indices = [int(i.strip()) for i in index.split(",")]
        else:
            indices = [int(index)]
    except ValueError:
        return [f"Invalid index format: {index}"]

    # For multiple indices, we need to map them correctly
    # User's #snip0 = oldest of the set, #snipN = newest
    max_index = max(indices)
    count_needed = max_index + 1

    if count_needed > len(screenshots):
        return [f"Requested index {max_index} but only {len(screenshots)} screenshots available"]

    # Get the N most recent screenshots and reverse so index 0 = oldest of set
    relevant_screenshots = list(reversed(screenshots[:count_needed]))

    result = []
    for idx in sorted(indices):
        filepath = relevant_screenshots[idx]
        image_bytes = read_image_bytes(filepath)
        result.append(f"#snip{idx}: {filepath.name}")
        result.append(Image(data=image_bytes, format="png"))

    return result


@mcp.tool()
def list_screenshots(limit: int = 10) -> str:
    """
    List available screenshots on the Desktop.

    Args:
        limit: Maximum number of screenshots to list (default 10)

    Returns:
        List of screenshot filenames with their indices.
    """
    screenshots = get_screenshots_sorted()[:limit]

    if not screenshots:
        return "No screenshots found on Desktop"

    lines = [f"Found {len(screenshots)} screenshots:"]
    # Reverse so index 0 = oldest in the set
    for i, s in enumerate(reversed(screenshots)):
        lines.append(f"  #snip{i}: {s.name}")

    return "\n".join(lines)


@mcp.tool()
def health() -> str:
    """Check if the SnipMCP server is healthy and can access screenshots."""
    screenshots = get_screenshots_sorted()
    return f"Healthy. Desktop: {DESKTOP_PATH}, Screenshots available: {len(screenshots)}"


if __name__ == "__main__":
    import uvicorn
    # Get the SSE app and run with uvicorn for proper host binding
    app = mcp.sse_app()
    uvicorn.run(app, host="0.0.0.0", port=8000)