@kabmo-labs/kabmo 0.2.0 → 0.3.0

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

@@ -52,16 +52,18 @@ describe('fetchAndroidRelease', () => {
   beforeEach(() => resetAndroidReleaseCache());
 
   test('picks the APK asset and its version', async () => {
-    const { impl } = stubFetch({
-      html_url: 'https://github.com/kabmo-labs/kabmo/releases/tag/v9.9.9',
-      assets: [
-        { name: 'source.tar.gz', browser_download_url: 'https://x/src.tgz' },
-        {
-          name: 'kabmo-android-v1.2.3.apk',
-          browser_download_url: 'https://x/kabmo-android-v1.2.3.apk',
-        },
-      ],
-    });
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://github.com/kabmo-labs/kabmo/releases/tag/v9.9.9',
+        assets: [
+          { name: 'source.tar.gz', browser_download_url: 'https://x/src.tgz' },
+          {
+            name: 'kabmo-android-v1.2.3.apk',
+            browser_download_url: 'https://x/kabmo-android-v1.2.3.apk',
+          },
+        ],
+      },
+    ]);
 
     const release = await fetchAndroidRelease(impl);
     expect(release).toEqual({
@@ -71,10 +73,54 @@ describe('fetchAndroidRelease', () => {
     });
   });
 
-  test('answers null for a release with no APK', async () => {
-    const { impl } = stubFetch({ html_url: 'https://x', assets: [{ name: 'notes.md' }] });
-    const release = await fetchAndroidRelease(impl);
-    expect(release).toEqual({ url: null, latest: null, releaseUrl: 'https://x' });
+  test('skips a newer release that carries no APK', async () => {
+    // This is the shape that broke the button: `release.yml` releases the npm
+    // packages FIRST, so `kabmo-sdk/v0.0.2` is newer than the app release that
+    // holds the APK. Asking `/releases/latest` answered the package release and
+    // the button vanished while the APK sat one entry below.
+    const { impl } = stubFetch([
+      { html_url: 'https://x/kabmo-sdk', assets: [{ name: 'source.tar.gz' }] },
+      { html_url: 'https://x/kabmo-ui', assets: [] },
+      {
+        html_url: 'https://x/app',
+        assets: [{ name: 'kabmo-android-v0.3.0.apk', browser_download_url: 'https://x/a.apk' }],
+      },
+    ]);
+
+    expect(await fetchAndroidRelease(impl)).toEqual({
+      url: 'https://x/a.apk',
+      latest: '0.3.0',
+      releaseUrl: 'https://x/app',
+    });
+  });
+
+  test('skips drafts and prereleases', async () => {
+    const { impl } = stubFetch([
+      {
+        draft: true,
+        html_url: 'https://x/draft',
+        assets: [{ name: 'kabmo-android-v9.9.9.apk', browser_download_url: 'https://x/draft.apk' }],
+      },
+      {
+        prerelease: true,
+        html_url: 'https://x/pre',
+        assets: [{ name: 'kabmo-android-v8.0.0.apk', browser_download_url: 'https://x/pre.apk' }],
+      },
+      {
+        html_url: 'https://x/app',
+        assets: [{ name: 'kabmo-android-v0.3.0.apk', browser_download_url: 'https://x/a.apk' }],
+      },
+    ]);
+
+    expect((await fetchAndroidRelease(impl))?.latest).toBe('0.3.0');
+  });
+
+  test('answers null for a list with no APK anywhere', async () => {
+    const { impl } = stubFetch([
+      { html_url: 'https://x', assets: [{ name: 'notes.md' }] },
+      { html_url: 'https://y', assets: [] },
+    ]);
+    expect(await fetchAndroidRelease(impl)).toEqual({ url: null, latest: null, releaseUrl: null });
   });
 
   test('answers null when the probe fails', async () => {

package/src/server/lib/updates/android-release.ts

@@ -3,8 +3,9 @@
  *
  * The APK is NOT an npm package (see `.github/workflows/publish-android.yml`), so
  * the npm probe that answers for the app and for `omp` cannot answer here. The
- * only record of a published APK is the GitHub release asset, which means one
- * unauthenticated REST read of the newest release.
+ * only record of a published APK is a GitHub release asset, which means one
+ * unauthenticated REST read of the release LIST — not `/releases/latest`, which
+ * answers the newest release of ANY kind (see `fetchAndroidRelease`).
  *
  * Two facts travel back, and they answer different questions:
  *
@@ -52,7 +53,17 @@ export function versionFromAssetName(name: string): string | null {
 }
 
 /**
- * The newest release's APK.
+ * The newest release that actually carries an APK.
+ *
+ * NOT `/releases/latest`, which answers the newest release of ANY kind. This
+ * repository publishes three artifacts from one push, and the packages are
+ * released FIRST (`packages → marketplace → android → app` in `release.yml`),
+ * so their `kabmo-sdk/v*` / `kabmo-ui/v*` releases are newer than the app
+ * release that carries the APK. `@semantic-release/github` runs in both
+ * pipelines, so those are real releases — measured against a stub that answered
+ * a package release: `/releases/latest` produced `{url: null, latest: null}` and
+ * the sidebar's button disappeared even though the APK sat on the release
+ * directly below.
  *
  * One request, cached for five minutes on `globalThis` for the same reason the
  * database handle is anchored there: `bun --hot` re-evaluates this module while
@@ -65,7 +76,7 @@ export async function fetchAndroidRelease(fetchImpl: typeof fetch = fetch): Prom
   if (cache.entry && now - cache.at < CACHE_MS) return cache.entry;
 
   try {
-    const response = await fetchImpl(`${githubApiBase()}/repos/${REPO}/releases/latest`, {
+    const response = await fetchImpl(`${githubApiBase()}/repos/${REPO}/releases?per_page=${RELEASE_SCAN}`, {
       headers: {
         accept: 'application/vnd.github+json',
         // GitHub rejects a request with no User-Agent.
@@ -74,32 +85,40 @@ export async function fetchAndroidRelease(fetchImpl: typeof fetch = fetch): Prom
     });
     if (!response.ok) return cache.entry ?? null;
 
-    const body = (await response.json()) as {
-      html_url?: unknown;
-      assets?: unknown;
-    };
-    // A body that is not the release document is a failed probe, not an empty
-    // release: answering `{url: null, latest: null}` here would be
-    // indistinguishable from "a release with no APK", and the caller would cache
-    // that mistake for five minutes.
-    if (!Array.isArray(body.assets)) return cache.entry ?? null;
-
-    const assets = body.assets;
-    const asset = assets
-      .map((entry) => (entry && typeof entry === 'object' ? (entry as Record<string, unknown>) : null))
-      .find((entry) => entry && typeof entry.name === 'string' && versionFromAssetName(entry.name) !== null);
-
-    const name = typeof asset?.name === 'string' ? asset.name : '';
-    const url = typeof asset?.browser_download_url === 'string' ? asset.browser_download_url : null;
-    const release: AndroidRelease = {
-      url,
-      latest: versionFromAssetName(name),
-      releaseUrl: typeof body.html_url === 'string' ? body.html_url : null,
+    const body = (await response.json()) as unknown;
+    // A body that is not the release list is a failed probe, not an empty
+    // repository: answering `{url: null, latest: null}` here would be
+    // indistinguishable from "no release carries an APK", and the caller would
+    // cache that mistake for five minutes.
+    if (!Array.isArray(body)) return cache.entry ?? null;
+
+    // Drafts are not published and prereleases are not what a console offers an
+    // installed app — the same two the `latest` endpoint excluded.
+    const published = body.filter(
+      (entry): entry is Record<string, unknown> =>
+        entry !== null && typeof entry === 'object' && entry.draft !== true && entry.prerelease !== true,
+    );
+
+    const release = published
+      .map((entry) => ({ entry, asset: apkAsset(entry.assets) }))
+      .find((candidate) => candidate.asset !== null);
+
+    if (!release?.asset) {
+      const fallback: AndroidRelease = { url: null, latest: null, releaseUrl: null };
+      cache.entry = fallback;
+      cache.at = now;
+      return fallback;
+    }
+
+    const resolved: AndroidRelease = {
+      url: typeof release.asset.browser_download_url === 'string' ? release.asset.browser_download_url : null,
+      latest: versionFromAssetName(String(release.asset.name)),
+      releaseUrl: typeof release.entry.html_url === 'string' ? release.entry.html_url : null,
     };
 
-    cache.entry = release;
+    cache.entry = resolved;
     cache.at = now;
-    return release;
+    return resolved;
   } catch {
     // Keep the last good answer rather than replacing it with a failure: a
     // momentary outage must not remove a download button that was valid.
@@ -107,6 +126,22 @@ export async function fetchAndroidRelease(fetchImpl: typeof fetch = fetch): Prom
   }
 }
 
+/** How many releases to look back through for the APK. */
+const RELEASE_SCAN = 20;
+
+/** The first asset of a release that names an APK, or null. */
+function apkAsset(assets: unknown): Record<string, unknown> | null {
+  if (!Array.isArray(assets)) return null;
+
+  for (const entry of assets) {
+    if (entry === null || typeof entry !== 'object') continue;
+    const asset = entry as Record<string, unknown>;
+    if (typeof asset.name === 'string' && versionFromAssetName(asset.name) !== null) return asset;
+  }
+
+  return null;
+}
+
 const CACHE_MS = 5 * 60_000;
 
 /**

package/src/server/plugins/ssr.ts

@@ -15,7 +15,7 @@ import { readSettingsBlob } from '@/shared/lib/settings/keys';
 import { resolveTheme } from '@/shared/lib/theme/catalog';
 import { windowChromeColor } from '@/shared/lib/theme/chrome';
 import { THEME_STYLE_ELEMENT_ID, themeStyleSheet } from '@/shared/lib/theme/css';
-import { androidShellVersion } from '@/shared/lib/updates/shell-ua';
+import { androidShellVersion, isAndroidDevice } from '@/shared/lib/updates/shell-ua';
 
 /** HTML-escape a string for interpolation into the failure page's `<pre>`. */
 function escapeHtmlText(value: string): string {
@@ -160,7 +160,12 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
   // HERE because the shell is rendered per request and the client's download
   // button needs the answer before its first paint: a fetch after hydration
   // would draw the button late, or draw it and then remove it.
+  //
+  // `isAndroid` is the wider fact and it exists for the INSTALL offer: a reader
+  // on Chrome or Brave for Android carries no shell token, and "not the app"
+  // alone cannot tell them from a desktop where an APK is useless.
   const shellVersion = androidShellVersion(userAgent);
+  const isAndroid = isAndroidDevice(userAgent);
 
   const rendered = await renderShell();
   if (!rendered.ok) return shellUnavailableResponse(rendered.reason);
@@ -172,7 +177,7 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
   // questions: "this browser has a session" versus "there is a session to have".
   // A Kabmo running open answers `authenticated: true` for every visitor, so
   // the navbar cannot use it to decide whether a sign-out control applies.
-  const bootstrap = JSON.stringify({ initialIsMobile, shellVersion, authenticated, authEnabled: isAuthEnabled(), production: !DEV_ASSETS_ENABLED, appSettings: settings }).replace(/</g, '\\u003c');
+  const bootstrap = JSON.stringify({ initialIsMobile, shellVersion, isAndroid, authenticated, authEnabled: isAuthEnabled(), production: !DEV_ASSETS_ENABLED, appSettings: settings }).replace(/</g, '\\u003c');
   // The template's own `<meta name="theme-color">` is REWRITTEN, not joined by
   // a second tag: with both present Chrome reads the first one, so an appended
   // tag would leave a dark theme painting light browser chrome.

package/src/shared/lib/updates/shell-ua.test.ts

@@ -5,7 +5,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { androidShellVersion, SHELL_UA_PREFIX } from '@/shared/lib/updates/shell-ua';
+import { androidShellVersion, isAndroidDevice, SHELL_UA_PREFIX } from '@/shared/lib/updates/shell-ua';
 
 /**
  * The token is the only signal that a page is running inside the Android app,
@@ -52,3 +52,70 @@ describe('androidShellVersion', () => {
     expect(androidShellVersion('Mozilla KabmoAndroid')).toBeNull();
   });
 });
+
+/**
+ * The wider fact, and the one the INSTALL offer rests on: a reader on Chrome or
+ * Brave for Android carries no shell token, so "not the app" alone cannot tell
+ * them from a desktop where an APK is useless.
+ *
+ * The two failure modes are a device wrongly included (a button offering an
+ * install to a machine that cannot install it) and a real Android device wrongly
+ * excluded (the offer never appears where it was the point).
+ */
+describe('isAndroidDevice', () => {
+  test('recognises the real Android browsers', () => {
+    // The three the report names, plus Firefox — the platform token is the same.
+    expect(
+      isAndroidDevice(
+        'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Mobile Safari/537.36',
+      ),
+    ).toBe(true);
+    expect(
+      isAndroidDevice(
+        'Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Mobile Safari/537.36 Brave/124',
+      ),
+    ).toBe(true);
+    expect(isAndroidDevice('Mozilla/5.0 (Android 14; Mobile; rv:126.0) Gecko/126.0 Firefox/126.0')).toBe(true);
+  });
+
+  test('recognises the shell itself, which also sends the platform token', () => {
+    expect(
+      isAndroidDevice(
+        `Mozilla/5.0 (Linux; Android 15; Pixel 6 Build/AP4A; wv) AppleWebKit/537.36 (KHTML, like Gecko) `
+        + `Version/4.0 Chrome/124.0.6367.219 Mobile Safari/537.36 ${SHELL_UA_PREFIX}0.3.0`,
+      ),
+    ).toBe(true);
+  });
+
+  test('recognises an Android tablet, which sends no Mobile token', () => {
+    // The reason this matches `Android` and not `Mobile`: a tablet is a device
+    // the APK installs on, and it is the case a `Mobile` test would drop.
+    expect(
+      isAndroidDevice(
+        'Mozilla/5.0 (Linux; Android 13; SM-X700) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+      ),
+    ).toBe(true);
+  });
+
+  test('excludes every platform the APK cannot install on', () => {
+    expect(isAndroidDevice('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/124.0 Safari/537.36')).toBe(false);
+    expect(isAndroidDevice('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0 Safari/537.36')).toBe(false);
+    expect(isAndroidDevice('Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124.0 Safari/537.36')).toBe(false);
+    // An iPad sends `Mobile` and has no APK to install — the token this
+    // deliberately does NOT match.
+    expect(isAndroidDevice('Mozilla/5.0 (iPad; CPU OS 17_4 like Mac OS X) AppleWebKit/605.1.15 Version/17.4 Mobile/15E148 Safari/604.1')).toBe(false);
+    expect(isAndroidDevice('Mozilla/5.0 (iPhone; CPU iPhone OS 17_4 like Mac OS X) AppleWebKit/605.1.15 Mobile/15E148 Safari/604.1')).toBe(false);
+  });
+
+  test('is false for an empty or missing UA', () => {
+    expect(isAndroidDevice('')).toBe(false);
+    expect(isAndroidDevice(null)).toBe(false);
+    expect(isAndroidDevice(undefined)).toBe(false);
+  });
+
+  test('does not match a lookalike word', () => {
+    // `` is what stops a crafted or unrelated token from counting.
+    expect(isAndroidDevice('Mozilla/5.0 (compatible; NotAndroidBot/1.0)')).toBe(false);
+    expect(isAndroidDevice('Mozilla/5.0 AndroidX/1.0')).toBe(false);
+  });
+});

package/src/shared/lib/updates/shell-ua.ts

@@ -16,6 +16,26 @@
 /** The token's name, before the slash. */
 export const SHELL_UA_PREFIX = 'KabmoAndroid/';
 
+/**
+ * Whether this request came from an Android device at all — the app or a
+ * browser on it.
+ *
+ * The download button has two reasons to appear and they are different offers:
+ * an installed APK that is behind (an UPDATE), and a reader using Chrome or
+ * Brave on a phone who may not know a native shell exists (an INSTALL). The
+ * second one needs this fact, which the shell token cannot supply: a browser
+ * carries no `KabmoAndroid/` token, and "no token" alone means "not the app" on
+ * every platform, including a desktop where an APK is useless.
+ *
+ * Matched on `Android`, the platform token every Android browser sends, and NOT
+ * on `Mobile`: an iPad sends `Mobile` and cannot install an APK, while an
+ * Android tablet sends `Android` without it.
+ */
+export function isAndroidDevice(userAgent: string | null | undefined): boolean {
+  if (!userAgent) return false;
+  return /\bAndroid\b/.test(userAgent);
+}
+
 /**
  * The APK version that sent this request, or null when it is not the app.
  *