runtfy 0.1.0__tar.gz

runtfy-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+
+"on":
+  push:
+  pull_request:
+
+
+jobs:
+  test:
+    name: Test (Python ${{ matrix.python-version }} / ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run test suite
+        run: |
+          python -m pytest tests/ -v

runtfy-0.1.0/.gitignore

@@ -0,0 +1,35 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Testing & coverage
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Local configs and secrets
+.env
+.env.*
+config.toml
+*.local
+
+# Editor directories
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db

runtfy-0.1.0/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-10-30
+
+- Package scaffolding configured with `hatchling` build system, Python >= 3.10 support, and CLI entrypoint.
+- Pseudo-terminal (PTY) runner (`runtfy/wrapper.py`) supporting transparent stdin, stdout, and stderr passthrough with exact exit code propagation.
+- Configuration manager (`runtfy/config.py`) loading settings from `~/.config/runtfy/config.toml` with owner-only (`0o600`) permissions and fallback defaults.
+- `runtfy init` subcommand generating cryptographically random topics and writing owner-only configuration files.
+- Resilient notification sender (`runtfy/notifier.py`) targeting ntfy via standard library `urllib.request` with 5-second timeout, quiet-hours suppression, event toggles, and strict topic sanitization.
+- Finish notification integration delivering command completion alerts with program basename, elapsed duration, exit status, and opt-in truncated output summaries.
+- Claude Code hook installer (`runtfy install-hooks`) supporting unified diff previews, automatic timestamped backups, and idempotent hook registration.
+- Claude Code lifecycle handlers (`runtfy hook-stop` and `runtfy hook-notify`) providing completion summaries and user input alerts without blocking agent execution.
+- Opt-in `--lock-when-away` mode on macOS utilizing native `pmset displaysleepnow` and `IOHIDSystem` input event monitoring with an enforced 60-second cooldown.
+- Opt-in `--lock-when-away` session locking on Linux via `loginctl`, `xdg-screensaver`, and `gnome-screensaver-command` fallbacks.
+- Comprehensive manual verification checklist (`LOCK_CHECKLIST.md`) for macOS and Linux lock modes.

runtfy-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,64 @@
+# Contributing to runtfy
+
+Thank you for contributing to **runtfy**! We welcome bug reports, documentation updates, and pull requests.
+
+---
+
+## Development Setup
+
+1. **Clone the repository**:
+   ```bash
+   git clone https://github.com/adilkt16/runtfy.git
+   cd runtfy
+   ```
+
+2. **Install in editable mode with development dependencies**:
+   ```bash
+   pip install -e ".[dev]"
+   ```
+
+3. **Run the test suite**:
+   ```bash
+   python -m pytest tests/ -v
+   ```
+
+---
+
+## Implementation Rules
+
+Every contributor must adhere strictly to these core project rules:
+
+1. **No hardcoded secrets or machine-specific paths**:
+   - Never hardcode a topic, token, username, email, or absolute home directory path.
+   - Always resolve home directories dynamically using `pathlib.Path.home()`.
+2. **Never log or print the ntfy topic**:
+   - The ntfy topic is considered private. Never print it in debug output, local logs, or test reports.
+3. **No extraneous network calls**:
+   - runtfy must not connect to telemetry, metrics, or third-party tracking services.
+   - The only allowed network traffic is directly to the configured ntfy server.
+   - All automated unit tests must mock external network calls.
+4. **Use placeholders everywhere**:
+   - Use generic placeholders (such as `your-topic-here` and `~/.config/runtfy`) across all documentation, error strings, and tests.
+5. **Write tests for every change**:
+   - Every bug fix, feature, and refactor must include corresponding unit tests. Run `python -m pytest tests/ -v` and ensure all tests pass before opening a PR.
+6. **Ask before adding dependencies**:
+   - runtfy prioritizes remaining lightweight and audit-friendly. Avoid introducing third-party runtime dependencies without prior discussion and approval.
+
+---
+
+## Submitting a Pull Request
+
+1. Create a feature branch from `main`:
+   ```bash
+   git checkout -b feature/my-feature-name
+   ```
+2. Make your changes adhering to the coding rules.
+3. Run the full test suite and confirm 100% pass rate:
+   ```bash
+   python -m pytest tests/ -v
+   ```
+4. Verify that no secrets, machine paths, or personal emails are present in your diff:
+   ```bash
+   git diff
+   ```
+5. Commit your changes with clear, descriptive messages and submit a pull request on GitHub.

runtfy-0.1.0/LICENSE

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

runtfy-0.1.0/LOCK_CHECKLIST.md

@@ -0,0 +1,110 @@
+# Manual Verification Checklist: Lock-When-Away
+
+This checklist covers manual verification of the `--lock-when-away` feature on macOS and Linux (FR7, FR8, FR12).
+
+---
+
+## Part 1: macOS Verification
+
+Tested on macOS Monterey, Ventura, Sonoma, and Sequoia.
+
+### Prerequisites
+
+1. Confirm macOS Lock Screen settings:
+   - Open **System Settings** → **Lock Screen** (or **Security & Privacy** on older macOS).
+   - Ensure **Require password after display turns off or screen saver begins** is set to **Immediately**.
+2. Install `runtfy` locally:
+   ```bash
+   pip install -e .
+   ```
+3. Initialize a test topic and subscribe on your phone:
+   ```bash
+   runtfy init
+   ```
+   Confirm you have subscribed to the topic in the ntfy app.
+
+### Test Cases (macOS)
+
+#### 1. Basic Screen Lock
+- [ ] Run:
+  ```bash
+  runtfy --lock-when-away sleep 10
+  ```
+- [ ] **Expected**:
+  - The display turns off / locks immediately via `pmset displaysleepnow`.
+  - No permission prompts (Accessibility or Input Monitoring) appear.
+  - After 10 seconds, wake the screen and log in.
+  - Phone receives notification: `runtfy: sleep finished` (`Status: ✓ success`).
+
+#### 2. Input Alert During Lock
+- [ ] Run:
+  ```bash
+  runtfy --lock-when-away sleep 30
+  ```
+- [ ] Wait 3 seconds for the screen to lock and settle.
+- [ ] Move the mouse or press any key on the keyboard while the screen is locked.
+- [ ] **Expected**:
+  - Phone receives notification:
+    - **Title**: `runtfy: input detected`
+    - **Body**: `Someone typed or moved the mouse while your screen was locked.`
+
+#### 3. Cooldown Verification (60-second cooldown)
+- [ ] Keep the screen locked after triggering Test Case 2.
+- [ ] Within 10–20 seconds of the first input alert, move the mouse again.
+- [ ] **Expected**:
+  - **No second notification** is sent immediately (enforcing the 60-second cooldown).
+- [ ] Wait at least 65 seconds, then move the mouse again.
+- [ ] **Expected**:
+  - Phone receives a second notification: `runtfy: input detected`.
+
+#### 4. Lock Failure Fallback (FR12)
+- [ ] Simulate a lock failure (e.g. running in an environment where `pmset` fails):
+  ```bash
+  runtfy --lock-when-away echo "lock failure test"
+  ```
+- [ ] **Expected**:
+  - If locking cannot be performed, the command (`echo "lock failure test"`) still executes and exits with its normal exit code.
+  - A notification alert is sent indicating that the screen could not be locked.
+
+---
+
+## Part 2: Linux Verification (v0.1)
+
+Tested on Ubuntu 22.04+ (GNOME / systemd-logind).
+
+### Linux Scope & Behavior
+- On Linux, `--lock-when-away` locks the session using `loginctl lock-session` (with fallbacks `xdg-screensaver lock` and `gnome-screensaver-command --lock`).
+- **Input watching is NOT implemented on Linux in v0.1** (PRD non-goal). Linux receives the screen lock only.
+- If locking fails, the command still runs and the user is alerted (FR12).
+
+### Test Cases (Linux)
+
+#### 1. Basic Screen Lock (loginctl / xdg-screensaver)
+- [ ] In a graphical Linux session (X11 or Wayland), run:
+  ```bash
+  runtfy --lock-when-away sleep 10
+  ```
+- [ ] **Expected**:
+  - The desktop locks immediately via `loginctl lock-session` (or fallback).
+  - The command runs uninterrupted in the background.
+  - After 10 seconds, unlock the screen.
+  - Phone receives notification: `runtfy: sleep finished` (`Status: ✓ success`).
+
+#### 2. No Input Alerts on Linux (v0.1 Scope)
+- [ ] Run:
+  ```bash
+  runtfy --lock-when-away sleep 20
+  ```
+- [ ] Move the mouse and type while locked.
+- [ ] **Expected**:
+  - No input alert is sent (confirming input watching is inactive on Linux in v0.1).
+
+#### 3. Lock Failure Fallback (FR12)
+- [ ] Run on a headless terminal or SSH session without a graphical session manager:
+  ```bash
+  runtfy --lock-when-away echo "headless test"
+  ```
+- [ ] **Expected**:
+  - A warning message is output indicating lock failure.
+  - The command runs and outputs `"headless test"`, exiting with code 0.
+  - Phone receives an alert that the screen could not be locked.

runtfy-0.1.0/PKG-INFO

@@ -0,0 +1,205 @@
+Metadata-Version: 2.5
+Name: runtfy
+Version: 0.1.0
+Summary: A CLI tool that wraps terminal commands and notifies your phone when they finish or need input.
+Project-URL: Homepage, https://github.com/adilkt16/runtfy
+Project-URL: Repository, https://github.com/adilkt16/runtfy
+Project-URL: Bug Tracker, https://github.com/adilkt16/runtfy/issues
+Project-URL: Changelog, https://github.com/adilkt16/runtfy/blob/main/CHANGELOG.md
+Author-email: Adil <adilkt16@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) 2026 Adil (adilkt16)
+        
+        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.
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# runtfy
+
+runtfy is an open-source command-line tool. It wraps terminal commands, such as long-running AI coding agent sessions, and sends push notifications to your phone when they complete or when Claude Code requires your input. It also features an opt-in lock-when-away mode that locks your screen while you are away and alerts you if anyone interacts with your machine.
+
+---
+
+## 1. What it does
+
+Developers often launch long AI coding runs and walk away, only to find the run finished in minutes and sat idle, or paused for permissions. runtfy bridges this gap by sending instant push notifications to your phone without requiring accounts, hosted servers, or complex setups. It wraps any command cleanly in a pseudo-terminal and exits with the exact same exit code.
+
+---
+
+## 2. Install
+
+Install with `pipx` (recommended):
+
+```bash
+pipx install runtfy
+```
+
+Or install with `pip`:
+
+```bash
+pip install runtfy
+```
+
+---
+
+## 3. Quick start
+
+Initialize your private notification topic:
+
+```bash
+runtfy init
+```
+
+Wrap any terminal command:
+
+```bash
+runtfy <your-command>
+```
+
+Examples:
+
+```bash
+runtfy sleep 10
+runtfy pytest tests/
+runtfy claude
+```
+
+---
+
+## 4. ntfy setup
+
+runtfy delivers notifications using [ntfy](https://ntfy.sh), an open-source HTTP-based notification service. No account is required.
+
+1. Install the **ntfy** app on your phone:
+   - **iOS**: Available on the [App Store](https://apps.apple.com/app/ntfy/id1625396347).
+   - **Android**: Available on [Google Play](https://play.google.com/store/apps/details?id=io.heckel.ntfy) or [F-Droid](https://f-droid.org/packages/io.heckel.ntfy/).
+2. Open the ntfy app and tap **+** (**Subscribe to topic**).
+3. Enter your generated topic name:
+   ```
+   your-topic-here
+   ```
+4. Notifications sent by runtfy will immediately appear on your device.
+
+---
+
+## 5. Claude Code hooks
+
+runtfy integrates directly with Claude Code via its built-in lifecycle hooks.
+
+Install the hooks with:
+
+```bash
+runtfy install-hooks
+```
+
+What this does:
+- Locates `~/.claude/settings.json`.
+- Displays a unified diff of proposed changes.
+- Creates a timestamped backup before writing.
+- Adds the `Stop` hook (`runtfy hook-stop`) and `Notification` hook (`runtfy hook-notify`).
+- Preserves all pre-existing hooks and is idempotent (safe to run multiple times).
+
+To verify the installation, inspect `~/.claude/settings.json` to confirm `Stop` and `Notification` entries are present under `"hooks"`.
+
+---
+
+## 6. Lock-when-away
+
+Lock your screen while away and alert on unauthorized input:
+
+```bash
+runtfy --lock-when-away <command>
+```
+
+Example:
+
+```bash
+runtfy --lock-when-away claude
+```
+
+### Important details:
+- **Opt-in only**: Screen locking is never active unless `--lock-when-away` is explicitly provided.
+- **macOS**: Locks the display immediately using `pmset displaysleepnow` (requiring zero Accessibility permissions). It then watches the kernel HID idle counter; if someone touches the keyboard or moves the mouse while locked, runtfy sends an input alert to your phone with an enforced 60-second cooldown between notifications.
+- **Linux (v0.1)**: Locks the graphical session using `loginctl lock-session` (with fallbacks to `xdg-screensaver` and `gnome-screensaver-command`). In v0.1, input alerts on Linux are out of scope; Linux receives the screen lock only.
+- **Resilience**: If screen locking fails, the wrapped command continues to run and a warning notification is sent to your phone.
+
+---
+
+## 7. Configuration
+
+Configuration lives at `~/.config/runtfy/config.toml` with owner-only (`0o600`) permissions:
+
+```toml
+[runtfy]
+topic = "your-topic-here"  # ntfy topic; generated by runtfy init
+summary = false            # opt-in output summary
+summary_lines = 5          # number of lines to include when summary = true
+
+[quiet_hours]
+enabled = false            # silence notifications during specific hours
+start = "22:00"
+end = "08:00"
+
+[events]
+finish = true              # notify when wrapped command or Claude session ends
+waiting = true             # notify when Claude Code needs input or permission
+```
+
+---
+
+## 8. Privacy
+
+- **Safe defaults**: Notifications contain only the program name (e.g. `claude`, never its arguments), exit code, duration, and status. Arguments are never included because they can contain secrets.
+- **No output leakage**: Command output, file paths, and file contents are never transmitted by default.
+- **Opt-in summaries**: Output summaries are strictly opt-in (`summary = true`).
+- **Secret topic protection**: Your ntfy topic is generated locally, stored in owner-only configuration files (`chmod 600`), and is never printed in logs or committed to version control.
+- **No credential handling**: runtfy never reads, stores, or handles operating system passwords.
+- **No telemetry**: runtfy contains no analytics or tracking. All network calls go exclusively to the configured ntfy server.
+- **Zero personal data**: The repository and default configurations contain no personal names, emails, usernames, or machine paths.
+
+---
+
+## 9. Self-hosting ntfy
+
+If you prefer not to use the public `ntfy.sh` server or wish to avoid public server rate limits, you can host your own ntfy instance using Docker or official binary distributions. To direct runtfy to your private instance, set `server = "https://ntfy.example.com"` under `[runtfy]` in `~/.config/runtfy/config.toml`. Refer to the [official ntfy documentation](https://docs.ntfy.sh/) for self-hosting instructions.
+
+---
+
+## 10. Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup instructions, implementation rules, and pull request guidelines.
+
+---
+
+## 11. Licence
+
+This project is licensed under the [MIT Licence](https://opensource.org/licenses/MIT).

runtfy-0.1.0/README.md

@@ -0,0 +1,160 @@
+# runtfy
+
+runtfy is an open-source command-line tool. It wraps terminal commands, such as long-running AI coding agent sessions, and sends push notifications to your phone when they complete or when Claude Code requires your input. It also features an opt-in lock-when-away mode that locks your screen while you are away and alerts you if anyone interacts with your machine.
+
+---
+
+## 1. What it does
+
+Developers often launch long AI coding runs and walk away, only to find the run finished in minutes and sat idle, or paused for permissions. runtfy bridges this gap by sending instant push notifications to your phone without requiring accounts, hosted servers, or complex setups. It wraps any command cleanly in a pseudo-terminal and exits with the exact same exit code.
+
+---
+
+## 2. Install
+
+Install with `pipx` (recommended):
+
+```bash
+pipx install runtfy
+```
+
+Or install with `pip`:
+
+```bash
+pip install runtfy
+```
+
+---
+
+## 3. Quick start
+
+Initialize your private notification topic:
+
+```bash
+runtfy init
+```
+
+Wrap any terminal command:
+
+```bash
+runtfy <your-command>
+```
+
+Examples:
+
+```bash
+runtfy sleep 10
+runtfy pytest tests/
+runtfy claude
+```
+
+---
+
+## 4. ntfy setup
+
+runtfy delivers notifications using [ntfy](https://ntfy.sh), an open-source HTTP-based notification service. No account is required.
+
+1. Install the **ntfy** app on your phone:
+   - **iOS**: Available on the [App Store](https://apps.apple.com/app/ntfy/id1625396347).
+   - **Android**: Available on [Google Play](https://play.google.com/store/apps/details?id=io.heckel.ntfy) or [F-Droid](https://f-droid.org/packages/io.heckel.ntfy/).
+2. Open the ntfy app and tap **+** (**Subscribe to topic**).
+3. Enter your generated topic name:
+   ```
+   your-topic-here
+   ```
+4. Notifications sent by runtfy will immediately appear on your device.
+
+---
+
+## 5. Claude Code hooks
+
+runtfy integrates directly with Claude Code via its built-in lifecycle hooks.
+
+Install the hooks with:
+
+```bash
+runtfy install-hooks
+```
+
+What this does:
+- Locates `~/.claude/settings.json`.
+- Displays a unified diff of proposed changes.
+- Creates a timestamped backup before writing.
+- Adds the `Stop` hook (`runtfy hook-stop`) and `Notification` hook (`runtfy hook-notify`).
+- Preserves all pre-existing hooks and is idempotent (safe to run multiple times).
+
+To verify the installation, inspect `~/.claude/settings.json` to confirm `Stop` and `Notification` entries are present under `"hooks"`.
+
+---
+
+## 6. Lock-when-away
+
+Lock your screen while away and alert on unauthorized input:
+
+```bash
+runtfy --lock-when-away <command>
+```
+
+Example:
+
+```bash
+runtfy --lock-when-away claude
+```
+
+### Important details:
+- **Opt-in only**: Screen locking is never active unless `--lock-when-away` is explicitly provided.
+- **macOS**: Locks the display immediately using `pmset displaysleepnow` (requiring zero Accessibility permissions). It then watches the kernel HID idle counter; if someone touches the keyboard or moves the mouse while locked, runtfy sends an input alert to your phone with an enforced 60-second cooldown between notifications.
+- **Linux (v0.1)**: Locks the graphical session using `loginctl lock-session` (with fallbacks to `xdg-screensaver` and `gnome-screensaver-command`). In v0.1, input alerts on Linux are out of scope; Linux receives the screen lock only.
+- **Resilience**: If screen locking fails, the wrapped command continues to run and a warning notification is sent to your phone.
+
+---
+
+## 7. Configuration
+
+Configuration lives at `~/.config/runtfy/config.toml` with owner-only (`0o600`) permissions:
+
+```toml
+[runtfy]
+topic = "your-topic-here"  # ntfy topic; generated by runtfy init
+summary = false            # opt-in output summary
+summary_lines = 5          # number of lines to include when summary = true
+
+[quiet_hours]
+enabled = false            # silence notifications during specific hours
+start = "22:00"
+end = "08:00"
+
+[events]
+finish = true              # notify when wrapped command or Claude session ends
+waiting = true             # notify when Claude Code needs input or permission
+```
+
+---
+
+## 8. Privacy
+
+- **Safe defaults**: Notifications contain only the program name (e.g. `claude`, never its arguments), exit code, duration, and status. Arguments are never included because they can contain secrets.
+- **No output leakage**: Command output, file paths, and file contents are never transmitted by default.
+- **Opt-in summaries**: Output summaries are strictly opt-in (`summary = true`).
+- **Secret topic protection**: Your ntfy topic is generated locally, stored in owner-only configuration files (`chmod 600`), and is never printed in logs or committed to version control.
+- **No credential handling**: runtfy never reads, stores, or handles operating system passwords.
+- **No telemetry**: runtfy contains no analytics or tracking. All network calls go exclusively to the configured ntfy server.
+- **Zero personal data**: The repository and default configurations contain no personal names, emails, usernames, or machine paths.
+
+---
+
+## 9. Self-hosting ntfy
+
+If you prefer not to use the public `ntfy.sh` server or wish to avoid public server rate limits, you can host your own ntfy instance using Docker or official binary distributions. To direct runtfy to your private instance, set `server = "https://ntfy.example.com"` under `[runtfy]` in `~/.config/runtfy/config.toml`. Refer to the [official ntfy documentation](https://docs.ntfy.sh/) for self-hosting instructions.
+
+---
+
+## 10. Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup instructions, implementation rules, and pull request guidelines.
+
+---
+
+## 11. Licence
+
+This project is licensed under the [MIT Licence](https://opensource.org/licenses/MIT).