[tor-commits] [Git][tpo/applications/tor-browser][tor-browser-155.0a1-17.0-1] 13 commits: BB 45308: Implement ./mach yeet command

Pier Angelo Vendrame pushed to branch tor-browser-155.0a1-17.0-1 at The Tor Project / Applications / Tor Browser

Commits:

89980175

by Beatriz Rizental at 2026-11-05T08:37:09+01:00

BB 45308: Implement ./mach yeet command

./mach yeet is the Tor Project version of try -- but much simpler.

7bf6dbd8

by Beatriz Rizental at 2026-11-05T08:37:09+01:00

fixup! BB 45308: Implement ./mach yeet command

Bug 45308: Implement ./mach yeet auth

fd82e86b

by Beatriz Rizental at 2026-11-05T08:37:10+01:00

fixup! BB 45308: Implement ./mach yeet command

Bug 45308: Implement ./mach yeet's upload step

Uploads a local file to the configured build server's public_html
over scp.

6c312932

by Beatriz Rizental at 2026-11-05T08:37:10+01:00

fixup! BB 45308: Implement ./mach yeet command

Bug 45308: Implement ./mach yeet remote's CI trigger

cdd4f1f1

by Beatriz Rizental at 2026-11-05T08:37:10+01:00

fixup! BB 45308: Implement ./mach yeet command

Address review comments

48a32237

by Beatriz Rizental at 2026-11-05T08:37:11+01:00

fixup! BB 45308: Implement ./mach yeet command

Attend more review comments.

f661f0d7
by Pier Angelo Vendrame at 2026-11-05T08:37:11+01:00
```
fixup! TB 42669: [android] Use custom no-op app-services
```
adc63271
by Pier Angelo Vendrame at 2026-11-05T08:37:11+01:00
```
fixup! [android] Modify build system
```

6353e646

by Beatriz Rizental at 2026-11-05T08:37:11+01:00

fixup! TB 41089: Add tor-browser build scripts + Makefile to tor-browser

This reverts commit 5f43c88992e4b69ac03c5e40aeba08fe8d0bd56e.

1ce02a42

by Beatriz Rizental at 2026-11-05T08:37:12+01:00

fixup! TB 43564: Modify ./mach bootstrap for Tor Browser

Move NoScript gitignore statement to this commit

d95babfc

by Beatriz Rizental at 2026-11-05T08:37:12+01:00

fixup! BB 45120: Add tests for Tor Browser

Bug 44820: Upstream geckoiew's own manifest requests
ACCESS_NETWORK_STATE. Tor Browser comments that line
out so geckoview doesn't ask for network-state access,
but the test app needs it. So we add it back.

1aaee7aa

by Beatriz Rizental at 2026-11-05T08:37:12+01:00

fixup! TB 43817: Add tests for Tor Browser

Disable Fenix unit tests by default, since most of them
don't work in Tor Browser (some don't even compile). An
allowlist in the Fenix build.gradle controls which unit
tests are compiled and run, so they can be re-enabled as
they get fixed. When the allowlist is empty, the unit test
compile and test tasks are skipped entirely.

Also add a trivial SanityTest, enabled in the allowlist,
to make sure the unit test pipeline works.

ac3d0ae7

by Henry Wilkes at 2026-11-05T08:37:13+01:00

fixup! TB 41600: Add a tor circuit display panel.

TB 45398: Move tor circuit button into the identity box.

30 changed files:

.gitignore
browser/base/content/navigator-toolbox.inc.xhtml
browser/themes/shared/identity-block/identity-block.css
mobile/android/fenix/app/build.gradle
+ mobile/android/fenix/app/src/test/java/org/mozilla/fenix/torbrowser/SanityTest.kt
mobile/android/geckoview/src/androidTest/AndroidManifest.xml
python/mach/mach/command_util.py
tools/moz.build
− tools/torbrowser/Makefile
− tools/torbrowser/browser-self-sign-macos.sh
− tools/torbrowser/build.sh
− tools/torbrowser/clobber.sh
− tools/torbrowser/config.sh
− tools/torbrowser/deploy.sh
− tools/torbrowser/fetch.sh
− tools/torbrowser/ide.sh
− tools/torbrowser/jslint.sh
− tools/torbrowser/prepare-tests.sh
+ tools/yeet/__init__.py
+ tools/yeet/auth.py
+ tools/yeet/common.py
+ tools/yeet/mach_commands.py
+ tools/yeet/remote.py
+ tools/yeet/tests/python/conftest.py
+ tools/yeet/tests/python/python.toml
+ tools/yeet/tests/python/test_auth.py
+ tools/yeet/tests/python/test_common.py
+ tools/yeet/tests/python/test_remote.py
+ tools/yeet/tests/python/test_upload.py
+ tools/yeet/upload.py

Changes:

.gitignore

@@ -430,14 +430,9 @@ CLAUDE.local.md
  # lint-ignore-next-line: git-only
  /*.json.gz
 -# Ignore binary base of Tor Browser
 -.binaries
 +# GitLab project and token saved by `mach yeet auth`
 +/.yeet.json
 -# Other files modified at build time
 -mobile/android/.experimenter.json
+-
 -# Tor libraries for local builds
 -mobile/android/fenix/tools/nimbus-fml
 -mobile/android/fenix/app/tor-expert-bundle.aar
 +# Symlink to NoScript .xpi. It lives in MOZBUILD, but needs to be symlinked
 +# to this path so it's added to the APK.
  mobile/android/fenix/app/src/main/assets/extensions/{73a6fe31-595d-460b-a920-fcc0f8843232}.xpi
+-

browser/base/content/navigator-toolbox.inc.xhtml

@@ -193,19 +193,6 @@
              <image id="remote-control-icon"/>
            </box>
 -          <!-- We follow the surrounding code and use a
 -             - <xul:box role="button"> rather than a more semantic
 -             - <html:button>, <xul:button> or <xul:toolbarbutton> -->
 -          <box id="tor-circuit-button"
 -               role="button"
 -               class="identity-box-button"
 -               align="center"
 -               data-l10n-id="tor-circuit-urlbar-button"
 -               urlbar-slot="site-info"
 -               hidden="true">
 -            <image id="tor-circuit-button-icon"/>
 -          </box>
+-
            <box
              id="trust-icon-container"
              align="center"
@@ -247,6 +234,17 @@
                  class="identity-box"
                  pageproxystate="invalid"
                  urlbar-slot="site-info">
 +            <!-- We follow the surrounding code and use a
 +               - <xul:box role="button"> rather than a more semantic
 +               - <html:button>, <xul:button> or <xul:toolbarbutton> -->
 +            <box id="tor-circuit-button"
 +                 role="button"
 +                 class="identity-box-button"
 +                 align="center"
 +                 data-l10n-id="tor-circuit-urlbar-button"
 +                 hidden="true">
 +              <image id="tor-circuit-button-icon"/>
 +            </box>
              <!-- Shown when trustPanel.featureGate is off, or for
              chromeUI/extensionPage where tracker blocking never runs, so we
              never update `data-l10n-args`. -->

browser/themes/shared/identity-block/identity-block.css

@@ -7,7 +7,6 @@
  #tracking-protection-icon-container,
  #identity-box,
  #trust-icon-container,
 -#tor-circuit-button,
  #urlbar-label-box {
    height: var(--urlbar-basic-component-size);
+ }
@@ -33,7 +32,9 @@
        /* And don't show the identity icon box in this case,
           just permissions indication */
 -      > #identity-icon-box {
 +      /* Hide the tor circuit when the identity box is also hidden.
 +       * tor-browser#45398. */
 +      > :is(#identity-icon-box, #tor-circuit-button) {
          display: none;
+       }
+     }

mobile/android/fenix/app/build.gradle

@@ -717,6 +717,39 @@ protobuf {
+     }
+ }
 +// Unit tests are disabled by default because most of them don't work in Tor Browser.
 +// Add source path patterns here (e.g. 'org/mozilla/fenix/home/**') to re-enable them
 +// as they get fixed. Only the listed tests (plus the shared helpers) are compiled and run.
 +// When the list is empty, unit tests are neither compiled nor run.
 +def enabledUnitTests = [
 +    'org/mozilla/fenix/torbrowser/**',
 +]
 +def unitTestHelpers = [
 +    'org/mozilla/fenix/helpers/**',
 +]
++
 +tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
 +    if (name.contains("UnitTest")) {
 +        if (enabledUnitTests) {
 +            // The task already has default include patterns, so we can only narrow it down with excludes.
 +            def allowed = new org.gradle.api.tasks.util.PatternSet()
 +                .include((enabledUnitTests + unitTestHelpers).collect { "**/$it" })
 +                .asSpec
 +            exclude { !it.directory && !allowed.isSatisfiedBy(it) }
 +        } else {
 +            enabled = false
 +        }
 +    }
 +}
++
 +tasks.withType(Test).configureEach {
 +    if (enabledUnitTests) {
 +        include enabledUnitTests
 +    } else {
 +        enabled = false
 +    }
 +}
++
  if (project.hasProperty("coverage")) {
      tasks.withType(Test).configureEach {
          jacoco.includeNoLocationClasses = true

mobile/android/fenix/app/src/test/java/org/mozilla/fenix/torbrowser/SanityTest.kt

 +/* This Source Code Form is subject to the terms of the Mozilla Public
 + * License, v. 2.0. If a copy of the MPL was not distributed with this
 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
 +package org.mozilla.fenix.torbrowser
++
 +import org.junit.Assert.assertEquals
 +import org.junit.Test
++
 +class SanityTest {
 +    @Test
 +    fun `one plus one is two`() {
 +        assertEquals(2, 1 + 1)
 +    }
 +}

mobile/android/geckoview/src/androidTest/AndroidManifest.xml

@@ -4,6 +4,7 @@
      <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
      <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
      <uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION"/>
 +    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
      <uses-permission android:name="android.permission.CAMERA"/>
      <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
      <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"

python/mach/mach/command_util.py

@@ -296,6 +296,7 @@ MACH_COMMANDS = {
      "xpcshell-test": MachCommandReference(
          "testing/xpcshell/mach_commands.py", ["test"]
      ),
 +    "yeet": MachCommandReference("tools/yeet/mach_commands.py"),
+ }

tools/moz.build

@@ -75,4 +75,5 @@ PYTHON_UNITTEST_MANIFESTS += [
      "lint/test/python.toml",
      "tryselect/test/python.toml",
      "update-packaging/test/python.toml",
 +    "yeet/tests/python/python.toml",
+ ]

tools/torbrowser/Makefile deleted

 -.DEFAULT_GOAL := all
+-
 -# https://stackoverflow.com/questions/18136918/how-to-get-current-relative-directory-of-your-makefile
 -mkfile_path := "$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))"
+-
 -DEV_ROOT = "$(mkfile_path)/../.."
 -BINARIES = "$(DEV_ROOT)/.binaries"
 -ARCHITECTURE = "$(shell uname -m)"
+-
 -# Correct the architecture naming for ARM to match what mozilla has
 -ifeq ($(ARCHITECTURE), "arm64")
 -  ARCHITECTURE = "aarch64"
 -endif
+-
 -ifeq ($(ARCHITECTURE), "aarch64")
 -  LINUX_VENDOR = "unknown"
 -else
 -  LINUX_VENDOR = "pc"
 -endif
+-
 -# Define build output path based on the platform.
 -ifeq ("$(shell uname)", "Darwin")
 -  BUILD_OUTPUT = "$(DEV_ROOT)/obj-$(ARCHITECTURE)-apple-darwin$(shell uname -r)"
 -else
 -  BUILD_OUTPUT = "$(DEV_ROOT)/obj-$(ARCHITECTURE)-$(LINUX_VENDOR)-linux-gnu"
 -endif
+-
 -# Define the run command based on the platform.
 -ifeq ("$(shell uname)", "Darwin")
 -  RUN_CMD := cd "$(BINARIES)/Tor Browser.app/Contents/MacOS/" && ./firefox --purgecaches
 -else
 -  RUN_CMD := "$(BINARIES)/dev/Browser/start-tor-browser" -v --purgecaches $(ARGS)
 -endif
+-
 -config:
 -	./config.sh $(DEV_ROOT)
+-
 -ide-vscode:
 -	./ide.sh vscode $(DEV_ROOT)
+-
 -ide-eclipse:
 -	./ide.sh eclipse $(DEV_ROOT)
+-
 -ide-visualstudio:
 -	./ide.sh visualstudio $(DEV_ROOT)
+-
 -fetch:
 -	./fetch.sh $(BINARIES)
+-
 -build:
 -	./build.sh $(DEV_ROOT)
+-
 -deploy:
 -	./deploy.sh $(BINARIES) $(BUILD_OUTPUT)
+-
 -prepare-tests:
 -	./prepare-tests.sh $(BINARIES) $(BUILD_OUTPUT)
+-
 -all: build deploy
+-
 -run:
 -	$(RUN_CMD)
+-
 -jslint:
 -	./jslint.sh $(DEV_ROOT) $(JS)
+-
 -clobber:
 -	./clobber.sh $(DEV_ROOT)
+-
 -clean:
 -	rm -rf $(BUILD_OUTPUT)
+-

tools/torbrowser/browser-self-sign-macos.sh deleted

 -#!/bin/bash
+-
 -CERTNAME=my-codesign-cert-tor
 -BROWSERPATH=.
+-
 -if [ $# -ge 1 ]
 -then
 -  BROWSERPATH=$1
 -fi
+-
+-
 -security find-certificate -c $CERTNAME > /dev/null
+-
 -if [ $? -ne 0 ]
 -then
 -  echo ""
 -  echo "ERROR: Self Signing Certificate not found, please create:"
 -  echo "  1. In the Keychain Access app on your Mac, choose Keychain Access > Certificate Assistant > Create a Certificate."
 -  echo "  2. Enter the name '$CERTNAME' for the certificate"
 -  echo "  3. Choose an identity type:  Self Signed Root"
 -  echo "  4. Certificate Type > Code Signing"
 -  echo "  5. Check 'Let me override defaults' & click Continue."
 -  echo "  6. Enter a unique Serial Number. (123 is fine)"
 -  echo "  7. Enter a big Validity Period (days), like 3560 & click Continue."
 -  echo "  8. Fill in your personal information & click Continue."
 -  echo "  9. Accept defaults for the rest of the dialog boxes. (Continue several times)"
 -  echo "  10. Certificate Created! Click Done."
 -  echo ""
 -  echo "For additional help see:"
 -  echo "  https://support.apple.com/en-ca/guide/keychain-access/kyca8916/mac"
 -  echo "  https://stackoverflow.com/questions/58356844/what-are-the-ways-or-technologies-to-sign-an-executable-application-file-in-mac"
+-
 -  echo ""
 -  read -n 1 -r -s -p $'Press enter to launch "Keychain Access"...\n'
 -  open /System/Applications/Utilities/Keychain\ Access.app
+-
 -  exit -1
 -fi
+-
 -echo "Found $CERTNAME, looking for browser to sign..."
+-
 -if [ ! -f "$BROWSERPATH/XUL" ]
 -then
 -  TESTPATH="$BROWSERPATH/Contents/MacOS"
 -  if [ -f "$TESTPATH/XUL" ]
 -  then
 -      BROWSERPATH=$TESTPATH
 -  else
 -    echo "Error: browser files not detected in $BROWSERPATH!"
 -    echo "  This script needs to be run in the 'Contents/MacOS' directory of a SomeBrowser.app directory"
 -    exit -1
 -  fi
 -fi
+-
 -echo "Mozilla based browser found, signing..."
 -echo '  Will be asked for password to certificate for all the things that need to be signed. Click "Always Allow" to automate'
+-
 -cd "$BROWSERPATH"
+-
 -codesign -s $CERTNAME *.dylib
 -codesign -s $CERTNAME plugin-container.app
+-
 -if [ -d Tor ]
 -then
 -  codesign -s $CERTNAME Tor/PluggableTransports/*
 -  codesign -s $CERTNAME Tor/libevent-2.1.7.dylib
 -  if [ -f Tor/tor.real ]
 -  then
 -    codesign -s $CERTNAME Tor/tor.real
 -  fi
 -  if [ -f Tor/tor ]
 -  then
 -    codesign -s $CERTNAME Tor/tor
 -  fi
 -fi
+-
 -codesign -s $CERTNAME XUL
+-
 -if [ -d updater.app ]
 -then
 -  codesign -s $CERTNAME updater.app
 -fi
+-
 -# mullvadbrowser
 -if [ -f mullvadbrowser ]
 -then
 -  codesign -s $CERTNAME mullvadbrowser
 -fi
+-
 -# BB or TB
 -if [ -f firefox ]
 -then
 -  codesign -s $CERTNAME firefox
 -fi
+-
 -echo ""
 -echo "Browser signing step done!"
 -echo ""
+-
 -echo "App still needs one more override to be easily opened with double click in Finder"
 -echo "Alternatively you can right click it, select 'Open' and then select 'Open' from the override popup"
 -echo "Or to enable it to be double clicked to open perform the following"
 -echo ""
 -echo "Double click the app and select either 'Ok' or 'Cancel' from the warning popup depending on which you get (Do Not 'Move to Trash')"
 -echo 'Go to Preferences -> Security & Privacy and click on padlock to allow changes. '
 -echo '  Then in "Allow appications downloaded from" select either:'
 -echo '    - App Store and identified developers'
 -echo '    - Anywhere'
 -echo '  Below that may be a notice about your specific app saying it was blocked because it was not from an identified developer. Click "Open Anyways" and "Open"'
+-

tools/torbrowser/build.sh deleted

 -#!/bin/bash
 -set -e
 -DEV_ROOT=$1
+-
 -cd $DEV_ROOT
 -./mach build
+-
 -if [ -z "$LOCALES" ]; then
 -  ./mach build stage-package
 -else
 -  export MOZ_CHROME_MULTILOCALE=$LOCALES
 -  # No quotes on purpose
 -  ./mach package-multi-locale --locales en-US $MOZ_CHROME_MULTILOCALE
 -  AB_CD=multi ./mach build stage-package
 -fi

tools/torbrowser/clobber.sh deleted

 -#!/bin/bash
 -set -e
 -DEV_ROOT=$1
+-
 -cd $DEV_ROOT
 -./mach clobber

tools/torbrowser/config.sh deleted

 -#!/bin/bash
 -set -e
 -DEV_ROOT=$1
+-
 -cd $DEV_ROOT
 -./mach configure

tools/torbrowser/deploy.sh deleted

 -#!/bin/bash
 -set -e
+-
 -BINARIES="$1"
 -BUILD_OUTPUT="$2"
 -SCRIPT_DIR="$(realpath "$(dirname "$0")")"
+-
 -RESDIR="$BUILD_OUTPUT/dist/firefox"
 -if [ "$(uname)" = "Darwin" ]; then
 -    RESDIR="$RESDIR/Tor Browser.app/Contents/Resources"
 -fi
+-
 -# Repackage the manual
 -# rm -rf $BUILD_OUTPUT/_omni
 -# mkdir $BUILD_OUTPUT/_omni
 -# unzip $BINARIES/dev/Browser/browser/omni.ja -d $BUILD_OUTPUT/_omni
 -# cd $BUILD_OUTPUT/_omni && zip -Xmr $RESDIR/browser/omni.ja chrome/browser/content/browser/manual
 -# rm -rf $BUILD_OUTPUT/_omni
+-
 -if [ "$(uname)" = "Darwin" ]; then
+-
 -    # copy binaries
 -    cp -r "$BUILD_OUTPUT/dist/firefox/"*.app/Contents/* "$BINARIES/Tor Browser.app/Contents/"
 -    rm -rf "$BINARIES/TorBrowser-Data/Browser/Caches/*.default/startupCache"
+-
 -    # Self sign the Binaries
 -    cd "$BINARIES/Tor Browser.app/Contents/MacOS"
 -    "$SCRIPT_DIR/browser-self-sign-macos.sh"
+-
 -else
+-
 -    # backup the startup script
 -    mv "$BINARIES/dev/Browser/firefox" "$BINARIES/dev/Browser/firefox.bak"
+-
 -    # copy binaries
 -    cp -r "$RESDIR/"* "$BINARIES/dev/Browser"
 -    rm -rf "$BINARIES/dev/Browser/TorBrowser/Data/Browser/profile.default/startupCache"
+-
 -    # shuffle firefox bin around and restore script to match a real deployment
 -    mv "$BINARIES/dev/Browser/firefox" "$BINARIES/dev/Browser/firefox.real"
 -    mv "$BINARIES/dev/Browser/firefox.bak" "$BINARIES/dev/Browser/firefox"
+-
 -fi

tools/torbrowser/fetch.sh deleted

 -#!/bin/sh
 -set -e
+-
 -BINARIES_DIR="$1"
+-
 -# download the current downloads.json
 -wget https://aus1.torproject.org/torbrowser/update_3/alpha/downloads.json
 -# get url for latest alpha linux package
 -TOR_BROWSER_VERSION=$(grep -Eo "\"version\"\s*:\s*\"[0-9.a]+\"" downloads.json | grep -Eo "[0-9.a]+")
 -if [ "$(uname)" = "Darwin" ]; then
 -    TOR_BROWSER_PACKAGE="tor-browser-macos-${TOR_BROWSER_VERSION}.dmg"
 -  else
 -    TOR_BROWSER_PACKAGE="tor-browser-linux-$(uname -m)-${TOR_BROWSER_VERSION}.tar.xz"
 -fi
 -TOR_BROWSER_PACKAGE_URL="https://dist.torproject.org/torbrowser/${TOR_BROWSER_VERSION}/${TOR_BROWSER_PACKAGE}"
+-
 -# remove download manifest
 -rm downloads.json
+-
 -# clear out previous tor-browser and previous package
 -rm -rf "${BINARIES_DIR}"
 -rm -f "${TOR_BROWSER_PACKAGE}"
+-
 -# download
 -wget "${TOR_BROWSER_PACKAGE_URL}"
 -mkdir -p "${BINARIES_DIR}"
+-
 -# and extract
 -if [ "$(uname)" = "Darwin" ]
 -  then
 -    hdiutil attach "${TOR_BROWSER_PACKAGE}"
 -    cp -R "/Volumes/Tor Browser Alpha/Tor Browser Alpha.app" "${BINARIES_DIR}/Tor Browser.app"
 -    hdiutil detach "/Volumes/Tor Browser Alpha"
 -  else
 -    tar -xf "${TOR_BROWSER_PACKAGE}" -C "${BINARIES_DIR}"
 -    mv "${BINARIES_DIR}/tor-browser" "${BINARIES_DIR}/dev"
 -fi
+-
 -# Final cleanup
 -rm -f "${TOR_BROWSER_PACKAGE}"

tools/torbrowser/ide.sh deleted

 -#!/bin/bash
 -set -e
 -IDE=$1
 -DEV_ROOT=$2
+-
 -cd $DEV_ROOT
 -./mach ide $IDE

tools/torbrowser/jslint.sh deleted

 -#!/bin/bash
 -set -e
 -DEV_ROOT=$1
 -JS_FILE=$2
+-
 -cd $DEV_ROOT
 -./mach lint -l eslint --fix $JS_FILE

tools/torbrowser/prepare-tests.sh deleted

 -#!/bin/sh
 -set -e
+-
 -BINARIES="$1"
 -BUILD_OUTPUT="$2"
+-
 -if [ ! -d "$BUILD_OUTPUT" ]; then
 -    echo "Error: $BUILD_OUTPUT directory does not exist."
 -    echo "Make sure to run `mach ./build` or `make -C tools/torbrowser build`."
 -    exit 1
 -fi
+-
 -if [ ! -d "$BINARIES" ]; then
 -    echo "Error: $BINARIES directory does not exist."
 -    echo "Make sure to run `make -C tools/torbrowser fetch`."
 -    exit 1
 -fi
+-
 -if [ "$(uname)" = "Darwin" ]; then
 -    cp -r "$BINARIES/Tor Browser.app/Contents/MacOS/Tor" "$BUILD_OUTPUT/dist/firefox/"*.app/Contents/MacOS
 -    cp -r "$BINARIES/Tor Browser.app/Contents/Resources/fonts" "$BUILD_OUTPUT/dist/firefox/"*.app/Contents/Resources
 -else
 -    cp -r "$BINARIES/dev/Browser/fonts" "$BUILD_OUTPUT/dist/bin"
 -    cp -r "$BINARIES/dev/Browser/TorBrowser" "$BUILD_OUTPUT/dist/bin"
 -fi

tools/yeet/__init__.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.

tools/yeet/auth.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +import json
 +import os
 +import subprocess
 +import urllib.error
 +import urllib.parse
 +import urllib.request
 +from pathlib import Path
++
 +from yeet.common import (
 +    CANONICAL_GITLAB_PROJECT,
 +    CANONICAL_GITLAB_REPO_NAME,
 +    DEFAULT_SSH_HOST,
 +    GITLAB_API_BASE,
 +    TERM,
 +    YEET_CONFIG_FILENAME,
 +    prompt,
 +)
++
++
 +def _resolve_project(raw_username):
 +    """Build a fork project path out of a GitLab username. Raises ValueError
 +    if it's empty or the canonical repo's own namespace.
 +    """
 +    username = raw_username.strip()
 +    if not username:
 +        raise ValueError("A GitLab username is required.")
++
 +    project = f"{username}/{CANONICAL_GITLAB_REPO_NAME}"
 +    if project.lower() == CANONICAL_GITLAB_PROJECT.lower():
 +        raise ValueError(
 +            "That's the canonical repo's namespace, not a fork. Use your "
 +            "own GitLab username instead."
 +        )
++
 +    return project
++
++
 +def _prompt_fork():
 +    print()
 +    print(
 +        TERM.yellow(
 +            f"""`mach yeet remote` runs against your own fork of
 +{CANONICAL_GITLAB_PROJECT}, never against the canonical repo
 +directly -- that keeps CI runs off the shared project.
++
 +If you haven't forked it yet, fork it first at:
 +  https://gitlab.torproject.org/{CANONICAL_GITLAB_PROJECT}/-/forks/new
++
 +Keep your fork up to date too. An outdated fork's .gitlab-ci.yml may be missing
 +pieces this command relies on, so pipelines could fail or come back empty."""
 +        )
 +    )
 +    print()
++
 +    while True:
 +        try:
 +            return _resolve_project(prompt("Your GitLab username: "))
 +        except ValueError as e:
 +            print(TERM.red(f"ERROR! {e}"))
++
++
 +def _gitlab_token_instructions(project):
 +    return f"""
 +Now you need a pipeline trigger token for your fork:
 +  {project}
++
 +This is NOT a personal access token -- it's specific to this one project, and
 +it's the only kind that can actually run CI jobs here (their rules require it):
++
 +  1. Go to https://gitlab.torproject.org/{project}/-/settings/ci_cd#js-pipeline-triggers
 +  2. Expand "Pipeline trigger tokens" and add a new one.
 +  3. Paste the token below.
++
 +The project and token will be saved to {YEET_CONFIG_FILENAME} at the root of the repository
 +and are not committed to it.
 +""".strip()
++
++
 +def _print_ssh_instructions():
 +    print()
 +    print(
 +        TERM.yellow(
 +            f"""`mach yeet` also uploads to and runs commands on a build server over SSH
 +({DEFAULT_SSH_HOST} by default). Uploaded files are served from your
 +account's public_html there, at:
 +  https://<host>/~<username>
++
 +Anything special about the connection -- port, jump host, a hardware key's
 +PKCS11 provider, agent forwarding -- belongs in your ~/.ssh/config, not here:
 +we just shell out to `ssh`. Whatever already works on your command line works
 +for `mach yeet` too."""
 +        )
 +    )
 +    print()
++
++
 +def _prompt_ssh_host():
 +    return prompt(f"SSH host [{DEFAULT_SSH_HOST}]: ").strip() or DEFAULT_SSH_HOST
++
++
 +def _prompt_ssh_username(ssh_host):
 +    while True:
 +        username = prompt(f"Your username on {ssh_host}: ").strip()
 +        if username:
 +            return username
 +        print(TERM.red("ERROR! Username cannot be empty."))
++
++
 +def _prompt_token():
 +    while True:
 +        token = prompt("GitLab token: ", secret=True).strip()
 +        if token:
 +            return token
 +        print(TERM.red("ERROR! Token cannot be empty."))
++
++
 +def _verify_ssh(target):
 +    """Try an actual SSH connection. stdin is /dev/null so ssh can't swallow
 +    input buffered for us; its touch/PIN/passphrase prompts go through
 +    /dev/tty and still reach the user.
 +    """
 +    try:
 +        result = subprocess.run(
 +            ["ssh", target, "true"],
 +            stdin=subprocess.DEVNULL,
 +            check=False,
 +        )
 +    except FileNotFoundError:
 +        print()
 +        print(TERM.red("ERROR! No `ssh` binary found on PATH."))
 +        return False
 +    return result.returncode == 0
++
++
 +def _verify_auth(project, token):
 +    """Check that `project`/`token` are accepted by GitLab, without
 +    actually triggering a pipeline.
++
 +    GitLab authenticates the trigger token before validating the rest of
 +    the request, so posting to the trigger endpoint without the required
 +    `ref` param never queues a pipeline: a valid token/project combination
 +    gets rejected with 400 (missing ref) instead, while an invalid token
 +    or unknown project is rejected with 401/404 before `ref` is even
 +    looked at.
 +    """
 +    url = f"{GITLAB_API_BASE}/projects/{urllib.parse.quote(project, safe='')}/trigger/pipeline"
 +    data = urllib.parse.urlencode({"token": token}).encode()
 +    request = urllib.request.Request(url, data=data, method="POST")
 +    try:
 +        with urllib.request.urlopen(request):
 +            pass
 +    except urllib.error.HTTPError as e:
 +        return e.code == 400
 +    else:
 +        return True
++
++
 +def run(command_context, **kwargs):
 +    gitlab_username = kwargs.get("gitlab_username")
 +    if gitlab_username is not None:
 +        try:
 +            project = _resolve_project(gitlab_username)
 +        except ValueError as e:
 +            print(TERM.red(f"ERROR! --gitlab-username: {e}"))
 +            return 1
 +    else:
 +        project = _prompt_fork()
++
 +    gitlab_token = kwargs.get("gitlab_token")
 +    if gitlab_token is not None:
 +        token = gitlab_token.strip()
 +        if not token:
 +            print()
 +            print(TERM.red("ERROR! --gitlab-token was empty."))
 +            return 1
 +    else:
 +        print()
 +        print(_gitlab_token_instructions(project))
 +        print()
 +        token = _prompt_token()
++
 +    verify = kwargs.get("verify", True)
 +    if verify:
 +        print()
 +        print("Verifying credentials with GitLab...")
 +        try:
 +            verified = _verify_auth(project, token)
 +        except urllib.error.URLError as e:
 +            print()
 +            print(TERM.red(f"ERROR! Could not reach GitLab: {e}"))
 +            return 1
++
 +        if not verified:
 +            print()
 +            print(
 +                TERM.red(
 +                    "ERROR! GitLab rejected that project/token combination. "
 +                    "Double-check the fork name and the trigger token."
 +                )
 +            )
 +            return 1
 +        print(TERM.green("Credentials verified."))
++
 +    ssh_host = kwargs.get("ssh_host")
 +    ssh_username = kwargs.get("ssh_username")
 +    if ssh_host is None or ssh_username is None:
 +        _print_ssh_instructions()
++
 +    if ssh_host is not None:
 +        ssh_host = ssh_host.strip()
 +        if not ssh_host:
 +            print()
 +            print(TERM.red("ERROR! --ssh-host was empty."))
 +            return 1
 +    else:
 +        ssh_host = _prompt_ssh_host()
++
 +    if ssh_username is not None:
 +        ssh_username = ssh_username.strip()
 +        if not ssh_username:
 +            print()
 +            print(TERM.red("ERROR! --ssh-user was empty."))
 +            return 1
 +    else:
 +        ssh_username = _prompt_ssh_username(ssh_host)
++
 +    if verify:
 +        ssh_target = f"{ssh_username}@{ssh_host}"
 +        print()
 +        print(f"Verifying SSH access to {ssh_target}...")
 +        if not _verify_ssh(ssh_target):
 +            print()
 +            print(
 +                TERM.red(
 +                    f"ERROR! Could not SSH into {ssh_target}. Make sure you "
 +                    "can `ssh` there yourself first."
 +                )
 +            )
 +            return 1
 +        print(TERM.green("SSH access verified."))
++
 +    tokens_path = Path(command_context.topsrcdir) / YEET_CONFIG_FILENAME
 +    file_desc = os.open(
 +        tokens_path, flags=os.O_WRONLY | os.O_CREAT | os.O_TRUNC, mode=0o600
 +    )
 +    with open(file_desc, "w") as f:
 +        json.dump(
 +            {
 +                "project": project,
 +                "token": token,
 +                "ssh_host": ssh_host,
 +                "ssh_user": ssh_username,
 +            },
 +            f,
 +        )
 +    os.chmod(tokens_path, 0o600)
++
 +    print()
 +    print(TERM.green(f"Saved to {tokens_path}"))
 +    return 0

tools/yeet/common.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +import getpass
 +import json
 +import sys
 +from pathlib import Path
++
 +from mozterm import Terminal
++
 +TERM = Terminal()
++
 +GITLAB_API_BASE = "https://gitlab.torproject.org/api/v4"
++
 +# The canonical repo. `mach yeet remote` must never target this directly --
 +# only a fork of it, so CI runs don't pile up on the shared project.
 +CANONICAL_GITLAB_NAMESPACE = "tpo/applications"
 +CANONICAL_GITLAB_REPO_NAME = "tor-browser-bundle-testsuite"
 +CANONICAL_GITLAB_PROJECT = f"{CANONICAL_GITLAB_NAMESPACE}/{CANONICAL_GITLAB_REPO_NAME}"
++
 +# Project and token saved by `mach yeet auth`.
 +YEET_CONFIG_FILENAME = ".yeet.json"
++
 +# The default server `mach yeet` uploads to and runs commands on over SSH.
 +# Uploaded files are served from the user's public_html on it.
 +DEFAULT_SSH_HOST = "tb-build-03.torproject.org"
++
++
 +def prompt(message, secret=False):
 +    """Read a line of user input, first discarding anything typed before the
 +    prompt appeared so stray keystrokes aren't taken as the answer.
 +    """
 +    if sys.stdin.isatty():
 +        try:
 +            import termios
++
 +            termios.tcflush(sys.stdin, termios.TCIFLUSH)
 +        except ImportError:
 +            pass
 +    if secret:
 +        return getpass.getpass(message)
 +    return input(message)
++
++
 +def confirm(message):
 +    """Ask a yes/no question, defaulting to no, until a valid answer is given."""
 +    while True:
 +        answer = prompt(f"{message} [y/N]: ").strip().lower()
 +        if answer in ("y", "yes"):
 +            return True
 +        if answer in ("", "n", "no"):
 +            return False
 +        print(TERM.red("ERROR! Please answer 'y' or 'n'."))
++
++
 +def read_config(topsrcdir):
 +    """Read the project/token/ssh_* config saved by `mach yeet auth`, or
 +    None if it hasn't been run yet.
 +    """
 +    config_path = Path(topsrcdir) / YEET_CONFIG_FILENAME
 +    if not config_path.is_file():
 +        return None
++
 +    with open(config_path) as f:
 +        return json.load(f)

tools/yeet/mach_commands.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +from mach.decorators import Command, CommandArgument, SubCommand  # noqa: I001
++
 +from yeet import remote
++
++
 +@Command(
 +    "yeet",
 +    category="ci",
 +    description="TODO: build / test remotely from the current state of the repo.",
 +)
 +def yeet(command_context):
 +    # TODO: this will be the main "yeet" command -- push, build and (maybe)
 +    # test remotely from the current state of the local repo, rather than
 +    # requiring an already-published build like `yeet remote` does.
 +    pass
++
++
 +@SubCommand(
 +    "yeet",
 +    "remote",
 +    description="Trigger a tor-browser-bundle-testsuite CI job against an "
 +    "already-published build, for a single platform.",
 +)
 +@CommandArgument(
 +    "--platform",
 +    default=None,
 +    choices=remote.PLATFORMS,
 +    help="Platform to test. Prompted for if not provided.",
 +)
 +@CommandArgument(
 +    "--channel",
 +    default=None,
 +    choices=remote.ANDROID_CHANNELS,
 +    help="Android build channel/flavor to install (only used with "
 +    "--platform android_x86_64). Prompted for if not provided.",
 +)
 +@CommandArgument(
 +    "installer_url",
 +    help="URL of the installer to test, or a local file path to upload first.",
 +)
 +@CommandArgument(
 +    "--sha256sums-url", default=None, help="URL of the build's sha256sums file."
 +)
 +@CommandArgument(
 +    "--artifacts-url",
 +    default=None,
 +    help="URL of the build's artifacts directory. Inferred from the "
 +    "in-tree browser version and --platform if not provided.",
 +)
 +@CommandArgument(
 +    "--mozharness-url",
 +    default=None,
 +    help="URL of the mozharness.zip to use. Inferred from the in-tree "
 +    "browser version and --platform if not provided.",
 +)
 +@CommandArgument(
 +    "--version",
 +    default=None,
 +    help="Browser version to use when inferring --artifacts-url and "
 +    "--mozharness-url. Defaults to the in-tree version "
 +    "(browser/config/version.txt).",
 +)
 +@CommandArgument(
 +    "--ref",
 +    default="main",
 +    help="tor-browser-bundle-testsuite ref to run on. Must have a "
 +    ".gitlab-ci.yml, which the default branch may not.",
 +)
 +@CommandArgument(
 +    "--tag",
 +    dest="tags",
 +    action="append",
 +    default=None,
 +    help="Test tag to filter tests by (can be passed multiple times, e.g. "
 +    "--tag tor --tag base-browser). Defaults to '--tag tor --tag base-browser'.",
 +)
 +@CommandArgument(
 +    "--dry-run",
 +    action="store_true",
 +    default=False,
 +    help="Print the curl command instead of triggering the pipeline.",
 +)
 +@CommandArgument(
 +    "--yes",
 +    "-y",
 +    dest="assume_yes",
 +    action="store_true",
 +    default=False,
 +    help="Upload a local installer without asking for confirmation.",
 +)
 +def yeet_remote(command_context, **kwargs):
 +    # With action="", argparse appends to a non-None default instead of
 +    # replacing it, so the default tags are applied here only if none were given.
 +    if kwargs["tags"] is None:
 +        kwargs["tags"] = ["tor", "base-browser"]
 +    return remote.run(command_context, **kwargs)
++
++
 +@SubCommand(
 +    "yeet",
 +    "auth",
 +    description="Save a GitLab project and access token for running CI jobs.",
 +)
 +@CommandArgument(
 +    "--no-verify",
 +    dest="verify",
 +    action="store_false",
 +    help="Skip checking the GitLab and SSH credentials before saving them.",
 +)
 +@CommandArgument(
 +    "--gitlab-username",
 +    default=None,
 +    help="GitLab username to use, skipping that prompt.",
 +)
 +@CommandArgument(
 +    "--gitlab-token",
 +    default=None,
 +    help=(
 +        "GitLab pipeline trigger token to use, skipping that prompt. Note "
 +        "this may end up in your shell history."
 +    ),
 +)
 +@CommandArgument(
 +    "--ssh-user",
 +    dest="ssh_username",
 +    default=None,
 +    help="Username on the build server, skipping that prompt.",
 +)
 +@CommandArgument(
 +    "--ssh-host",
 +    default=None,
 +    help="Build server to upload to and run commands on over SSH, skipping that prompt.",
 +)
 +def yeet_auth(command_context, **kwargs):
 +    from yeet import auth
++
 +    return auth.run(command_context, **kwargs)

tools/yeet/remote.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +import json
 +import os
 +import shlex
 +import urllib.error
 +import urllib.parse
 +import urllib.request
++
 +from yeet import upload
 +from yeet.common import (
 +    GITLAB_API_BASE,
 +    TERM,
 +    prompt,
 +    read_config,
 +)
++
 +PLATFORM_TOOLCHAIN_DIR = {
 +    "debian_x86_64": "linux-x86_64",
 +    "windows_x86_64": "windows-x86_64",
 +    "macos_x86_64": "macos-x86_64",
 +    "android_x86_64": "android-x86_64",
 +}
++
 +PLATFORMS = list(PLATFORM_TOOLCHAIN_DIR.keys())
++
 +GITLAB_REQUEST_TIMEOUT_SECONDS = 30
++
 +TOOLCHAINS_URL_BASE = "https://nightlies.tbb.torproject.org/nightly-builds/toolchains"
++
 +# Each Android build channel/flavor ships under its own package name, so the
 +# pipeline needs to be told which one to install.
 +ANDROID_CHANNEL_PACKAGE_NAMES = {
 +    "debug": "org.torproject.torbrowser_debug",
 +    "nightly": "org.torproject.torbrowser_nightly",
 +    "alpha": "org.torproject.torbrowser_alpha",
 +    "release": "org.torproject.torbrowser",
 +}
 +ANDROID_CHANNELS = list(ANDROID_CHANNEL_PACKAGE_NAMES)
++
++
 +def _read_browser_version(topsrcdir):
 +    version_path = os.path.join(topsrcdir, "browser", "config", "version.txt")
 +    with open(version_path) as f:
 +        return f.read().strip()
++
++
 +def _resolve_version(topsrcdir, version):
 +    if version:
 +        return version
++
 +    version = _read_browser_version(topsrcdir)
 +    print(
 +        TERM.yellow(
 +            f"""Inferred platform version {version} from browser/config/version.txt.
 +Pass --version if this isn't the version you want to test."""
 +        )
 +    )
 +    return version
++
++
 +def _artifacts_url(version, platform):
 +    return f"{TOOLCHAINS_URL_BASE}/{version}/{PLATFORM_TOOLCHAIN_DIR[platform]}/"
++
++
 +def _mozharness_url(version, platform):
 +    return f"{_artifacts_url(version, platform)}mozharness.zip"
++
++
 +def _curl_command(url, headers, data):
 +    args = ["curl", "--request", "POST"]
 +    for name, value in headers.items():
 +        args += ["--header", f"{name}: {value}"]
 +    args += ["--data", data.decode("utf-8"), url]
 +    return shlex.join(args)
++
++
 +def _resolve_installer_url(topsrcdir, installer, platform, assume_yes, dry_run):
 +    """Accept either an installer URL directly, or a local file path to
 +    upload first. On a dry run a local file is not uploaded, and a
 +    placeholder URL is returned instead. Raises whatever
 +    `upload.run` raises on failure.
 +    """
 +    if urllib.parse.urlparse(installer).scheme in ("http", "https"):
 +        return installer
 +    if dry_run:
 +        file_path = upload.resolve_file(installer)
 +        print(TERM.yellow(f"Dry run: not uploading {file_path}."))
 +        return f"<URL of uploaded {file_path.name}>"
 +    return upload.run(topsrcdir, installer, platform, assume_yes=assume_yes)
++
++
 +def _prompt_platform():
 +    print()
 +    print(
 +        TERM.bold(
 +            "Select the platform you are testing for (if not listed, tests are not supported yet):"
 +        )
 +    )
 +    for i, platform in enumerate(PLATFORMS, 1):
 +        print(f"  {TERM.cyan(str(i))}) {platform}")
 +    print()
++
 +    while True:
 +        choice = prompt(f"Platform [1-{len(PLATFORMS)}]: ").strip()
 +        if choice.isdigit() and 1 <= int(choice) <= len(PLATFORMS):
 +            print()
 +            return PLATFORMS[int(choice) - 1]
 +        print(TERM.red(f"ERROR! Please enter a number between 1 and {len(PLATFORMS)}."))
++
++
 +def _prompt_channel():
 +    print()
 +    print(TERM.bold("Select the Android build channel/flavor you are testing:"))
 +    for i, channel in enumerate(ANDROID_CHANNELS, 1):
 +        print(f"  {TERM.cyan(str(i))}) {channel}")
 +    print()
++
 +    while True:
 +        choice = prompt(f"Channel [1-{len(ANDROID_CHANNELS)}]: ").strip()
 +        if choice.isdigit() and 1 <= int(choice) <= len(ANDROID_CHANNELS):
 +            print()
 +            return ANDROID_CHANNELS[int(choice) - 1]
 +        print(
 +            TERM.red(
 +                f"ERROR! Please enter a number between 1 and {len(ANDROID_CHANNELS)}."
 +            )
 +        )
++
++
 +def run(command_context, **kwargs):
 +    # TODO(tor-browser-bundle-testsuite#40120): this runs whatever the pipeline
 +    # runs, indiscriminately -- fine for now since marionette is the only suite
 +    # it has, but once others (xpcshell, cppunittest, mochitest, ...) exist, add
 +    # a --suite argument here and thread it into `inputs` so a run can be scoped
 +    # to just one.
 +    config = read_config(command_context.topsrcdir)
 +    if config is None:
 +        print(TERM.red("No GitLab fork/token found, run `mach yeet auth` first."))
 +        return 1
++
 +    installer_url = kwargs["installer_url"].strip()
 +    if not installer_url:
 +        print(TERM.red("ERROR! The installer URL or path was empty."))
 +        return 1
++
 +    platform = kwargs.get("platform") or _prompt_platform()
 +    dry_run = kwargs.get("dry_run", False)
++
 +    try:
 +        installer_url = _resolve_installer_url(
 +            command_context.topsrcdir,
 +            installer_url,
 +            platform,
 +            kwargs.get("assume_yes", False),
 +            dry_run,
 +        )
 +    except (FileNotFoundError, RuntimeError) as e:
 +        print()
 +        print(TERM.red(f"ERROR! {e}"))
 +        return 1
++
 +    package_name = None
 +    if platform == "android_x86_64":
 +        channel = kwargs.get("channel") or _prompt_channel()
 +        if channel not in ANDROID_CHANNEL_PACKAGE_NAMES:
 +            print(TERM.red(f"ERROR! Unknown channel {channel!r}."))
 +            return 1
 +        package_name = ANDROID_CHANNEL_PACKAGE_NAMES[channel]
++
 +    artifacts_url = kwargs.get("artifacts_url")
 +    mozharness_url = kwargs.get("mozharness_url")
 +    if not artifacts_url or not mozharness_url:
 +        version = _resolve_version(command_context.topsrcdir, kwargs.get("version"))
 +    if not artifacts_url:
 +        artifacts_url = _artifacts_url(version, platform)
 +    if not mozharness_url:
 +        mozharness_url = _mozharness_url(version, platform)
++
 +    inputs = {
 +        "mozharness_url": mozharness_url,
 +        f"{platform}_installer_url": installer_url,
 +        f"{platform}_artifacts_url": artifacts_url,
 +    }
 +    if package_name:
 +        inputs[f"{platform}_package_name"] = package_name
 +    if sha256sums_url := kwargs.get("sha256sums_url"):
 +        inputs[f"{platform}_sha256sums_url"] = sha256sums_url
 +    if tags := kwargs.get("tags"):
 +        inputs["tags"] = shlex.join(arg for tag in tags for arg in ("--tag", tag))
++
 +    project_id = urllib.parse.quote(config["project"], safe="")
 +    url = f"{GITLAB_API_BASE}/projects/{project_id}/trigger/pipeline"
 +    headers = {"Content-Type": "application/json"}
 +    data = json.dumps({
 +        "token": config["token"],
 +        "ref": kwargs.get("ref", "main"),
 +        "inputs": inputs,
 +    }).encode("utf-8")
++
 +    if dry_run:
 +        print()
 +        print(TERM.cyan(_curl_command(url, headers, data)))
 +        print()
 +        return 0
++
 +    request = urllib.request.Request(url, data=data, headers=headers, method="POST")
++
 +    try:
 +        with urllib.request.urlopen(
 +            request, timeout=GITLAB_REQUEST_TIMEOUT_SECONDS
 +        ) as response:
 +            result = json.load(response)
 +    except urllib.error.HTTPError as e:
 +        body = e.read().decode("utf-8", "replace")
 +        print(
 +            TERM.red(f"ERROR! Failed to trigger pipeline: {e.code} {e.reason}\n{body}")
 +        )
 +        return 1
 +    except urllib.error.URLError as e:
 +        print(TERM.red(f"ERROR! Could not reach GitLab: {e}"))
 +        return 1
++
 +    print()
 +    print(TERM.green(f"Pipeline triggered: {result.get('web_url')}"))
 +    return 0

tools/yeet/tests/python/conftest.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +import json
++
 +from yeet import common  # noqa: E402
++
++
 +def write_config(tmp_path, **overrides):
 +    """Write a `.yeet.json` under `tmp_path`, as `mach yeet auth` would,
 +    for tests that need one already in place.
 +    """
 +    config = {
 +        "project": "bea/tor-browser-bundle-testsuite",
 +        "token": "s3cr3t",
 +        "ssh_host": common.DEFAULT_SSH_HOST,
 +        "ssh_user": "bea",
 +    }
 +    config.update(overrides)
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME, "w") as f:
 +        json.dump(config, f)
 +    return config

tools/yeet/tests/python/python.toml

 +[DEFAULT]
 +subsuite = "base-browser"
++
 +["test_auth.py"]
++
 +["test_upload.py"]
++
 +["test_remote.py"]
++
 +["test_common.py"]

tools/yeet/tests/python/test_auth.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +import json
 +import urllib.error
 +from types import SimpleNamespace
++
 +import mozunit
 +import pytest
 +from yeet import auth, common
++
++
 +def _set_inputs(monkeypatch, *values):
 +    values = iter(values)
 +    monkeypatch.setattr("builtins.input", lambda prompt="": next(values))
++
++
 +def _forbid_prompts(monkeypatch):
 +    """Make input()/getpass() blow up instead of hanging, so a test can
 +    assert that a fully non-interactive call never prompts."""
++
 +    def _fail(prompt=""):
 +        raise AssertionError(f"unexpected prompt: {prompt!r}")
++
 +    monkeypatch.setattr("builtins.input", _fail)
 +    monkeypatch.setattr(common.getpass, "getpass", _fail)
++
++
 +@pytest.mark.parametrize("value", ["bea", "  bea  ", "bea.b", "bea_b-1"])
 +def test_resolve_project_accepts_username(value):
 +    project = auth._resolve_project(value)
++
 +    assert project == f"{value.strip()}/{common.CANONICAL_GITLAB_REPO_NAME}"
++
++
 +@pytest.mark.parametrize(
 +    "value",
 +    [
 +        common.CANONICAL_GITLAB_NAMESPACE,
 +        common.CANONICAL_GITLAB_NAMESPACE.upper(),
 +        f"  {common.CANONICAL_GITLAB_NAMESPACE}  ",
 +    ],
 +)
 +def test_resolve_project_rejects_canonical_namespace(value):
 +    with pytest.raises(ValueError, match="canonical"):
 +        auth._resolve_project(value)
++
++
 +def test_resolve_project_accepts_top_level_group_of_canonical_namespace():
 +    group = common.CANONICAL_GITLAB_NAMESPACE.split("/", 1)[0]
++
 +    assert auth._resolve_project(group) == (
 +        f"{group}/{common.CANONICAL_GITLAB_REPO_NAME}"
 +    )
++
++
 +def test_prompt_fork_rejects_canonical_namespace(monkeypatch, capsys):
 +    canonical_namespace = common.CANONICAL_GITLAB_NAMESPACE
 +    _set_inputs(monkeypatch, canonical_namespace, "bea")
++
 +    project = auth._prompt_fork()
++
 +    assert project == f"bea/{common.CANONICAL_GITLAB_REPO_NAME}"
 +    assert "not a" in capsys.readouterr().out.lower()
++
++
 +@pytest.mark.parametrize("value", ["", "   ", "\t\n"])
 +def test_resolve_project_rejects_blank_username(value):
 +    with pytest.raises(ValueError):
 +        auth._resolve_project(value)
++
++
 +def test_prompt_fork_rejects_empty_username(monkeypatch):
 +    _set_inputs(monkeypatch, "", " \t ", "bea")
++
 +    project = auth._prompt_fork()
++
 +    assert project == f"bea/{common.CANONICAL_GITLAB_REPO_NAME}"
++
++
 +@pytest.mark.parametrize("status", [400])
 +def test_verify_auth_accepts_valid_token(monkeypatch, status):
 +    def fake_urlopen(request, *args, **kwargs):
 +        raise urllib.error.HTTPError("url", status, "msg", None, None)
++
 +    monkeypatch.setattr(auth.urllib.request, "urlopen", fake_urlopen)
++
 +    assert auth._verify_auth("bea/tor-browser-bundle-testsuite", "tok") is True
++
++
 +@pytest.mark.parametrize("status", [401, 404])
 +def test_verify_auth_rejects_bad_token_or_project(monkeypatch, status):
 +    def fake_urlopen(request, *args, **kwargs):
 +        raise urllib.error.HTTPError("url", status, "msg", None, None)
++
 +    monkeypatch.setattr(auth.urllib.request, "urlopen", fake_urlopen)
++
 +    assert auth._verify_auth("bea/tor-browser-bundle-testsuite", "tok") is False
++
++
 +def test_verify_auth_propagates_network_errors(monkeypatch):
 +    def fake_urlopen(request, *args, **kwargs):
 +        raise urllib.error.URLError("unreachable")
++
 +    monkeypatch.setattr(auth.urllib.request, "urlopen", fake_urlopen)
++
 +    with pytest.raises(urllib.error.URLError):
 +        auth._verify_auth("bea/tor-browser-bundle-testsuite", "tok")
++
++
 +def test_verify_ssh_success(monkeypatch):
 +    calls = []
++
 +    def fake_run(cmd, **kwargs):
 +        calls.append((cmd, kwargs))
 +        return SimpleNamespace(returncode=0)
++
 +    monkeypatch.setattr(auth.subprocess, "run", fake_run)
++
 +    assert auth._verify_ssh("bea@xxxxxxxxxxxxxxxxxxxxxxxxxx") is True
 +    cmd, kwargs = calls[0]
 +    assert cmd[-2:] == ["bea@xxxxxxxxxxxxxxxxxxxxxxxxxx", "true"]
 +    assert kwargs["stdin"] is auth.subprocess.DEVNULL
++
++
 +def test_verify_ssh_failure(monkeypatch):
 +    monkeypatch.setattr(
 +        auth.subprocess,
 +        "run",
 +        lambda *args, **kwargs: SimpleNamespace(returncode=255),
 +    )
++
 +    assert auth._verify_ssh("bea@xxxxxxxxxxxxxxxxxxxxxxxxxx") is False
++
++
 +def test_verify_ssh_missing_binary(monkeypatch, capsys):
 +    def fake_run(*args, **kwargs):
 +        raise FileNotFoundError()
++
 +    monkeypatch.setattr(auth.subprocess, "run", fake_run)
++
 +    assert auth._verify_ssh("bea@xxxxxxxxxxxxxxxxxxxxxxxxxx") is False
 +    assert "no `ssh` binary" in capsys.readouterr().out.lower()
++
++
 +def test_run_saves_config_and_skips_verification(tmp_path, monkeypatch):
 +    _set_inputs(monkeypatch, "bea", "", "bea")
 +    monkeypatch.setattr(common.getpass, "getpass", lambda prompt="": "s3cr3t")
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(command_context, verify=False)
++
 +    assert result == 0
 +    config_path = tmp_path / common.YEET_CONFIG_FILENAME
 +    with open(config_path) as f:
 +        saved = json.load(f)
 +    assert saved == {
 +        "project": f"bea/{common.CANONICAL_GITLAB_REPO_NAME}",
 +        "token": "s3cr3t",
 +        "ssh_host": common.DEFAULT_SSH_HOST,
 +        "ssh_user": "bea",
 +    }
 +    assert (config_path.stat().st_mode & 0o777) == 0o600
++
++
 +def test_prompt_ssh_username_reprompts_until_non_empty(monkeypatch, capsys):
 +    _set_inputs(monkeypatch, "", "  ", "bea")
++
 +    assert auth._prompt_ssh_username(common.DEFAULT_SSH_HOST) == "bea"
 +    assert capsys.readouterr().out.count("ERROR!") == 2
++
++
 +def test_prompt_ssh_host_defaults_when_empty(monkeypatch):
 +    _set_inputs(monkeypatch, "  ")
++
 +    assert auth._prompt_ssh_host() == common.DEFAULT_SSH_HOST
++
++
 +def test_run_prompts_for_ssh_host(tmp_path, monkeypatch):
 +    _set_inputs(monkeypatch, "build.example.com", "bea")
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(
 +        command_context, verify=False, gitlab_username="bea", gitlab_token="s3cr3t"
 +    )
++
 +    assert result == 0
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME) as f:
 +        saved = json.load(f)
 +    assert saved["ssh_host"] == "build.example.com"
 +    assert saved["ssh_user"] == "bea"
++
++
 +def test_prompt_token_reprompts_until_non_empty(monkeypatch, capsys):
 +    values = iter(["", "  ", "s3cr3t"])
 +    monkeypatch.setattr(common.getpass, "getpass", lambda prompt="": next(values))
++
 +    assert auth._prompt_token() == "s3cr3t"
 +    assert capsys.readouterr().out.count("ERROR!") == 2
++
++
 +def test_run_aborts_when_gitlab_verification_fails(tmp_path, monkeypatch, capsys):
 +    _set_inputs(monkeypatch, "bea", "", "bea")
 +    monkeypatch.setattr(common.getpass, "getpass", lambda prompt="": "s3cr3t")
 +    monkeypatch.setattr(auth, "_verify_auth", lambda project, token: False)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(command_context, verify=True)
++
 +    assert result == 1
 +    assert not (tmp_path / common.YEET_CONFIG_FILENAME).exists()
 +    assert (
 +        "ERROR! GitLab rejected that project/token combination."
 +        in capsys.readouterr().out
 +    )
++
++
 +def test_run_aborts_when_gitlab_unreachable(tmp_path, monkeypatch, capsys):
 +    _set_inputs(monkeypatch, "bea", "", "bea")
 +    monkeypatch.setattr(common.getpass, "getpass", lambda prompt="": "s3cr3t")
++
 +    def raise_url_error(project, token):
 +        raise urllib.error.URLError("unreachable")
++
 +    monkeypatch.setattr(auth, "_verify_auth", raise_url_error)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(command_context, verify=True)
++
 +    assert result == 1
 +    assert not (tmp_path / common.YEET_CONFIG_FILENAME).exists()
 +    assert (
 +        "ERROR! Could not reach GitLab: <urlopen error unreachable>"
 +        in capsys.readouterr().out
 +    )
++
++
 +def test_run_aborts_when_ssh_verification_fails(tmp_path, monkeypatch, capsys):
 +    _set_inputs(monkeypatch, "bea", "", "bea")
 +    monkeypatch.setattr(common.getpass, "getpass", lambda prompt="": "s3cr3t")
 +    monkeypatch.setattr(auth, "_verify_auth", lambda project, token: True)
 +    monkeypatch.setattr(auth, "_verify_ssh", lambda target: False)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(command_context, verify=True)
++
 +    assert result == 1
 +    assert not (tmp_path / common.YEET_CONFIG_FILENAME).exists()
 +    assert (
 +        f"ERROR! Could not SSH into bea@{common.DEFAULT_SSH_HOST}."
 +        in capsys.readouterr().out
 +    )
++
++
 +def test_run_saves_config_when_verification_succeeds(tmp_path, monkeypatch):
 +    _set_inputs(monkeypatch, "bea", "", "bea")
 +    monkeypatch.setattr(common.getpass, "getpass", lambda prompt="": "s3cr3t")
 +    monkeypatch.setattr(auth, "_verify_auth", lambda project, token: True)
 +    monkeypatch.setattr(auth, "_verify_ssh", lambda target: True)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(command_context, verify=True)
++
 +    assert result == 0
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME) as f:
 +        assert json.load(f) == {
 +            "project": f"bea/{common.CANONICAL_GITLAB_REPO_NAME}",
 +            "token": "s3cr3t",
 +            "ssh_host": common.DEFAULT_SSH_HOST,
 +            "ssh_user": "bea",
 +        }
++
++
 +def test_run_uses_cli_gitlab_username_and_still_prompts_for_rest(tmp_path, monkeypatch):
 +    # ssh host and username aren't given via CLI, so they're the only things
 +    # prompted for.
 +    _set_inputs(monkeypatch, "", "bea")
 +    monkeypatch.setattr(common.getpass, "getpass", lambda prompt="": "s3cr3t")
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(command_context, verify=False, gitlab_username="bea")
++
 +    assert result == 0
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME) as f:
 +        saved = json.load(f)
 +    assert saved["project"] == f"bea/{common.CANONICAL_GITLAB_REPO_NAME}"
 +    assert saved["ssh_user"] == "bea"
++
++
 +def test_run_rejects_invalid_cli_gitlab_username(tmp_path, monkeypatch, capsys):
 +    _forbid_prompts(monkeypatch)
 +    canonical_namespace = common.CANONICAL_GITLAB_NAMESPACE
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(
 +        command_context, verify=False, gitlab_username=canonical_namespace
 +    )
++
 +    assert result == 1
 +    assert not (tmp_path / common.YEET_CONFIG_FILENAME).exists()
 +    assert "not a" in capsys.readouterr().out.lower()
++
++
 +def test_run_fully_noninteractive_with_all_cli_args(tmp_path, monkeypatch):
 +    _forbid_prompts(monkeypatch)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(
 +        command_context,
 +        verify=False,
 +        gitlab_username="bea",
 +        gitlab_token="s3cr3t",
 +        ssh_username="bea",
 +        ssh_host=common.DEFAULT_SSH_HOST,
 +    )
++
 +    assert result == 0
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME) as f:
 +        saved = json.load(f)
 +    assert saved == {
 +        "project": f"bea/{common.CANONICAL_GITLAB_REPO_NAME}",
 +        "token": "s3cr3t",
 +        "ssh_host": common.DEFAULT_SSH_HOST,
 +        "ssh_user": "bea",
 +    }
++
++
 +def test_run_saves_cli_ssh_host(tmp_path, monkeypatch):
 +    _forbid_prompts(monkeypatch)
 +    targets = []
 +    monkeypatch.setattr(auth, "_verify_auth", lambda project, token: True)
 +    monkeypatch.setattr(
 +        auth, "_verify_ssh", lambda target: targets.append(target) or True
 +    )
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(
 +        command_context,
 +        verify=True,
 +        gitlab_username="bea",
 +        gitlab_token="s3cr3t",
 +        ssh_username="bea",
 +        ssh_host="build.example.com",
 +    )
++
 +    assert result == 0
 +    assert targets == ["bea@xxxxxxxxxxxxxxxxx"]
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME) as f:
 +        assert json.load(f)["ssh_host"] == "build.example.com"
++
++
 +def test_run_fully_noninteractive_with_verification(tmp_path, monkeypatch):
 +    _forbid_prompts(monkeypatch)
 +    monkeypatch.setattr(auth, "_verify_auth", lambda project, token: True)
 +    monkeypatch.setattr(auth, "_verify_ssh", lambda target: True)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(
 +        command_context,
 +        verify=True,
 +        gitlab_username="bea",
 +        gitlab_token="s3cr3t",
 +        ssh_username="bea",
 +        ssh_host=common.DEFAULT_SSH_HOST,
 +    )
++
 +    assert result == 0
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME) as f:
 +        assert json.load(f) == {
 +            "project": f"bea/{common.CANONICAL_GITLAB_REPO_NAME}",
 +            "token": "s3cr3t",
 +            "ssh_host": common.DEFAULT_SSH_HOST,
 +            "ssh_user": "bea",
 +        }
++
++
 +_CLI_ARGS = {
 +    "gitlab_username": "bea",
 +    "gitlab_token": "s3cr3t",
 +    "ssh_username": "bea",
 +    "ssh_host": "build.example.com",
 +}
++
 +_SAVED_CONFIG = {
 +    "project": f"bea/{common.CANONICAL_GITLAB_REPO_NAME}",
 +    "token": "s3cr3t",
 +    "ssh_host": "build.example.com",
 +    "ssh_user": "bea",
 +}
++
++
 +@pytest.mark.parametrize("padding", [" ", "\t", "\n", " \t\n "])
 +def test_run_trims_cli_args(tmp_path, monkeypatch, padding):
 +    _forbid_prompts(monkeypatch)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(
 +        command_context,
 +        verify=False,
 +        **{name: f"{padding}{value}{padding}" for name, value in _CLI_ARGS.items()},
 +    )
++
 +    assert result == 0
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME) as f:
 +        assert json.load(f) == _SAVED_CONFIG
++
++
 +def test_run_trims_prompted_values(tmp_path, monkeypatch):
 +    _set_inputs(monkeypatch, "  bea\t", " build.example.com\n", "\tbea  ")
 +    monkeypatch.setattr(common.getpass, "getpass", lambda prompt="": "  s3cr3t\t")
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(command_context, verify=False)
++
 +    assert result == 0
 +    with open(tmp_path / common.YEET_CONFIG_FILENAME) as f:
 +        assert json.load(f) == _SAVED_CONFIG
++
++
 +@pytest.mark.parametrize("arg", list(_CLI_ARGS))
 +@pytest.mark.parametrize("blank", ["", "   ", "\t\n"])
 +def test_run_rejects_blank_cli_arg(tmp_path, monkeypatch, capsys, arg, blank):
 +    _forbid_prompts(monkeypatch)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = auth.run(command_context, verify=False, **{**_CLI_ARGS, arg: blank})
++
 +    assert result == 1
 +    assert not (tmp_path / common.YEET_CONFIG_FILENAME).exists()
 +    assert "ERROR!" in capsys.readouterr().out
++
++
 +if __name__ == "__main__":
 +    mozunit.main()

tools/yeet/tests/python/test_common.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +import sys
 +from types import SimpleNamespace
++
 +import mozunit
 +import pytest
 +from yeet import common
++
++
 +@pytest.mark.parametrize("secret", [False, True])
 +def test_prompt_flushes_pending_tty_input(monkeypatch, secret):
 +    termios = pytest.importorskip("termios")
 +    events = []
 +    monkeypatch.setattr(sys, "stdin", SimpleNamespace(isatty=lambda: True))
 +    monkeypatch.setattr(
 +        termios, "tcflush", lambda fd, queue: events.append(("flush", queue))
 +    )
 +    monkeypatch.setattr(
 +        "builtins.input", lambda message="": events.append("input") or "plain"
 +    )
 +    monkeypatch.setattr(
 +        common.getpass,
 +        "getpass",
 +        lambda message="": events.append("getpass") or "hidden",
 +    )
++
 +    answer = common.prompt("Q: ", secret=secret)
++
 +    assert answer == ("hidden" if secret else "plain")
 +    assert events == [
 +        ("flush", termios.TCIFLUSH),
 +        "getpass" if secret else "input",
 +    ]
++
++
 +def test_prompt_skips_flush_when_not_a_tty(monkeypatch):
 +    termios = pytest.importorskip("termios")
 +    monkeypatch.setattr(sys, "stdin", SimpleNamespace(isatty=lambda: False))
 +    monkeypatch.setattr(
 +        termios,
 +        "tcflush",
 +        lambda *args: pytest.fail("tcflush called on non-tty stdin"),
 +    )
 +    monkeypatch.setattr("builtins.input", lambda message="": "piped")
++
 +    assert common.prompt("Q: ") == "piped"
++
++
 +@pytest.mark.parametrize(
 +    "answers,expected",
 +    [
 +        (["y"], True),
 +        (["YES"], True),
 +        ([" yes "], True),
 +        ([""], False),
 +        (["n"], False),
 +        (["No"], False),
 +        (["maybe", "y"], True),
 +    ],
 +)
 +def test_confirm(monkeypatch, answers, expected):
 +    answers = iter(answers)
 +    monkeypatch.setattr("builtins.input", lambda message="": next(answers))
++
 +    assert common.confirm("Go?") is expected
++
++
 +def test_confirm_reprompts_on_invalid_answer(monkeypatch, capsys):
 +    answers = iter(["maybe", "sure", "n"])
 +    monkeypatch.setattr("builtins.input", lambda message="": next(answers))
++
 +    assert common.confirm("Go?") is False
 +    assert capsys.readouterr().out.count("ERROR!") == 2
++
++
 +if __name__ == "__main__":
 +    mozunit.main()

tools/yeet/tests/python/test_remote.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +import json
 +import shlex
 +import urllib.error
 +from types import SimpleNamespace
++
 +import mozunit
 +import pytest
 +from conftest import write_config
 +from yeet import remote
++
++
 +class _FakeResponse:
 +    def __init__(self, body):
 +        self._body = body
++
 +    def __enter__(self):
 +        return self
++
 +    def __exit__(self, *args):
 +        return False
++
 +    def read(self):
 +        return self._body
++
++
 +def _write_version(tmp_path, version="153.2.0"):
 +    version_dir = tmp_path / "browser" / "config"
 +    version_dir.mkdir(parents=True)
 +    (version_dir / "version.txt").write_text(f"{version}\n")
++
++
 +def test_read_browser_version(tmp_path):
 +    _write_version(tmp_path, "1.2.3")
++
 +    assert remote._read_browser_version(tmp_path) == "1.2.3"
++
++
 +def test_resolve_version_prefers_given_value(tmp_path):
++
 +    assert remote._resolve_version(tmp_path, "9.9.9") == "9.9.9"
++
++
 +def test_resolve_version_falls_back_to_in_tree_version(tmp_path, capsys):
 +    _write_version(tmp_path, "1.2.3")
++
 +    assert remote._resolve_version(tmp_path, None) == "1.2.3"
 +    assert "1.2.3" in capsys.readouterr().out
++
++
 +def test_artifacts_and_mozharness_urls():
 +    artifacts = remote._artifacts_url("1.2.3", "android_x86_64")
++
 +    assert artifacts == f"{remote.TOOLCHAINS_URL_BASE}/1.2.3/android-x86_64/"
 +    assert remote._mozharness_url("1.2.3", "android_x86_64") == (
 +        artifacts + "mozharness.zip"
 +    )
++
++
 +def test_curl_command_includes_header_data_and_url():
 +    command = remote._curl_command(
 +        "https://example.org/trigger",
 +        {"Content-Type": "application/json"},
 +        b'{"a": 1}',
 +    )
++
 +    assert shlex.split(command) == [
 +        "curl",
 +        "--request",
 +        "POST",
 +        "--header",
 +        "Content-Type: application/json",
 +        "--data",
 +        '{"a": 1}',
 +        "https://example.org/trigger",
 +    ]
++
++
 +def _failing_upload_run(topsrcdir, file, platform, assume_yes):
 +    raise RuntimeError("boom")
++
++
 +def test_resolve_installer_url_passes_through_a_url(tmp_path):
++
 +    url = remote._resolve_installer_url(
 +        tmp_path,
 +        "https://example.org/app.apk",
 +        "android_x86_64",
 +        assume_yes=False,
 +        dry_run=False,
 +    )
++
 +    assert url == "https://example.org/app.apk"
++
++
 +def test_resolve_installer_url_uploads_a_local_path(tmp_path, monkeypatch):
 +    calls = []
++
 +    def fake_upload_run(topsrcdir, file, platform, assume_yes):
 +        calls.append((topsrcdir, file, platform, assume_yes))
 +        return "https://tb-build-03.torproject.org/~bea/yeet/ts.apk"
++
 +    monkeypatch.setattr(remote.upload, "run", fake_upload_run)
++
 +    url = remote._resolve_installer_url(
 +        tmp_path,
 +        "/tmp/app.apk",
 +        "android_x86_64",
 +        assume_yes=True,
 +        dry_run=False,
 +    )
++
 +    assert url == "https://tb-build-03.torproject.org/~bea/yeet/ts.apk"
 +    assert calls == [(tmp_path, "/tmp/app.apk", "android_x86_64", True)]
++
++
 +def test_resolve_installer_url_propagates_upload_error(tmp_path, monkeypatch):
 +    monkeypatch.setattr(remote.upload, "run", _failing_upload_run)
++
 +    with pytest.raises(RuntimeError, match="boom"):
 +        remote._resolve_installer_url(
 +            tmp_path,
 +            "/tmp/app.apk",
 +            "android_x86_64",
 +            assume_yes=False,
 +            dry_run=False,
 +        )
++
++
 +def test_prompt_platform_rejects_invalid_choice_then_accepts(monkeypatch):
 +    values = iter(["0", "99", "not-a-number", "2"])
 +    monkeypatch.setattr("builtins.input", lambda prompt="": next(values))
++
 +    assert remote._prompt_platform() == remote.PLATFORMS[1]
++
++
 +def test_prompt_channel_rejects_invalid_choice_then_accepts(monkeypatch):
 +    values = iter(["0", "99", "not-a-number", "2"])
 +    monkeypatch.setattr("builtins.input", lambda prompt="": next(values))
++
 +    assert remote._prompt_channel() == remote.ANDROID_CHANNELS[1]
++
++
 +def _run_kwargs(**overrides):
 +    kwargs = dict(
 +        platform="android_x86_64",
 +        channel="debug",
 +        installer_url="https://example.org/app.apk",
 +        sha256sums_url=None,
 +        artifacts_url="https://example.org/artifacts/",
 +        mozharness_url="https://example.org/mozharness.zip",
 +        version=None,
 +        ref="main",
 +        tags=["tor"],
 +        dry_run=False,
 +    )
 +    kwargs.update(overrides)
 +    return kwargs
++
++
 +def test_run_aborts_without_config(tmp_path, capsys):
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = remote.run(command_context, **_run_kwargs())
++
 +    assert result == 1
 +    assert "mach yeet auth" in capsys.readouterr().out
++
++
 +def test_run_dry_run_prints_curl_and_skips_network(tmp_path, monkeypatch, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    def fail_urlopen(*args, **kwargs):
 +        raise AssertionError("urlopen should not be called in dry-run mode")
++
 +    monkeypatch.setattr(remote.urllib.request, "urlopen", fail_urlopen)
++
 +    result = remote.run(command_context, **_run_kwargs(dry_run=True))
++
 +    assert result == 0
 +    out = capsys.readouterr().out
 +    assert "curl --request POST" in out
 +    assert "app.apk" in out
++
++
 +def test_run_prompts_for_platform_when_missing(tmp_path, monkeypatch, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    calls = []
++
 +    def fake_prompt_platform():
 +        calls.append(True)
 +        return "debian_x86_64"
++
 +    monkeypatch.setattr(remote, "_prompt_platform", fake_prompt_platform)
++
 +    result = remote.run(command_context, **_run_kwargs(platform=None, dry_run=True))
++
 +    assert result == 0
 +    assert len(calls) == 1
 +    assert "debian_x86_64_installer_url" in capsys.readouterr().out
++
++
 +def test_run_prompts_for_channel_when_android_and_missing(
 +    tmp_path, monkeypatch, capsys
 +):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    calls = []
++
 +    def fake_prompt_channel():
 +        calls.append(True)
 +        return "nightly"
++
 +    monkeypatch.setattr(remote, "_prompt_channel", fake_prompt_channel)
++
 +    result = remote.run(command_context, **_run_kwargs(channel=None, dry_run=True))
++
 +    assert result == 0
 +    assert len(calls) == 1
 +    assert remote.ANDROID_CHANNEL_PACKAGE_NAMES["nightly"] in capsys.readouterr().out
++
++
 +def test_run_adds_package_name_input_for_android(tmp_path, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = remote.run(command_context, **_run_kwargs(channel="nightly", dry_run=True))
++
 +    assert result == 0
 +    out = capsys.readouterr().out
 +    assert "android_x86_64_package_name" in out
 +    assert remote.ANDROID_CHANNEL_PACKAGE_NAMES["nightly"] in out
++
++
 +def test_run_skips_channel_for_non_android_platforms(tmp_path, monkeypatch, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    monkeypatch.setattr(
 +        remote,
 +        "_prompt_channel",
 +        lambda: (_ for _ in ()).throw(AssertionError("should not prompt")),
 +    )
++
 +    result = remote.run(
 +        command_context,
 +        **_run_kwargs(
 +            platform="debian_x86_64",
 +            channel=None,
 +            artifacts_url="https://example.org/artifacts/",
 +            mozharness_url="https://example.org/mozharness.zip",
 +            dry_run=True,
 +        ),
 +    )
++
 +    assert result == 0
 +    out = capsys.readouterr().out
 +    assert "package_name" not in out
++
++
 +def test_run_rejects_unknown_channel(tmp_path, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = remote.run(command_context, **_run_kwargs(channel="not-a-channel"))
++
 +    assert result == 1
 +    assert "ERROR! Unknown channel 'not-a-channel'." in capsys.readouterr().out
++
++
 +@pytest.mark.parametrize("dry_run", [False, True])
 +@pytest.mark.parametrize("installer_url", ["", "   ", "\t\n"])
 +def test_run_rejects_empty_installer(
 +    tmp_path, monkeypatch, capsys, installer_url, dry_run
 +):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    monkeypatch.setattr(
 +        remote, "_prompt_platform", lambda: pytest.fail("prompted for platform")
 +    )
 +    monkeypatch.setattr(
 +        remote.upload, "run", lambda *args, **kwargs: pytest.fail("uploaded")
 +    )
 +    monkeypatch.setattr(
 +        remote.urllib.request,
 +        "urlopen",
 +        lambda *args, **kwargs: pytest.fail("pipeline triggered"),
 +    )
++
 +    result = remote.run(
 +        command_context,
 +        **_run_kwargs(platform=None, installer_url=installer_url, dry_run=dry_run),
 +    )
++
 +    assert result == 1
 +    out = capsys.readouterr().out
 +    assert "ERROR! The installer URL or path was empty." in out
 +    assert "curl" not in out
++
++
 +def test_run_trims_installer_url(tmp_path, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = remote.run(
 +        command_context,
 +        **_run_kwargs(installer_url="  https://example.org/app.apk\n", dry_run=True),
 +    )
++
 +    assert result == 0
 +    assert '"android_x86_64_installer_url": "https://example.org/app.apk"' in (
 +        capsys.readouterr().out
 +    )
++
++
 +def test_run_ignores_channel_for_non_android_platforms(tmp_path, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = remote.run(
 +        command_context,
 +        **_run_kwargs(platform="debian_x86_64", channel="nightly", dry_run=True),
 +    )
++
 +    assert result == 0
 +    out = capsys.readouterr().out
 +    assert "package_name" not in out
 +    assert remote.ANDROID_CHANNEL_PACKAGE_NAMES["nightly"] not in out
++
++
 +@pytest.mark.parametrize(
 +    "platform,installer",
 +    [
 +        ("debian_x86_64", "tor-browser-linux-x86_64.tar.xz"),
 +        ("windows_x86_64", "tor-browser-windows-x86_64-portable.exe"),
 +        ("macos_x86_64", "tor-browser-macos.dmg"),
 +        ("android_x86_64", "tor-browser-android-x86_64.apk"),
 +    ],
 +)
 +def test_run_uploads_a_local_path_before_triggering(
 +    tmp_path, monkeypatch, platform, installer
 +):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    installer_path = f"/tmp/{installer}"
 +    uploaded_url = (
 +        f"https://tb-build-03.torproject.org/~bea/yeet/ts-{platform}/{installer}"
 +    )
 +    uploads = []
++
 +    def fake_upload_run(topsrcdir, file, platform, assume_yes):
 +        uploads.append((file, platform))
 +        return uploaded_url
++
 +    monkeypatch.setattr(remote.upload, "run", fake_upload_run)
 +    requests = []
++
 +    def fake_urlopen(request, timeout=None):
 +        requests.append(request)
 +        return _FakeResponse(json.dumps({"web_url": "https://x"}).encode())
++
 +    monkeypatch.setattr(remote.urllib.request, "urlopen", fake_urlopen)
++
 +    result = remote.run(
 +        command_context,
 +        **_run_kwargs(platform=platform, installer_url=installer_path),
 +    )
++
 +    assert result == 0
 +    assert uploads == [(installer_path, platform)]
 +    inputs = json.loads(requests[0].data)["inputs"]
 +    assert inputs[f"{platform}_installer_url"] == uploaded_url
 +    assert (f"{platform}_package_name" in inputs) == (platform == "android_x86_64")
++
++
 +def test_run_prompts_for_platform_before_uploading(tmp_path, monkeypatch):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    monkeypatch.setattr(remote, "_prompt_platform", lambda: "debian_x86_64")
 +    seen = []
++
 +    def fake_upload_run(topsrcdir, file, platform, assume_yes):
 +        seen.append(platform)
 +        raise RuntimeError("stop here")
++
 +    monkeypatch.setattr(remote.upload, "run", fake_upload_run)
++
 +    remote.run(
 +        command_context, **_run_kwargs(platform=None, installer_url="/tmp/app.tar.xz")
 +    )
++
 +    assert seen == ["debian_x86_64"]
++
++
 +@pytest.mark.parametrize("assume_yes", [False, True])
 +def test_run_forwards_assume_yes_to_upload(tmp_path, monkeypatch, assume_yes):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    seen = []
++
 +    def fake_upload_run(topsrcdir, file, platform, assume_yes):
 +        seen.append(assume_yes)
 +        raise RuntimeError("stop here")
++
 +    monkeypatch.setattr(remote.upload, "run", fake_upload_run)
++
 +    remote.run(
 +        command_context,
 +        **_run_kwargs(installer_url="/tmp/app.apk", assume_yes=assume_yes),
 +    )
++
 +    assert seen == [assume_yes]
++
++
 +@pytest.mark.parametrize(
 +    "tags,expected",
 +    [
 +        (["tor", "base-browser"], "--tag tor --tag base-browser"),
 +        (["a b"], "--tag 'a b'"),
 +        (["a b", '"c"'], """--tag 'a b' --tag '"c"'"""),
 +    ],
 +)
 +def test_run_formats_tags_as_flags(tmp_path, monkeypatch, tags, expected):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    requests = []
++
 +    def fake_urlopen(request, timeout=None):
 +        requests.append(request)
 +        return _FakeResponse(json.dumps({"web_url": "https://x"}).encode())
++
 +    monkeypatch.setattr(remote.urllib.request, "urlopen", fake_urlopen)
++
 +    remote.run(command_context, **_run_kwargs(tags=tags))
++
 +    assert json.loads(requests[0].data)["inputs"]["tags"] == expected
++
++
 +def test_run_omits_tags_input_when_empty(tmp_path, monkeypatch):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    requests = []
++
 +    def fake_urlopen(request, timeout=None):
 +        requests.append(request)
 +        return _FakeResponse(json.dumps({"web_url": "https://x"}).encode())
++
 +    monkeypatch.setattr(remote.urllib.request, "urlopen", fake_urlopen)
++
 +    remote.run(command_context, **_run_kwargs(tags=[]))
++
 +    assert "tags" not in json.loads(requests[0].data)["inputs"]
++
++
 +def _triggered_inputs(tmp_path, monkeypatch, **overrides):
 +    write_config(tmp_path)
 +    _write_version(tmp_path, "1.2.3")
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    requests = []
++
 +    def fake_urlopen(request, timeout=None):
 +        requests.append(request)
 +        return _FakeResponse(json.dumps({"web_url": "https://x"}).encode())
++
 +    monkeypatch.setattr(remote.urllib.request, "urlopen", fake_urlopen)
++
 +    assert remote.run(command_context, **_run_kwargs(**overrides)) == 0
 +    return json.loads(requests[0].data)["inputs"]
++
++
 +@pytest.mark.parametrize("sha256sums_url", [None, "https://example.org/sha256sums.txt"])
 +def test_run_includes_sha256sums_input_only_when_given(
 +    tmp_path, monkeypatch, sha256sums_url
 +):
 +    inputs = _triggered_inputs(tmp_path, monkeypatch, sha256sums_url=sha256sums_url)
++
 +    assert inputs.get("android_x86_64_sha256sums_url") == sha256sums_url
++
++
 +@pytest.mark.parametrize("artifacts_url", [None, "https://example.org/artifacts/"])
 +@pytest.mark.parametrize("mozharness_url", [None, "https://example.org/mozharness.zip"])
 +def test_run_uses_given_artifacts_and_mozharness_urls_or_infers_them(
 +    tmp_path, monkeypatch, artifacts_url, mozharness_url
 +):
 +    inputs = _triggered_inputs(
 +        tmp_path,
 +        monkeypatch,
 +        artifacts_url=artifacts_url,
 +        mozharness_url=mozharness_url,
 +    )
++
 +    assert inputs["android_x86_64_artifacts_url"] == (
 +        artifacts_url or remote._artifacts_url("1.2.3", "android_x86_64")
 +    )
 +    assert inputs["mozharness_url"] == (
 +        mozharness_url or remote._mozharness_url("1.2.3", "android_x86_64")
 +    )
++
++
 +def test_run_aborts_when_local_upload_fails(tmp_path, monkeypatch, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    monkeypatch.setattr(remote.upload, "run", _failing_upload_run)
 +    monkeypatch.setattr(
 +        remote.urllib.request,
 +        "urlopen",
 +        lambda *args, **kwargs: pytest.fail("pipeline triggered after failed upload"),
 +    )
++
 +    result = remote.run(command_context, **_run_kwargs(installer_url="/tmp/app.apk"))
++
 +    assert result == 1
 +    assert "ERROR! boom" in capsys.readouterr().out
++
++
 +def test_run_dry_run_does_not_upload_a_local_path(tmp_path, monkeypatch, capsys):
 +    write_config(tmp_path)
 +    apk = tmp_path / "app.apk"
 +    apk.write_bytes(b"not really an apk")
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    monkeypatch.setattr(
 +        remote.upload,
 +        "run",
 +        lambda *args, **kwargs: pytest.fail("uploaded during a dry run"),
 +    )
++
 +    result = remote.run(
 +        command_context, **_run_kwargs(installer_url=str(apk), dry_run=True)
 +    )
++
 +    assert result == 0
 +    assert "<URL of uploaded app.apk>" in capsys.readouterr().out
++
++
 +def test_run_dry_run_rejects_missing_local_path(tmp_path, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
 +    missing = tmp_path / "missing.apk"
++
 +    result = remote.run(
 +        command_context, **_run_kwargs(installer_url=str(missing), dry_run=True)
 +    )
++
 +    assert result == 1
 +    out = capsys.readouterr().out
 +    assert f"ERROR! No such file: {missing}" in out
 +    assert "curl" not in out
++
++
 +def test_run_infers_version_artifacts_and_mozharness(tmp_path, capsys):
 +    write_config(tmp_path)
 +    _write_version(tmp_path, "1.2.3")
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    result = remote.run(
 +        command_context,
 +        **_run_kwargs(artifacts_url=None, mozharness_url=None, dry_run=True),
 +    )
++
 +    assert result == 0
 +    out = capsys.readouterr().out
 +    assert "1.2.3" in out
 +    assert "android-x86_64" in out
++
++
 +def test_run_triggers_pipeline_and_reports_url(tmp_path, monkeypatch, capsys):
 +    config = write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    requests = []
++
 +    def fake_urlopen(request, timeout=None):
 +        requests.append(request)
 +        body = json.dumps({"web_url": "https://gitlab.example/pipelines/1"}).encode()
 +        return _FakeResponse(body)
++
 +    monkeypatch.setattr(remote.urllib.request, "urlopen", fake_urlopen)
++
 +    result = remote.run(command_context, **_run_kwargs())
++
 +    assert result == 0
 +    assert "https://gitlab.example/pipelines/1" in capsys.readouterr().out
 +    assert requests[0].full_url == (
 +        f"{remote.GITLAB_API_BASE}/projects/"
 +        f"{config['project'].replace('/', '%2F')}/trigger/pipeline"
 +    )
 +    payload = json.loads(requests[0].data)
 +    assert payload["token"] == config["token"]
 +    assert payload["ref"] == "main"
 +    assert payload["inputs"]["tags"] == "--tag tor"
++
++
 +def test_run_reports_http_error(tmp_path, monkeypatch, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    def fake_urlopen(request, timeout=None):
 +        raise urllib.error.HTTPError(
 +            request.full_url,
 +            401,
 +            "Unauthorized",
 +            None,
 +            SimpleNamespace(read=lambda: b"bad token", close=lambda: None),
 +        )
++
 +    monkeypatch.setattr(remote.urllib.request, "urlopen", fake_urlopen)
++
 +    result = remote.run(command_context, **_run_kwargs())
++
 +    assert result == 1
 +    out = capsys.readouterr().out
 +    assert "401" in out
 +    assert "bad token" in out
++
++
 +def test_run_reports_url_error(tmp_path, monkeypatch, capsys):
 +    write_config(tmp_path)
 +    command_context = SimpleNamespace(topsrcdir=str(tmp_path))
++
 +    def fake_urlopen(request, timeout=None):
 +        raise urllib.error.URLError("unreachable")
++
 +    monkeypatch.setattr(remote.urllib.request, "urlopen", fake_urlopen)
++
 +    result = remote.run(command_context, **_run_kwargs())
++
 +    assert result == 1
 +    assert "unreachable" in capsys.readouterr().out
++
++
 +if __name__ == "__main__":
 +    mozunit.main()

tools/yeet/tests/python/test_upload.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +from datetime import datetime, timedelta, timezone
 +from types import SimpleNamespace
++
 +import mozunit
 +import pytest
 +from conftest import write_config
 +from yeet import upload
++
++
 +def _freeze_time(monkeypatch, fixed):
 +    class _FrozenDatetime(datetime):
 +        @classmethod
 +        def now(cls, tz=None):
 +            return fixed.astimezone(tz)
++
 +    monkeypatch.setattr(upload, "datetime", _FrozenDatetime)
++
++
 +def test_resolve_file_missing():
 +    with pytest.raises(FileNotFoundError, match="No such file"):
 +        upload.resolve_file("/no/such/file/here")
++
++
 +def test_resolve_file_existing(tmp_path):
 +    apk = tmp_path / "fenix-x86_64-debug.apk"
 +    apk.write_bytes(b"not really an apk")
++
 +    assert upload.resolve_file(str(apk)) == apk.resolve()
++
++
 +@pytest.mark.parametrize(
 +    "fixed,expected",
 +    [
 +        (datetime(2026, 9, 14, 12, 34, 56, tzinfo=timezone.utc), "20260914-123456"),
 +        (
 +            datetime(
 +                2026, 9, 14, 18, 4, 56, tzinfo=timezone(timedelta(hours=5, minutes=30))
 +            ),
 +            "20260914-123456",
 +        ),
 +        (
 +            datetime(2026, 9, 14, 21, 0, 0, tzinfo=timezone(timedelta(hours=-5))),
 +            "20260915-020000",
 +        ),
 +    ],
 +)
 +def test_remote_dir_name_is_current_utc_time_and_platform(monkeypatch, fixed, expected):
 +    _freeze_time(monkeypatch, fixed)
++
 +    assert upload._remote_dir_name("android_x86_64") == f"{expected}-android_x86_64"
++
++
 +def test_upload_success(monkeypatch):
 +    calls = []
++
 +    def fake_run(cmd, **kwargs):
 +        calls.append(cmd)
 +        assert kwargs["stdin"] is upload.subprocess.DEVNULL
 +        return SimpleNamespace(returncode=0)
++
 +    monkeypatch.setattr(upload.subprocess, "run", fake_run)
++
 +    url = upload._upload(upload.Path("/tmp/app.apk"), "bea", "example.org", "ts-os")
++
 +    assert url == "https://example.org/~bea/yeet/ts-os/app.apk"
 +    assert calls[0][0] == "ssh"
 +    assert calls[0][-3:] == ["mkdir", "-p", "~/public_html/yeet/ts-os"]
 +    assert calls[1][0] == "scp"
 +    assert calls[1][-2:] == [
 +        "/tmp/app.apk",
 +        "bea@xxxxxxxxxxx:~/public_html/yeet/ts-os/app.apk",
 +    ]
++
++
 +def test_upload_replaces_unsafe_filename_characters(monkeypatch):
 +    calls = []
++
 +    def fake_run(cmd, **kwargs):
 +        calls.append(cmd)
 +        return SimpleNamespace(returncode=0)
++
 +    monkeypatch.setattr(upload.subprocess, "run", fake_run)
++
 +    url = upload._upload(
 +        upload.Path("/tmp/app (1)#%?.apk"), "bea", "example.org", "ts-os"
 +    )
++
 +    assert url == "https://example.org/~bea/yeet/ts-os/app__1____.apk"
 +    assert calls[1][-2:] == [
 +        "/tmp/app (1)#%?.apk",
 +        "bea@xxxxxxxxxxx:~/public_html/yeet/ts-os/app__1____.apk",
 +    ]
++
++
 +def test_upload_stops_if_mkdir_fails(monkeypatch):
 +    calls = []
++
 +    def fake_run(cmd, **kwargs):
 +        calls.append(cmd)
 +        return SimpleNamespace(returncode=1)
++
 +    monkeypatch.setattr(upload.subprocess, "run", fake_run)
++
 +    with pytest.raises(RuntimeError):
 +        upload._upload(upload.Path("/tmp/app.apk"), "bea", "example.org", "ts-os")
++
 +    assert len(calls) == 1
++
++
 +def test_upload_fails_if_scp_fails(monkeypatch):
 +    def fake_run(cmd, **kwargs):
 +        return SimpleNamespace(returncode=0 if cmd[0] == "ssh" else 1)
++
 +    monkeypatch.setattr(upload.subprocess, "run", fake_run)
++
 +    with pytest.raises(RuntimeError):
 +        upload._upload(upload.Path("/tmp/app.apk"), "bea", "example.org", "ts-os")
++
++
 +def test_run_aborts_without_config(tmp_path):
 +    apk = tmp_path / "app.apk"
 +    apk.touch()
++
 +    with pytest.raises(RuntimeError, match="mach yeet auth"):
 +        upload.run(tmp_path, str(apk), "android_x86_64")
++
++
 +def test_run_aborts_when_file_missing(tmp_path):
 +    write_config(tmp_path)
++
 +    with pytest.raises(FileNotFoundError):
 +        upload.run(tmp_path, str(tmp_path / "missing.apk"), "android_x86_64")
++
++
 +def _write_apk(tmp_path):
 +    apk = tmp_path / "app.apk"
 +    apk.write_bytes(b"not really an apk")
 +    return apk
++
++
 +def _set_confirm_answers(monkeypatch, *answers):
 +    answers = iter(answers)
 +    monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
++
++
 +def test_run_uploads_into_timestamped_dir_and_prints_url(tmp_path, monkeypatch, capsys):
 +    config = write_config(tmp_path)
 +    apk = tmp_path / "app.apk"
 +    apk.write_bytes(b"not really an apk")
 +    _freeze_time(monkeypatch, datetime(2026, 9, 14, 12, 34, 56, tzinfo=timezone.utc))
++
 +    calls = []
++
 +    def fake_upload(file_path, ssh_user, ssh_host, remote_dir):
 +        calls.append((file_path, ssh_user, ssh_host, remote_dir))
 +        return f"https://{ssh_host}/~{ssh_user}/yeet/{remote_dir}/{file_path.name}"
++
 +    monkeypatch.setattr(upload, "_upload", fake_upload)
++
 +    url = upload.run(tmp_path, str(apk), "android_x86_64", assume_yes=True)
++
 +    assert url == (
 +        f"https://{config['ssh_host']}/~{config['ssh_user']}/yeet/20260914-123456-android_x86_64/app.apk"
 +    )
 +    assert calls == [
 +        (
 +            apk.resolve(),
 +            config["ssh_user"],
 +            config["ssh_host"],
 +            "20260914-123456-android_x86_64",
 +        )
 +    ]
 +    assert url in capsys.readouterr().out
++
++
 +def test_run_reports_upload_failure(tmp_path, monkeypatch):
 +    write_config(tmp_path)
 +    apk = tmp_path / "app.apk"
 +    apk.write_bytes(b"not really an apk")
++
 +    def fake_upload(file_path, ssh_user, ssh_host, remote_dir):
 +        raise RuntimeError("boom")
++
 +    monkeypatch.setattr(upload, "_upload", fake_upload)
++
 +    with pytest.raises(RuntimeError, match="boom"):
 +        upload.run(tmp_path, str(apk), "android_x86_64", assume_yes=True)
++
++
 +@pytest.mark.parametrize("answer", ["y", "yes", "Y"])
 +def test_run_uploads_after_confirmation(tmp_path, monkeypatch, answer):
 +    write_config(tmp_path)
 +    apk = _write_apk(tmp_path)
 +    _set_confirm_answers(monkeypatch, answer)
 +    monkeypatch.setattr(
 +        upload,
 +        "_upload",
 +        lambda file_path, ssh_user, ssh_host, remote_dir: "https://x/y",
 +    )
++
 +    assert upload.run(tmp_path, str(apk), "android_x86_64") == "https://x/y"
++
++
 +@pytest.mark.parametrize("answers", [("",), ("n",), ("no",), ("maybe", "n")])
 +def test_run_does_not_upload_when_declined(tmp_path, monkeypatch, answers):
 +    write_config(tmp_path)
 +    apk = _write_apk(tmp_path)
 +    _set_confirm_answers(monkeypatch, *answers)
 +    monkeypatch.setattr(
 +        upload,
 +        "_upload",
 +        lambda *args: pytest.fail("_upload called after the user declined"),
 +    )
++
 +    with pytest.raises(RuntimeError, match="cancelled"):
 +        upload.run(tmp_path, str(apk), "android_x86_64")
++
++
 +def test_run_skips_confirmation_with_assume_yes(tmp_path, monkeypatch):
 +    write_config(tmp_path)
 +    apk = _write_apk(tmp_path)
 +    monkeypatch.setattr(
 +        "builtins.input", lambda prompt="": pytest.fail("unexpected prompt")
 +    )
 +    monkeypatch.setattr(
 +        upload,
 +        "_upload",
 +        lambda file_path, ssh_user, ssh_host, remote_dir: "https://x/y",
 +    )
++
 +    assert (
 +        upload.run(tmp_path, str(apk), "android_x86_64", assume_yes=True)
 +        == "https://x/y"
 +    )
++
++
 +if __name__ == "__main__":
 +    mozunit.main()

tools/yeet/upload.py

 +# This Source Code Form is subject to the terms of the Mozilla Public
 +# License, v. 2.0. If a copy of the MPL was not distributed with this
 +# file, You can obtain one at http://mozilla.org/MPL/2.0/.
++
 +import re
 +import subprocess
 +from datetime import datetime, timezone
 +from pathlib import Path
++
 +from yeet.common import TERM, YEET_CONFIG_FILENAME, confirm, read_config
++
++
 +def resolve_file(file_arg):
 +    path = Path(file_arg).resolve()
 +    if not path.is_file():
 +        raise FileNotFoundError(f"No such file: {path}")
 +    return path
++
++
 +def _remote_dir_name(platform):
 +    """Name the upload's directory after the current time and `platform`,
 +    so repeated uploads never collide or overwrite each other.
 +    """
 +    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
 +    return f"{timestamp}-{platform}"
++
++
 +def _upload(file_path, ssh_user, ssh_host, remote_dir):
 +    """scp `file_path` into ~/public_html/yeet/`remote_dir` on
 +    ssh_user@ssh_host, keeping its name (with characters unsafe in a URL or
 +    shell replaced by `_`) and creating that directory first if needed. Both
 +    commands get /dev/null as stdin so they can't swallow input buffered for
 +    us; their touch/PIN/passphrase prompts go through /dev/tty and still reach
 +    the user.
++
 +    Returns the file's final https:// URL. Raises RuntimeError on failure.
 +    """
 +    ssh_target = f"{ssh_user}@{ssh_host}"
 +    remote_name = re.sub(r"[^A-Za-z0-9._-]", "_", file_path.name)
 +    dest_dir = f"~/public_html/yeet/{remote_dir}"
 +    dest_path = f"{dest_dir}/{remote_name}"
 +    html_path = f"~{ssh_user}/yeet/{remote_dir}/{remote_name}"
++
 +    mkdir = subprocess.run(
 +        ["ssh", ssh_target, "mkdir", "-p", dest_dir],
 +        stdin=subprocess.DEVNULL,
 +        check=False,
 +    )
 +    if mkdir.returncode != 0:
 +        raise RuntimeError(f"Could not create {dest_dir} on {ssh_target}.")
++
 +    scp = subprocess.run(
 +        ["scp", str(file_path), f"{ssh_target}:{dest_path}"],
 +        stdin=subprocess.DEVNULL,
 +        check=False,
 +    )
 +    if scp.returncode != 0:
 +        raise RuntimeError(f"Upload to {ssh_target} failed.")
++
 +    return f"https://{ssh_host}/{html_path}"
++
++
 +def run(topsrcdir, file, platform, assume_yes=False):
 +    """Upload `file` for `platform` to the configured server, asking for
 +    confirmation first unless `assume_yes`. Returns the file's final https://
 +    URL. Raises FileNotFoundError if `file` or the config is missing, and
 +    RuntimeError if the upload fails or is cancelled.
 +    """
 +    config = read_config(topsrcdir)
 +    if config is None:
 +        raise RuntimeError(
 +            f"No {YEET_CONFIG_FILENAME} found. Run `mach yeet auth` first."
 +        )
++
 +    file_path = resolve_file(file)
++
 +    remote_dir = _remote_dir_name(platform)
++
 +    if not assume_yes:
 +        print()
 +        print(
 +            TERM.yellow(
 +                f"{file_path} will be uploaded to {config['ssh_host']} and "
 +                "be publicly accessible."
 +            )
 +        )
 +        if not confirm("Upload it?"):
 +            raise RuntimeError("Upload cancelled.")
++
 +    print()
 +    print(f"Uploading {file_path.name} to {remote_dir}/...")
 +    url = _upload(file_path, config["ssh_user"], config["ssh_host"], remote_dir)
++
 +    print()
 +    print(TERM.green(f"Uploaded: {url}"))
 +    return url