windows-apple-remote 0.1.1__tar.gz

windows_apple_remote-0.1.1/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_call:
+
+jobs:
+  test:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[test]"
+      - run: pytest -v

windows_apple_remote-0.1.1/.github/workflows/publish.yml

@@ -0,0 +1,72 @@
+name: Publish
+
+# Publishing a GitHub release uploads to PyPI.
+# Running this workflow by hand (Actions tab -> Publish -> Run workflow) uploads to
+# TestPyPI instead, for a dry run.
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  test:
+    uses: ./.github/workflows/ci.yml
+
+  build:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build twine
+      - name: Check release tag matches package version
+        if: github.event_name == 'release'
+        run: |
+          version=$(sed -n 's/^__version__ = "\(.*\)"/\1/p' src/atv_remote/__init__.py)
+          tag="${GITHUB_REF_NAME#v}"
+          if [ "$version" != "$tag" ]; then
+            echo "Release tag $GITHUB_REF_NAME does not match __version__ $version" >&2
+            exit 1
+          fi
+      - run: python -m build
+      - run: twine check --strict dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  pypi:
+    if: github.event_name == 'release'
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/windows-apple-remote
+    permissions:
+      id-token: write  # PyPI trusted publishing, no API token needed
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  testpypi:
+    if: github.event_name == 'workflow_dispatch'
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/windows-apple-remote
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/

windows_apple_remote-0.1.1/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+build/
+.pytest_cache/

windows_apple_remote-0.1.1/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+<!--
+Maintained for both humans and Claude Code to reference. Before
+implementing a feature or fix, check the entries below first — it may
+already be done, which saves searching the whole codebase.
+
+Format (based on Keep a Changelog: https://keepachangelog.com/en/1.1.0/):
+- New entries go under "## [Unreleased]" until a release is cut.
+- Categories: Added, Changed, Fixed, Deprecated, Removed, Security.
+  Only add a category heading once it has an entry under it.
+- One bullet per entry, imperative mood, one line where possible:
+    - Add CSV export to the reports page. (Refs: JIRA-482, #210)
+- Include "(Refs: ...)" only when there's an external reference — a Jira
+  key, GitHub issue/PR number, Trello card title/URL, or similar tracker
+  ID. Comma-separate multiple references. Omit the parenthetical entirely
+  if there's nothing to reference.
+- To cut a release: rename "## [Unreleased]" to "## [X.Y.Z] - YYYY-MM-DD"
+  and start a fresh, empty "## [Unreleased]" section above it.
+- Never delete or rewrite past entries — only append.
+-->
+
+## [Unreleased]
+
+## [0.1.1] - 2026-09-24
+
+### Changed
+- Rename the PyPI package from `atv-remote-server` to `windows-apple-remote` to match the repository and the PyPI trusted publisher; the `atv-remote` command and `atv_remote` import are unchanged.
+
+### Fixed
+- Fix the PyPI upload failing with `400 Non-user identities cannot create new projects` (package name didn't match the pending publisher); 0.1.0 was never uploaded.
+
+## [0.1.0] - 2026-09-24
+
+### Added
+- Add `atv-remote` server that advertises the PC as an Apple TV (Companion protocol via pyatv) so the iOS Apple TV Remote can pair with a PIN and control media keys, volume, arrows, Enter and Escape on Windows.
+- Add per-install identity, random pairing PIN per attempt, and rejection of unpaired devices on pair-verify.
+- Add end-to-end tests that pair and send commands using pyatv's own client.
+- Add GitHub Actions for Windows CI and PyPI trusted publishing on release.
+- Add TestPyPI dry-run publishing (manual workflow run), a release-tag/version check and `twine check` to the publish workflow; run CI on every push.
+- Add GitHub project links (aryakvn/windows-apple-remote) to the README and package metadata, with PyPI trusted-publisher setup steps.
+
+### Fixed
+- Encrypt the connection right after pair-setup, since iOS keeps using it, and parse only OPACK frame types, which fixes the `TypeError: 0xc9` disconnect after pairing.
+- Answer `_systemInfo` with device info, reply "No request handler" to unknown requests and drop `_i` from responses to match a real Apple TV; log outgoing messages with `-v`.
+- Decode OPACK back-references the way Apple encodes them (skip 1-byte objects like `''`); pyatv's decoder was off by one, so iOS 27's `_systemInfo` arrived without its `_i` and was rejected.
+- Keep the iOS remote session open: answer every message successfully (replacing the "No request handler" errors), return a touch session id from `_touchStart` and flags from `FetchMediaControlStatus`, and send a full Apple TV `_systemInfo` (`_lP`, `_stA` with `com.apple.tvremoteservices`, Siri peer data) with `rpFl=0xB6782` and model `AppleTV5,3`, matching thiccaxe/CompanionGames, a server known to work with the remote.
+
+### Changed
+- Make the touch area a media controller: tap plays/pauses, swipe left/right changes track, swipe up/down changes volume (longer swipe = more steps); D-pad directions map the same way.
+- Advertise volume control (`_mcF` Volume flag) so the iPhone's volume buttons control the PC, and turn `SetVolume` into volume key steps.
+
+### Removed
+- Remove arrow-key, Enter and ±10s skip mappings, which the touch-only iOS remote can't reach.

windows_apple_remote-0.1.1/CLAUDE.md

@@ -0,0 +1,193 @@
+# CLAUDE.md — windows-apple-remote
+
+Makes a Windows PC appear as an Apple TV so the iOS **Apple TV Remote** (Control
+Center) can pair with it and send media keys. PyPI name `windows-apple-remote`, import
+`atv_remote`, CLI `atv-remote`. macOS support is planned; HomeKit is out of scope.
+
+## Status (2026-09-24)
+
+- Session now stays open on the iPhone (CompanionGames-style replies fixed it).
+  The iOS 27 remote shows only a touch area, so control is gesture-based.
+
+- Working against a real iPhone (iOS 27.0, iPhone12,1): mDNS discovery, pair-setup
+  with PIN, pair-verify on reconnect, encrypted session, `_systemInfo` decode.
+- Earlier the iPhone sent `TVRCSessionStop` ~30 ms after setup; fixed by the replies
+  listed below. Gestures and hardware-volume routing (`_mcF` Volume bit 0x100) are
+  not yet confirmed on a device.
+
+## Layout
+
+- `src/atv_remote/server.py` — `RemoteServer` (one asyncio.Protocol per connection,
+  subclasses pyatv's `CompanionServerAuth`), `Identity`, `unpack_opack`.
+- `src/atv_remote/keys.py` — action name → Windows virtual key via `keybd_event`.
+  Swap/extend this for macOS. `SUPPORTED` gates the CLI.
+- `src/atv_remote/cli.py` — argparse, TCP server, zeroconf `_companion-link._tcp`
+  registration, PIN printing.
+- `tests/test_server.py` — pyatv's own Companion client pairs and presses buttons
+  end to end; wrong PIN / unpaired device rejected; OPACK regression; replay of the
+  iOS 27 request sequence.
+- `.github/workflows/ci.yml` (Windows, py3.10–3.13), `publish.yml` (GitHub release →
+  PyPI trusted publishing, environment `pypi`). Version lives in
+  `src/atv_remote/__init__.py` (hatch dynamic version).
+
+## Reusable pieces
+
+- `Identity(path)` — persistent server identity in JSON: `id` (UUID), `seed` (32 bytes,
+  Ed25519/X25519 key seed), `clients` (pairing id → client Ed25519 public key hex).
+  `txt_record()` gives the mDNS TXT; `system_info(name, port)` gives the `_systemInfo`
+  reply. All ids derived deterministically from the seed. Default path
+  `%APPDATA%\atv-remote\state.json`; delete it to forget all paired devices.
+- `unpack_opack(data)` — correct OPACK decoder (wraps pyatv's `_unpack` with a fixed
+  back-reference table). Use this instead of `pyatv.support.opack.unpack` for anything
+  coming from iOS.
+- `keys.press(action)` — actions: `play_pause next previous volume_up volume_down up
+  down left right select back`.
+
+## Protocol facts learned (Companion / "rapport")
+
+Discovery and auth:
+- Modern iOS Remote uses the **Companion** protocol (`_companion-link._tcp`), not MRP.
+- TXT values known to work: `rpFl=0xB6782`, `rpMd=AppleTV5,3`, `rpMac=2`, plus
+  `rpHN rpHA rpAD rpHI` (12 hex chars each), `rpBA` (MAC), `rpMRtID` (server id).
+- Frame: 1 byte type + 3 byte big-endian length + payload. Encrypted payloads use
+  ChaCha20-Poly1305, 12-byte nonce counter, AAD = the 4-byte header, +16 byte tag.
+- **After pair-setup M6, iOS keeps the same connection and encrypts immediately**
+  with `hkdf("", "ServerEncrypt-main"/"ClientEncrypt-main", SRP session key)`. pyatv's
+  client disconnects after pairing, so its tests never exercise this.
+- pyatv's `CompanionServerAuth` weaknesses we override: fixed PIN 1111 (its `pin`
+  arg is ignored), public fixed private key, and `_m3_verify` never checks the
+  client's signature (any device could connect unpaired). We use a random PIN per
+  pairing attempt, a per-install seed, verify the controller signature in M5, and
+  verify the M3 signature against the stored client key.
+
+OPACK:
+- **pyatv 0.18 `opack.unpack` bug:** it adds 1-byte objects (`''`, `b''`) to the
+  back-reference table and dedupes by `==`. Apple's encoder (and pyatv's own `pack`)
+  skips 1-byte objects, so any message containing `''` resolves later references one
+  slot off. iOS 27's `_systemInfo` has `'myriadTrialTreatment': ''`, which turned the
+  top-level `_i` into another value. Fixed by `_RefTable` in server.py. Worth
+  reporting upstream to pyatv.
+
+Messages (`_t`: 1=event, 2=request, 3=response; responses match on `_x`, carry no `_i`):
+- iOS 27 sequence after pair-verify: `_systemInfo`, `_sessionStart`
+  (`_srvT=com.apple.tvremoteservices`), `TVRCSessionStart` (`ProtocolVersionKey
+  1.2`), `FetchAttentionState`, `FetchSiriRemoteInfo`, `_interest`
+  (PushSiriRemoteInfo, SupportedActions, NowPlayingInfo, TopShelfItems,
+  MediaControlStatus), `FetchSupportedActionsEvent`,
+  `FetchCurrentNowPlayingInfoEvent`, `FetchCurrentTopShelfItemsEvent`,
+  `FetchMediaControlStatus`, `_touchStart`, `_tiStart`.
+- Replies that did **not** keep the session open: empty `{}` for everything, and
+  `No request handler` errors (code 58822, RPErrorDomain) for unknown requests.
+- Replies now sent (from CompanionGames): a normal `{}` reply to every message, never
+  an error; `_touchStart` → `{"_i": 1}`; `FetchMediaControlStatus` →
+  `{"MediaControlFlags": flags}`; `FetchAttentionState` → `{"state": 3}`;
+  `_sessionStart` → `{"_sid": random32}`; `TVRCSessionStart` echoes its content;
+  `_systemInfo` → name, model, `_i`, `_idsID`, `_pubID`, `_mrID`, `_mRtID`,
+  `_lP` (listening port), `_stA` (must include `com.apple.tvremoteservices`),
+  `_sf 65536`, `_bf 1920`, `_cf 512`, `_clFl 128`, `_msSt/_msRo/_dCapF 1`, and
+  `_siriInfo.peerData` with `userInterfaceIdiom: "ZEUS"` (Apple TV).
+- Input: `_hidC` with `_hBtS` 1=down / 2=up and `_hidC` = pyatv `HidCommand`; a tap
+  on the touchpad also arrives as `_hidC` Select. `_hidT` touch events: `_tPh`
+  1=start, 3=move, 4=end, 5=click; `_cx/_cy` 0–1000. `_mcc` = pyatv
+  `MediaControlCommand` (`SkipBy` carries `_skpS`).
+- Real `FetchSiriRemoteInfo` reply is `{"SiriRemoteInfoKey": <NSKeyedArchiver
+  bplist of TVRCSiriRemoteInfo>}`; `SupportedActions` event carries
+  `GuideSupportedKey`; `NowPlayingInfo` event carries `NowPlayingInfoKey` bplist
+  (`TVRCNowPlayingInfo`, `playbackRate`). Not implemented; see pyatv issues #2325
+  and #2461.
+
+## README format
+
+Keep `README.md` in this shape so every release reads the same:
+
+1. `# windows-apple-remote` (repo name), then the CI and PyPI badges, then
+   `Package: [\`windows-apple-remote\`](pypi link) · Source: [github.com/aryakvn/windows-apple-remote](repo link)`.
+2. One short paragraph: what it does (iOS Apple TV Remote → Windows media keys, via pyatv).
+3. Mapping table with columns `Remote (touch area) | PC`, one row per gesture or
+   button. It must match `HID_ACTIONS`, `MCC_ACTIONS` and `_touch()` in `server.py`;
+   update it in the same commit as any mapping change.
+4. `## Install & run`: `pip install windows-apple-remote` + `atv-remote`, then the
+   `pip install git+https://github.com/aryakvn/windows-apple-remote.git` alternative,
+   the pairing steps (same Wi-Fi, Control Center → Apple TV Remote, PIN in terminal),
+   and an `Options:` block listing every `cli.py` flag with a one-line comment.
+5. `## Notes`: firewall, state file location, behaviour limits, platform support.
+6. `## Development`: clone, venv, `pip install -e ".[test]"`, `pytest`, and the
+   editable-install warning.
+7. `## Releasing to PyPI`: one-time trusted-publisher values and the per-release
+   steps (keep them in sync with the release process below).
+
+Style: short sentences, second person, Windows commands (`.venv\Scripts\activate`).
+Files must stay UTF-8. On Windows, Python's `read_text()`/`write_text()` default to
+cp1252 and `"\a"` in a normal string becomes a bell character; use the Edit tool or
+bytes with explicit `utf-8`.
+
+## Release process
+
+Versioning is semver: patch for fixes, minor for features; while 0.x, a breaking
+change bumps the minor. Tags are `vX.Y.Z`. Work reaches `main` only through a PR
+from a feature branch; the release commit is the only thing pushed straight to `main`.
+
+1. `main` is up to date and its CI is green.
+2. Bump `__version__` in `src/atv_remote/__init__.py` (if not bumped yet).
+3. Cut the changelog (`changelog:release` skill): rename `## [Unreleased]` to
+   `## [X.Y.Z] - YYYY-MM-DD` and add an empty `## [Unreleased]` above it. Don't touch
+   any entry.
+4. Commit on `main` with the message `Release X.Y.Z` (plus the co-author trailer).
+5. Annotated tag: `git tag -a vX.Y.Z -m "windows-apple-remote X.Y.Z"`, then push `main`
+   and the tag.
+6. GitHub release: tag `vX.Y.Z`, title `vX.Y.Z`, body:
+
+   ````markdown
+   <one-line summary of the release>
+
+   ```
+   pip install windows-apple-remote
+   atv-remote
+   ```
+
+   <the X.Y.Z section of CHANGELOG.md, copied as is: ### Added / Changed / Fixed / Removed>
+   ````
+
+   If something in the release hasn't been tried on a real iPhone, add a
+   `### Known issues` section at the end saying what.
+7. This machine has no `gh` or GitHub login (git pushes over SSH), so build the URL
+   `https://github.com/aryakvn/windows-apple-remote/releases/new?tag=vX.Y.Z&title=vX.Y.Z&body=<url-encoded body>`
+   and open it with PowerShell `Start-Process`; the user clicks **Publish release**.
+   PRs work the same way via `.../compare/main...<branch>?expand=1&title=...&body=...`.
+8. Publishing the release runs `publish.yml`: tests, tag vs `__version__` check,
+   build, `twine check`, upload to PyPI. PyPI versions can't be reused, so offer a
+   TestPyPI dry run first (run the Publish workflow by hand) when a change is untested.
+9. Check the Actions run; if the upload failed because the trusted publisher wasn't
+   set up yet, re-run the failed job after the user adds it.
+
+## References
+
+- pyatv protocol docs: docs/documentation/protocols.md in postlund/pyatv.
+- pyatv issue #2325 "[Companion] Documentation Dumps" — real Apple TV message dumps.
+- thiccaxe/CompanionGames — a working Companion server for the iOS remote.
+  **AGPL**: take protocol facts only, never copy code (this package is MIT).
+- pyatv's `scripts/atvproxy.py companion` can MITM a real Apple TV to capture replies.
+
+## Gotchas
+
+- Dev install must be editable: `pip install -e ".[test]"`. A plain `pip install .`
+  puts a stale copy in `site-packages` and source edits stop taking effect (this
+  happened repeatedly while debugging; check traceback paths).
+- pyatv is pinned `>=0.18,<0.19` because we use internals (`CompanionServerAuth`,
+  `opack._unpack`, companion framing). Re-check the OPACK fix and auth overrides
+  before bumping.
+- Windows Firewall must allow Python on private networks (TCP port + UDP 5353).
+- Windows has one Play/Pause key, so Play and Pause both toggle.
+- Without the Volume bit (0x100) in `_mcF`, iOS doesn't route the iPhone's volume
+  buttons to the device. `SetVolume` (absolute `_vol`) is turned into one relative
+  key step.
+- `atv-remote.exe` running locks the venv: pip can't reinstall (WinError 32) and may
+  leave the package uninstalled. Stop the server before `pip install -e .`, or run
+  tests with `PYTHONPATH=src`.
+- Run with `atv-remote -v` to log every received and sent message.
+- The PyPI trusted publisher's project name must equal `name` in `pyproject.toml`
+  (`windows-apple-remote`). A mismatch still passes the token exchange but the upload
+  fails with `400 Non-user identities cannot create new projects`. That is why v0.1.0
+  (published as `atv-remote-server`) never reached PyPI and 0.1.1 is the first upload.
+- Distribution name is `windows-apple-remote`, but the import package stays
+  `atv_remote` and the command stays `atv-remote`.

windows_apple_remote-0.1.1/LICENSE

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

windows_apple_remote-0.1.1/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.5
+Name: windows-apple-remote
+Version: 0.1.1
+Summary: Control your PC's media with the iOS Apple TV Remote app (powered by pyatv).
+Project-URL: Homepage, https://github.com/aryakvn/windows-apple-remote
+Project-URL: Issues, https://github.com/aryakvn/windows-apple-remote/issues
+Project-URL: Changelog, https://github.com/aryakvn/windows-apple-remote/blob/main/CHANGELOG.md
+Author-email: Arya Kavian <aryakvn@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: apple tv,companion,media keys,pyatv,remote
+Classifier: Environment :: Console
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=42
+Requires-Dist: pyatv<0.19,>=0.18
+Requires-Dist: zeroconf>=0.131
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# windows-apple-remote
+
+[![CI](https://github.com/aryakvn/windows-apple-remote/actions/workflows/ci.yml/badge.svg)](https://github.com/aryakvn/windows-apple-remote/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/windows-apple-remote)](https://pypi.org/project/windows-apple-remote/)
+
+Package: [`windows-apple-remote`](https://pypi.org/project/windows-apple-remote/) · Source:
+[github.com/aryakvn/windows-apple-remote](https://github.com/aryakvn/windows-apple-remote)
+
+Control your Windows PC's media with the **Apple TV Remote** on your iPhone or iPad
+(Control Center → Apple TV Remote). The PC advertises itself as an Apple TV over the
+Companion protocol using [pyatv](https://pyatv.dev), and turns remote buttons into
+media keys.
+
+| Remote (touch area)                  | PC                                   |
+|---------------------------------------|--------------------------------------|
+| Tap                                   | Play/Pause                           |
+| Swipe right / left                    | Next / Previous track                |
+| Swipe up / down (longer = more)       | Volume Up / Down                     |
+| iPhone volume buttons                 | Volume Up / Down                     |
+| Back (Menu)                           | Escape                               |
+
+## Install & run
+
+```sh
+pip install windows-apple-remote
+atv-remote
+```
+
+Or the latest code from GitHub:
+
+```sh
+pip install git+https://github.com/aryakvn/windows-apple-remote.git
+```
+
+Then on the iPhone (same Wi-Fi network): Control Center → Apple TV Remote → pick your
+PC's name. The first time, a 4-digit PIN is printed in the terminal; type it on the
+phone. The phone is remembered afterwards.
+
+Options:
+
+```
+atv-remote --name "Living Room PC"   # name shown on the phone (default: hostname)
+atv-remote --address 192.168.1.20    # IP to advertise if auto-detect picks the wrong adapter
+atv-remote --port 49200              # fixed TCP port (useful for firewall rules)
+atv-remote -v                        # debug logging
+```
+
+## Notes
+
+- **Windows Firewall:** allow Python on private networks when prompted, or the phone
+  can't connect. mDNS (UDP 5353) must be allowed too.
+- **Forget all paired devices:** delete `%APPDATA%\atv-remote\state.json`. It also
+  holds this PC's private identity key, so keep it private.
+- Media and volume keys are global; Back (Escape) goes to the focused window.
+- Windows has a single Play/Pause key, so the remote's separate Play and Pause both toggle.
+- Now-playing info and the volume slider are not supported (they need AirPlay/MRP).
+- macOS support is planned. HomeKit is not supported.
+
+## Development
+
+```sh
+git clone https://github.com/aryakvn/windows-apple-remote.git
+cd windows-apple-remote
+python -m venv .venv
+.venv\Scripts\activate
+pip install -e ".[test]"
+pytest
+```
+
+Use `pip install -e` (editable). A plain `pip install .` copies the code into the venv
+and later edits stop taking effect. Stop a running `atv-remote` before reinstalling;
+Windows locks its executable.
+
+The tests use pyatv's own client to pair with the server and press buttons end to end.
+Bugs and ideas: [issues](https://github.com/aryakvn/windows-apple-remote/issues).
+
+## Releasing to PyPI
+
+Publishing uses [trusted publishing](https://docs.pypi.org/trusted-publishers/), so no
+API token is stored in GitHub. One-time setup:
+
+1. On [pypi.org](https://pypi.org/manage/account/publishing/) add a *pending publisher*:
+   project `windows-apple-remote`, owner `aryakvn`, repository `windows-apple-remote`,
+   workflow `publish.yml`, environment `pypi`.
+2. Optional dry run: do the same on [test.pypi.org](https://test.pypi.org/manage/account/publishing/)
+   with environment `testpypi`.
+
+Each release:
+
+1. Bump `__version__` in `src/atv_remote/__init__.py` and move the `Unreleased`
+   entries in `CHANGELOG.md` under the new version.
+2. Optional: run the **Publish** workflow by hand (Actions tab) to upload to TestPyPI.
+3. Publish a GitHub release tagged `vX.Y.Z` (matching `__version__`). The workflow runs
+   the tests, checks the tag against the version, builds, and uploads to PyPI.

windows_apple_remote-0.1.1/README.md

@@ -0,0 +1,94 @@
+# windows-apple-remote
+
+[![CI](https://github.com/aryakvn/windows-apple-remote/actions/workflows/ci.yml/badge.svg)](https://github.com/aryakvn/windows-apple-remote/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/windows-apple-remote)](https://pypi.org/project/windows-apple-remote/)
+
+Package: [`windows-apple-remote`](https://pypi.org/project/windows-apple-remote/) · Source:
+[github.com/aryakvn/windows-apple-remote](https://github.com/aryakvn/windows-apple-remote)
+
+Control your Windows PC's media with the **Apple TV Remote** on your iPhone or iPad
+(Control Center → Apple TV Remote). The PC advertises itself as an Apple TV over the
+Companion protocol using [pyatv](https://pyatv.dev), and turns remote buttons into
+media keys.
+
+| Remote (touch area)                  | PC                                   |
+|---------------------------------------|--------------------------------------|
+| Tap                                   | Play/Pause                           |
+| Swipe right / left                    | Next / Previous track                |
+| Swipe up / down (longer = more)       | Volume Up / Down                     |
+| iPhone volume buttons                 | Volume Up / Down                     |
+| Back (Menu)                           | Escape                               |
+
+## Install & run
+
+```sh
+pip install windows-apple-remote
+atv-remote
+```
+
+Or the latest code from GitHub:
+
+```sh
+pip install git+https://github.com/aryakvn/windows-apple-remote.git
+```
+
+Then on the iPhone (same Wi-Fi network): Control Center → Apple TV Remote → pick your
+PC's name. The first time, a 4-digit PIN is printed in the terminal; type it on the
+phone. The phone is remembered afterwards.
+
+Options:
+
+```
+atv-remote --name "Living Room PC"   # name shown on the phone (default: hostname)
+atv-remote --address 192.168.1.20    # IP to advertise if auto-detect picks the wrong adapter
+atv-remote --port 49200              # fixed TCP port (useful for firewall rules)
+atv-remote -v                        # debug logging
+```
+
+## Notes
+
+- **Windows Firewall:** allow Python on private networks when prompted, or the phone
+  can't connect. mDNS (UDP 5353) must be allowed too.
+- **Forget all paired devices:** delete `%APPDATA%\atv-remote\state.json`. It also
+  holds this PC's private identity key, so keep it private.
+- Media and volume keys are global; Back (Escape) goes to the focused window.
+- Windows has a single Play/Pause key, so the remote's separate Play and Pause both toggle.
+- Now-playing info and the volume slider are not supported (they need AirPlay/MRP).
+- macOS support is planned. HomeKit is not supported.
+
+## Development
+
+```sh
+git clone https://github.com/aryakvn/windows-apple-remote.git
+cd windows-apple-remote
+python -m venv .venv
+.venv\Scripts\activate
+pip install -e ".[test]"
+pytest
+```
+
+Use `pip install -e` (editable). A plain `pip install .` copies the code into the venv
+and later edits stop taking effect. Stop a running `atv-remote` before reinstalling;
+Windows locks its executable.
+
+The tests use pyatv's own client to pair with the server and press buttons end to end.
+Bugs and ideas: [issues](https://github.com/aryakvn/windows-apple-remote/issues).
+
+## Releasing to PyPI
+
+Publishing uses [trusted publishing](https://docs.pypi.org/trusted-publishers/), so no
+API token is stored in GitHub. One-time setup:
+
+1. On [pypi.org](https://pypi.org/manage/account/publishing/) add a *pending publisher*:
+   project `windows-apple-remote`, owner `aryakvn`, repository `windows-apple-remote`,
+   workflow `publish.yml`, environment `pypi`.
+2. Optional dry run: do the same on [test.pypi.org](https://test.pypi.org/manage/account/publishing/)
+   with environment `testpypi`.
+
+Each release:
+
+1. Bump `__version__` in `src/atv_remote/__init__.py` and move the `Unreleased`
+   entries in `CHANGELOG.md` under the new version.
+2. Optional: run the **Publish** workflow by hand (Actions tab) to upload to TestPyPI.
+3. Publish a GitHub release tagged `vX.Y.Z` (matching `__version__`). The workflow runs
+   the tests, checks the tag against the version, builds, and uploads to PyPI.

windows_apple_remote-0.1.1/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "windows-apple-remote"
+dynamic = ["version"]
+description = "Control your PC's media with the iOS Apple TV Remote app (powered by pyatv)."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Arya Kavian", email = "aryakvn@gmail.com" }]
+keywords = ["apple tv", "remote", "pyatv", "media keys", "companion"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: Microsoft :: Windows",
+    "Topic :: Multimedia",
+    "Environment :: Console",
+]
+dependencies = [
+    # Pinned to a minor: we build on pyatv internals (server auth, companion framing).
+    "pyatv>=0.18,<0.19",
+    "zeroconf>=0.131",
+    "cryptography>=42",
+]
+
+[project.urls]
+Homepage = "https://github.com/aryakvn/windows-apple-remote"
+Issues = "https://github.com/aryakvn/windows-apple-remote/issues"
+Changelog = "https://github.com/aryakvn/windows-apple-remote/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-asyncio>=0.23"]
+
+[project.scripts]
+atv-remote = "atv_remote.cli:main"
+
+[tool.hatch.version]
+path = "src/atv_remote/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/atv_remote"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

windows_apple_remote-0.1.1/src/atv_remote/__init__.py

@@ -0,0 +1,3 @@
+"""Control a PC's media with the iOS Apple TV Remote app, via pyatv."""
+
+__version__ = "0.1.1"

windows_apple_remote-0.1.1/src/atv_remote/__main__.py

@@ -0,0 +1,3 @@
+from atv_remote.cli import main
+
+main()