Debloat any Android or Google TV over Wi-Fi and get an Apple TV-style home.
Python adbadblockandroid-tvandroid-tv-launcherapple-tvbloatware-removalclaude-codedebloatfire-tvgoogle-tvlauncherprivacysmart-tvsony-braviatclvibe-codingxiaomi
"""A PowerShell command in the docs runs as written: the script exists, the parameters do too.
Every Windows recipe in this repo is a `tools\\restore.ps1 <list> -Stock <package>` style line that a
reader copies onto their computer at the moment the TV looks wrong. Two ways such a line dies before
it reaches the TV, and both leave the TV as it was:
- the named parameter is not one the script declares (`restore.ps1` takes `-Stock`, its own usage line
says so, and PowerShell refuses the whole script with "A parameter cannot be found"), so the undo
never runs and the TV stays debloated;
- the script is not in the repository at all (a contributor's own helper named in an example), so
`-File` fails with "cannot be found".
The third check is the one the argument order causes: the list is the only positional parameter, so a
stock-launcher package name typed as a second bare argument is bound to nothing and PowerShell stops
with "A positional parameter cannot be found that accepts argument". A package name is the one bare
argument a debloat-list invocation never has - the list itself is a path - so a package-shaped token
that is not a parameter's value is that mistake.
Parameters are read out of the scripts themselves (`param( ... )`), so a script that renames a
parameter fails the pages that still pass the old one instead of letting them go stale.
Run from the repository root: python3 -m unittest discover -s tests -v
"""
import re
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
# Directories the other repository-wide walkers skip: build output, the CI venv, and a person's own
# backups, screenshots and traces, which are gitignored.
SKIP_DIRS = {".git", "venv", "node_modules", "build", ".gradle", "__pycache__", "shots", "backup", "traces"}
SCRIPT_RE = re.compile(r"([A-Za-z0-9_.\\/-]+\.ps1)\b")
# `-TvHost`, not the second half of `--fix`: a parameter is written with one dash and a letter.
PARAM_RE = re.compile(r"(?<![\w-])-([A-Za-z][A-Za-z0-9]*)")
POSITION_RE = re.compile(r"Position\s*=\s*(\d+)\s*\)")
PARAM_DECL_RE = re.compile(r"\[([A-Za-z_][\w.\[\]]*)\]\s*\$(\w+)")
# A package name as tools/disable.sh, disable.ps1 and recovery.py accept it: at least two dots, so
# `check.py` in prose is not one.
PACKAGE_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+){2,}")
# Where an invocation stops: the next command in the same line.
BREAK_RE = re.compile(r"(?:;|&&|\|\||\|)")
def param_block_of(text):
"""The text of a script's param( ... ) block, or "" when it has none."""
match = re.search(r"\bparam\s*\(", text)
if not match:
return ""
depth, i = 1, match.end()
while i < len(text) and depth:
if text[i] == "(":
depth += 1
elif text[i] == ")":
depth -= 1
i += 1
return text[match.end():i - 1]
def parameters(block):
"""Declared parameter names, in order, from a param block."""
return [name for _, name in PARAM_DECL_RE.findall(block)]
def positional_names(block):
"""Parameters given an explicit Position, as [(index, name)]."""
found = []
for match in POSITION_RE.finditer(block):
name = PARAM_DECL_RE.search(block[match.end():])
if name:
found.append((int(match.group(1)), name.group(2)))
return found
def invocations(text):
"""(script token, argument text) for every .ps1 named in a line of text.
The argument text stops at the next shell separator, so a line that names two scripts in one
command is read as the two invocations it would run - which is how a `-Stock` meant for
restore.ps1 ends up in disable.ps1's argument list.
"""
for line in text.split("\n"):
for match in SCRIPT_RE.finditer(line):
token = match.group(1)
if token == ".ps1":
continue
# A URL path is somebody else's file, and a `<name>` placeholder names nothing.
if match.start() and line[match.start() - 1] in "/:<>":
continue
if "<" in token or "*" in token:
continue
rest = line[match.end():]
stop = BREAK_RE.search(rest)
yield token, (rest[:stop.start()] if stop else rest)
def lines_problems(text, resolve, block_of):
"""What is wrong with the PowerShell commands in this text, as human-readable lines.
`resolve(token)` returns the script source texts a documented path could mean (empty when the
repository has no such file), and `block_of(text)` its param block.
"""
found = []
for token, rest in invocations(text):
sources = resolve(token)
if not sources:
found.append(f"{token}: no such script in the repository")
continue
blocks = [block_of(source) for source in sources]
declared = sorted({name for block in blocks for name in parameters(block)})
if not declared:
continue
lower = [name.lower() for name in declared]
for flag in PARAM_RE.findall(rest):
low = flag.lower()
matches = [name for name in lower if name.startswith(low)]
if not matches:
found.append(
f"{token} -{flag}: {token} declares {', '.join('-' + n for n in declared)}, "
f"so PowerShell refuses the script and nothing runs")
elif len(matches) > 1:
found.append(f"{token} -{flag}: matches {', '.join('-' + n for n in matches)}")
# A stock-launcher package name is what a reader types after the list, but the list is the
# only positional parameter: the package has to be the flag's value.
skip_next = False
for word in rest.split():
if skip_next:
skip_next = False
continue
if word.startswith("-"):
skip_next = True
continue
if PACKAGE_RE.fullmatch(word.strip("\"'`")):
found.append(
f"{token} {word}: a package name as a bare argument; the scripts take the stock "
f"launcher with {_stock_flag(declared)}")
return found
def _stock_flag(declared):
for name in declared:
if name.lower().startswith("stock"):
return "-" + name
return "their own flag"
def problems(text):
return lines_problems(text, resolve_in_repo, param_block_of)
def importable_files():
for path in sorted(ROOT.rglob("*")):
if path.suffix not in {".md", ".txt", ".sh", ".ps1"} or not path.is_file():
continue
if SKIP_DIRS & set(path.relative_to(ROOT).parts):
continue
yield path
def resolve_in_repo(token):
"""The script sources a documented path could name, from the repository root.
A path with a directory in it is taken as written (backslashes are Windows). A bare file name is
looked up by name, since `build-and-install.ps1` is how the pages refer to the launcher's, the
add-ons' and the tools' own scripts.
"""
cleaned = token.replace("\\", "/").lstrip("./")
if "/" in cleaned:
path = ROOT / cleaned
return [path.read_text(encoding="utf-8-sig", errors="replace")] if path.is_file() else []
found = [p for p in ROOT.rglob(cleaned) if p.is_file() and not SKIP_DIRS & set(p.parts)]
return [p.read_text(encoding="utf-8-sig", errors="replace") for p in found]
class WindowsCommandTest(unittest.TestCase):
def test_every_documented_powershell_command_runs(self):
findings, read, scripts = [], 0, set()
for path in importable_files():
text = path.read_text(encoding="utf-8-sig", errors="replace")
for token, _ in invocations(text):
read += 1
if resolve_in_repo(token):
scripts.add(token)
for problem in problems(text):
findings.append(f"{path.relative_to(ROOT)}: {problem}")
self.assertEqual([], findings, "\n".join(findings))
# Cannot pass by reading nothing: the repo documents plenty of these commands, against the
# tools, the launcher and the add-ons.
self.assertGreaterEqual(read, 30, "the walk found almost no PowerShell commands")
self.assertGreaterEqual(len(scripts), 5, "the walk resolved almost no scripts")
class ProblemReaderTest(unittest.TestCase):
"""The checks themselves, on documents written here."""
SCRIPTS = {
"tools/restore.ps1": "param(\n [Parameter(Mandatory = $true, Position = 0)][string]$List,\n"
" [string]$Stock = 'com.google.android.tvlauncher',\n"
" [string]$TvHost = $env:TV_HOST\n)\n",
"tools/disable.ps1": "param(\n [Parameter(Mandatory = $true, Position = 0)][string]$List,\n"
" [string]$TvHost = $env:TV_HOST\n)\n",
}
def reader(self, text):
def resolve(token):
return [self.SCRIPTS[token.replace("\\", "/")]] if token.replace("\\", "/") in self.SCRIPTS else []
return lines_problems(text, resolve, param_block_of)
def test_undeclared_parameter_is_reported(self):
found = self.reader(r"tools\restore.ps1 -TvHost 1.2.3.4 list.txt -StockLauncher com.foo.bar")
self.assertEqual(1, len(found), found)
self.assertIn("-StockLauncher", found[0])
self.assertIn("-Stock", found[0])
def test_declared_parameter_is_quiet(self):
self.assertEqual([], self.reader(r"tools\restore.ps1 -TvHost 1.2.3.4 list.txt -Stock com.foo.bar"))
self.assertEqual([], self.reader(r"tools\disable.ps1 -TvHost 1.2.3.4 list.txt"))
def test_a_parameter_belongs_to_the_script_it_is_written_after(self):
# The shape examples/tcl-65c735/debloat.txt had: both scripts on one line, one `-Stock`.
found = self.reader(r"tools\disable.ps1 / tools\restore.ps1 -TvHost 1.2.3.4 list.txt -Stock com.foo.bar")
self.assertTrue(any("-Stock" in line and "disable.ps1" in line for line in found), found)
def test_package_name_as_a_second_bare_argument_is_reported(self):
found = self.reader(r"tools\restore.ps1 list.txt com.google.android.apps.tv.launcherx")
self.assertEqual(1, len(found), found)
self.assertIn("-Stock", found[0])
self.assertIn("com.google.android.apps.tv.launcherx", found[0])
def test_a_list_path_is_not_a_package_name(self):
self.assertEqual([], self.reader(r"tools\restore.ps1 examples\a-b\debloat.txt"))
def test_a_script_the_repository_does_not_ship_is_reported(self):
found = self.reader(r"powershell -ExecutionPolicy Bypass -File run_build.ps1")
self.assertEqual(1, len(found), found)
self.assertIn("no such script", found[0])
def test_a_url_path_is_somebody_elses_file(self):
self.assertEqual([], self.reader("see https://github.com/x/y/blob/main/build.ps1 for that"))
def test_a_placeholder_names_nothing(self):
self.assertEqual([], self.reader(r"addons\<name>\build-and-install.ps1 -TvHost 1.2.3.4"))
def test_the_invocation_stops_at_the_next_command(self):
# `$env:TV_HOST='1.2.3.4'; tools\restore.ps1 list.txt` - the setting is not an argument.
self.assertEqual([], self.reader("$env:TV_HOST='1.2.3.4'; tools\\restore.ps1 list.txt"))
found = self.reader(r"tools\restore.ps1 list.txt; tools\disable.ps1 -Stock com.foo.bar")
self.assertTrue(any("disable.ps1" in line for line in found), found)
def test_two_dots_make_a_package_name_one_does_not(self):
self.assertEqual([], self.reader(r"tools\disable.ps1 whatever check.py says"))
def test_parameters_come_out_of_the_param_block(self):
block = param_block_of(self.SCRIPTS["tools/restore.ps1"])
self.assertEqual(["List", "Stock", "TvHost"], parameters(block))
self.assertEqual([(0, "List")], positional_names(block))
if __name__ == "__main__":
unittest.main()