fix(desktop): guarantee the update feed resolves the newest release

The stable channel reads a GitHub release list it shares with web-app
releases, SDK tags, and legacy prereleases, but only ever looked at the
first 30 entries. Once enough unrelated releases stack on top, the feed
404s and every stable shell silently stops updating.

Walk pages (100 per page, up to 5) until one yields a release for the
channel, and fail the feed rather than serving an older build when a page
cannot be read.

Also point the update gate's manual download at a new
/api/desktop/update/download redirect, which resolves through the same
channel selection. It previously opened GitHub's repository-wide latest
release, which can be a tag carrying no desktop artifact at all.

Author: waleedlatif1

apps/sim/app/_shell/desktop-update-gate.tsx

@@ -6,8 +6,23 @@ import { Button, useNativeSurfaceOcclusionReady } from '@sim/emcn'
 import { getDesktopBridge, getDesktopShellVersion, getDesktopUpdates } from '@/lib/desktop'
 import { isShellOutdated } from '@/lib/desktop/min-version'
 
+/**
+ * Resolves this deployment's channel to the newest release's installer, so a
+ * manual download lands on the same build the updater would have installed.
+ */
+const DOWNLOAD_REDIRECT_PATH = '/api/desktop/update/download'
+
 const DOWNLOAD_FALLBACK_URL = 'https://github.com/simstudioai/sim/releases/latest'
 
+function manualDownloadUrl(): string {
+  const origin = window.location.origin
+  // openExternal only accepts https, so an http self-hosted origin cannot
+  // serve the redirect to the system browser.
+  return origin.startsWith('https://')
+    ? `${origin}${DOWNLOAD_REDIRECT_PATH}`
+    : DOWNLOAD_FALLBACK_URL
+}
+
 interface GateAction {
   label: string
   disabled?: boolean
@@ -21,7 +36,7 @@ function gateActionFor(state: DesktopUpdateState): GateAction {
     // background; the button covers the manual path.
     return {
       label: 'Get the latest version',
-      onClick: () => void getDesktopBridge()?.openExternal(DOWNLOAD_FALLBACK_URL),
+      onClick: () => void getDesktopBridge()?.openExternal(manualDownloadUrl()),
     }
   }
   switch (state.status) {

apps/sim/app/api/desktop/update/download/route.test.ts

@@ -0,0 +1,111 @@
+/**
+ * @vitest-environment node
+ */
+import { setEnv } from '@sim/testing'
+import { NextRequest } from 'next/server'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  DESKTOP_PRERELEASE_REPOSITORY,
+  DESKTOP_STABLE_RELEASE_REPOSITORY,
+  MANIFEST_ASSET_NAME,
+  releasesApiUrl,
+} from '@/lib/desktop/update-feed'
+import { GET } from '@/app/api/desktop/update/download/route'
+
+const STABLE_RELEASES_URL = releasesApiUrl(DESKTOP_STABLE_RELEASE_REPOSITORY, 1)
+const PRERELEASE_RELEASES_URL = releasesApiUrl(DESKTOP_PRERELEASE_REPOSITORY, 1)
+
+function release(tag: string, repository: string) {
+  const base = `https://github.com/${repository}/releases/download/${tag}`
+  const version = tag.replace(/^v/, '')
+  return {
+    tag_name: tag,
+    draft: false,
+    prerelease: tag.includes('-'),
+    assets: [
+      { name: MANIFEST_ASSET_NAME, browser_download_url: `${base}/${MANIFEST_ASSET_NAME}` },
+      {
+        name: `Sim-${version}-universal.zip`,
+        browser_download_url: `${base}/Sim-${version}-universal.zip`,
+      },
+      {
+        name: `Sim-${version}-universal.dmg`,
+        browser_download_url: `${base}/Sim-${version}-universal.dmg`,
+      },
+    ],
+  }
+}
+
+async function getDownload(): Promise<Response> {
+  return GET(new NextRequest('https://www.sim.ai/api/desktop/update/download'), undefined)
+}
+
+describe('desktop update download route', () => {
+  const fetchMock = vi.fn()
+
+  beforeEach(() => {
+    fetchMock.mockReset()
+    vi.stubGlobal('fetch', fetchMock)
+    setEnv({ APPCONFIG_ENVIRONMENT: undefined })
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('redirects to the newest stable installer', async () => {
+    fetchMock.mockResolvedValueOnce(
+      Response.json([
+        release('v1.1.0', DESKTOP_STABLE_RELEASE_REPOSITORY),
+        release('v1.3.0', DESKTOP_STABLE_RELEASE_REPOSITORY),
+        release('v1.2.0', DESKTOP_STABLE_RELEASE_REPOSITORY),
+      ])
+    )
+
+    const response = await getDownload()
+
+    expect(response.status).toBe(302)
+    expect(response.headers.get('location')).toBe(
+      `https://github.com/${DESKTOP_STABLE_RELEASE_REPOSITORY}/releases/download/v1.3.0/Sim-1.3.0-universal.dmg`
+    )
+    expect(fetchMock).toHaveBeenCalledWith(STABLE_RELEASES_URL, expect.any(Object))
+  })
+
+  it('serves its own deployment channel rather than the stable stream', async () => {
+    setEnv({ APPCONFIG_ENVIRONMENT: 'dev' })
+    fetchMock.mockResolvedValueOnce(
+      Response.json([
+        release('v1.3.0-dev.4', DESKTOP_PRERELEASE_REPOSITORY),
+        release('v1.4.0-staging.1', DESKTOP_PRERELEASE_REPOSITORY),
+      ])
+    )
+
+    const response = await getDownload()
+
+    expect(response.status).toBe(302)
+    expect(response.headers.get('location')).toContain('Sim-1.3.0-dev.4-universal.dmg')
+    expect(fetchMock).toHaveBeenCalledWith(PRERELEASE_RELEASES_URL, expect.any(Object))
+  })
+
+  it('reports no release when the channel has none', async () => {
+    fetchMock.mockResolvedValueOnce(
+      Response.json([release('v1.3.0-dev.4', DESKTOP_PRERELEASE_REPOSITORY)])
+    )
+
+    const response = await getDownload()
+
+    expect(response.status).toBe(404)
+    expect(await response.json()).toMatchObject({
+      error: 'No desktop release for channel latest',
+    })
+  })
+
+  it('surfaces an unreadable release list instead of redirecting', async () => {
+    fetchMock.mockResolvedValueOnce(new Response(null, { status: 500 }))
+
+    const response = await getDownload()
+
+    expect(response.status).toBe(502)
+    expect(await response.json()).toMatchObject({ error: 'Release feed unavailable' })
+  })
+})

apps/sim/app/api/desktop/update/download/route.ts

@@ -0,0 +1,77 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { env } from '@/lib/core/config/env'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import {
+  channelForDeploymentEnvironment,
+  type DesktopReleaseCandidate,
+  releaseRepositoryForChannel,
+  releasesApiUrl,
+  resolveLatestRelease,
+  selectInstallerAsset,
+} from '@/lib/desktop/update-feed'
+
+const logger = createLogger('DesktopUpdateDownloadAPI')
+
+/** Matches the manifest feed so both paths resolve the same release. */
+const REVALIDATE_SECONDS = 300
+
+/**
+ * Redirects to the installer for the newest release of this deployment's
+ * channel (see `lib/desktop/update-feed.ts`).
+ *
+ * This is the manual escape hatch behind the blocking update gate: shells too
+ * old to expose the updater bridge send the user here instead of
+ * self-updating. It resolves through the same channel selection as the
+ * manifest feed, so a manual download lands on exactly the build
+ * electron-updater would have installed — never an intermediate version, and
+ * never a repository release carrying no desktop artifact.
+ *
+ * Public by the same reasoning as the manifest feed: it only points at public
+ * GitHub release assets.
+ */
+export const GET = withRouteHandler(async (_request: NextRequest): Promise<Response> => {
+  const channel = channelForDeploymentEnvironment(env.APPCONFIG_ENVIRONMENT)
+  const releaseRepository = releaseRepositoryForChannel(channel)
+
+  const githubToken = process.env.GITHUB_TOKEN
+  const resolved = await resolveLatestRelease(channel, async (page) => {
+    const response = await fetch(releasesApiUrl(releaseRepository, page), {
+      headers: {
+        accept: 'application/vnd.github+json',
+        ...(githubToken ? { authorization: `Bearer ${githubToken}` } : {}),
+      },
+      next: { revalidate: REVALIDATE_SECONDS },
+    })
+    if (!response.ok) {
+      logger.error('GitHub releases lookup failed', {
+        status: response.status,
+        page,
+        channel,
+        releaseRepository,
+      })
+      return null
+    }
+    return (await response.json()) as DesktopReleaseCandidate[]
+  })
+  if ('error' in resolved) {
+    return NextResponse.json({ error: 'Release feed unavailable' }, { status: 502 })
+  }
+
+  const release = resolved.release
+  const asset = release ? selectInstallerAsset(release) : null
+  if (!release || !asset) {
+    if (release) {
+      logger.error('Release has no installer artifact', { tag: release.tag_name, channel })
+    }
+    return NextResponse.json(
+      { error: `No desktop release for channel ${channel}` },
+      { status: 404 }
+    )
+  }
+
+  return NextResponse.redirect(asset.browser_download_url, {
+    status: 302,
+    headers: { 'cache-control': `public, max-age=${REVALIDATE_SECONDS}` },
+  })
+})

apps/sim/app/api/desktop/update/latest-mac.yml/route.test.ts

@@ -6,13 +6,15 @@ import { NextRequest } from 'next/server'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   DESKTOP_PRERELEASE_REPOSITORY,
+  DESKTOP_RELEASES_PAGE_SIZE,
   DESKTOP_STABLE_RELEASE_REPOSITORY,
   MANIFEST_ASSET_NAME,
+  releasesApiUrl,
 } from '@/lib/desktop/update-feed'
 import { GET } from '@/app/api/desktop/update/latest-mac.yml/route'
 
-const STABLE_RELEASES_URL = `https://api.github.com/repos/${DESKTOP_STABLE_RELEASE_REPOSITORY}/releases?per_page=30`
-const PRERELEASE_RELEASES_URL = `https://api.github.com/repos/${DESKTOP_PRERELEASE_REPOSITORY}/releases?per_page=30`
+const STABLE_RELEASES_URL = releasesApiUrl(DESKTOP_STABLE_RELEASE_REPOSITORY, 1)
+const PRERELEASE_RELEASES_URL = releasesApiUrl(DESKTOP_PRERELEASE_REPOSITORY, 1)
 const FEED_STATUS_HEADER = 'x-sim-desktop-update-feed'
 
 function release(tag: string) {
@@ -156,6 +158,61 @@ describe('desktop update manifest route', () => {
     expect(fetchMock).toHaveBeenCalledTimes(1)
   })
 
+  it('walks past a page of unrelated releases to reach the newest desktop build', async () => {
+    const filler = Array.from({ length: DESKTOP_RELEASES_PAGE_SIZE }, (_, index) => ({
+      tag_name: `python-sdk-v0.${index}.0`,
+      draft: false,
+      prerelease: false,
+      assets: [],
+    }))
+    fetchMock.mockImplementation(async (input: string | URL | Request) => {
+      const url = String(input)
+      if (url === releasesApiUrl(DESKTOP_STABLE_RELEASE_REPOSITORY, 1)) {
+        return Response.json(filler)
+      }
+      if (url === releasesApiUrl(DESKTOP_STABLE_RELEASE_REPOSITORY, 2)) {
+        return Response.json([release('v1.1.0')])
+      }
+      if (url === `https://downloads.example/v1.1.0/${MANIFEST_ASSET_NAME}`) {
+        return new Response(manifest('1.1.0'))
+      }
+      return new Response(null, { status: 404 })
+    })
+
+    const response = await getFeed('www.sim.ai')
+
+    expect(response.status).toBe(200)
+    expect(await response.text()).toContain('version: 1.1.0')
+  })
+
+  it('stops walking at a short page rather than requesting empty ones', async () => {
+    fetchMock.mockResolvedValueOnce(
+      Response.json([release('v1.2.0-dev.4'), release('v1.2.0-staging.5')])
+    )
+
+    const response = await getFeed('www.sim.ai')
+
+    expect(response.status).toBe(404)
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('fails the feed instead of serving an older release when a page cannot be read', async () => {
+    const filler = Array.from({ length: DESKTOP_RELEASES_PAGE_SIZE }, (_, index) => ({
+      tag_name: `python-sdk-v0.${index}.0`,
+      draft: false,
+      prerelease: false,
+      assets: [],
+    }))
+    fetchMock
+      .mockResolvedValueOnce(Response.json(filler))
+      .mockResolvedValueOnce(new Response(null, { status: 500 }))
+
+    const response = await getFeed('www.sim.ai')
+
+    expect(response.status).toBe(502)
+    expect(await response.json()).toMatchObject({ error: 'Release feed unavailable' })
+  })
+
   it('rejects a manifest whose version does not match its selected release', async () => {
     setEnv({ APPCONFIG_ENVIRONMENT: 'dev' })
     fetchMock

apps/sim/app/api/desktop/update/latest-mac.yml/route.ts

@@ -7,8 +7,9 @@ import {
   type DesktopReleaseCandidate,
   MANIFEST_ASSET_NAME,
   releaseRepositoryForChannel,
+  releasesApiUrl,
+  resolveLatestRelease,
   rewriteManifestUrls,
-  selectReleaseForChannel,
 } from '@/lib/desktop/update-feed'
 
 const logger = createLogger('DesktopUpdateFeedAPI')
@@ -37,29 +38,34 @@ export const GET = withRouteHandler(async (_request: NextRequest): Promise<Respo
    */
   const channel = channelForDeploymentEnvironment(env.APPCONFIG_ENVIRONMENT)
   const releaseRepository = releaseRepositoryForChannel(channel)
-  const releasesApiUrl = `https://api.github.com/repos/${releaseRepository}/releases?per_page=30`
 
   // A token raises the GitHub API quota from 60/h per NAT IP to 5000/h.
   // Optional: the repo is public, so the feed works without one.
   const githubToken = process.env.GITHUB_TOKEN
-  const releasesResponse = await fetch(releasesApiUrl, {
-    headers: {
-      accept: 'application/vnd.github+json',
-      ...(githubToken ? { authorization: `Bearer ${githubToken}` } : {}),
-    },
-    next: { revalidate: REVALIDATE_SECONDS },
-  })
-  if (!releasesResponse.ok) {
-    logger.error('GitHub releases lookup failed', {
-      status: releasesResponse.status,
-      channel,
-      releaseRepository,
+  const resolved = await resolveLatestRelease(channel, async (page) => {
+    const response = await fetch(releasesApiUrl(releaseRepository, page), {
+      headers: {
+        accept: 'application/vnd.github+json',
+        ...(githubToken ? { authorization: `Bearer ${githubToken}` } : {}),
+      },
+      next: { revalidate: REVALIDATE_SECONDS },
     })
+    if (!response.ok) {
+      logger.error('GitHub releases lookup failed', {
+        status: response.status,
+        page,
+        channel,
+        releaseRepository,
+      })
+      return null
+    }
+    return (await response.json()) as DesktopReleaseCandidate[]
+  })
+  if ('error' in resolved) {
     return NextResponse.json({ error: 'Release feed unavailable' }, { status: 502 })
   }
-  const releases = (await releasesResponse.json()) as DesktopReleaseCandidate[]
 
-  const release = selectReleaseForChannel(releases, channel)
+  const release = resolved.release
   if (!release) {
     return NextResponse.json(
       { error: `No desktop release for channel ${channel}` },