A Mac and Windows app for cleanyourtv by @gathint. It debloats an Android TV, installs the clean launcher and lets you customise it, without Python, Java, Android Studio or adb on your computer.

New to this? The user guide walks every step at TV-owner pace, including rollback and troubleshooting. This README is the technical overview.

This is an independent project, not part of cleanyourtv. The debloat lists, themes and launcher come from upstream unchanged; this app is the desktop front end for them. Tested on a Xiaomi Mi Box S from Windows.

Get the latest version from Releases:

The installers are not signed with a paid developer certificate, so your computer warns you the first time:

• Mac: open the dmg and drag CleanMyTV to Applications. The first time, right-click it and choose Open, then Open again. macOS asks whether CleanMyTV may find devices on your local network: choose Allow, or it cannot reach the TV.
• Windows: when SmartScreen says it protected your PC, choose More info, then Run anyway.

1. Settings → Device Preferences → About (on some Google TVs: Settings → System → About).
2. Press OK on Build (or Android TV OS build) seven times, until the TV says you are a developer.
3. Back one screen → Developer options → turn on USB debugging. If you also see Network debugging or ADB debugging, turn that on too.
4. Keep the TV on and on the same Wi-Fi as your computer.

Open CleanMyTV, find the TV and choose Allow when the TV asks. Tick Always allow from this computer to skip the question next time.

Nothing is uninstalled. Packages are switched off for your user, and Restore puts every package back the way it was before the first cleanup.

Turn USB debugging on again, open the app, and it reconnects to the TV you used last time. When the clean launcher is already Home it opens Customise, loaded with what is on the TV now. Switch debugging off again when you're done. If you didn't revoke the authorisations, there's no Allow prompt.

If the router gave the TV a new address, or another device now answers at the old one, the app says so and scans the network. You pick the TV from the list; the app does not log in to devices it found by itself.

• What it talks to. Only the TV address you choose, over ADB on port 5555 of your local network. The optional downloads (Java, the Android SDK, Google's adb, the launcher source) come from Adoptium, dl.google.com and GitHub over HTTPS, and only when you click them. No analytics, no accounts, no server of its own.
• Your keys. The app makes its own ADB key in its data folder and signs only with that. It never uses ~/.android/adbkey, which your phones may also trust, and it only logs in to an address you picked. Network ADB is plaintext by design, so use it on a network you trust.
• Pinned upstream. The lists, themes and launcher source come from one upstream commit pinned in upstream.json with a content hash. A build refuses anything that doesn't match, so a change upstream reaches this app only after someone reviews it and moves the pin.
• The launcher signing key ships inside the app, on purpose. resources/signing/cleanmytv.jks (password cleanyourtv) identifies the sideloaded launcher for upgrades, so a "Build from source" copy installs over the bundled one. It gives no access to a TV: installing anything still needs ADB access the owner allowed.
• Close debugging when you're done. Some TVs (ro.adb.secure=0) accept any device on the network without the Allow prompt; the app warns you if yours is one. The Finish step checks that port 5555 is closed. The launcher keeps working without debugging.
• Window lockdown. The app window is sandboxed, cannot navigate away from its own page, and only that page may call into the part that talks to the TV.

Found a security problem? Please report it privately through the repository's Security → Report a vulnerability page rather than in a public issue.

The app is a TypeScript port of upstream's tools/ and launcher/build-and-install.sh:

• src/main/adb/ is an ADB-over-TCP client, the twin of tools/tv.py.
• src/main/debloat.ts has the same guards as disable.sh: it won't disable the app that owns Home while nothing else can take it, and it won't disable setupwraith while it owns the Wi-Fi network. It writes the same recovery record to ~/.cleanyourtv/, plus the TV's device name so the record follows the TV to a new address. tests/engine.test.ts checks that the record names and the restore batch match upstream recovery.py exactly, so tools/restore.sh ~/.cleanyourtv/lists/<tv>.txt can also undo what the app did.
• src/main/launcher.ts follows the handover order of build-and-install.sh: install, start, disable the stock launcher, set Home, check, roll back.
• src/main/theme.ts pushes what tools/theme.sh pushes, with the same restart.

The app bundles a launcher built by npm run apk from the pinned upstream commit. That script downloads JDK 17 and the Android SDK into .cytv-build/, the same way the app's "Build from source" option does, and both builds use the same signing key. resources/launcher.json records the upstream commit each APK came from.

A launcher built with upstream's own script is signed with that computer's debug key. The app detects the mismatch and asks before replacing it, because a reinstall loses the tile order set on the TV.

npm install
npm run sync                 # lists and themes from the pinned upstream commit
npm run apk                  # resources/launcher.apk (first run downloads ~800 MB of build tools)
npm run dev                  # the app, with hot reload
npx tsx scripts/fake-tv.ts   # a pretend TV on 127.0.0.1:5556 to try the app without one
UPSTREAM_DIR=<clone at the pinned commit> npm test
npm run dist:mac             # dist/*.dmg   (on a Mac)
npm run dist:win             # dist/*.exe   (on Windows, a Mac, or in CI)

To move to a newer upstream: review its changes, then node scripts/pin-upstream.mjs <commit sha>, npm run sync, npm run apk, and test on a TV. UPSTREAM_UNPINNED=1 lets sync and apk use other content for a local trial.

.github/workflows/build.yml builds the APK on Linux and runs the tests on every push and pull request. Pushes to main and version tags also build the macOS and Windows installers; download them from the run's Artifacts. It runs with read-only repository permissions and actions pinned to commits.

1. Set the new version in package.json and commit it.
2. Tag and push: git tag v0.1.1 && git push origin main v0.1.1.
3. The workflow builds both installers and opens a draft release with them attached. Check it, then press Publish release.

The tag has to match the version in package.json, or the release step stops.

• Tile order and app-library choices made on the TV live in the launcher's private storage, which ADB can't read. The app sets the order through dock_apps, which takes precedence over the on-TV order.
• App names come from a built-in table of common TV apps. Others get a name made from the package, and the TV's own labels and icons aren't read.
• Wireless debugging pairing uses Google's adb, downloaded on demand. On macOS, Local Network privacy can block that binary. If pairing fails there, pair from a Windows PC or run adb pair in Terminal once.

MIT, see LICENSE. The bundled lists, themes and launcher are from cleanyourtv, also MIT; its licence ships in resources/upstream/LICENSE.