keystroke-sender 0.1.0__tar.gz

keystroke_sender-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,46 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install build dependencies
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

keystroke_sender-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+.env
+venv/
+.venv/
+keystroke_sender_wrapper.bat
+dist/
+build/
+*.egg-info/
+nul

keystroke_sender-0.1.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: keystroke-sender
+Version: 0.1.0
+Summary: Chrome Native Messaging host that simulates OS-level keystrokes and mouse clicks
+Project-URL: Repository, https://github.com/PropDream/keystroke-sender
+License-Expression: MIT
+Requires-Python: >=3.7
+Requires-Dist: pynput
+Description-Content-Type: text/markdown
+
+# Keystroke Sender
+
+A Chrome Native Messaging host that simulates OS-level keystrokes. Receives text strings from a Chrome extension and types them out as real key presses using `pynput`.
+
+Works on **macOS**, **Linux**, and **Windows**.
+
+Companion extension: [Chrome Form Filler](https://chromewebstore.google.com/detail/chrome-form-filler/dpdolkkncejkelemckjmjoaefmgdhepj) (`dpdolkkncejkelemckjmjoaefmgdhepj`)
+
+## Prerequisites
+
+- Python 3.7+
+- pip
+- Google Chrome
+- [Chrome Form Filler](https://chromewebstore.google.com/detail/chrome-form-filler/dpdolkkncejkelemckjmjoaefmgdhepj) extension
+
+## Installation
+
+### pip install (recommended)
+
+```bash
+pip install git+https://github.com/PropDream/keystroke-sender.git
+```
+
+Then register the Chrome native messaging host:
+
+```bash
+keystroke-sender-register YOUR_EXTENSION_ID
+```
+
+To unregister later:
+
+```bash
+keystroke-sender-register --unregister
+```
+
+### Manual install (macOS / Linux)
+
+```bash
+chmod +x install.sh
+./install.sh
+```
+
+### Manual install (Windows)
+
+```cmd
+install.bat
+```
+
+The manual installer will:
+1. Prompt you for your Chrome extension ID (find it at `chrome://extensions`)
+2. Create the native messaging host manifest in the correct OS location
+3. Install the `pynput` Python dependency
+
+### macOS Accessibility Permission
+
+On macOS, you must grant Accessibility permission to your terminal app (or Python) for keystroke simulation to work:
+
+**System Preferences > Privacy & Security > Accessibility** — add your terminal app (Terminal, iTerm2, etc.).
+
+## Usage
+
+From a Chrome extension, send a message to the native host:
+
+```javascript
+chrome.runtime.sendNativeMessage(
+  "com.propdream.keystroke_sender",
+  { text: "Hello, world!" },
+  (response) => {
+    console.log(response);
+    // { status: "ok", typed: 13 }
+  }
+);
+```
+
+### Message Format
+
+**Request:**
+```json
+{
+  "text": "string to type",
+  "delay": 0.05
+}
+```
+
+- `text` (required): The string to type as OS-level keystrokes.
+- `delay` (optional): Seconds between each keystroke. Default: `0.05`.
+
+**Response:**
+```json
+{ "status": "ok", "typed": 13 }
+```
+
+or on error:
+```json
+{ "status": "error", "message": "description" }
+```
+
+## Extension Setup
+
+Add `"nativeMessaging"` to your extension's `manifest.json` permissions:
+
+```json
+{
+  "permissions": ["nativeMessaging"]
+}
+```
+
+## Uninstallation
+
+### macOS / Linux
+
+```bash
+chmod +x uninstall.sh
+./uninstall.sh
+```
+
+### Windows
+
+```cmd
+uninstall.bat
+```
+
+## Security
+
+This app simulates real keystrokes and mouse clicks at the OS level, so it includes several safeguards to prevent misuse:
+
+**Chrome Native Messaging isolation** — The host process can *only* be launched by Chrome, and *only* the extension ID you registered in `allowed_origins` can send it messages. No network socket is opened; communication is purely via stdin/stdout. An unauthorized extension or external program cannot talk to it.
+
+**Idle timeout** — The host automatically exits after **1 minute** of inactivity. It does not stay running indefinitely.
+
+**Rate limiting** — A maximum of **100 actions per second** is enforced. Bursts beyond this are rejected with an error response.
+
+**Input size limits** — Messages larger than **1 MB** are rejected before parsing. Text payloads longer than **10,000 characters** are rejected before typing.
+
+| Limit | Default |
+|---|---|
+| Idle timeout | 60 s (1 min) |
+| Rate limit | 100 actions / 1 s |
+| Max message size | 1 MB |
+| Max text length | 10,000 chars |
+
+These constants are defined at the top of `src/keystroke_sender/host.py` and can be adjusted if needed.
+
+## Debugging
+
+- Launch Chrome from the terminal to see native host stderr output
+- Use `chrome://extensions` > Service Worker > Console to see extension-side errors
+- Check `chrome.runtime.lastError` in the `sendNativeMessage` callback

keystroke_sender-0.1.0/README.md

@@ -0,0 +1,148 @@
+# Keystroke Sender
+
+A Chrome Native Messaging host that simulates OS-level keystrokes. Receives text strings from a Chrome extension and types them out as real key presses using `pynput`.
+
+Works on **macOS**, **Linux**, and **Windows**.
+
+Companion extension: [Chrome Form Filler](https://chromewebstore.google.com/detail/chrome-form-filler/dpdolkkncejkelemckjmjoaefmgdhepj) (`dpdolkkncejkelemckjmjoaefmgdhepj`)
+
+## Prerequisites
+
+- Python 3.7+
+- pip
+- Google Chrome
+- [Chrome Form Filler](https://chromewebstore.google.com/detail/chrome-form-filler/dpdolkkncejkelemckjmjoaefmgdhepj) extension
+
+## Installation
+
+### pip install (recommended)
+
+```bash
+pip install git+https://github.com/PropDream/keystroke-sender.git
+```
+
+Then register the Chrome native messaging host:
+
+```bash
+keystroke-sender-register YOUR_EXTENSION_ID
+```
+
+To unregister later:
+
+```bash
+keystroke-sender-register --unregister
+```
+
+### Manual install (macOS / Linux)
+
+```bash
+chmod +x install.sh
+./install.sh
+```
+
+### Manual install (Windows)
+
+```cmd
+install.bat
+```
+
+The manual installer will:
+1. Prompt you for your Chrome extension ID (find it at `chrome://extensions`)
+2. Create the native messaging host manifest in the correct OS location
+3. Install the `pynput` Python dependency
+
+### macOS Accessibility Permission
+
+On macOS, you must grant Accessibility permission to your terminal app (or Python) for keystroke simulation to work:
+
+**System Preferences > Privacy & Security > Accessibility** — add your terminal app (Terminal, iTerm2, etc.).
+
+## Usage
+
+From a Chrome extension, send a message to the native host:
+
+```javascript
+chrome.runtime.sendNativeMessage(
+  "com.propdream.keystroke_sender",
+  { text: "Hello, world!" },
+  (response) => {
+    console.log(response);
+    // { status: "ok", typed: 13 }
+  }
+);
+```
+
+### Message Format
+
+**Request:**
+```json
+{
+  "text": "string to type",
+  "delay": 0.05
+}
+```
+
+- `text` (required): The string to type as OS-level keystrokes.
+- `delay` (optional): Seconds between each keystroke. Default: `0.05`.
+
+**Response:**
+```json
+{ "status": "ok", "typed": 13 }
+```
+
+or on error:
+```json
+{ "status": "error", "message": "description" }
+```
+
+## Extension Setup
+
+Add `"nativeMessaging"` to your extension's `manifest.json` permissions:
+
+```json
+{
+  "permissions": ["nativeMessaging"]
+}
+```
+
+## Uninstallation
+
+### macOS / Linux
+
+```bash
+chmod +x uninstall.sh
+./uninstall.sh
+```
+
+### Windows
+
+```cmd
+uninstall.bat
+```
+
+## Security
+
+This app simulates real keystrokes and mouse clicks at the OS level, so it includes several safeguards to prevent misuse:
+
+**Chrome Native Messaging isolation** — The host process can *only* be launched by Chrome, and *only* the extension ID you registered in `allowed_origins` can send it messages. No network socket is opened; communication is purely via stdin/stdout. An unauthorized extension or external program cannot talk to it.
+
+**Idle timeout** — The host automatically exits after **1 minute** of inactivity. It does not stay running indefinitely.
+
+**Rate limiting** — A maximum of **100 actions per second** is enforced. Bursts beyond this are rejected with an error response.
+
+**Input size limits** — Messages larger than **1 MB** are rejected before parsing. Text payloads longer than **10,000 characters** are rejected before typing.
+
+| Limit | Default |
+|---|---|
+| Idle timeout | 60 s (1 min) |
+| Rate limit | 100 actions / 1 s |
+| Max message size | 1 MB |
+| Max text length | 10,000 chars |
+
+These constants are defined at the top of `src/keystroke_sender/host.py` and can be adjusted if needed.
+
+## Debugging
+
+- Launch Chrome from the terminal to see native host stderr output
+- Use `chrome://extensions` > Service Worker > Console to see extension-side errors
+- Check `chrome.runtime.lastError` in the `sendNativeMessage` callback

keystroke_sender-0.1.0/install.bat

@@ -0,0 +1,53 @@
+@echo off
+REM install.bat — Install the Chrome Native Messaging host on Windows
+setlocal enabledelayedexpansion
+
+set HOST_NAME=com.propdream.keystroke_sender
+set SCRIPT_DIR=%~dp0
+set HOST_PATH=%SCRIPT_DIR%keystroke_sender_wrapper.bat
+
+REM Create the wrapper batch file that Chrome will execute
+echo @echo off > "%SCRIPT_DIR%keystroke_sender_wrapper.bat"
+echo python "%SCRIPT_DIR%keystroke_sender.py" %%* >> "%SCRIPT_DIR%keystroke_sender_wrapper.bat"
+
+REM Set manifest directory
+set TARGET_DIR=%LOCALAPPDATA%\Google\Chrome\User Data\NativeMessagingHosts
+
+REM Prompt for Chrome extension ID
+set /p EXTENSION_ID="Enter your Chrome extension ID (found at chrome://extensions): "
+
+if "%EXTENSION_ID%"=="" (
+    echo Error: Extension ID cannot be empty.
+    exit /b 1
+)
+
+REM Create target directory
+if not exist "%TARGET_DIR%" mkdir "%TARGET_DIR%"
+
+REM Write the native messaging host manifest
+(
+echo {
+echo   "name": "%HOST_NAME%",
+echo   "description": "Simulates OS-level keystrokes for Chrome Form Filler",
+echo   "path": "%HOST_PATH:\=\\%",
+echo   "type": "stdio",
+echo   "allowed_origins": [
+echo     "chrome-extension://%EXTENSION_ID%/"
+echo   ]
+echo }
+) > "%TARGET_DIR%\%HOST_NAME%.json"
+
+REM Add registry key (required on Windows)
+reg add "HKCU\Software\Google\Chrome\NativeMessagingHosts\%HOST_NAME%" /ve /t REG_SZ /d "%TARGET_DIR%\%HOST_NAME%.json" /f
+
+REM Install Python dependencies
+echo Installing Python dependencies...
+pip install -r "%SCRIPT_DIR%requirements.txt"
+
+echo.
+echo Native messaging host '%HOST_NAME%' installed successfully.
+echo   Manifest: %TARGET_DIR%\%HOST_NAME%.json
+echo   Host:     %HOST_PATH%
+echo   Registry: HKCU\Software\Google\Chrome\NativeMessagingHosts\%HOST_NAME%
+
+endlocal

keystroke_sender-0.1.0/install.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+# install.sh — Install the Chrome Native Messaging host on macOS or Linux
+set -e
+
+HOST_NAME="com.propdream.keystroke_sender"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+HOST_PATH="$SCRIPT_DIR/keystroke_sender.py"
+
+# Detect OS and set manifest directory
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    TARGET_DIR="$HOME/Library/Application Support/Google/Chrome/NativeMessagingHosts"
+elif [[ "$OSTYPE" == "linux"* ]]; then
+    TARGET_DIR="$HOME/.config/google-chrome/NativeMessagingHosts"
+else
+    echo "Unsupported OS: $OSTYPE"
+    echo "Use install.bat for Windows."
+    exit 1
+fi
+
+# Prompt for Chrome extension ID
+echo "Enter your Chrome extension ID (found at chrome://extensions):"
+read -r EXTENSION_ID
+
+if [ -z "$EXTENSION_ID" ]; then
+    echo "Error: Extension ID cannot be empty."
+    exit 1
+fi
+
+# Create target directory
+mkdir -p "$TARGET_DIR"
+
+# Write the native messaging host manifest
+cat > "$TARGET_DIR/$HOST_NAME.json" << EOF
+{
+  "name": "$HOST_NAME",
+  "description": "Simulates OS-level keystrokes for Chrome Form Filler",
+  "path": "$HOST_PATH",
+  "type": "stdio",
+  "allowed_origins": [
+    "chrome-extension://$EXTENSION_ID/"
+  ]
+}
+EOF
+
+# Make the host script executable
+chmod +x "$HOST_PATH"
+
+# Install Python dependencies
+echo "Installing Python dependencies..."
+pip3 install -r "$SCRIPT_DIR/requirements.txt"
+
+echo ""
+echo "Native messaging host '$HOST_NAME' installed successfully."
+echo "  Manifest: $TARGET_DIR/$HOST_NAME.json"
+echo "  Host:     $HOST_PATH"
+echo ""
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    echo "IMPORTANT: On macOS, you must grant Accessibility permission to your"
+    echo "terminal/Python in System Preferences > Privacy & Security > Accessibility."
+fi

keystroke_sender-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "keystroke-sender"
+version = "0.1.0"
+description = "Chrome Native Messaging host that simulates OS-level keystrokes and mouse clicks"
+readme = "README.md"
+requires-python = ">=3.7"
+license = "MIT"
+dependencies = ["pynput"]
+
+[project.scripts]
+keystroke-sender = "keystroke_sender.host:main"
+keystroke-sender-register = "keystroke_sender.register:main"
+
+[project.urls]
+Repository = "https://github.com/PropDream/keystroke-sender"

keystroke_sender-0.1.0/requirements.txt

@@ -0,0 +1 @@
+pynput

keystroke_sender-0.1.0/src/keystroke_sender/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

keystroke_sender-0.1.0/src/keystroke_sender/host.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Chrome Native Messaging host that simulates OS-level keystrokes and mouse clicks.
+
+Receives JSON messages from a Chrome extension via stdin and performs
+OS-level input simulation using pynput. Works on macOS, Linux, and Windows.
+
+Message protocol: 4-byte uint32 length prefix (native byte order) + UTF-8 JSON.
+
+Actions:
+  type:  {"action": "type", "text": "string to type", "delay": 0.05}
+         -> {"status": "ok", "typed": <count>}
+  click: {"action": "click", "x": 500, "y": 300}
+         -> {"status": "ok", "action": "click", "x": 500, "y": 300}
+
+Legacy (no action field): {"text": "..."} is treated as type action.
+Error response: {"status": "error", "message": "..."}
+"""
+
+import sys
+import os
+import json
+import struct
+import threading
+import time
+
+# Ensure unbuffered stdout (critical for native messaging protocol)
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(write_through=True)
+os.environ["PYTHONUNBUFFERED"] = "1"
+
+# --- Safety limits ---
+MAX_MESSAGE_BYTES = 1_048_576  # 1 MB — reject anything larger
+MAX_TEXT_LENGTH = 10_000       # max characters per type action
+IDLE_TIMEOUT_SECONDS = 60      # exit after 1 min with no messages
+RATE_LIMIT_WINDOW = 1.0        # rolling window in seconds
+RATE_LIMIT_MAX = 100           # max actions per window
+
+
+def log(text):
+    """Write debug output to stderr (never stdout)."""
+    sys.stderr.write(f"[keystroke-sender] {text}\n")
+    sys.stderr.flush()
+
+
+def read_message():
+    """Read a single native messaging message from stdin.
+
+    Raises ValueError if the message exceeds MAX_MESSAGE_BYTES.
+    """
+    raw_length = sys.stdin.buffer.read(4)
+    if len(raw_length) == 0:
+        # Chrome disconnected
+        sys.exit(0)
+    if len(raw_length) < 4:
+        log(f"Expected 4 bytes for length, got {len(raw_length)}")
+        sys.exit(1)
+    message_length = struct.unpack("@I", raw_length)[0]
+    if message_length > MAX_MESSAGE_BYTES:
+        log(f"Message too large: {message_length} bytes (limit {MAX_MESSAGE_BYTES})")
+        raise ValueError(f"Message exceeds {MAX_MESSAGE_BYTES} byte limit")
+    raw_message = sys.stdin.buffer.read(message_length)
+    if len(raw_message) < message_length:
+        log(f"Expected {message_length} bytes, got {len(raw_message)}")
+        sys.exit(1)
+    return json.loads(raw_message.decode("utf-8"))
+
+
+def send_message(message_obj):
+    """Send a single native messaging message to stdout."""
+    encoded = json.dumps(message_obj, separators=(",", ":")).encode("utf-8")
+    sys.stdout.buffer.write(struct.pack("@I", len(encoded)))
+    sys.stdout.buffer.write(encoded)
+    sys.stdout.buffer.flush()
+
+
+def type_text(text, delay=0.05):
+    """
+    Simulate OS-level keystrokes for the given text using pynput.
+
+    Args:
+        text: The string to type.
+        delay: Seconds to wait between each keystroke.
+
+    Returns:
+        The number of characters typed.
+    """
+    from pynput.keyboard import Controller
+
+    keyboard = Controller()
+    count = 0
+    for char in text:
+        keyboard.type(char)
+        count += 1
+        if delay > 0:
+            time.sleep(delay)
+    return count
+
+
+def click_at(x, y):
+    """
+    Simulate an OS-level left mouse click at the given screen coordinates.
+
+    Args:
+        x: Screen X coordinate (pixels from left edge).
+        y: Screen Y coordinate (pixels from top edge).
+    """
+    from pynput.mouse import Controller, Button
+
+    mouse = Controller()
+    mouse.position = (x, y)
+    time.sleep(0.05)  # brief pause after moving to ensure position is set
+    mouse.click(Button.left, 1)
+
+
+def _check_rate_limit(timestamps):
+    """Enforce a sliding-window rate limit. Returns True if the action is allowed."""
+    now = time.monotonic()
+    # Discard timestamps outside the window
+    while timestamps and timestamps[0] <= now - RATE_LIMIT_WINDOW:
+        timestamps.pop(0)
+    if len(timestamps) >= RATE_LIMIT_MAX:
+        return False
+    timestamps.append(now)
+    return True
+
+
+def _start_idle_watchdog(last_activity_ref):
+    """Background thread that exits the process after IDLE_TIMEOUT_SECONDS of inactivity."""
+    def watchdog():
+        while True:
+            elapsed = time.monotonic() - last_activity_ref[0]
+            remaining = IDLE_TIMEOUT_SECONDS - elapsed
+            if remaining <= 0:
+                log(f"Idle timeout ({IDLE_TIMEOUT_SECONDS}s) — exiting")
+                os._exit(0)  # hard exit from background thread
+            time.sleep(min(remaining, 10))
+    t = threading.Thread(target=watchdog, daemon=True)
+    t.start()
+
+
+def main():
+    log("Native messaging host started")
+    log(f"Platform: {sys.platform}")
+    log(f"Safety limits: idle_timeout={IDLE_TIMEOUT_SECONDS}s, "
+        f"rate_limit={RATE_LIMIT_MAX}/{RATE_LIMIT_WINDOW}s, "
+        f"max_text={MAX_TEXT_LENGTH}, max_msg={MAX_MESSAGE_BYTES}B")
+
+    action_timestamps = []  # for rate limiting
+    # Mutable ref so the watchdog thread can see updates
+    last_activity = [time.monotonic()]
+    _start_idle_watchdog(last_activity)
+
+    while True:
+        try:
+            message = read_message()
+        except ValueError as e:
+            # Message size exceeded
+            send_message({"status": "error", "message": str(e)})
+            continue
+
+        last_activity[0] = time.monotonic()
+
+        try:
+            log(f"Received: {message}")
+
+            # --- Rate limit ---
+            if not _check_rate_limit(action_timestamps):
+                log("Rate limit exceeded")
+                send_message({"status": "error", "message": f"Rate limit exceeded ({RATE_LIMIT_MAX} actions per {RATE_LIMIT_WINDOW}s)"})
+                continue
+
+            # Determine action: explicit "action" field, or default to "type" if "text" present
+            action = message.get("action")
+            if action is None:
+                if "text" in message:
+                    action = "type"
+                else:
+                    send_message({"status": "error", "message": "Missing 'action' field"})
+                    continue
+
+            if action == "type":
+                text = message.get("text")
+                if text is None:
+                    send_message({"status": "error", "message": "Missing 'text' field"})
+                    continue
+
+                if not isinstance(text, str):
+                    send_message({"status": "error", "message": "'text' must be a string"})
+                    continue
+
+                if len(text) > MAX_TEXT_LENGTH:
+                    send_message({"status": "error", "message": f"Text too long ({len(text)} chars, limit {MAX_TEXT_LENGTH})"})
+                    continue
+
+                if len(text) == 0:
+                    send_message({"status": "ok", "typed": 0})
+                    continue
+
+                delay = message.get("delay", 0.05)
+                typed = type_text(text, delay=delay)
+                log(f"Typed {typed} characters")
+                send_message({"status": "ok", "typed": typed})
+
+            elif action == "click":
+                x = message.get("x")
+                y = message.get("y")
+                if x is None or y is None:
+                    send_message({"status": "error", "message": "Missing 'x' or 'y' for click"})
+                    continue
+
+                x = int(x)
+                y = int(y)
+                click_at(x, y)
+                log(f"Clicked at ({x}, {y})")
+                send_message({"status": "ok", "action": "click", "x": x, "y": y})
+
+            else:
+                send_message({"status": "error", "message": f"Unknown action: {action}"})
+
+        except json.JSONDecodeError as e:
+            log(f"Invalid JSON: {e}")
+            send_message({"status": "error", "message": f"Invalid JSON: {e}"})
+        except Exception as e:
+            log(f"Error: {e}")
+            send_message({"status": "error", "message": str(e)})
+
+
+if __name__ == "__main__":
+    main()

keystroke_sender-0.1.0/src/keystroke_sender/register.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+Register (or unregister) the Chrome Native Messaging host manifest.
+
+Usage:
+  keystroke-sender-register <extension-id>
+  keystroke-sender-register --unregister
+"""
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+HOST_NAME = "com.propdream.keystroke_sender"
+
+
+def _manifest_dir():
+    """Return the platform-specific directory for Chrome native messaging manifests."""
+    if sys.platform == "darwin":
+        return os.path.expanduser(
+            "~/Library/Application Support/Google/Chrome/NativeMessagingHosts"
+        )
+    elif sys.platform == "linux":
+        return os.path.expanduser(
+            "~/.config/google-chrome/NativeMessagingHosts"
+        )
+    elif sys.platform == "win32":
+        return os.path.join(
+            os.environ.get("LOCALAPPDATA", ""),
+            "Google", "Chrome", "User Data", "NativeMessagingHosts",
+        )
+    else:
+        sys.exit(f"Unsupported platform: {sys.platform}")
+
+
+def _host_executable():
+    """Find the installed keystroke-sender console script."""
+    path = shutil.which("keystroke-sender")
+    if path is None:
+        sys.exit(
+            "Error: 'keystroke-sender' not found on PATH.\n"
+            "Install the package first: pip install keystroke-sender"
+        )
+    return os.path.abspath(path)
+
+
+def register(extension_id):
+    """Write the native messaging host manifest and (on Windows) the registry key."""
+    manifest_dir = _manifest_dir()
+    os.makedirs(manifest_dir, exist_ok=True)
+
+    host_path = _host_executable()
+
+    # On Windows, Chrome expects a .bat or .exe — the pip console_script is an .exe
+    manifest = {
+        "name": HOST_NAME,
+        "description": "Simulates OS-level keystrokes for Chrome Form Filler",
+        "path": host_path,
+        "type": "stdio",
+        "allowed_origins": [f"chrome-extension://{extension_id}/"],
+    }
+
+    manifest_path = os.path.join(manifest_dir, f"{HOST_NAME}.json")
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+
+    print(f"Manifest written to: {manifest_path}")
+    print(f"Host executable:     {host_path}")
+
+    # Windows requires a registry key pointing to the manifest
+    if sys.platform == "win32":
+        reg_key = rf"HKCU\Software\Google\Chrome\NativeMessagingHosts\{HOST_NAME}"
+        subprocess.run(
+            ["reg", "add", reg_key, "/ve", "/t", "REG_SZ", "/d", manifest_path, "/f"],
+            check=True,
+        )
+        print(f"Registry key:        {reg_key}")
+
+    print()
+    print(f"Native messaging host '{HOST_NAME}' registered successfully.")
+
+    if sys.platform == "darwin":
+        print()
+        print("IMPORTANT: On macOS, grant Accessibility permission to your")
+        print("terminal/Python in System Preferences > Privacy & Security > Accessibility.")
+
+
+def unregister():
+    """Remove the native messaging host manifest and (on Windows) the registry key."""
+    manifest_dir = _manifest_dir()
+    manifest_path = os.path.join(manifest_dir, f"{HOST_NAME}.json")
+
+    if os.path.exists(manifest_path):
+        os.remove(manifest_path)
+        print(f"Removed manifest: {manifest_path}")
+    else:
+        print(f"Manifest not found: {manifest_path}")
+
+    if sys.platform == "win32":
+        reg_key = rf"HKCU\Software\Google\Chrome\NativeMessagingHosts\{HOST_NAME}"
+        subprocess.run(
+            ["reg", "delete", reg_key, "/f"],
+            check=False,  # OK if key doesn't exist
+        )
+        print(f"Removed registry key: {reg_key}")
+
+    print(f"Native messaging host '{HOST_NAME}' unregistered.")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Register the keystroke-sender Chrome Native Messaging host."
+    )
+    parser.add_argument(
+        "extension_id",
+        nargs="?",
+        help="Chrome extension ID (find it at chrome://extensions)",
+    )
+    parser.add_argument(
+        "--unregister",
+        action="store_true",
+        help="Remove the native messaging host registration",
+    )
+    args = parser.parse_args()
+
+    if args.unregister:
+        unregister()
+    elif args.extension_id:
+        register(args.extension_id)
+    else:
+        # Interactive prompt
+        ext_id = input("Enter your Chrome extension ID (found at chrome://extensions): ").strip()
+        if not ext_id:
+            sys.exit("Error: Extension ID cannot be empty.")
+        register(ext_id)
+
+
+if __name__ == "__main__":
+    main()

keystroke_sender-0.1.0/uninstall.bat

@@ -0,0 +1,30 @@
+@echo off
+REM uninstall.bat — Remove the Chrome Native Messaging host on Windows
+setlocal
+
+set HOST_NAME=com.propdream.keystroke_sender
+set TARGET_DIR=%LOCALAPPDATA%\Google\Chrome\User Data\NativeMessagingHosts
+set SCRIPT_DIR=%~dp0
+
+REM Remove manifest file
+if exist "%TARGET_DIR%\%HOST_NAME%.json" (
+    del "%TARGET_DIR%\%HOST_NAME%.json"
+    echo Removed manifest: %TARGET_DIR%\%HOST_NAME%.json
+) else (
+    echo Manifest not found — nothing to remove.
+)
+
+REM Remove registry key
+reg delete "HKCU\Software\Google\Chrome\NativeMessagingHosts\%HOST_NAME%" /f 2>nul
+echo Removed registry key.
+
+REM Remove wrapper batch file
+if exist "%SCRIPT_DIR%keystroke_sender_wrapper.bat" (
+    del "%SCRIPT_DIR%keystroke_sender_wrapper.bat"
+    echo Removed wrapper script.
+)
+
+echo.
+echo Native messaging host '%HOST_NAME%' uninstalled.
+
+endlocal

keystroke_sender-0.1.0/uninstall.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+# uninstall.sh — Remove the Chrome Native Messaging host on macOS or Linux
+set -e
+
+HOST_NAME="com.propdream.keystroke_sender"
+
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    TARGET_DIR="$HOME/Library/Application Support/Google/Chrome/NativeMessagingHosts"
+elif [[ "$OSTYPE" == "linux"* ]]; then
+    TARGET_DIR="$HOME/.config/google-chrome/NativeMessagingHosts"
+else
+    echo "Unsupported OS: $OSTYPE"
+    exit 1
+fi
+
+MANIFEST="$TARGET_DIR/$HOST_NAME.json"
+
+if [ -f "$MANIFEST" ]; then
+    rm -f "$MANIFEST"
+    echo "Native messaging host '$HOST_NAME' uninstalled."
+    echo "  Removed: $MANIFEST"
+else
+    echo "Manifest not found at $MANIFEST — nothing to remove."
+fi