Skip to content

A desktop coding agent with free access to frontier models.

TypeScript

fix: keep releases above the latest version

ogsamrat6bf0cbf62885
diff --git a/.github/workflows/release-desktop.yml b/.github/workflows/release-desktop.yml
index 4bfcf3d3..2770110e 100644
--- a/.github/workflows/release-desktop.yml
+++ b/.github/workflows/release-desktop.yml
@@ -59,6 +59,22 @@ jobs:
shell: bash
run: node scripts/box/check-pins.mjs apps/server/src/box/images.json apps/server/src/box/wsl.json
+ # Installed apps take only a version higher than their own, from the
+ # release marked Latest. A tag at or below an existing release (v3.3.8
+ # published after v3.4.1) is refused before anything is built.
+ - name: Release version is above every published release
+ env:
+ GH_TOKEN: ${{ github.token }}
+ RELEASE_TAG: ${{ steps.release.outputs.tag }}
+ RELEASE_VERSION: ${{ steps.release.outputs.version }}
+ GUARD_MODE: ${{ github.event_name == 'push' && 'fresh' || 'recovery' }}
+ shell: bash
+ run: |
+ set -euo pipefail
+ git fetch --depth=1 --force --quiet origin 'refs/tags/v*:refs/tags/v*'
+ node scripts/release/verify-tag.mjs --tag "$RELEASE_TAG" --mode "$GUARD_MODE"
+ node scripts/release/latest-guard.mjs --version "$RELEASE_VERSION" --mode "$GUARD_MODE"
+
- name: Create draft release
env:
GH_TOKEN: ${{ github.token }}
@@ -312,9 +328,59 @@ jobs:
--repo "$GITHUB_REPOSITORY" \
--clobber
+ - name: Check out release scripts
+ uses: actions/checkout@v4
+ with:
+ ref: ${{ needs.prepare.outputs.tag }}
+ fetch-depth: 1
+ sparse-checkout: scripts/release
+
+ # Latest is the update feed. It moves only forward: a rebuild of an
+ # older tag is published without taking Latest from a newer release.
+ - name: Decide whether this release becomes Latest
+ id: latest
+ env:
+ GH_TOKEN: ${{ github.token }}
+ RELEASE_VERSION: ${{ needs.prepare.outputs.version }}
+ shell: bash
+ run: node scripts/release/latest-guard.mjs --version "$RELEASE_VERSION" --mode recovery >> "$GITHUB_OUTPUT"
+
- name: Publish GitHub release
env:
GH_TOKEN: ${{ github.token }}
RELEASE_TAG: ${{ needs.prepare.outputs.tag }}
+ MARK_LATEST: ${{ steps.latest.outputs.mark_latest }}
shell: bash
- run: gh release edit "$RELEASE_TAG" --repo "$GITHUB_REPOSITORY" --draft=false --latest
+ run: gh release edit "$RELEASE_TAG" --repo "$GITHUB_REPOSITORY" --draft=false --latest="$MARK_LATEST"
+
+ # What installed apps will read: every Latest manifest names this
+ # version, and every file it lists is an asset of this release.
+ - name: Verify the update feed
+ if: steps.latest.outputs.mark_latest == 'true'
+ env:
+ GH_TOKEN: ${{ github.token }}
+ RELEASE_TAG: ${{ needs.prepare.outputs.tag }}
+ RELEASE_VERSION: ${{ needs.prepare.outputs.version }}
+ shell: bash
+ run: |
+ set -euo pipefail
+ assets="$(gh release view "$RELEASE_TAG" --repo "$GITHUB_REPOSITORY" --json assets --jq '.assets[].name')"
+ for manifest in latest.yml latest-mac.yml latest-linux.yml latest-linux-arm64.yml; do
+ ok=""
+ for attempt in 1 2 3 4 5 6 7 8 9 10; do
+ body="$(curl -fsSL "https://github.com/$GITHUB_REPOSITORY/releases/latest/download/$manifest?attempt=$attempt" || true)"
+ if [ "$(printf '%s\n' "$body" | sed -n 's/^version: *//p' | tr -d "'\"\r")" = "$RELEASE_VERSION" ]; then ok=1; break; fi
+ sleep 15
+ done
+ if [ -z "$ok" ]; then
+ echo "releases/latest/download/$manifest does not name $RELEASE_VERSION; installed apps would not find this release." >&2
+ exit 1
+ fi
+ for file in $(printf '%s\n' "$body" | sed -n 's/^ *- url: *//p'); do
+ if ! printf '%s\n' "$assets" | grep -qxF "$file"; then
+ echo "$manifest lists $file, which is not an asset of $RELEASE_TAG." >&2
+ exit 1
+ fi
+ done
+ echo "$manifest: $RELEASE_VERSION"
+ done
diff --git a/scripts/release/latest-guard.mjs b/scripts/release/latest-guard.mjs
new file mode 100644
index 00000000..4c4a64b6
--- /dev/null
+++ b/scripts/release/latest-guard.mjs
@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Guards the GitHub "Latest" release, which is the desktop update feed:
+ * installed apps read `releases/latest/download/latest*.yml` and install only
+ * a version higher than their own.
+ *
+ * - A fresh release must be higher than the release marked Latest. A lower
+ * version (v3.3.8 published after v3.4.1) is never installed by newer apps,
+ * and marking it Latest leaves every app at or above it with no update to
+ * find, so a required update dead-ends.
+ * - A rebuild of an existing tag (recovery) is marked Latest only when it is
+ * not below the current Latest release.
+ *
+ * Usage:
+ * node scripts/release/latest-guard.mjs --version X.Y.Z --mode fresh|recovery [--latest-tag vA.B.C]
+ * Without --latest-tag the current Latest release is read with `gh api`.
+ * Prints `mark_latest=true|false` (append it to $GITHUB_OUTPUT) and exits 1
+ * when the release must not be published.
+ */
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { compareStableVersions, parseStableVersion, stableVersionFromTag } from "./versions.mjs";
+
+export const GUARD_MODES = ["fresh", "recovery"];
+
+export function latestReleaseDecision({ version, latestVersion, mode }) {
+ const problems = [];
+ if (!GUARD_MODES.includes(mode)) problems.push(`Unknown mode: ${mode} (expected ${GUARD_MODES.join("|")}).`);
+ if (!parseStableVersion(version)) problems.push(`Version ${version || "(empty)"} is not a stable x.y.z version.`);
+ if (problems.length) return { ok: false, markLatest: false, problems };
+ if (!latestVersion) return { ok: true, markLatest: true, problems };
+ if (!parseStableVersion(latestVersion)) {
+ return { ok: false, markLatest: false, problems: [`The release marked Latest has no stable version (${latestVersion}).`] };
+ }
+ const comparison = compareStableVersions(version, latestVersion);
+ if (comparison > 0) return { ok: true, markLatest: true, problems };
+ if (mode === "recovery") return { ok: true, markLatest: comparison === 0, problems };
+ problems.push(
+ comparison === 0
+ ? `v${version} is already the release marked Latest; rebuild it with a workflow_dispatch (recovery) run.`
+ : `v${version} is lower than the release marked Latest (v${latestVersion}). Installed apps only update to a higher version: ` +
+ `apps on v${latestVersion} would never take it, and marking it Latest would leave them, and any app required to reach ` +
+ `v${latestVersion}, with no update to find. Publish v${bumpPatch(latestVersion)} or higher instead.`,
+ );
+ return { ok: false, markLatest: false, problems };
+}
+
+function bumpPatch(version) {
+ const [major, minor, patch] = parseStableVersion(version);
+ return `${major}.${minor}.${patch + 1}`;
+}
+
+function readLatestTag(repo) {
+ try {
+ return execFileSync("gh", ["api", `repos/${repo}/releases/latest`, "--jq", ".tag_name"], { encoding: "utf8" }).trim();
+ } catch (error) {
+ // 404: the repository has no published release yet.
+ if (/HTTP 404/.test(String(error?.stderr ?? error?.message ?? ""))) return "";
+ throw error;
+ }
+}
+
+function argValue(args, name) {
+ const index = args.indexOf(name);
+ return index >= 0 ? args[index + 1] : undefined;
+}
+
+function main() {
+ const args = process.argv.slice(2);
+ const version = (argValue(args, "--version") ?? "").trim().replace(/^v/, "");
+ const mode = (argValue(args, "--mode") ?? "fresh").trim();
+ const repo = argValue(args, "--repo") ?? process.env.GITHUB_REPOSITORY ?? "omnirush-ai/omnirush-gui";
+ const latestTag = argValue(args, "--latest-tag") ?? readLatestTag(repo);
+ const latestVersion = latestTag ? stableVersionFromTag(latestTag) ?? latestTag : null;
+ const decision = latestReleaseDecision({ version, latestVersion, mode });
+ if (!decision.ok) {
+ console.error(`Release v${version} refused (${mode}; Latest is ${latestTag || "none"}):`);
+ for (const problem of decision.problems) console.error(`- ${problem}`);
+ process.exit(1);
+ }
+ console.error(`Release v${version} (${mode}; Latest is ${latestTag || "none"}): ${decision.markLatest ? "will be" : "will not be"} marked Latest.`);
+ console.log(`mark_latest=${decision.markLatest}`);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+ try {
+ main();
+ } catch (error) {
+ console.error(error instanceof Error ? error.message : String(error));
+ process.exit(1);
+ }
+}
diff --git a/scripts/release/latest-guard.test.mjs b/scripts/release/latest-guard.test.mjs
new file mode 100644
index 00000000..f99a7d2d
--- /dev/null
+++ b/scripts/release/latest-guard.test.mjs
@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { latestReleaseDecision } from "./latest-guard.mjs";
+
+test("a fresh release must be higher than the release marked Latest", () => {
+ assert.deepEqual(latestReleaseDecision({ version: "3.4.2", latestVersion: "3.4.1", mode: "fresh" }), {
+ ok: true,
+ markLatest: true,
+ problems: [],
+ });
+ assert.equal(latestReleaseDecision({ version: "4.0.0", latestVersion: "3.4.1", mode: "fresh" }).markLatest, true);
+});
+
+test("v3.3.8 after v3.4.1 is refused before anything is built", () => {
+ const decision = latestReleaseDecision({ version: "3.3.8", latestVersion: "3.4.1", mode: "fresh" });
+ assert.equal(decision.ok, false);
+ assert.equal(decision.markLatest, false);
+ assert.match(decision.problems[0], /lower than the release marked Latest \(v3\.4\.1\)/);
+ assert.match(decision.problems[0], /Publish v3\.4\.2 or higher/);
+});
+
+test("a fresh release equal to Latest is refused", () => {
+ const decision = latestReleaseDecision({ version: "3.4.1", latestVersion: "3.4.1", mode: "fresh" });
+ assert.equal(decision.ok, false);
+ assert.match(decision.problems[0], /already the release marked Latest/);
+});
+
+test("a rebuild keeps Latest on the newest release", () => {
+ assert.deepEqual(latestReleaseDecision({ version: "3.4.1", latestVersion: "3.4.1", mode: "recovery" }).markLatest, true);
+ const older = latestReleaseDecision({ version: "3.3.8", latestVersion: "3.4.1", mode: "recovery" });
+ assert.equal(older.ok, true);
+ assert.equal(older.markLatest, false, "rebuilding an older tag must not move Latest backwards");
+});
+
+test("the first release is marked Latest", () => {
+ assert.equal(latestReleaseDecision({ version: "1.0.0", latestVersion: null, mode: "fresh" }).markLatest, true);
+});
+
+test("malformed input is refused", () => {
+ assert.equal(latestReleaseDecision({ version: "3.4.2-beta.1", latestVersion: "3.4.1", mode: "fresh" }).ok, false);
+ assert.equal(latestReleaseDecision({ version: "3.4.2", latestVersion: "3.4.1", mode: "other" }).ok, false);
+ assert.equal(latestReleaseDecision({ version: "3.4.2", latestVersion: "garbage", mode: "fresh" }).ok, false);
+});