tenant.openagents/omega

1use std::path::Path;
2
3use crate::tasks::workflows::{
4    release::ReleaseBundleJobs,
5    runners::{Arch, Platform, ReleaseChannel},
6    steps::{
7        CommonPermissionSets, FluentBuilder, IfNoFilesFound, NamedJob, UploadArtifactStep,
8        dependant_job, named,
9    },
10    vars::{self, assets, bundle_envs},
11};
12
13use super::{runners, steps};
14use gh_workflow::*;
15use indoc::indoc;
16
17pub fn run_bundling() -> Workflow {
18    let bundle = ReleaseBundleJobs {
19        linux_aarch64: bundle_linux(Arch::AARCH64, None, &[]),
20        linux_x86_64: bundle_linux(Arch::X86_64, None, &[]),
21        bwrap_linux_aarch64: build_static_bwrap(Arch::AARCH64, &[]),
22        bwrap_linux_x86_64: build_static_bwrap(Arch::X86_64, &[]),
23        mac_aarch64: bundle_mac(Arch::AARCH64, None, &[]),
24        mac_x86_64: bundle_mac(Arch::X86_64, None, &[]),
25        windows_aarch64: bundle_windows(Arch::AARCH64, None, &[]),
26        windows_x86_64: bundle_windows(Arch::X86_64, None, &[]),
27    };
28    named::workflow()
29        .with_minimal_permissions()
30        .on(Event::default().pull_request(
31            PullRequest::default().types([PullRequestType::Labeled, PullRequestType::Synchronize]),
32        ))
33        .concurrency(
34            Concurrency::new(Expression::new(
35                "${{ github.workflow }}-${{ github.head_ref || github.ref }}",
36            ))
37            .cancel_in_progress(true),
38        )
39        .add_env(("CARGO_TERM_COLOR", "always"))
40        .add_env(("RUST_BACKTRACE", "1"))
41        .map(|mut workflow| {
42            for job in bundle.into_jobs() {
43                workflow = workflow.add_job(job.name, job.job);
44            }
45            workflow
46        })
47}
48
49fn bundle_job(deps: &[&NamedJob]) -> Job {
50    dependant_job(deps)
51        .when(deps.len() == 0, |job|
52            job.cond(Expression::new(
53                indoc! {
54                    r#"(github.event.action == 'labeled' && github.event.label.name == 'run-bundling') ||
55                    (github.event.action == 'synchronize' && contains(github.event.pull_request.labels.*.name, 'run-bundling'))"#,
56                })))
57        .timeout_minutes(60u32)
58}
59
60pub(crate) fn bundle_mac(
61    arch: Arch,
62    release_channel: Option<ReleaseChannel>,
63    deps: &[&NamedJob],
64) -> NamedJob {
65    pub fn bundle_mac(arch: Arch) -> Step<Run> {
66        named::bash(&format!("./script/bundle-mac {arch}-apple-darwin"))
67    }
68    let platform = Platform::Mac;
69    let artifact_name = match arch {
70        Arch::X86_64 => assets::MAC_X86_64,
71        Arch::AARCH64 => assets::MAC_AARCH64,
72    };
73    let remote_server_artifact_name = match arch {
74        Arch::X86_64 => assets::REMOTE_SERVER_MAC_X86_64,
75        Arch::AARCH64 => assets::REMOTE_SERVER_MAC_AARCH64,
76    };
77    NamedJob {
78        name: format!("bundle_mac_{arch}"),
79        job: bundle_job(deps)
80            .runs_on(runners::MAC_DEFAULT)
81            .envs(bundle_envs(platform))
82            .add_step(steps::checkout_repo())
83            .add_step(steps::cache_rust_dependencies_namespace())
84            .when_some(release_channel, |job, release_channel| {
85                job.add_step(set_release_channel(platform, release_channel))
86            })
87            .add_step(steps::setup_node())
88            .add_step(steps::setup_sentry())
89            .add_step(steps::clear_target_dir_if_large(runners::Platform::Mac))
90            .add_step(bundle_mac(arch))
91            .add_step(upload_artifact(&format!(
92                "target/{arch}-apple-darwin/release/{artifact_name}"
93            )))
94            .add_step(upload_artifact(&format!(
95                "target/{remote_server_artifact_name}"
96            ))),
97    }
98}
99
100pub fn upload_artifact(path: &str) -> UploadArtifactStep {
101    let name = Path::new(path).file_name().unwrap().to_str().unwrap();
102    steps::upload_artifact(name, path).if_no_files_found(IfNoFilesFound::Error)
103}
104
105pub(crate) fn build_static_bwrap(arch: Arch, deps: &[&NamedJob]) -> NamedJob {
106    let artifact_name = match arch {
107        Arch::X86_64 => assets::BWRAP_LINUX_X86_64,
108        Arch::AARCH64 => assets::BWRAP_LINUX_AARCH64,
109    };
110    let binary_name = artifact_name
111        .strip_suffix(".gz")
112        .expect("static bwrap artifact name should end in .gz");
113    let copy_artifact = indoc::formatdoc! {r#"
114        cp result/bin/bwrap {binary_name}
115        chmod 755 {binary_name}
116        gzip -f --stdout --best {binary_name} > {artifact_name}
117    "#};
118
119    NamedJob {
120        name: format!("build_static_bwrap_linux_{arch}"),
121        job: bundle_job(deps)
122            .runs_on(arch.linux_bundler())
123            .timeout_minutes(60u32)
124            .add_step(steps::cache_nix_dependencies_namespace())
125            .add_step(
126                named::uses(
127                    "cachix",
128                    "install-nix-action",
129                    "02a151ada4993995686f9ed4f1be7cfbb229e56f", // v31
130                )
131                .add_with(("github_access_token", vars::GITHUB_TOKEN)),
132            )
133            .add_step(
134                named::uses(
135                    "cachix",
136                    "cachix-action",
137                    "0fc020193b5a1fa3ac4575aa3a7d3aa6a35435ad", // v16
138                )
139                .add_with(("name", "zed"))
140                .add_with(("authToken", vars::CACHIX_AUTH_TOKEN))
141                .add_with(("cachixArgs", "-v")),
142            )
143            .add_step(named::bash("nix build nixpkgs#pkgsStatic.bubblewrap -L"))
144            .add_step(named::bash(&copy_artifact))
145            .add_step(upload_artifact(artifact_name)),
146    }
147}
148
149pub(crate) fn bundle_linux(
150    arch: Arch,
151    release_channel: Option<ReleaseChannel>,
152    deps: &[&NamedJob],
153) -> NamedJob {
154    let platform = Platform::Linux;
155    let artifact_name = match arch {
156        Arch::X86_64 => assets::LINUX_X86_64,
157        Arch::AARCH64 => assets::LINUX_AARCH64,
158    };
159    let remote_server_artifact_name = match arch {
160        Arch::X86_64 => assets::REMOTE_SERVER_LINUX_X86_64,
161        Arch::AARCH64 => assets::REMOTE_SERVER_LINUX_AARCH64,
162    };
163    NamedJob {
164        name: format!("bundle_linux_{arch}"),
165        job: bundle_job(deps)
166            .runs_on(arch.linux_bundler())
167            .envs(bundle_envs(platform))
168            .add_env(Env::new("CC", "clang-18"))
169            .add_env(Env::new("CXX", "clang++-18"))
170            .add_step(steps::checkout_repo())
171            .add_step(steps::cache_rust_dependencies_namespace())
172            .when_some(release_channel, |job, release_channel| {
173                job.add_step(set_release_channel(platform, release_channel))
174            })
175            .add_step(steps::setup_sentry())
176            .map(steps::install_linux_dependencies)
177            .add_step(steps::script("./script/bundle-linux"))
178            .add_step(upload_artifact(&format!("target/release/{artifact_name}")))
179            .add_step(upload_artifact(&format!(
180                "target/{remote_server_artifact_name}"
181            ))),
182    }
183}
184
185pub(crate) fn bundle_windows(
186    arch: Arch,
187    release_channel: Option<ReleaseChannel>,
188    deps: &[&NamedJob],
189) -> NamedJob {
190    let platform = Platform::Windows;
191    pub fn bundle_windows(arch: Arch) -> Step<Run> {
192        let step = match arch {
193            Arch::X86_64 => named::pwsh("script/bundle-windows.ps1 -Architecture x86_64"),
194            Arch::AARCH64 => named::pwsh("script/bundle-windows.ps1 -Architecture aarch64"),
195        };
196        step.working_directory("${{ env.ZED_WORKSPACE }}")
197    }
198    let artifact_name = match arch {
199        Arch::X86_64 => assets::WINDOWS_X86_64,
200        Arch::AARCH64 => assets::WINDOWS_AARCH64,
201    };
202    let remote_server_artifact_name = match arch {
203        Arch::X86_64 => assets::REMOTE_SERVER_WINDOWS_X86_64,
204        Arch::AARCH64 => assets::REMOTE_SERVER_WINDOWS_AARCH64,
205    };
206    NamedJob {
207        name: format!("bundle_windows_{arch}"),
208        job: bundle_job(deps)
209            .runs_on(runners::WINDOWS_DEFAULT)
210            .envs(bundle_envs(platform))
211            .add_step(steps::checkout_repo())
212            .when_some(release_channel, |job, release_channel| {
213                job.add_step(set_release_channel(platform, release_channel))
214            })
215            .add_step(steps::setup_sentry())
216            .add_step(steps::clear_target_dir_if_large(platform))
217            .add_step(bundle_windows(arch))
218            .add_step(upload_artifact(&format!("target/{artifact_name}")))
219            .add_step(upload_artifact(&format!(
220                "target/{remote_server_artifact_name}"
221            ))),
222    }
223}
224
225fn set_release_channel(platform: Platform, release_channel: ReleaseChannel) -> Step<Run> {
226    match release_channel {
227        ReleaseChannel::Nightly => set_release_channel_to_nightly(platform),
228    }
229}
230
231fn set_release_channel_to_nightly(platform: Platform) -> Step<Run> {
232    match platform {
233        Platform::Linux | Platform::Mac => named::bash(indoc::indoc! {r#"
234            set -eu
235            version=$(git rev-parse --short HEAD)
236            echo "Publishing version: ${version} on release channel nightly"
237            echo "nightly" > crates/zed/RELEASE_CHANNEL
238        "#}),
239        Platform::Windows => named::pwsh(indoc::indoc! {r#"
240            $ErrorActionPreference = "Stop"
241            $version = git rev-parse --short HEAD
242            Write-Host "Publishing version: $version on release channel nightly"
243            "nightly" | Set-Content -Path "crates/zed/RELEASE_CHANNEL"
244        "#})
245        .working_directory("${{ env.ZED_WORKSPACE }}"),
246    }
247}
248