Skip to content

A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.

34.0 KB
Raw Blame
#!/usr/bin/env python3
import os
import sys
import glob
from copy import deepcopy

# These workflows are WezTerm's, kept for reference only -- see the README in
# that directory. Generating into .github/workflows/ would resurrect 33 live
# workflows, eleven of which trigger on tags and would race release.yml for the
# same release assets.
GEN_DIR = "ci/legacy-workflows"

TRIGGER_PATHS = [
    "**/*.rs",
    "**/Cargo.lock",
    "**/Cargo.toml",
    ".cargo/config.toml",
    "assets/fonts/**/*",
    "assets/icon/*",
    "ci/deploy.sh",
]

TRIGGER_PATHS_APPIMAGE = [
    "ci/appimage.sh",
    "ci/appstreamcli",
    "ci/source-archive.sh",
]

TRIGGER_PATHS_UNIX = [
    "assets/open-thinkterm-here",
    "assets/open-wezterm-here",
    "assets/shell-completion/**/*",
    "assets/shell-integration/**/*",
    "assets/wezterm-nautilus.py",
    "assets/wezterm.appdata.xml",
    "assets/wezterm.desktop",
    "get-deps",
    "ci/tag-name.sh",
    "termwiz/data/wezterm.terminfo",
]

TRIGGER_PATHS_MAC = [
    "assets/macos/**/*",
    "ci/macos-entitlement.plist",
    "get-deps",
    "ci/tag-name.sh",
]

TRIGGER_PATHS_WIN = [
    "assets/windows/**/*",
    "ci/windows-installer.iss",
]


def yv(v, depth=0):
    if v is True:
        return "true"
    if v is False:
        return "false"
    if v is None:
        return "nil"

    if isinstance(v, str):
        if "\n" in v:
            indent = "  " * depth
            result = ""
            for l in v.splitlines():
                result = result + "\n" + (f"{indent}{l}" if l else "")
            return "|" + result
        # This is hideous
        if '"' in v:
            return "'" + v + "'"
        return '"' + v + '"'

    return v


class Step(object):
    def render(self, f, depth=0):
        raise NotImplementedError(repr(self))


class RunStep(Step):
    def __init__(self, name, run, shell="bash", env=None, condition=None):
        self.name = name
        self.run = run
        self.shell = shell
        self.env = env
        self.condition = condition

    def render(self, f, depth=0):
        indent = "  " * depth
        f.write(f"{indent}- name: {yv(self.name)}\n")
        if self.condition:
            f.write(f"{indent}  if: {self.condition}\n")
        if self.env:
            f.write(f"{indent}  env:\n")
            keys = list(self.env.keys())
            keys.sort()
            for k in keys:
                v = self.env[k]
                f.write(f"{indent}    {k}: {v}\n")
        if self.shell:
            f.write(f"{indent}  shell: {self.shell}\n")

        run = self.run

        f.write(f"{indent}  run: {yv(run, depth + 2)}\n")


class ActionStep(Step):
    def __init__(self, name, action, params=None, env=None, condition=None, id=None):
        self.name = name
        self.action = action
        self.params = params
        self.env = env
        self.condition = condition
        self.id = id

    def render(self, f, depth=0):
        indent = "  " * depth
        f.write(f"{indent}- name: {yv(self.name)}\n")
        f.write(f"{indent}  uses: {self.action}\n")
        if self.id:
            f.write(f"{indent}  id: {self.id}\n")
        if self.condition:
            f.write(f"{indent}  if: {self.condition}\n")
        if self.params:
            f.write(f"{indent}  with:\n")
            for k, v in self.params.items():
                f.write(f"{indent}    {k}: {yv(v, depth + 3)}\n")
        if self.env:
            f.write(f"{indent}  env:\n")
            for k, v in self.env.items():
                f.write(f"{indent}    {k}: {yv(v, depth + 3)}\n")


class CacheStep(ActionStep):
    def __init__(self, name, path, key, id=None):
        super().__init__(
            name, action="actions/cache@v4", params={"path": path, "key": key}, id=id
        )


class SccacheStep(ActionStep):
    def __init__(self, name):
        super().__init__(name, action="mozilla-actions/[email protected]")


class CheckoutStep(ActionStep):
    def __init__(self, name="checkout repo", submodules=True, container=None):
        params = {}
        if submodules:
            params["submodules"] = "recursive"
        # Newer versions of the checkout action use a binary-incompatible node
        # binary, so we are pinned back on v3
        # https://github.com/actions/checkout/issues/1442
        version = "v3" if container is not None and "centos7" in container else "v4"
        super().__init__(name, action=f"actions/checkout@{version}", params=params)


class InstallCrateStep(ActionStep):
    def __init__(self, crate: str, key: str, version=None):
        params = {"crate": crate, "cache-key": key}
        if version is not None:
            params["version"] = version
        super().__init__(
            f"Install {crate} from Cargo",
            action="baptiste0928/cargo-install@v3",
            params=params,
        )


class Job(object):
    def __init__(self, runs_on, container=None, steps=None, env=None):
        self.runs_on = runs_on
        self.container = container
        self.steps = steps
        self.env = env

    def render(self, f, depth=0):
        f.write("\n    steps:\n")
        for s in self.steps:
            s.render(f, depth)


class Target(object):
    def __init__(
        self,
        name=None,
        os="ubuntu-latest",
        container=None,
        bootstrap_git=False,
        rust_target=None,
        continuous_only=False,
        app_image=False,
        is_tag=False,
    ):
        if not name:
            if container:
                name = container
            else:
                name = os
        self.name = name.replace(":", "")
        self.os = os
        self.container = container
        self.bootstrap_git = bootstrap_git
        self.rust_target = rust_target
        self.continuous_only = continuous_only
        self.app_image = app_image
        self.env = {}
        self.is_tag = is_tag

    def render_env(self, f, depth=0):
        self.global_env()
        if self.env:
            indent = "    "
            f.write(f"{indent}env:\n")
            for k, v in self.env.items():
                f.write(f"{indent}  {k}: {yv(v, depth + 3)}\n")

    def uses_yum(self):
        if "fedora" in self.name:
            return True
        if "centos" in self.name:
            return True
        return False

    def uses_apt(self):
        if "ubuntu" in self.name:
            return True
        if "debian" in self.name:
            return True
        return False

    def uses_apk(self):
        if "alpine" in self.name:
            return True
        return False

    def uses_zypper(self):
        if "suse" in self.name:
            return True
        return False

    def needs_sudo(self):
        if not self.container and self.uses_apt():
            return True
        return False

    def install_system_package(self, name):
        installer = None
        if self.uses_yum():
            installer = "yum"
        elif self.uses_apt():
            installer = "apt-get"
        elif self.uses_apk():
            installer = "apk"
        elif self.uses_zypper():
            installer = "zypper"
        else:
            return []
        if self.needs_sudo():
            installer = f"sudo -n {installer}"
        if self.uses_apk():
            return [RunStep(f"Install {name}", f"{installer} add {name}")]
        else:
            return [RunStep(f"Install {name}", f"{installer} install -y {name}")]

    def install_curl(self):
        if (
            self.uses_yum()
            or self.uses_apk()
            or self.uses_zypper()
            or (self.uses_apt() and self.container)
        ):
            if "centos:stream9" in self.container:
                return self.install_system_package("curl-minimal")
            else:
                return self.install_system_package("curl")
        return []

    def install_openssh_server(self):
        steps = []
        if (
            self.uses_yum()
            or self.uses_zypper()
            or (self.uses_apt() and self.container)
        ):
            steps += [
                RunStep("Ensure /run/sshd exists", "mkdir -p /run/sshd")
            ] + self.install_system_package("openssh-server")
        if self.uses_apk():
            steps += self.install_system_package("openssh")
        return steps

    def install_newer_compiler(self):
        steps = []
        if self.name == "centos7":
            steps.append(
                RunStep(
                    "Install SCL",
                    "yum install -y centos-release-scl-rh",
                )
            )
            steps.append(
                RunStep(
                    "Update compiler",
                    "yum install -y devtoolset-9-gcc devtoolset-9-gcc-c++",
                )
            )
        return steps

    def install_git(self):
        steps = []
        if self.bootstrap_git:
            GIT_VERS = "2.26.2"
            steps.append(
                CacheStep(
                    "Cache Git installation",
                    path="/usr/local/git",
                    key=f"{self.name}-git-{GIT_VERS}",
                )
            )

            pre_reqs = ""
            if self.uses_yum():
                pre_reqs = "yum install -y wget curl-devel expat-devel gettext-devel openssl-devel zlib-devel gcc perl-ExtUtils-MakeMaker make"
            elif self.uses_apt():
                pre_reqs = "apt-get install -y wget libcurl4-openssl-dev libexpat-dev gettext libssl-dev libz-dev gcc libextutils-autoinstall-perl make"
            elif self.uses_zypper():
                pre_reqs = "zypper install -y wget libcurl-devel libexpat-devel gettext-tools libopenssl-devel zlib-devel gcc perl-ExtUtils-MakeMaker make"

            steps.append(
                RunStep(
                    name="Install Git from source",
                    shell="bash",
                    run=f"""{pre_reqs}
if test ! -x /usr/local/git/bin/git ; then
    cd /tmp
    wget https://github.com/git/git/archive/v{GIT_VERS}.tar.gz
    tar xzf v{GIT_VERS}.tar.gz
    cd git-{GIT_VERS}
    make prefix=/usr/local/git install
fi
ln -s /usr/local/git/bin/git /usr/local/bin/git""",
                )
            )

        else:
            if "tumbleweed" in self.name:
                # git-core requires /usr/bin/which and that gets satisfied
                # by busybox-which by default, which blocks installing
                # rpmbuild, which depends on the which rpm directly,
                # but that is blocked by the conflicting busybox-which rpm.
                # So we explicitly install which here now
                steps += self.install_system_package("which")

            steps += self.install_system_package("git")

        return steps

    def install_rust(self, cache=True, toolchain="stable"):
        salt = "2"
        key_prefix = f"{self.name}-{self.rust_target}-{salt}-${{{{ runner.os }}}}"
        params = dict()
        if self.rust_target:
            params["target"] = self.rust_target
        steps = []
        # Manually setup rust toolchain in CentOS7 curl is too old for the action
        if "centos7" in self.name:
            steps += [
                RunStep(
                    name="Install Rustup",
                    run="""
if ! command -v rustup &>/dev/null; then
  curl --proto '=https' --tlsv1.2 --retry 10 -fsSL "https://sh.rustup.rs" | sh -s -- --default-toolchain none -y
  echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
fi
""",
                ),
                RunStep(
                    name="Setup Toolchain",
                    run=f"""
rustup toolchain install {toolchain} --profile minimal --no-self-update
rustup default {toolchain}
""",
                ),
            ]
        elif "macos" in self.name:
            steps += [
                RunStep(
                    name="Install Rust (ARM)",
                    run="rustup target add aarch64-apple-darwin",
                ),
                RunStep(
                    name="Install Rust (Intel)",
                    run="rustup target add x86_64-apple-darwin",
                )
            ]
        else:
            steps += [
                ActionStep(
                    name="Install Rust",
                    action=f"dtolnay/rust-toolchain@{toolchain}",
                    params=params,
                ),
            ]
        if cache:
            steps += [
                SccacheStep(name="Compile with sccache"),
                # Cache vendored dependecies
                CacheStep(
                    name="Cache Rust Dependencies",
                    path="vendor\n.cargo/config",
                    key="cargo-deps-${{ hashFiles('**/Cargo.lock') }}",
                    id="cache-cargo-vendor",
                ),
                # Vendor dependencies
                RunStep(
                    name="Vendor dependecies",
                    condition="steps.cache-cargo-vendor.outputs.cache-hit != 'true'",
                    run="cargo vendor --locked --versioned-dirs >> .cargo/config",
                ),
            ]
        return steps

    def install_system_deps(self):
        if "win" in self.name:
            return []
        sudo = "sudo -n " if self.needs_sudo() else ""
        return [
            RunStep(
                name="Install System Deps",
                run=f"{sudo}env CI=yes PATH=$PATH ./get-deps",
            )
        ]

    def fixup_windows_path(self, cmd):
        if "win" in self.name:
            return "PATH C:\\Strawberry\\perl\\bin;%PATH%\n" + cmd
        return cmd

    def build_all_release(self):
        bin_crates = [
            "wezterm",
            "wezterm-gui",
            "wezterm-mux-server",
            "strip-ansi-escapes",
        ]
        steps = []
        for bin in bin_crates:
            if "win" in self.name:
                steps += [
                    RunStep(
                        name=f"Build {bin} (Release mode)",
                        shell="cmd",
                        run=self.fixup_windows_path(f"cargo build -p {bin} --release"),
                    )
                ]
            elif "macos" in self.name:
                steps += [
                    RunStep(
                        name=f"Build {bin} (Release mode Intel)",
                        run=f"cargo build --target x86_64-apple-darwin -p {bin} --release",
                    ),
                    RunStep(
                        name=f"Build {bin} (Release mode ARM)",
                        run=f"cargo build --target aarch64-apple-darwin -p {bin} --release",
                    ),
                ]
            else:
                if self.name == "centos7":
                    enable = "source /opt/rh/devtoolset-9/enable && "
                else:
                    enable = ""
                steps += [
                    RunStep(
                        name=f"Build {bin} (Release mode)",
                        run=enable + f"cargo build -p {bin} --release",
                    )
                ]
        return steps

    def test_all(self):
        run = "cargo nextest run --all --no-fail-fast"
        if "macos" in self.name:
            run += " --target=x86_64-apple-darwin"
        if self.name == "centos7":
            run = "source /opt/rh/devtoolset-9/enable\n" + run
        return [
            # Install cargo-nextest
            InstallCrateStep("cargo-nextest", key=self.name),
            # Run tests
            RunStep(name="Test", run=self.fixup_windows_path(run), shell="cmd")
            if "win" in self.name
            else RunStep(name="Test", run=run),
        ]

    def package(self, trusted=False):
        steps = []
        deploy_env = None
        if trusted and ("mac" in self.name):
            deploy_env = {
                "MACOS_CERT": "${{ secrets.MACOS_CERT }}",
                "MACOS_CERT_PW": "${{ secrets.MACOS_CERT_PW }}",
                "MACOS_TEAM_ID": "${{ secrets.MACOS_TEAM_ID }}",
                "MACOS_APPLEID": "${{ secrets.MACOS_APPLEID }}",
                "MACOS_APP_PW": "${{ secrets.MACOS_APP_PW }}",
            }
        steps = [RunStep("Package", "bash ci/deploy.sh", env=deploy_env)]
        if self.app_image:
            # AppImage needs fuse
            steps += self.install_system_package("libfuse2")
            steps.append(RunStep("Source Tarball", "bash ci/source-archive.sh"))
            steps.append(RunStep("Build AppImage", "bash ci/appimage.sh"))
        return steps

    def upload_artifact(self):
        steps = []

        if self.uses_yum():
            steps.append(
                RunStep(
                    "Move RPM",
                    f"mv ~/rpmbuild/RPMS/*/*.rpm .",
                )
            )
        elif self.uses_apk():
            steps += [
                # Add the distro name/version into the filename
                RunStep(
                    "Rename APKs",
                    f"mv ~/packages/wezterm/x86_64/*.apk $(echo ~/packages/wezterm/x86_64/*.apk | sed -e 's/wezterm-/wezterm-{self.name}-/')",
                ),
                # Move it to the repo dir
                RunStep(
                    "Move APKs",
                    f"mv ~/packages/wezterm/x86_64/*.apk .",
                ),
                # Move and rename the keys
                RunStep(
                    "Move APK keys",
                    f"mv ~/.abuild/*.pub wezterm-{self.name}.pub",
                ),
            ]
        elif self.uses_zypper():
            steps.append(
                RunStep(
                    "Move RPM",
                    f"mv /usr/src/packages/RPMS/*/*.rpm .",
                )
            )

        patterns = self.asset_patterns()
        glob = " ".join(patterns)
        paths = "\n".join(patterns)

        return steps + [
            ActionStep(
                "Upload artifact",
                action="actions/upload-artifact@v4",
                params={"name": self.name, "path": paths},
            ),
        ]

    def asset_patterns(self):
        patterns = []
        if self.uses_yum() or self.uses_zypper():
            patterns += ["wezterm-*.rpm"]
        elif "win" in self.name:
            patterns += ["ThinkTerm-*.zip", "ThinkTerm-*.exe"]
        elif "mac" in self.name:
            patterns += ["ThinkTerm-*.zip"]
        elif ("ubuntu" in self.name) or ("debian" in self.name):
            patterns += ["wezterm-*.deb", "wezterm-*.xz"]
        elif "alpine" in self.name:
            patterns += ["wezterm-*.apk"]
            if self.is_tag:
                patterns.append("*.pub")

        if self.app_image:
            patterns.append("*src.tar.gz")
            patterns.append("*.AppImage")
            #patterns.append("*.zsync") broken upstream: <https://github.com/linuxdeploy/linuxdeploy/issues/309>
        return patterns

    def upload_artifact_nightly(self):
        steps = []

        if self.uses_yum() or self.uses_zypper():

            rpmbuild = "~/rpmbuild/RPMS/*"
            if self.uses_zypper():
                rpmbuild = "/usr/src/packages/RPMS/*"

            script = ""
            # Note that 'wezterm' MUST be last in this list,
            # otherwise the globbing will mess things up
            for pkg in ['wezterm-common', 'wezterm-gui', 'wezterm-mux-server', 'wezterm']:
                script = script + f"mv {rpmbuild}/{pkg}-*.rpm {pkg}-nightly-{self.name}.rpm\n"

            steps.append(
                RunStep(
                    "Move RPM",
                    script
                )
            )
        elif self.uses_apk():
            steps.append(
                RunStep(
                    "Move APKs",
                    f"mv ~/packages/wezterm/x86_64/*.apk wezterm-nightly-{self.name}.apk",
                )
            )

        patterns = self.asset_patterns()
        glob = " ".join(patterns)
        paths = "\n".join(patterns)

        return steps + [
            ActionStep(
                "Upload artifact",
                action="actions/upload-artifact@v4",
                params={"name": self.name, "path": paths, "retention-days": 5},
            ),
        ]

    def upload_asset_nightly(self):
        steps = []

        patterns = self.asset_patterns()
        checksum = RunStep(
            "Checksum",
            f"for f in {' '.join(patterns)} ; do sha256sum $f > $f.sha256 ; done",
        )

        patterns.append("*.sha256")
        glob = " ".join(patterns)

        if self.container == "ubuntu:22.04":
            steps += [
                RunStep(
                    "Upload to gemfury",
                    f"for f in wezterm*.deb ; do curl -i -F package=@$f https://[email protected]/wez/ ; done",
                    env={"FURY_TOKEN": "${{ secrets.FURY_TOKEN }}"},
                ),
            ]

        return [
            ActionStep(
                "Download artifact",
                action="actions/download-artifact@v4",
                params={"name": self.name},
            ),
            checksum,
            RunStep(
                "Upload to Nightly Release",
                f"bash ci/retry.sh gh release upload --clobber nightly {glob}",
                env={"GITHUB_TOKEN": "${{ secrets.GITHUB_TOKEN }}"},
            ),
        ] + steps

    def upload_asset_tag(self):
        steps = []

        patterns = self.asset_patterns()
        checksum = RunStep(
            "Checksum",
            f"for f in {' '.join(patterns)} ; do sha256sum $f > $f.sha256 ; done",
        )

        patterns.append("*.sha256")
        glob = " ".join(patterns)

        if self.container == "ubuntu:22.04":
            steps += [
                RunStep(
                    "Upload to gemfury",
                    f"for f in wezterm*.deb ; do curl -i -F package=@$f https://[email protected]/wez/ ; done",
                    env={"FURY_TOKEN": "${{ secrets.FURY_TOKEN }}"},
                ),
            ]

        return steps + [
            ActionStep(
                "Download artifact",
                action="actions/download-artifact@v4",
                params={"name": self.name},
            ),
            checksum,
            RunStep(
                "Create pre-release",
                "bash ci/retry.sh bash ci/create-release.sh $(ci/tag-name.sh)",
                env={
                    "GITHUB_TOKEN": "${{ secrets.GITHUB_TOKEN }}",
                },
            ),
            RunStep(
                "Upload to Tagged Release",
                f"bash ci/retry.sh gh release upload --clobber $(ci/tag-name.sh) {glob}",
                env={
                    "GITHUB_TOKEN": "${{ secrets.GITHUB_TOKEN }}",
                },
            ),
        ]

    def create_flathub_pr(self):
        if not self.app_image:
            return []
        return [
            ActionStep(
                "Checkout flathub/com.roversx.thinkterm",
                action="actions/checkout@v4",
                params={
                    "repository": "flathub/com.roversx.thinkterm",
                    "path": "flathub",
                    "token": "${{ secrets.GH_PAT }}",
                },
            ),
            RunStep(
                "Create flathub commit and push",
                "bash ci/make-flathub-pr.sh",
            ),
            RunStep(
                "Submit PR",
                'cd flathub && gh pr create --fill --body "PR automatically created by release automation in the ThinkTerm repo"',
                env={
                    "GITHUB_TOKEN": "${{ secrets.GH_PAT }}",
                },
            ),
        ]

    def create_winget_pr(self):
        # ThinkTerm release uploads are enabled for RoversX/thinkterm, but the
        # upstream Winget automation still targets wez-owned forks and paths.
        # Keep publishing to GitHub releases; re-enable this after a ThinkTerm
        # Winget fork/package id is configured.
        return []

    def update_homebrew_tap(self):
        # The upstream tap automation still targets Wez-owned Homebrew taps.
        # Do not run it from ThinkTerm tag uploads; configure ThinkTerm-owned
        # taps before restoring this.
        return []

    def global_env(self):
        self.env["CARGO_INCREMENTAL"] = "0"
        self.env["SCCACHE_GHA_ENABLED"] = "true"
        self.env["RUSTC_WRAPPER"] = "sccache"
        if "macos" in self.name:
            self.env["MACOSX_DEPLOYMENT_TARGET"] = "14.0"
        if "alpine" in self.name:
            self.env["RUSTFLAGS"] = "-C target-feature=-crt-static"
        if "win" in self.name:
            self.env["RUSTUP_WINDOWS_PATH_ADD_BIN"] = "1"
        return

    def prep_environment(self, cache=True):
        steps = []
        sudo = "sudo -n " if self.needs_sudo() else ""
        if self.uses_apt():
            if self.container:
                steps += [
                    RunStep(
                        "set APT to non-interactive",
                        "echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections",
                    ),
                ]
            steps += [
                RunStep("Update APT", f"{sudo}apt update"),
            ]

        if self.uses_zypper():
            if self.container:
                steps += [
                    RunStep(
                        "Seed GITHUB_PATH to work around possible @action/core bug",
                        f'echo "$PATH:/bin:/usr/bin" >> $GITHUB_PATH',
                    ),
                    RunStep(
                        "Install util-linux",
                        "zypper install -y util-linux",
                    ),
                ]
        if self.container:
            if ("fedora" in self.container) or (
                ("centos" in self.container) and ("centos7" not in self.container)
            ):
                steps += [
                    RunStep(
                        "Install config manager",
                        "dnf install -y 'dnf-command(config-manager)'",
                    ),
                ]
            if "centos:stream8" in self.container:
                steps += [
                    RunStep(
                        "Enable PowerTools",
                        "dnf config-manager --set-enabled powertools",
                    ),
                ]
            if "centos:stream9" in self.container:
                steps += [
                    # This holds the xcb bits
                    RunStep(
                        "Enable CRB repo for X bits",
                        "dnf config-manager --set-enabled crb",
                    ),
                ]
            if "alpine" in self.container:
                steps += [
                    RunStep(
                        "Upgrade system",
                        "apk upgrade --update-cache",
                        shell="sh",
                    ),
                    RunStep(
                        "Install CI dependencies",
                        "apk add nodejs zstd wget bash coreutils tar findutils",
                        shell="sh",
                    ),
                    RunStep(
                        "Allow root login",
                        "sed 's/root:!/root:*/g' -i /etc/shadow",
                    ),
                ]
            if "opensuse" in self.container:
                steps += [
                    # This holds the xcb bits
                    RunStep(
                        "Install tar",
                        "zypper install -yl tar gzip",
                    ),
                ]

        steps += self.install_newer_compiler()
        steps += self.install_git()
        steps += self.install_curl()

        if self.uses_apt():
            if self.container:
                steps += [
                    RunStep("Update APT", f"{sudo}apt update"),
                ]

        steps += self.install_openssh_server()
        steps += self.checkout()
        # We should be able to cache mac builds now?
        steps += self.install_rust()  # cache="mac" not in self.name)
        steps += self.install_system_deps()
        return steps

    def pull_request(self):
        steps = self.prep_environment()
        steps += self.build_all_release()
        steps += self.test_all()
        steps += self.package()
        steps += self.upload_artifact()

        return (
            Job(
                runs_on=self.os,
                container=self.container,
                steps=steps,
                env=self.env,
            ),
            None,
        )

    def checkout(self, submodules=True):
        steps = []
        if self.container:
            steps += [
                RunStep(
                    "Workaround git permissions issue",
                    "git config --global --add safe.directory /__w/wezterm/wezterm",
                )
            ]
        steps += [CheckoutStep(submodules=submodules, container=self.container)]
        return steps

    def continuous(self):
        steps = self.prep_environment()
        steps += self.build_all_release()
        steps += self.test_all()
        steps += self.package(trusted=True)
        steps += self.upload_artifact_nightly()

        self.env["BUILD_REASON"] = "Schedule"

        uploader = Job(
            runs_on="ubuntu-latest",
            steps=self.checkout(submodules=False) + self.upload_asset_nightly(),
        )

        return (
            Job(
                runs_on=self.os,
                container=self.container,
                steps=steps,
                env=self.env,
            ),
            uploader,
        )

    def tag(self):
        steps = self.prep_environment()
        steps += self.build_all_release()
        steps += self.test_all()
        steps += self.package(trusted=True)
        steps += self.upload_artifact()

        uploader = Job(
            runs_on="ubuntu-latest",
            steps=self.checkout(submodules=False)
            + self.update_homebrew_tap()
            + self.upload_asset_tag()
            + self.create_winget_pr()
            + self.create_flathub_pr(),
        )

        return (
            Job(
                runs_on=self.os,
                container=self.container,
                steps=steps,
                env=self.env,
            ),
            uploader,
        )


TARGETS = [
    Target(container="ubuntu:20.04", continuous_only=True, app_image=True),
    Target(container="ubuntu:22.04", continuous_only=True),
    Target(container="ubuntu:24.04", continuous_only=True),
    # debian 8's wayland libraries are too old for wayland-client
    # Target(container="debian:8.11", continuous_only=True, bootstrap_git=True),
    # harfbuzz's C++ is too new for debian 9's toolchain
    # Target(container="debian:9.12", continuous_only=True, bootstrap_git=True),
    Target(container="debian:11", continuous_only=True),
    Target(container="debian:12", continuous_only=True),
    Target(name="centos9", container="quay.io/centos/centos:stream9"),
    Target(name="macos", os="macos-latest"),
    # https://fedoraproject.org/wiki/End_of_life?rd=LifeCycle/EOL
    Target(container="fedora:39"),
    Target(container="fedora:40"),
    Target(container="fedora:41"),
    # Target(container="alpine:3.15"),

    # Windows is on 2022 for the time being due to
    # https://github.com/actions/runner-images/issues/11644
    Target(name="windows", os="windows-2022", rust_target="x86_64-pc-windows-msvc"),
]


def generate_actions(namer, jobber, trigger, is_continuous, is_tag=False):
    for t in TARGETS:
        # Clone the definition, as some Target methods called
        # in the body below have side effects that we don't
        # want to bleed across into different schedule types
        t = deepcopy(t)

        t.is_tag = is_tag
        # if t.continuous_only and not is_continuous:
        #    continue
        name = namer(t).replace(":", "")
        print(name)
        job, uploader = jobber(t)

        file_name = f"{GEN_DIR}/gen_{name}.yml"
        if job.container:
            if t.app_image:
                container = f"container:\n      image: {yv(job.container)}\n      options: --privileged"
            else:
                container = f"container: {yv(job.container)}"

        else:
            container = ""

        trigger_paths = [file_name]
        trigger_paths += TRIGGER_PATHS
        if "win" in name:
            trigger_paths += TRIGGER_PATHS_WIN
        elif "macos" in name:
            trigger_paths += TRIGGER_PATHS_MAC
        else:
            trigger_paths += TRIGGER_PATHS_UNIX
        if t.app_image:
            trigger_paths += TRIGGER_PATHS_APPIMAGE

        trigger_paths = "- " + "\n      - ".join(yv(p) for p in sorted(trigger_paths))
        trigger_with_paths = trigger.replace("@PATHS@", trigger_paths)

        with open(file_name, "w") as f:
            f.write(
                f"""name: {name}
{trigger_with_paths}
jobs:
  build:
    runs-on: {yv(job.runs_on)}
    {container}
"""
            )

            t.render_env(f)

            job.render(f, 3)

            # We upload using a native runner as github API access
            # inside a container is really unreliable and can result
            # in broken releases that can't automatically be repaired
            # <https://github.com/cli/cli/issues/4863>
            if uploader:
                f.write(
                    """
  upload:
    runs-on: ubuntu-latest
    needs: build
    if: github.repository == 'RoversX/thinkterm'
    permissions:
      contents: write
      pages: write
      id-token: write
"""
                )
                uploader.render(f, 3)

        # Sanity check the yaml, if pyyaml is available
        try:
            import yaml

            with open(file_name) as f:
                yaml.safe_load(f)
        except ImportError:
            pass


def generate_pr_actions():
    generate_actions(
        lambda t: f"{t.name}",
        lambda t: t.pull_request(),
        trigger="""
on:
  pull_request:
    branches:
      - main
    paths:
      @PATHS@
""",
        is_continuous=False,
    )


def continuous_actions():
    generate_actions(
        lambda t: f"{t.name}_continuous",
        lambda t: t.continuous(),
        trigger="""
on:
  schedule:
    - cron: "10 3 * * *"
  push:
    branches:
      - main
    paths:
      @PATHS@
""",
        is_continuous=True,
    )


def tag_actions():
    generate_actions(
        lambda t: f"{t.name}_tag",
        lambda t: t.tag(),
        trigger="""
on:
  push:
    tags:
      - "20*"
""",
        is_continuous=True,
        is_tag=True,
    )


def remove_gen_actions():
    for name in glob.glob(f"{GEN_DIR}/gen_*.yml"):
        os.remove(name)


remove_gen_actions()
generate_pr_actions()
continuous_actions()
tag_actions()