remote-pc-mcp 0.5.0__py3-none-any.whl

remote_pc_mcp/__init__.py

@@ -0,0 +1,17 @@
+"""remote-pc-mcp — expose a PC's capabilities as MCP tools over streamable HTTP."""
+
+import os
+from pathlib import Path
+
+__version__ = "0.5.0"
+
+
+def app_dir() -> Path:
+    """Directory for this server's .env, logs, and .state.
+
+    REMOTE_PC_MCP_HOME when set (the root shims set it to the repo root, so a
+    git clone keeps today's file locations exactly), else the working
+    directory — which the Startup shortcut and the systemd unit both pin to
+    the install directory.
+    """
+    return Path(os.environ.get("REMOTE_PC_MCP_HOME") or Path.cwd())

remote_pc_mcp/_logging.py

@@ -0,0 +1,45 @@
+"""Centralized logging setup for the server and its supervisor.
+
+One RotatingFileHandler writes to server.log for both this project's logger
+and uvicorn's. Importing and calling configure() is safe to do multiple times
+in the same process (logging.config.dictConfig replaces the prior config).
+"""
+
+import logging
+import logging.config
+
+from remote_pc_mcp import app_dir
+
+LOG_FILE = app_dir() / "server.log"
+
+LOG_CONFIG: dict = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "default": {"format": "%(asctime)s %(levelname)s %(name)s %(message)s"},
+    },
+    "handlers": {
+        "file": {
+            "class": "logging.handlers.RotatingFileHandler",
+            "filename": str(LOG_FILE),
+            "maxBytes": 10 * 1024 * 1024,
+            "backupCount": 5,
+            "encoding": "utf-8",
+            "formatter": "default",
+        },
+    },
+    "loggers": {
+        "remote-pc-mcp": {"handlers": ["file"], "level": "INFO", "propagate": False},
+        "uvicorn": {"handlers": ["file"], "level": "INFO", "propagate": False},
+        "uvicorn.error": {"handlers": ["file"], "level": "INFO", "propagate": False},
+        "uvicorn.access": {"handlers": ["file"], "level": "INFO", "propagate": False},
+    },
+}
+
+
+def configure() -> None:
+    logging.config.dictConfig(LOG_CONFIG)
+
+
+def get_logger(name: str = "remote-pc-mcp") -> logging.Logger:
+    return logging.getLogger(name)

remote_pc_mcp/daemon.py

@@ -0,0 +1,100 @@
+"""Supervisor: run the server and restart with exponential backoff on crash.
+
+Designed to be invoked via `pythonw daemon.py` (the repo-root shim) from a
+Startup-folder shortcut (see install.bat / install.sh), or as the
+`remote-pc-mcp-daemon` console script from a pip install. For an unsupervised
+foreground run, execute the server entry point directly.
+
+Logs to daemon.log (separate from server.log) so the supervisor's writes never
+contend with the server's RotatingFileHandler for the same file.
+"""
+
+import logging
+import logging.handlers
+import os
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+from remote_pc_mcp import app_dir
+
+_LOG_FILE = app_dir() / "daemon.log"
+
+# The server runs as `python -m remote_pc_mcp.server`. Prepending this
+# package's parent to PYTHONPATH makes that resolve in a plain git clone
+# (where nothing is pip-installed); in an installed environment the entry is
+# redundant but harmless.
+_PKG_PARENT = Path(__file__).resolve().parents[1]
+
+# Backoff after a crash: walk through this schedule, capped at the last value.
+# Reset to the first value after the server stays up for LONG_RUN_SECONDS.
+_BACKOFF_SCHEDULE = (5, 10, 20, 40, 60)
+_LONG_RUN_SECONDS = 300
+
+
+def _server_already_up() -> bool:
+    port = os.environ.get("REMOTE_PC_MCP_PORT", "8765")
+    try:
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=2):
+            return True
+    except Exception:
+        return False
+
+
+def _configure_logging() -> logging.Logger:
+    handler = logging.handlers.RotatingFileHandler(
+        _LOG_FILE, maxBytes=2 * 1024 * 1024, backupCount=3, encoding="utf-8"
+    )
+    handler.setFormatter(
+        logging.Formatter("%(asctime)s %(levelname)s daemon %(message)s")
+    )
+    logger = logging.getLogger("remote-pc-mcp.daemon")
+    logger.setLevel(logging.INFO)
+    logger.addHandler(handler)
+    return logger
+
+
+def main() -> int:
+    logger = _configure_logging()
+    if _server_already_up():
+        logger.info("server already healthy on configured port; daemon exiting")
+        return 0
+    logger.info("daemon starting (server=%s -m remote_pc_mcp.server)", sys.executable)
+    env = os.environ.copy()
+    env["PYTHONPATH"] = str(_PKG_PARENT) + os.pathsep + env.get("PYTHONPATH", "")
+    backoff_idx = 0
+    try:
+        while True:
+            started = time.monotonic()
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "remote_pc_mcp.server"], env=env
+                )
+            except FileNotFoundError:
+                logger.error("interpreter not found at %s; exiting", sys.executable)
+                return 1
+            uptime = time.monotonic() - started
+
+            if result.returncode == 0:
+                logger.info("server exited cleanly after %.1fs; stopping daemon", uptime)
+                return 0
+
+            if uptime >= _LONG_RUN_SECONDS:
+                backoff_idx = 0
+
+            delay = _BACKOFF_SCHEDULE[min(backoff_idx, len(_BACKOFF_SCHEDULE) - 1)]
+            logger.warning(
+                "server crashed (exit=%d, uptime=%.1fs); restarting in %ds",
+                result.returncode, uptime, delay,
+            )
+            time.sleep(delay)
+            backoff_idx += 1
+    except KeyboardInterrupt:
+        logger.info("daemon interrupted; exiting")
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

remote_pc_mcp/server.py

@@ -0,0 +1,699 @@
+#!/usr/bin/env python3
+"""
+remote-pc-mcp — expose a PC's capabilities as MCP tools over streamable HTTP.
+
+Tools: shell_exec, read_file, write_file, list_directory, system_info,
+       start_process, get_process_output, kill_process, download_file,
+       take_screenshot, click, move_mouse, type_text, press_key, scroll.
+"""
+
+# Set Windows event loop policy before any other asyncio import. ProactorEventLoop
+# crashes uvicorn on certain transient socket errors; SelectorEventLoop is stable.
+import platform
+import sys
+
+if platform.system() == "Windows":
+    import asyncio
+
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+from pathlib import Path
+
+import asyncio
+import base64
+import json
+import os
+import secrets
+import subprocess
+import tempfile
+import threading
+import time
+from datetime import datetime, timezone
+from typing import Optional
+
+from remote_pc_mcp import __version__, app_dir
+from remote_pc_mcp import _logging
+
+_logging.configure()
+
+import httpx
+import psutil
+import pyautogui
+import uvicorn
+from dotenv import load_dotenv
+from mcp.server.fastmcp import FastMCP
+from mcp.server.transport_security import TransportSecuritySettings
+from starlette.applications import Starlette
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+pyautogui.FAILSAFE = False  # disable corner-hit abort; we're driving remotely
+
+# .env lives in the app dir (repo root for a clone via the root shims'
+# REMOTE_PC_MCP_HOME; the working directory otherwise), not wherever
+# find_dotenv's frame-walk lands now that this module sits in a package.
+_APP_DIR = app_dir()
+load_dotenv(_APP_DIR / ".env")
+
+# ── Config ─────────────────────────────────────────────────────────────────
+
+_TOKEN = os.environ.get("REMOTE_PC_MCP_TOKEN", "")
+_HOST = os.getenv("REMOTE_PC_MCP_HOST", "0.0.0.0")
+_PORT = int(os.getenv("REMOTE_PC_MCP_PORT", "8765"))
+
+# Resource caps. Override via env when a host needs different limits.
+_MAX_SHELL_TIMEOUT = int(os.getenv("REMOTE_PC_MCP_MAX_SHELL_TIMEOUT", "600"))
+_MAX_READ_BYTES = int(os.getenv("REMOTE_PC_MCP_MAX_READ_BYTES", str(50 * 1024 * 1024)))
+_MAX_WRITE_BYTES = int(os.getenv("REMOTE_PC_MCP_MAX_WRITE_BYTES", str(50 * 1024 * 1024)))
+_MAX_DOWNLOAD_BYTES = int(os.getenv("REMOTE_PC_MCP_MAX_DOWNLOAD_BYTES", str(2 * 1024**3)))
+
+IS_WINDOWS = platform.system() == "Windows"
+_STATE_DIR = _APP_DIR / ".state"
+_STATE_DIR.mkdir(parents=True, exist_ok=True)
+_PROCS_FILE = _STATE_DIR / "procs.json"
+
+# ── Logging ────────────────────────────────────────────────────────────────
+
+logger = _logging.get_logger()
+
+
+# ── Error sanitization ─────────────────────────────────────────────────────
+
+
+def _build_redactions() -> list[tuple[str, str]]:
+    r = [(str(Path.home()), "~"), (str(_APP_DIR), "<server-dir>")]
+    if _TOKEN:
+        r.append((_TOKEN, "<token>"))
+    return r
+
+
+_REDACTIONS = _build_redactions()
+
+
+def _safe_msg(msg: str) -> str:
+    for src, dst in _REDACTIONS:
+        if src:
+            msg = msg.replace(src, dst)
+    return msg[:500]
+
+
+def _safe_error(e: Exception) -> str:
+    return _safe_msg(f"{type(e).__name__}: {e}")
+
+
+# ── Process registry (persists across restarts) ────────────────────────────
+
+_procs_lock = threading.Lock()
+
+
+def _load_procs() -> dict[int, dict]:
+    try:
+        return {int(k): v for k, v in json.loads(_PROCS_FILE.read_text()).items()}
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def _save_procs() -> None:
+    """Atomic write: serialize to <file>.tmp, then os.replace into place. A
+    power loss between the write and the replace leaves the previous registry
+    intact instead of half-written JSON that _load_procs would discard."""
+    try:
+        tmp = _PROCS_FILE.with_suffix(".tmp")
+        tmp.write_text(json.dumps({str(k): v for k, v in _procs.items()}))
+        tmp.replace(_PROCS_FILE)
+    except Exception as e:
+        logger.error("Failed to persist process registry: %s", _safe_error(e))
+
+
+def _gc_proc(pid: int) -> None:
+    """Drop a registry entry and delete its temp stdout/stderr files. Caller
+    must hold _procs_lock."""
+    info = _procs.pop(pid, None)
+    if not info:
+        return
+    for key in ("stdout_path", "stderr_path"):
+        path = info.get(key)
+        if path:
+            try:
+                Path(path).unlink(missing_ok=True)
+            except Exception:
+                pass
+
+
+def _gc_dead_procs() -> None:
+    """Drop registry entries whose PIDs are no longer running. Idempotent."""
+    with _procs_lock:
+        dead = []
+        for pid in list(_procs):
+            try:
+                p = psutil.Process(pid)
+                if not p.is_running() or p.status() == psutil.STATUS_ZOMBIE:
+                    dead.append(pid)
+            except psutil.NoSuchProcess:
+                dead.append(pid)
+        for pid in dead:
+            _gc_proc(pid)
+        if dead:
+            _save_procs()
+
+
+_procs: dict[int, dict] = _load_procs()
+
+
+# ── MCP server (stateless streamable HTTP) ─────────────────────────────────
+#
+# stateless_http=True means each request is self-contained: no in-memory
+# session_id cache to go stale on restart. json_response=True means responses
+# are single JSON payloads (not SSE event streams), so a client that POSTs and
+# walks away cannot leave a zombie stream behind. This is the fix for the
+# class of bugs where a server restart bricks the client.
+#
+# DNS-rebinding protection in the SDK rejects any Host header not in its
+# allowlist, which breaks legitimate access via Tailscale IPs and LAN hostnames.
+# This server is already protected by a 256-bit bearer token (constant-time
+# compared); DNS rebinding is the wrong threat model on a tailnet/LAN. We
+# default the protection OFF and let operators opt in by setting
+# REMOTE_PC_MCP_ALLOWED_HOSTS to a comma-separated list when they want it.
+
+_ALLOWED_HOSTS = [
+    h.strip() for h in os.getenv("REMOTE_PC_MCP_ALLOWED_HOSTS", "").split(",") if h.strip()
+]
+_TRANSPORT_SECURITY = TransportSecuritySettings(
+    enable_dns_rebinding_protection=bool(_ALLOWED_HOSTS),
+    allowed_hosts=_ALLOWED_HOSTS,
+    allowed_origins=_ALLOWED_HOSTS,
+)
+
+mcp = FastMCP(
+    "remote-pc-mcp",
+    stateless_http=True,
+    json_response=True,
+    transport_security=_TRANSPORT_SECURITY,
+)
+
+
+# ── Tools ───────────────────────────────────────────────────────────────────
+
+
+def _shell_exec_sync(command: str, capped_timeout: int, working_dir: Optional[str]) -> dict:
+    proc = subprocess.Popen(
+        command,
+        shell=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        cwd=working_dir,
+    )
+    try:
+        stdout, stderr = proc.communicate(timeout=capped_timeout)
+        return {"stdout": stdout, "stderr": stderr, "exit_code": proc.returncode, "timed_out": False}
+    except subprocess.TimeoutExpired:
+        _kill_process_tree(proc.pid)
+        try:
+            proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            pass
+        return {"stdout": "", "stderr": "Timed out", "exit_code": -1, "timed_out": True}
+    except Exception as e:
+        _kill_process_tree(proc.pid)
+        return {"stdout": "", "stderr": _safe_error(e), "exit_code": -1, "timed_out": False}
+
+
+@mcp.tool()
+async def shell_exec(
+    command: str,
+    timeout: int = 30,
+    working_dir: Optional[str] = None,
+) -> dict:
+    """Run a shell command. Returns stdout, stderr, exit_code.
+
+    timeout is capped at REMOTE_PC_MCP_MAX_SHELL_TIMEOUT (default 600s). The
+    blocking subprocess runs in a thread so /health and other tool calls keep
+    being served while a long command is in flight.
+    """
+    capped_timeout = min(max(1, timeout), _MAX_SHELL_TIMEOUT)
+    audit_cmd = command if len(command) <= 200 else command[:200] + "..."
+    logger.info("shell_exec timeout=%d cwd=%s cmd=%r", capped_timeout, working_dir, audit_cmd)
+    return await asyncio.to_thread(_shell_exec_sync, command, capped_timeout, working_dir)
+
+
+def _kill_process_tree(pid: int) -> None:
+    """Kill a process and all of its children. shell=True on Windows spawns
+    cmd.exe which spawns the real command; killing only the parent leaves the
+    grandchild alive."""
+    try:
+        parent = psutil.Process(pid)
+    except psutil.NoSuchProcess:
+        return
+    for child in parent.children(recursive=True):
+        try:
+            child.kill()
+        except psutil.NoSuchProcess:
+            pass
+    try:
+        parent.kill()
+    except psutil.NoSuchProcess:
+        pass
+
+
+@mcp.tool()
+def read_file(path: str, encoding: str = "utf-8") -> dict:
+    """Read a file as text, with base64 fallback for binary files.
+
+    Files larger than REMOTE_PC_MCP_MAX_READ_BYTES (default 50 MB) are rejected.
+    """
+    try:
+        p = Path(path)
+        if not p.exists():
+            return {"error": _safe_msg(f"Not found: {path}")}
+        size = p.stat().st_size
+        if size > _MAX_READ_BYTES:
+            return {"error": f"File too large ({size} bytes, max {_MAX_READ_BYTES})"}
+        try:
+            return {"content": p.read_text(encoding=encoding), "encoding": encoding, "size": size}
+        except UnicodeDecodeError:
+            return {
+                "content": base64.b64encode(p.read_bytes()).decode(),
+                "encoding": "base64",
+                "size": size,
+            }
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def write_file(
+    path: str, content: str, encoding: str = "utf-8", base64_encoded: bool = False
+) -> dict:
+    """Write content to a file. Set base64_encoded=True for binary data.
+
+    Content larger than REMOTE_PC_MCP_MAX_WRITE_BYTES (default 50 MB) is rejected.
+    """
+    try:
+        if base64_encoded:
+            data = base64.b64decode(content)
+            if len(data) > _MAX_WRITE_BYTES:
+                return {"error": f"Content too large ({len(data)} bytes, max {_MAX_WRITE_BYTES})"}
+            p = Path(path)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_bytes(data)
+        else:
+            encoded = content.encode(encoding)
+            if len(encoded) > _MAX_WRITE_BYTES:
+                return {
+                    "error": f"Content too large ({len(encoded)} bytes, max {_MAX_WRITE_BYTES})"
+                }
+            p = Path(path)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text(content, encoding=encoding)
+        return {"success": True, "path": str(p.resolve()), "size": p.stat().st_size}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def list_directory(path: str, recursive: bool = False) -> dict:
+    """List files and subdirectories at a path."""
+    try:
+        p = Path(path)
+        if not p.exists():
+            return {"error": _safe_msg(f"Not found: {path}")}
+        if not p.is_dir():
+            return {"error": _safe_msg(f"Not a directory: {path}")}
+        entries = []
+        items = p.rglob("*") if recursive else p.iterdir()
+        for item in sorted(items):
+            try:
+                st = item.stat()
+                entries.append(
+                    {
+                        "name": item.name,
+                        "path": str(item),
+                        "type": "dir" if item.is_dir() else "file",
+                        "size": st.st_size if item.is_file() else None,
+                        "modified": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                    }
+                )
+            except PermissionError:
+                pass
+        return {"path": str(p.resolve()), "count": len(entries), "entries": entries}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def system_info() -> dict:
+    """Return OS, CPU, RAM, and GPU (via nvidia-smi) information."""
+    vm = psutil.virtual_memory()
+    info = {
+        "hostname": platform.node(),
+        "os": platform.system(),
+        "os_version": platform.version(),
+        "architecture": platform.machine(),
+        "cpu_count_logical": psutil.cpu_count(),
+        "cpu_count_physical": psutil.cpu_count(logical=False),
+        "cpu_percent": psutil.cpu_percent(interval=1),
+        "ram_total_gb": round(vm.total / 1e9, 2),
+        "ram_used_gb": round(vm.used / 1e9, 2),
+        "ram_percent": vm.percent,
+        "gpu": [],
+        "server_version": __version__,
+    }
+    try:
+        r = subprocess.run(
+            [
+                "nvidia-smi",
+                "--query-gpu=name,memory.total,memory.used,utilization.gpu,temperature.gpu",
+                "--format=csv,noheader,nounits",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if r.returncode == 0:
+            for line in r.stdout.strip().splitlines():
+                parts = [x.strip() for x in line.split(",")]
+                if len(parts) == 5:
+                    info["gpu"].append(
+                        {
+                            "name": parts[0],
+                            "vram_total_mb": int(parts[1]),
+                            "vram_used_mb": int(parts[2]),
+                            "utilization_pct": int(parts[3]),
+                            "temp_c": int(parts[4]),
+                        }
+                    )
+    except Exception:
+        pass
+    return info
+
+
+@mcp.tool()
+def start_process(command: str, working_dir: Optional[str] = None) -> dict:
+    """Start a long-running command in the background. Returns PID to track it."""
+    try:
+        out = tempfile.NamedTemporaryFile(delete=False, suffix=".out.txt", mode="w")
+        err = tempfile.NamedTemporaryFile(delete=False, suffix=".err.txt", mode="w")
+        proc = subprocess.Popen(command, shell=True, stdout=out, stderr=err, cwd=working_dir)
+        out.close()
+        err.close()
+        with _procs_lock:
+            _procs[proc.pid] = {
+                "pid": proc.pid,
+                "command": command,
+                "stdout_path": out.name,
+                "stderr_path": err.name,
+                "started_at": datetime.now(timezone.utc).isoformat(),
+            }
+            _save_procs()
+        logger.info("start_process pid=%d cmd=%r", proc.pid, command[:200])
+        return {"pid": proc.pid, "command": command}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def get_process_output(pid: int, tail_lines: int = 100) -> dict:
+    """Get the latest stdout/stderr from a process started with start_process.
+
+    Reads output even after the process has exited (until the next call notices
+    it's dead and the temp files are reaped). After the reap, subsequent calls
+    return 'not tracked'.
+    """
+    if pid not in _procs:
+        return {"error": f"PID {pid} not tracked. Only processes started via start_process are tracked."}
+    info = _procs[pid]
+
+    def tail(fpath: str, n: int) -> str:
+        try:
+            lines = Path(fpath).read_text(errors="replace").splitlines()
+            return "\n".join(lines[-n:])
+        except Exception as ex:
+            return f"[error reading output: {_safe_error(ex)}]"
+
+    try:
+        proc = psutil.Process(pid)
+        running = proc.is_running() and proc.status() != psutil.STATUS_ZOMBIE
+    except psutil.NoSuchProcess:
+        running = False
+
+    result = {
+        "pid": pid,
+        "running": running,
+        "command": info["command"],
+        "started_at": info["started_at"],
+        "stdout": tail(info["stdout_path"], tail_lines),
+        "stderr": tail(info["stderr_path"], tail_lines),
+    }
+    # Reap on this call: once the caller has seen the final output of a dead
+    # process, drop the registry entry and the temp files so they don't leak
+    # for the lifetime of the server.
+    if not running:
+        with _procs_lock:
+            _gc_proc(pid)
+            _save_procs()
+    return result
+
+
+@mcp.tool()
+def kill_process(pid: int) -> dict:
+    """Terminate a running process by PID."""
+    try:
+        p = psutil.Process(pid)
+        p.terminate()
+        force = False
+        try:
+            p.wait(timeout=5)
+        except psutil.TimeoutExpired:
+            p.kill()
+            force = True
+        with _procs_lock:
+            _gc_proc(pid)
+            _save_procs()
+        logger.info("kill_process pid=%d force=%s", pid, force)
+        return {"pid": pid, "killed": True, "force_killed": force}
+    except psutil.NoSuchProcess:
+        with _procs_lock:
+            _gc_proc(pid)
+            _save_procs()
+        return {"error": f"No process with PID {pid}"}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+async def download_file(url: str, destination: str) -> dict:
+    """Download a file from a URL to a local path on this machine.
+
+    Downloads larger than REMOTE_PC_MCP_MAX_DOWNLOAD_BYTES (default 2 GB) are aborted.
+    """
+    try:
+        dest = Path(destination)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        downloaded = 0
+        async with httpx.AsyncClient(follow_redirects=True, timeout=600) as client:
+            async with client.stream("GET", url) as resp:
+                resp.raise_for_status()
+                with open(dest, "wb") as f:
+                    async for chunk in resp.aiter_bytes(8192):
+                        downloaded += len(chunk)
+                        if downloaded > _MAX_DOWNLOAD_BYTES:
+                            f.close()
+                            dest.unlink(missing_ok=True)
+                            return {"error": f"Download exceeded {_MAX_DOWNLOAD_BYTES} bytes; aborted"}
+                        f.write(chunk)
+        return {"success": True, "path": str(dest.resolve()), "size": dest.stat().st_size}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def take_screenshot(save_path: Optional[str] = None) -> dict:
+    """Capture the primary display. Returns base64-encoded PNG.
+
+    Requires an interactive desktop session on Windows; pyautogui-driven tools
+    cannot reach a Session 0 (service-context) desktop.
+    """
+    if save_path is None:
+        save_path = str(
+            Path(tempfile.gettempdir())
+            / f"screenshot_{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.png"
+        )
+
+    if IS_WINDOWS:
+        ps = f"""
+Add-Type -AssemblyName System.Windows.Forms,System.Drawing
+$s = [System.Windows.Forms.SystemInformation]::VirtualScreen
+$b = New-Object System.Drawing.Bitmap($s.Width, $s.Height)
+$g = [System.Drawing.Graphics]::FromImage($b)
+$g.CopyFromScreen($s.Left, $s.Top, 0, 0, $b.Size)
+$b.Save('{save_path}')
+$g.Dispose(); $b.Dispose()
+"""
+        r = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", ps],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if r.returncode != 0:
+            return {"error": _safe_error(RuntimeError(r.stderr.strip()))}
+    else:
+        taken = False
+        for cmd in [
+            f"scrot '{save_path}'",
+            f"gnome-screenshot -f '{save_path}'",
+            f"import -window root '{save_path}'",
+        ]:
+            r = subprocess.run(cmd, shell=True, capture_output=True, timeout=10)
+            if r.returncode == 0:
+                taken = True
+                break
+        if not taken:
+            return {"error": "No screenshot tool found. On Linux install scrot: sudo apt install scrot"}
+
+    data = base64.b64encode(Path(save_path).read_bytes()).decode()
+    return {"success": True, "path": save_path, "image_base64": data, "format": "png"}
+
+
+# ── UI control (pyautogui) ──────────────────────────────────────────────────
+#
+# These require an interactive desktop session — they cannot drive a locked
+# screen or a service-context (Session 0) Windows process.
+
+
+@mcp.tool()
+def click(x: int, y: int, button: str = "left", clicks: int = 1) -> dict:
+    """Click at screen coordinates (x, y). button = 'left' | 'right' | 'middle'."""
+    try:
+        pyautogui.click(x=x, y=y, clicks=clicks, button=button)
+        return {"success": True, "x": x, "y": y, "button": button, "clicks": clicks}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def move_mouse(x: int, y: int, duration: float = 0.0) -> dict:
+    """Move the cursor to (x, y). duration > 0 animates the movement."""
+    try:
+        pyautogui.moveTo(x=x, y=y, duration=duration)
+        return {"success": True, "x": x, "y": y}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def type_text(text: str, interval: float = 0.0) -> dict:
+    """Type a string into the focused window. interval = seconds between keys."""
+    try:
+        pyautogui.typewrite(text, interval=interval)
+        return {"success": True, "length": len(text)}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def press_key(key: str) -> dict:
+    """Press a single key or hotkey combo. Examples: 'enter', 'f11', 'ctrl+c', 'win+d'."""
+    try:
+        if "+" in key:
+            pyautogui.hotkey(*[k.strip() for k in key.split("+")])
+        else:
+            pyautogui.press(key)
+        return {"success": True, "key": key}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+@mcp.tool()
+def scroll(amount: int, x: Optional[int] = None, y: Optional[int] = None) -> dict:
+    """Scroll the mouse wheel. Positive = up, negative = down. Optional (x, y) anchors at coords."""
+    try:
+        if x is not None and y is not None:
+            pyautogui.moveTo(x, y)
+        pyautogui.scroll(amount)
+        return {"success": True, "amount": amount}
+    except Exception as e:
+        return {"error": _safe_error(e)}
+
+
+# ── Auth middleware ─────────────────────────────────────────────────────────
+
+
+class _AuthMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        if request.url.path == "/health":
+            return await call_next(request)
+        auth = request.headers.get("authorization", "")
+        if not auth.startswith("Bearer "):
+            return JSONResponse({"error": "Unauthorized"}, status_code=401)
+        if not secrets.compare_digest(auth[7:].encode(), _TOKEN.encode()):
+            return JSONResponse({"error": "Unauthorized"}, status_code=401)
+        return await call_next(request)
+
+
+# ── Starlette app (streamable HTTP transport) ──────────────────────────────
+
+
+async def _health(_request: Request) -> JSONResponse:
+    return JSONResponse(
+        {"status": "ok", "server": "remote-pc-mcp", "version": __version__}
+    )
+
+
+def _build_app() -> Starlette:
+    app: Starlette = mcp.streamable_http_app()
+    app.routes.insert(0, Route("/health", endpoint=_health))
+    app.add_middleware(_AuthMiddleware)
+    return app
+
+
+# ── Entry point ─────────────────────────────────────────────────────────────
+
+
+def main() -> None:
+    if not _TOKEN:
+        sys.exit("ERROR: REMOTE_PC_MCP_TOKEN not set. Copy .env.example → .env and fill it in.")
+
+    # Reap registry entries whose PIDs died while we were down. Without this,
+    # background processes that the user never explicitly killed accumulate in
+    # the registry across server restarts and leak their temp stdout/stderr
+    # files in %TEMP%.
+    _gc_dead_procs()
+
+    logger.info("remote-pc-mcp v%s starting on %s:%d", __version__, _HOST, _PORT)
+
+    # log_config=None preserves our dictConfig setup; uvicorn's default would
+    # overwrite it and route its loggers back to stderr (which is hollow under
+    # pythonw on Python 3.10+).
+    config = uvicorn.Config(
+        _build_app(), host=_HOST, port=_PORT, log_config=None
+    )
+    # Wrap the uvicorn server so a transient OSError on accept() (e.g. when the
+    # Tailscale interface briefly loses its bound IP during a network change)
+    # doesn't permanently kill the listener. Back off exponentially so a
+    # permanent OSError (interface gone for real) doesn't spin at 2s forever
+    # and flood the log; the schedule resets after a long-running success.
+    _REBIND_BACKOFF = (2, 5, 10, 30, 60)
+    _REBIND_LONG_RUN_SECONDS = 300
+    backoff_idx = 0
+    while True:
+        started = time.monotonic()
+        server = uvicorn.Server(config)
+        try:
+            server.run()
+            break
+        except OSError as e:
+            uptime = time.monotonic() - started
+            if uptime >= _REBIND_LONG_RUN_SECONDS:
+                backoff_idx = 0
+            delay = _REBIND_BACKOFF[min(backoff_idx, len(_REBIND_BACKOFF) - 1)]
+            logger.error("Listener died (%s); rebinding in %ds", _safe_error(e), delay)
+            time.sleep(delay)
+            backoff_idx += 1
+
+
+if __name__ == "__main__":
+    main()

remote_pc_mcp-0.5.0.dist-info/METADATA

@@ -0,0 +1,331 @@
+Metadata-Version: 2.4
+Name: remote-pc-mcp
+Version: 0.5.0
+Summary: Expose any PC's capabilities - shell, filesystem, background processes, system stats, screenshots, UI control, and file transfer - to any MCP client over streamable HTTP.
+Author: Raghib Murt
+License: MIT License
+        
+        Copyright (c) 2026 Raghib Murt
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/raghibrm/remote-pc-mcp
+Project-URL: Repository, https://github.com/raghibrm/remote-pc-mcp
+Project-URL: Changelog, https://github.com/raghibrm/remote-pc-mcp/blob/main/CHANGELOG.md
+Keywords: mcp,model-context-protocol,remote-control,automation,tailscale
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.10.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: starlette>=0.40.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: pyautogui>=0.9.54
+Requires-Dist: pillow>=10.0.0
+Dynamic: license-file
+
+# remote-pc-mcp
+
+Expose any PC's capabilities — shell, filesystem, background processes, system stats, screenshots, UI control, and file transfer — to **any MCP client** (Claude Desktop, Claude Code, Cursor, Cline, Continue, Windsurf, custom agents — anything that speaks the [Model Context Protocol](https://modelcontextprotocol.io)) over streamable HTTP.
+
+Drop it on any machine you want to drive remotely: a home server, a desktop, a build/CI box, a media server, a workstation, a Raspberry Pi. From a separate machine, your AI agent of choice can run commands on it, manage files, launch and monitor background jobs, take screenshots, and drive the desktop UI.
+
+The transport is the `mcp` SDK's streamable HTTP (`stateless_http=True`), so a server restart does not break already-connected clients. Each request is self-contained — there is no in-memory session to go stale.
+
+> ⚠️ **`shell_exec` runs arbitrary commands on the host as the user that started the server.** The bearer token is a root-equivalent credential. See [Security](#security) before exposing the server.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `shell_exec` | Run any shell command — returns stdout, stderr, exit code |
+| `read_file` | Read a file as text or base64 (binary fallback) |
+| `write_file` | Write text or binary content to a file |
+| `list_directory` | List files and directories, optionally recursive |
+| `system_info` | OS, CPU, RAM, and GPU stats (NVIDIA GPUs via `nvidia-smi`; absent on non-GPU hosts) |
+| `start_process` | Start a long-running command in the background — returns a PID |
+| `get_process_output` | Poll stdout/stderr of a background process by PID |
+| `kill_process` | Terminate a process by PID |
+| `download_file` | Download a URL directly to this machine |
+| `take_screenshot` | Capture the primary display — returns base64-encoded PNG |
+| `click` | Click at screen coordinates `(x, y)` — left / right / middle, single or multi-click |
+| `move_mouse` | Move cursor to `(x, y)`, optionally animated |
+| `type_text` | Type a string into the focused window |
+| `press_key` | Press a single key or hotkey combo (e.g. `enter`, `f11`, `ctrl+c`, `win+d`) |
+| `scroll` | Scroll the mouse wheel up or down, optionally at a specific point |
+
+## Requirements
+
+- Python 3.10+
+- Windows 10/11, or Linux with systemd (for autostart)
+
+## Install
+
+On the machine you want to control:
+
+```bash
+git clone https://github.com/raghibrm/remote-pc-mcp
+cd remote-pc-mcp
+cp .env.example .env
+```
+
+Set a strong token in `.env`:
+
+```
+REMOTE_PC_MCP_TOKEN=your-long-random-token-here
+```
+
+Generate one:
+
+```bash
+# Windows
+python -c "import secrets; print(secrets.token_hex(32))"
+
+# Linux / macOS
+openssl rand -hex 32
+```
+
+Then run the installer:
+
+```bash
+# Windows
+install.bat
+
+# Linux
+chmod +x install.sh
+./install.sh
+```
+
+That's it — one command. The installer:
+
+- installs Python dependencies
+- registers the server to launch hidden on every login (Startup-folder shortcut on Windows, systemd user unit on Linux)
+- starts it now
+- supervises it with exponential backoff on crash (5→10→20→40→60 seconds, resets after 5 minutes of uptime)
+- survives reboots — set once, runs forever
+
+### Verify it's up
+
+```bash
+curl http://localhost:8765/health
+# {"status":"ok","server":"remote-pc-mcp","version":"0.5.0"}
+```
+
+### When to rerun the installer
+
+`install.bat` / `install.sh` are idempotent and self-healing. Rerun any time after:
+
+- You **move the repo** to a different folder
+- You **reinstall or upgrade Python** to a different path
+- You **rebuild the machine** and want to restore autostart
+
+For day-to-day operation you never need to think about it.
+
+### After a reboot
+
+Autostart fires when you **sign in** to Windows. A reboot that sits at the lock screen will NOT start the daemon until somebody logs in. This is intentional — enabling Windows auto-logon to make reboots fully hands-off would let anyone with physical access to the machine get a logged-in desktop, which is the wrong trade-off for a remote-control tool.
+
+If you need to bring the daemon back up after a reboot without walking to the PC, sign in remotely via Remote Desktop or Tailscale SSH. Once you're logged in, the Startup shortcut fires and the daemon starts.
+
+Linux is different: `install.sh --linger` runs `sudo loginctl enable-linger $USER` so the systemd user unit runs across reboots without any logon. systemd's user services don't share the auto-logon security problem because they don't grant interactive desktop access — they just keep your user-scoped daemons alive.
+
+### Uninstall
+
+```bash
+# Windows
+install.bat --uninstall
+
+# Linux
+./install.sh --uninstall
+```
+
+Removes the autostart entry and stops the running server + supervisor.
+
+### Foreground run (development)
+
+For a one-off run with visible console output and no autostart:
+
+```bash
+python server.py
+```
+
+That's it — no special script. Use `install.bat` / `install.sh` for the normal supervised setup.
+
+### Or install from PyPI
+
+```bash
+pip install remote-pc-mcp
+remote-pc-mcp          # run the server in the foreground
+remote-pc-mcp-daemon   # supervised: restarts the server on crash
+```
+
+A pip install gives you the server and supervisor commands but does not register autostart. For autostart on sign-in, use the clone and install-script path above. `.env`, logs, and `.state/` live in `REMOTE_PC_MCP_HOME` (default: the working directory).
+
+## Adding to your MCP client
+
+Most MCP clients use the same JSON schema; the file just lives in different places. Example:
+
+```json
+{
+  "mcpServers": {
+    "remote-pc": {
+      "type": "http",
+      "url": "http://YOUR_PC_IP_OR_HOSTNAME:8765/mcp",
+      "headers": {
+        "Authorization": "Bearer your-long-random-token-here"
+      }
+    }
+  }
+}
+```
+
+Where to put it:
+
+| Client | Config file |
+|--------|-------------|
+| Claude Code | `.mcp.json` in the project root (or `~/.claude.json` for user-wide) |
+| Claude Desktop | `claude_desktop_config.json` (Settings → Developer → Edit Config) |
+| Cursor | `.cursor/mcp.json` |
+| Cline / Continue / Windsurf | each has its own MCP servers panel — paste the JSON there |
+| Custom agents | wherever your agent reads MCP server definitions |
+
+For Tailscale users, the magic-DNS hostname works in the URL:
+
+```json
+"url": "http://your-pc.tail12345.ts.net:8765/mcp"
+```
+
+Restart (or reload) your client. The tools appear automatically. The `"remote-pc"` key is just a label — pick whatever name you want.
+
+## Security
+
+`shell_exec` runs **any command** on the host as the user that started the server. That is intentional — it is what makes the server useful for remote-driving a PC. It also means:
+
+- **The bearer token is a root-equivalent credential.** Generate a 32-byte hex token, store it only in `.env` (which is git-ignored), and treat it like a password.
+- **Never expose the server to the public internet** without TLS and a reverse proxy (nginx, Caddy, Cloudflare Tunnel).
+- **Use Tailscale** (strongly recommended): bind to your Tailscale IP (set `REMOTE_PC_MCP_HOST=100.x.x.x` in `.env`) so the listener is only reachable from devices in your tailnet.
+- **LAN-only deployments** with `REMOTE_PC_MCP_HOST=0.0.0.0` are reasonable if you trust every device on the LAN and have a strong token. Don't do this on an untrusted network.
+
+The token is compared with `secrets.compare_digest` (constant-time). All error messages pass through a sanitiser that strips absolute paths, the home directory, and the token before being returned to clients.
+
+## Configuration
+
+All env vars are optional except `REMOTE_PC_MCP_TOKEN`.
+
+| Var | Default | Description |
+|-----|---------|-------------|
+| `REMOTE_PC_MCP_TOKEN` | _(required)_ | Bearer token clients must present |
+| `REMOTE_PC_MCP_HOST` | `0.0.0.0` | Bind address. Set to a Tailscale IP to restrict reach |
+| `REMOTE_PC_MCP_PORT` | `8765` | Listen port |
+| `REMOTE_PC_MCP_ALLOWED_HOSTS` | _(empty)_ | Comma-separated allowlist for DNS-rebinding protection. Empty disables it (default — wrong threat model on a tailnet) |
+| `REMOTE_PC_MCP_MAX_SHELL_TIMEOUT` | `600` (s) | Cap on per-call `shell_exec` timeout |
+| `REMOTE_PC_MCP_MAX_READ_BYTES` | 50 MB | `read_file` upper limit |
+| `REMOTE_PC_MCP_MAX_WRITE_BYTES` | 50 MB | `write_file` upper limit |
+| `REMOTE_PC_MCP_MAX_DOWNLOAD_BYTES` | 2 GB | `download_file` upper limit |
+
+After changing `.env`, restart the server so the new value takes effect:
+
+```bash
+# Windows: easiest path is just re-run the installer (idempotent)
+install.bat --uninstall && install.bat
+
+# Linux
+systemctl --user restart remote-pc-mcp
+```
+
+## Logs and troubleshooting
+
+Two log files in the repo root, both rotated automatically:
+
+| File | What's in it | Rotation |
+|------|--------------|----------|
+| `server.log` | App events + uvicorn startup/access logs | 10 MB × 5 |
+| `daemon.log` | Supervisor events (crashes, restarts, backoff) | 2 MB × 3 |
+
+**Server isn't responding?**
+
+```bash
+# Is the listener up locally?
+curl http://localhost:8765/health
+
+# What's the supervisor seeing?
+tail -f daemon.log
+
+# Linux: full journal
+journalctl --user -u remote-pc-mcp -f
+
+# Windows: is the autostart registered?
+explorer shell:startup    # look for remote-pc-mcp.lnk
+```
+
+**MCP client says tools are missing after a server restart?**
+
+The streamable HTTP transport is designed so a restart does not brick clients, but the client still has to issue a request to notice the new server. First fix: invoke any tool from this server (e.g. ask your agent to run `system_info`) — the client will retry the connection. If that fails, reconnect the MCP server in your client (Claude Code: `/mcp` ; Cursor: refresh in MCP panel) or restart the client.
+
+**Stuck process / port already in use?**
+
+```bash
+# Windows
+install.bat --uninstall && install.bat
+
+# Linux
+./install.sh --uninstall && ./install.sh
+```
+
+## UI-driving tools
+
+`take_screenshot`, `click`, `move_mouse`, `type_text`, `press_key`, and `scroll` require an **interactive desktop session**:
+
+- **Windows**: a user must be logged in and the screen unlocked. A service running under Session 0 cannot reach the desktop. The Startup-folder install gives you exactly this — the daemon runs in your user session.
+- **Linux**: needs an X11 or Wayland session. For screenshots specifically, install `scrot`, `gnome-screenshot`, or ImageMagick's `import` — `sudo apt install scrot` is the easiest.
+
+## Development
+
+Project layout:
+
+| File | Purpose |
+|------|---------|
+| `server.py` | The MCP server — tools, auth, transport |
+| `daemon.py` | Supervisor — spawns server, restarts on crash with backoff |
+| `_logging.py` | Shared logging config — one handler for app + uvicorn loggers |
+| `install.{bat,sh}` | Single entry point: default installs, `--uninstall` removes |
+
+### Tests
+
+A self-contained test suite under `tests/` launches its own isolated server on a high port with an ephemeral token, exercises every tool, and verifies that a mid-run server restart does not lock the client out. It does **not** touch the production server you have running.
+
+```bash
+pip install -r requirements-dev.txt
+python -m pytest tests/ -v
+```
+
+## License
+
+MIT
+
+<!-- mcp-name: io.github.raghibrm/remote-pc-mcp -->

remote_pc_mcp-0.5.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+remote_pc_mcp/__init__.py,sha256=kjFeUKi0GgeoBLqkM_HJF28ciNmdCS2CE42VsZpclLw,559
+remote_pc_mcp/_logging.py,sha256=bAaYPuEDv7RGBUHbuN9BcObsPYiXuATAj_4nBxLSpGw,1424
+remote_pc_mcp/daemon.py,sha256=ktd6vS6n9frjhVCgninZYWX-WsC4MXvbIynO1mSTG98,3415
+remote_pc_mcp/server.py,sha256=Rndry9utOYQfl1QTSCecjYSsrtsUThj11D-oHMZrTKQ,25758
+remote_pc_mcp-0.5.0.dist-info/licenses/LICENSE,sha256=BvQ-76P3GAlZPL7B0UPVz_HtiyJJGvLaylVWvruegdk,1068
+remote_pc_mcp-0.5.0.dist-info/METADATA,sha256=R1ed_Rc9hRoGp0Ydk2mCQ16h66mTNHYuf_Cqcwu2K3E,13721
+remote_pc_mcp-0.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+remote_pc_mcp-0.5.0.dist-info/entry_points.txt,sha256=-GruXC6iqGnpzkIArg6FiFfXyDAlqokbhsiPXyqnUc0,109
+remote_pc_mcp-0.5.0.dist-info/top_level.txt,sha256=Lgxuudm9ccsOtUmGCHFJ-KxkSkKdH9uZ_s27G0NI_lE,14
+remote_pc_mcp-0.5.0.dist-info/RECORD,,

remote_pc_mcp-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

remote_pc_mcp-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+remote-pc-mcp = remote_pc_mcp.server:main
+remote-pc-mcp-daemon = remote_pc_mcp.daemon:main

remote_pc_mcp-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Raghib Murt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

remote_pc_mcp-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+remote_pc_mcp