tenant.openagents/omega

1use gh_workflow::*;
2
3use crate::tasks::workflows::{
4    runners,
5    steps::{self, CommonPermissionSets, named},
6    vars::{self, StepOutput, WorkflowInput},
7};
8
9pub fn bump_zed_version() -> Workflow {
10    let target = WorkflowInput::string("target", Some("all".to_string()))
11        .description("Which channels to bump: all, main, preview, or stable");
12
13    let (versions_job, outputs) = resolve_versions();
14
15    let bump_main_job = bump_main(&target, &versions_job, &outputs);
16    let preview_job = create_preview_branch(&target, &versions_job, &outputs);
17    let stable_job = promote_to_stable(&target, &versions_job, &outputs);
18
19    named::workflow()
20        .with_minimal_permissions()
21        .on(Event::default()
22            .workflow_dispatch(WorkflowDispatch::default().add_input(target.name, target.input())))
23        .add_job(versions_job.name, versions_job.job)
24        .add_job(bump_main_job.name, bump_main_job.job)
25        .add_job(preview_job.name, preview_job.job)
26        .add_job(stable_job.name, stable_job.job)
27}
28
29struct ResolvedOutputs {
30    next_version: vars::JobOutput,
31    pr_branch: vars::JobOutput,
32    preview_branch: vars::JobOutput,
33    preview_tag: vars::JobOutput,
34    stable_branch: vars::JobOutput,
35}
36
37fn resolve_versions() -> (steps::NamedJob, ResolvedOutputs) {
38    fn extract_versions() -> Step<Run> {
39        named::bash(indoc::indoc! {r#"
40            version=$(script/get-crate-version zed)
41            major=$(echo "$version" | cut -d. -f1)
42            minor=$(echo "$version" | cut -d. -f2)
43
44            channel=$(cat crates/zed/RELEASE_CHANNEL)
45            if [[ "$channel" != "dev" && "$channel" != "nightly" ]]; then
46                echo "::error::release channel on main should be dev or nightly, found: $channel"
47                exit 1
48            fi
49
50            # Next main version after bump
51            next_version="${major}.$((minor + 1)).0"
52            next_major=$(echo "$next_version" | cut -d. -f1)
53            next_minor=$(echo "$next_version" | cut -d. -f2)
54            pr_branch="bump-zed-to-v${next_major}.${next_minor}.0"
55
56            # New preview branch from current main
57            preview_branch="v${major}.${minor}.x"
58            preview_tag="v${version}-pre"
59
60            # Current preview to promote to stable — derive branch from released preview version
61            released_preview=$(script/get-released-version preview)
62            if [[ -z "$released_preview" ]]; then
63                echo "::error::could not determine released preview version"
64                exit 1
65            fi
66            stable_major=$(echo "$released_preview" | cut -d. -f1)
67            stable_minor=$(echo "$released_preview" | cut -d. -f2)
68            stable_branch="v${stable_major}.${stable_minor}.x"
69
70            # Final validation
71            for var in next_version pr_branch preview_branch preview_tag stable_branch; do
72                if [[ -z "${!var}" ]]; then
73                    echo "::error::failed to compute $var"
74                    exit 1
75                fi
76            done
77
78            {
79                echo "next_version=$next_version"
80                echo "pr_branch=$pr_branch"
81                echo "preview_branch=$preview_branch"
82                echo "preview_tag=$preview_tag"
83                echo "stable_branch=$stable_branch"
84            } >> "$GITHUB_OUTPUT"
85
86            echo "Resolved: next=$next_version preview=$preview_branch($preview_tag) stable=$stable_branch pr=$pr_branch"
87        "#})
88        .id("versions")
89    }
90
91    let (authenticate, token) = steps::authenticate_as_zippy()
92        .for_repository(steps::RepositoryTarget::current())
93        .with_permissions([(steps::TokenPermissions::Contents, Level::Read)])
94        .into();
95    let versions_step = extract_versions();
96    let next_version = StepOutput::new(&versions_step, "next_version");
97    let pr_branch = StepOutput::new(&versions_step, "pr_branch");
98    let preview_branch = StepOutput::new(&versions_step, "preview_branch");
99    let preview_tag = StepOutput::new(&versions_step, "preview_tag");
100    let stable_branch = StepOutput::new(&versions_step, "stable_branch");
101
102    let job = named::job(
103        Job::default()
104            .cond(Expression::new(
105                "github.repository_owner == 'zed-industries'",
106            ))
107            .runs_on(runners::LINUX_XL)
108            .add_step(authenticate)
109            .add_step(steps::checkout_repo().with_token(&token).with_ref("main"))
110            .add_step(versions_step)
111            .outputs([
112                (next_version.name.to_owned(), next_version.to_string()),
113                (pr_branch.name.to_owned(), pr_branch.to_string()),
114                (preview_branch.name.to_owned(), preview_branch.to_string()),
115                (preview_tag.name.to_owned(), preview_tag.to_string()),
116                (stable_branch.name.to_owned(), stable_branch.to_string()),
117            ]),
118    );
119
120    let outputs = ResolvedOutputs {
121        next_version: next_version.as_job_output(&job),
122        pr_branch: pr_branch.as_job_output(&job),
123        preview_branch: preview_branch.as_job_output(&job),
124        preview_tag: preview_tag.as_job_output(&job),
125        stable_branch: stable_branch.as_job_output(&job),
126    };
127
128    (job, outputs)
129}
130
131fn bump_main(
132    target: &WorkflowInput,
133    versions_job: &steps::NamedJob,
134    outputs: &ResolvedOutputs,
135) -> steps::NamedJob {
136    fn bump_version() -> Step<Run> {
137        named::bash("cargo set-version -p zed --bump minor")
138    }
139
140    let (authenticate, token) = steps::authenticate_as_zippy()
141        .for_repository(steps::RepositoryTarget::current())
142        .with_permissions([
143            (steps::TokenPermissions::Contents, Level::Write),
144            (steps::TokenPermissions::PullRequests, Level::Write),
145        ])
146        .into();
147
148    named::job(
149        Job::default()
150            .cond(Expression::new(format!(
151                "{} == 'all' || {} == 'main'",
152                target.expr(),
153                target.expr(),
154            )))
155            .permissions(
156                Permissions::default()
157                    .contents(Level::Write)
158                    .pull_requests(Level::Write),
159            )
160            .needs(vec![versions_job.name.clone()])
161            .runs_on(runners::LINUX_DEFAULT)
162            .add_step(authenticate)
163            .add_step(steps::checkout_repo().with_token(&token).with_ref("main"))
164            .add_step(steps::install_cargo_edit())
165            .add_step(bump_version())
166            .add_step(steps::CreatePrStep::new(
167                format!("Bump Zed to v{}", outputs.next_version),
168                &outputs.pr_branch,
169                &token,
170            )),
171    )
172}
173
174fn create_preview_branch(
175    target: &WorkflowInput,
176    versions_job: &steps::NamedJob,
177    outputs: &ResolvedOutputs,
178) -> steps::NamedJob {
179    fn promote_to_preview() -> Step<Run> {
180        named::bash("echo -n preview > crates/zed/RELEASE_CHANNEL")
181    }
182
183    fn get_main_sha() -> Step<Run> {
184        named::bash("echo \"main_sha=$(git rev-parse HEAD)\" >> \"$GITHUB_OUTPUT\"").id("main-sha")
185    }
186
187    let (authenticate, token) = steps::authenticate_as_zippy()
188        .for_repository(steps::RepositoryTarget::current())
189        .with_permissions([(steps::TokenPermissions::Contents, Level::Write)])
190        .into();
191
192    let main_sha_step = get_main_sha();
193    let main_sha = StepOutput::new(&main_sha_step, "main_sha");
194
195    let commit_step: Step<Use> = steps::BotCommitStep::new(
196        format!(
197            "{} preview for @${{{{ github.actor }}}}",
198            outputs.preview_branch
199        ),
200        &outputs.preview_branch,
201        &token,
202    )
203    .with_files("crates/zed/RELEASE_CHANNEL")
204    .into();
205    let commit_sha = StepOutput::new_unchecked(&commit_step, "commit");
206
207    named::job(
208        Job::default()
209            .cond(Expression::new(format!(
210                "{} == 'all' || {} == 'preview'",
211                target.expr(),
212                target.expr(),
213            )))
214            .permissions(Permissions::default().contents(Level::Write))
215            .needs(vec![versions_job.name.clone()])
216            .runs_on(runners::LINUX_DEFAULT)
217            .add_step(authenticate)
218            .add_step(steps::checkout_repo().with_token(&token).with_ref("main"))
219            .add_step(main_sha_step)
220            .add_step(promote_to_preview())
221            .add_step(steps::create_ref(
222                steps::GitRef::branch(&outputs.preview_branch),
223                &main_sha,
224                &token,
225            ))
226            .add_step(commit_step)
227            .add_step(steps::create_ref(
228                steps::GitRef::tag(&outputs.preview_tag),
229                &commit_sha,
230                &token,
231            )),
232    )
233}
234
235fn promote_to_stable(
236    target: &WorkflowInput,
237    versions_job: &steps::NamedJob,
238    outputs: &ResolvedOutputs,
239) -> steps::NamedJob {
240    let (authenticate, token) = steps::authenticate_as_zippy()
241        .for_repository(steps::RepositoryTarget::current())
242        .with_permissions([(steps::TokenPermissions::Contents, Level::Write)])
243        .into();
244
245    let read_version_step = named::bash(indoc::indoc! {r#"
246            stable_version=$(script/get-crate-version zed)
247            {
248                echo "stable_tag=v${stable_version}"
249            } >> "$GITHUB_OUTPUT"
250        "#})
251    .id("stable-info");
252    let stable_tag = StepOutput::new(&read_version_step, "stable_tag");
253
254    let write_channel = named::bash("echo -n stable > crates/zed/RELEASE_CHANNEL");
255
256    let commit_step: Step<Use> = steps::BotCommitStep::new(
257        format!(
258            "{} stable for @${{{{ github.actor }}}}",
259            outputs.stable_branch
260        ),
261        &outputs.stable_branch,
262        &token,
263    )
264    .with_files("crates/zed/RELEASE_CHANNEL")
265    .into();
266    let commit_sha = StepOutput::new_unchecked(&commit_step, "commit");
267
268    named::job(
269        Job::default()
270            .cond(Expression::new(format!(
271                "{} == 'all' || {} == 'stable'",
272                target.expr(),
273                target.expr(),
274            )))
275            .permissions(Permissions::default().contents(Level::Write))
276            .needs(vec![versions_job.name.clone()])
277            .runs_on(runners::LINUX_DEFAULT)
278            .add_step(authenticate)
279            .add_step(
280                steps::checkout_repo()
281                    .with_token(&token)
282                    .with_ref(outputs.stable_branch.to_string()),
283            )
284            .add_step(read_version_step)
285            .add_step(write_channel)
286            .add_step(commit_step)
287            .add_step(steps::create_ref(
288                steps::GitRef::tag(&stable_tag),
289                &commit_sha,
290                &token,
291            )),
292    )
293}
294