@kabmo-labs/kabmo 0.8.0 → 0.9.0

package/src/server/lib/updates/shell-pages.test.ts

@@ -89,6 +89,7 @@ describe('the fallback when the API is unavailable', () => {
       url: 'https://github.com/kabmo-labs/kabmo/releases/download/v0.7.0/Kabmo-0.6.0-android.apk',
       latest: '0.6.0',
       releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v0.7.0',
+      direct: true,
     });
     expect(calls.some((url) => url.includes('/repos/'))).toBe(true);
     expect(calls.some((url) => url.endsWith('/releases.atom'))).toBe(true);
@@ -106,13 +107,38 @@ describe('the fallback when the API is unavailable', () => {
     expect((await fetchShellRelease('android', impl))?.latest).toBe('0.6.0');
   });
 
-  test('answers the release page for a desktop shell', async () => {
+  test('answers the release page for a desktop shell with no arch', async () => {
     const { impl } = routedFetch({ atom: ATOM, assets: { 'v0.7.0': ASSETS_V070 } });
 
     expect(await fetchShellRelease('macos', impl)).toEqual({
       url: 'https://github.com/kabmo-labs/kabmo/releases/tag/v0.7.0',
       latest: '0.2.0',
       releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v0.7.0',
+      direct: false,
+    });
+  });
+
+  test('answers that arch’s own artifact when the fragment lists it', async () => {
+    // The pages fallback carries the same arch rule as the API read: a desktop
+    // shell that named its machine gets that machine's installer, and a build it
+    // does not publish is never substituted.
+    const { impl } = routedFetch({ atom: ATOM, assets: { 'v0.7.0': ASSETS_V070 } });
+
+    expect(await fetchShellRelease('macos', impl, 'arm64')).toEqual({
+      url: 'https://github.com/kabmo-labs/kabmo/releases/download/v0.7.0/Kabmo-0.2.0-mac-arm64.zip',
+      latest: '0.2.0',
+      releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v0.7.0',
+      direct: true,
+    });
+
+    // x64 is not in the fragment, so the page is the answer rather than the
+    // arm64 file.
+    const again = routedFetch({ atom: ATOM, assets: { 'v0.7.0': ASSETS_V070 } });
+    expect(await fetchShellRelease('macos', again.impl, 'x64')).toEqual({
+      url: 'https://github.com/kabmo-labs/kabmo/releases/tag/v0.7.0',
+      latest: '0.2.0',
+      releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v0.7.0',
+      direct: false,
     });
   });
 
@@ -121,7 +147,12 @@ describe('the fallback when the API is unavailable', () => {
     // distinguishable: the first is cacheable and the second keeps the last good
     // answer.
     const { impl } = routedFetch({ atom: ATOM, assets: { 'v0.7.0': '<div></div>' } });
-    expect(await fetchShellRelease('android', impl)).toEqual({ url: null, latest: null, releaseUrl: null });
+    expect(await fetchShellRelease('android', impl)).toEqual({
+      url: null,
+      latest: null,
+      releaseUrl: null,
+      direct: false,
+    });
   });
 
   test('an unreachable feed answers null rather than an empty result', async () => {

package/src/server/lib/updates/shell-pages.ts

@@ -21,7 +21,8 @@
  */
 
 import { REPO } from '@/server/lib/updates/release-url';
-import { SHELL_ASSETS, versionFromAssetName } from '@/server/lib/updates/shell-assets';
+import { SHELL_ASSETS, selfUpdateArtifact, versionFromAssetName } from '@/server/lib/updates/shell-assets';
+import type { ShellArch } from '@/shared/lib/updates/shell-arch';
 import type { ShellKind } from '@/shared/lib/updates/shell-ua';
 
 /** How many tags to walk before giving up. */
@@ -64,6 +65,7 @@ export async function findAssetInPages(
   kind: ShellKind,
   fetchImpl: typeof fetch,
   headers: Record<string, string>,
+  arch: ShellArch | null = null,
 ): Promise<PagesResult> {
   const feed = await fetchImpl(`https://github.com/${REPO}/releases.atom`, {
     headers: { accept: 'application/atom+xml, text/xml', ...headers },
@@ -80,7 +82,7 @@ export async function findAssetInPages(
     );
     if (!page.ok) continue;
 
-    const asset = shellAssetFromPage(kind, await page.text());
+    const asset = shellAssetFromPage(kind, await page.text(), arch);
     if (!asset) continue;
 
     return { kind: 'found', asset, releaseUrl: tag.url };
@@ -121,19 +123,29 @@ export function releaseTags(xml: string): ReleaseTag[] {
  * `shell-release`'s API path documents: a release carrying both spellings must
  * not resolve to the older version.
  */
-export function shellAssetFromPage(kind: ShellKind, html: string): PageAsset | null {
+export function shellAssetFromPage(kind: ShellKind, html: string, arch: ShellArch | null = null): PageAsset | null {
   const found: PageAsset[] = [];
-  const pattern = /href="(\/[^"]+\/releases\/download\/[^"]+)"/g;
 
-  for (const match of html.matchAll(pattern)) {
+  for (const match of html.matchAll(ASSET_HREF)) {
     const path = decodeEntities(match[1] ?? '');
     const name = decodeURIComponent(path.slice(path.lastIndexOf('/') + 1));
     if (versionFromAssetName(kind, name) !== null) found.push({ name, downloadUrl: `https://github.com${path}` });
   }
 
+  // The architecture decides FIRST, for the reason the API path documents: a
+  // desktop shell that named its own machine must not be handed the other
+  // architecture's installer just because the fragment lists it first.
+  if (arch) {
+    const exact = found.find((asset) => selfUpdateArtifact(kind, arch, asset.name) !== null);
+    if (exact) return exact;
+  }
+
   return found.find((asset) => SHELL_ASSETS[kind].current.test(asset.name)) ?? found[0] ?? null;
 }
 
+/** One asset link in a release fragment. Stated once: the loop and the regex must agree. */
+const ASSET_HREF = /href="(\/[^"]+\/releases\/download\/[^"]+)"/g;
+
 /** The entities that appear in a feed title or a link. */
 function decodeEntities(text: string): string {
   return text

package/src/server/lib/updates/shell-release-desktop.test.ts

@@ -0,0 +1,166 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The DESKTOP half of the shell-release read: which artifact a per-architecture
+ * shell installs, and when the answer is only the release page.
+ *
+ * Split from `shell-release.test.ts` because that file is at the repo's 350-line
+ * ceiling, and the two questions are separable: the mobile pair resolves ONE
+ * artifact for every device, while the desktop trio's answer depends on the
+ * architecture the shell reported.
+ */
+
+import { beforeEach, describe, expect, test } from 'bun:test';
+
+import { fetchShellRelease, resetShellReleaseCache } from '@/server/lib/updates/shell-release';
+
+/** A fetch double that answers one body. */
+function stubFetch(body: unknown) {
+  const calls: string[] = [];
+  const impl = (async (input: string | URL | Request) => {
+    calls.push(String(input));
+    return {
+      ok: true,
+      json: async () => body,
+      text: async () => (typeof body === 'string' ? body : JSON.stringify(body)),
+    } as Response;
+  }) as unknown as typeof fetch;
+  return { impl, calls };
+}
+
+describe('fetchShellRelease — desktop architectures', () => {
+  // The cache is process-wide (see `resetShellReleaseCache`), so every case
+  // starts from a cold one or it reads the previous case's answer.
+  beforeEach(() => resetShellReleaseCache());
+
+  /**
+   * A desktop probe WITHOUT an architecture answers the RELEASE PAGE.
+   *
+   * Every desktop artifact is per-architecture, and a console served to another
+   * machine cannot know which one the window asking runs on. Naming one arch's
+   * file would hand half the readers a build that will not launch, so the link is
+   * the page that lists all of them and `direct` says it is not installable.
+   */
+  test('a desktop probe without an arch answers the release page', async () => {
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-mac-arm64.zip', browser_download_url: 'https://x/mac-arm.zip' },
+          { name: 'Kabmo-0.2.0-mac-x64.dmg', browser_download_url: 'https://x/mac-x64.dmg' },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('macos', impl)).toEqual({
+      url: 'https://x/app',
+      latest: '0.2.0',
+      releaseUrl: 'https://x/app',
+      direct: false,
+    });
+  });
+
+  /**
+   * WITH an architecture it answers that machine's own installer.
+   *
+   * This is what makes the desktop self-update possible at all: the shell
+   * reports its arch over the bridge, and the console names ONE file instead of
+   * a page a human has to read.
+   */
+  test('a desktop probe with an arch answers that arch’s installer', async () => {
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-mac-x64.zip', browser_download_url: 'https://x/mac-x64.zip' },
+          { name: 'Kabmo-0.2.0-mac-arm64.zip', browser_download_url: 'https://x/mac-arm.zip' },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('macos', impl, 'arm64')).toEqual({
+      url: 'https://x/mac-arm.zip',
+      latest: '0.2.0',
+      releaseUrl: 'https://x/app',
+      direct: true,
+    });
+  });
+
+  test('an arch the release does not publish keeps the page, never the sibling', async () => {
+    // A build that only shipped x64 must not be installed on an arm64 machine:
+    // the page is a correct answer, the other architecture's file is not.
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-mac-x64.zip', browser_download_url: 'https://x/mac-x64.zip' },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('macos', impl, 'arm64')).toEqual({
+      url: 'https://x/app',
+      latest: '0.2.0',
+      releaseUrl: 'https://x/app',
+      direct: false,
+    });
+  });
+
+  test('the self-update file is the ONE file that shell can install', async () => {
+    // macOS installs from the `.zip` (ditto extracts it); the `.dmg` beside it is
+    // for a human. Windows installs from the Inno `.exe`; Linux from the
+    // AppImage, which is the only one of its four formats a shell can replace.
+    const mac = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-mac-arm64.dmg', browser_download_url: 'https://x/mac-arm.dmg' },
+          { name: 'Kabmo-0.2.0-mac-arm64.zip', browser_download_url: 'https://x/mac-arm.zip' },
+        ],
+      },
+    ]);
+    expect((await fetchShellRelease('macos', mac.impl, 'arm64'))?.url).toBe('https://x/mac-arm.zip');
+
+    const win = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-win-x64-setup.exe', browser_download_url: 'https://x/win-x64.exe' },
+        ],
+      },
+    ]);
+    expect((await fetchShellRelease('windows', win.impl, 'x64'))?.url).toBe('https://x/win-x64.exe');
+
+    const linux = stubFetch([
+      {
+        html_url: 'https://x/app',
+        assets: [
+          { name: 'Kabmo-0.2.0-linux-x86_64.tar.gz', browser_download_url: 'https://x/linux.tgz' },
+          { name: 'Kabmo-0.2.0-linux-x86_64.AppImage', browser_download_url: 'https://x/linux.AppImage' },
+        ],
+      },
+    ]);
+    expect((await fetchShellRelease('linux', linux.impl, 'x64'))?.url).toBe('https://x/linux.AppImage');
+  });
+
+  test('the arch is part of the cache key', async () => {
+    // One console is routinely shared by a whole team, and two machines on it
+    // differ only by architecture. A shared slot would answer the second one with
+    // the first one's installer.
+    const release = {
+      html_url: 'https://x/app',
+      assets: [
+        { name: 'Kabmo-0.3.0-mac-arm64.zip', browser_download_url: 'https://x/arm.zip' },
+        { name: 'Kabmo-0.3.0-mac-x64.zip', browser_download_url: 'https://x/x64.zip' },
+      ],
+    };
+    expect((await fetchShellRelease('macos', stubFetch([release]).impl, 'arm64'))?.url).toBe('https://x/arm.zip');
+
+    const { impl, calls } = stubFetch([release]);
+    expect((await fetchShellRelease('macos', impl, 'x64'))?.url).toBe('https://x/x64.zip');
+    expect(calls.length, 'a different arch is a different question').toBeGreaterThan(0);
+  });
+});

package/src/server/lib/updates/shell-release.test.ts

@@ -84,6 +84,7 @@ describe('fetchShellRelease', () => {
       url: 'https://x/Kabmo-1.2.3-android.apk',
       latest: '1.2.3',
       releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v9.9.9',
+      direct: true,
     });
   });
 
@@ -102,6 +103,7 @@ describe('fetchShellRelease', () => {
       url: 'https://x/i.ipa',
       latest: '0.4.0',
       releaseUrl: 'https://x/app',
+      direct: true,
     });
   });
 
@@ -130,6 +132,7 @@ describe('fetchShellRelease', () => {
       url: 'https://x/new.apk',
       latest: '0.6.0',
       releaseUrl: 'https://x/r',
+      direct: true,
     });
   });
 
@@ -183,6 +186,7 @@ describe('fetchShellRelease', () => {
       url: 'https://x/a.apk',
       latest: '0.3.0',
       releaseUrl: 'https://x/app',
+      direct: true,
     });
   });
 
@@ -212,7 +216,12 @@ describe('fetchShellRelease', () => {
       { html_url: 'https://x', assets: [{ name: 'notes.md' }] },
       { html_url: 'https://y', assets: [] },
     ]);
-    expect(await fetchShellRelease('android', impl)).toEqual({ url: null, latest: null, releaseUrl: null });
+    expect(await fetchShellRelease('android', impl)).toEqual({
+      url: null,
+      latest: null,
+      releaseUrl: null,
+      direct: false,
+    });
   });
 
   test('answers null when the probe fails', async () => {
@@ -231,30 +240,4 @@ describe('fetchShellRelease', () => {
     const { impl } = routedFetch({ api: { assets: 'nope' } });
     expect(await fetchShellRelease('android', impl)).toBeNull();
   });
-
-  /**
-   * The desktop trio reads the same release list and answers the RELEASE PAGE.
-   *
-   * Every desktop artifact is per-architecture, and this server cannot know which
-   * architecture the window asking is running on — it may be a remote console on
-   * another machine. Naming one arch's file would hand half the readers a build
-   * that will not launch, so the link is the page that lists all of them.
-   */
-  test('a desktop probe answers the release page, never one architecture', async () => {
-    const { impl } = stubFetch([
-      {
-        html_url: 'https://x/app',
-        assets: [
-          { name: 'Kabmo-0.2.0-mac-arm64.zip', browser_download_url: 'https://x/mac-arm.zip' },
-          { name: 'Kabmo-0.2.0-mac-x64.dmg', browser_download_url: 'https://x/mac-x64.dmg' },
-        ],
-      },
-    ]);
-
-    expect(await fetchShellRelease('macos', impl)).toEqual({
-      url: 'https://x/app',
-      latest: '0.2.0',
-      releaseUrl: 'https://x/app',
-    });
-  });
 });