@kabmo-labs/kabmo 0.6.1 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kabmo-labs/kabmo",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Web console and diagnostic workbench for AI coding agents — Elysia + Preact on Bun.",
   "license": "UNLICENSED",
   "author": "Wijanarko Putra Rajeb <wijanarko.rajeb@gmail.com>",

package/src/client/hooks/ui/updates/shell-download.test.ts

@@ -16,7 +16,7 @@ import {
 
 /** The published release every case compares against. */
 const RELEASE = {
-  url: 'https://github.com/kabmo-labs/kabmo/releases/download/v1.2.3/kabmo-android-v1.2.3.apk',
+  url: 'https://github.com/kabmo-labs/kabmo/releases/download/v1.2.3/Kabmo-1.2.3-android.apk',
   latest: '1.2.3',
   releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v1.2.3',
 };

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

@@ -17,26 +17,57 @@ import { fetchShellRelease, resetShellReleaseCache, versionFromAssetName } from
  */
 describe('versionFromAssetName', () => {
   test('reads the version the release workflows write', () => {
-    expect(versionFromAssetName('android', 'kabmo-android-v1.2.3.apk')).toBe('1.2.3');
-    expect(versionFromAssetName('ios', 'kabmo-ios-v1.2.3.ipa')).toBe('1.2.3');
+    expect(versionFromAssetName('android', 'Kabmo-0.5.0-android.apk')).toBe('0.5.0');
+    expect(versionFromAssetName('ios', 'Kabmo-0.1.0-ios.ipa')).toBe('0.1.0');
   });
 
-  test('accepts a hand-uploaded name without the v', () => {
-    expect(versionFromAssetName('android', 'kabmo-android-1.2.3.apk')).toBe('1.2.3');
-    expect(versionFromAssetName('ios', 'kabmo-ios-1.2.3.ipa')).toBe('1.2.3');
+  /**
+   * The old spelling is still READ, and that is not sentiment.
+   *
+   * These names are the only record of a published shell, and every release
+   * already on GitHub carries `kabmo-android-v<v>.apk`. A parser that only knew
+   * the new scheme would answer "no update" for an installed shell the moment
+   * this shipped — silently, because a name that does not match reads exactly
+   * like a release with no artifact.
+   */
+  test('still reads the legacy spelling every published release carries', () => {
+    expect(versionFromAssetName('android', 'kabmo-android-v0.5.0.apk')).toBe('0.5.0');
+    expect(versionFromAssetName('ios', 'kabmo-ios-v0.1.0.ipa')).toBe('0.1.0');
   });
 
   test('ignores anything that is not that shell’s artifact', () => {
-    expect(versionFromAssetName('android', 'kabmo-android-v1.2.3.apk.zip')).toBeNull();
+    expect(versionFromAssetName('android', 'Kabmo-1.2.3-android.apk.zip')).toBeNull();
     expect(versionFromAssetName('android', 'source.tar.gz')).toBeNull();
-    expect(versionFromAssetName('android', 'kabmo-android-latest.apk')).toBeNull();
+    expect(versionFromAssetName('android', 'Kabmo-latest-android.apk')).toBeNull();
+    expect(versionFromAssetName('android', 'Kabmo--android.apk')).toBeNull();
     expect(versionFromAssetName('android', '')).toBeNull();
   });
 
+  /**
+   * The desktop assets share the `Kabmo-` prefix, so the EXTENSION is what keeps
+   * them out. A probe that matched on the prefix alone would offer a Mac `.dmg`
+   * to an Android phone.
+   */
+  test('does not read a desktop asset as a mobile one', () => {
+    for (const name of [
+      'Kabmo-0.1.2-mac-arm64.zip',
+      'Kabmo-0.1.2-mac-arm64.dmg',
+      'Kabmo-0.1.0-win-x64-setup.exe',
+      'Kabmo-0.1.0-linux-x86_64.tar.gz',
+      'Kabmo-0.1.0-linux-amd64.deb',
+      'Kabmo-0.1.0-linux-x86_64.AppImage',
+    ]) {
+      expect(versionFromAssetName('android', name), name).toBeNull();
+      expect(versionFromAssetName('ios', name), name).toBeNull();
+    }
+  });
+
   test('does not accept one shell’s asset for the other', () => {
     // The two probes read the SAME release list, so a parser that ignored the
     // kind would let an iOS probe answer with the APK (and offer an `.apk` to an
     // iPhone).
+    expect(versionFromAssetName('ios', 'Kabmo-0.5.0-android.apk')).toBeNull();
+    expect(versionFromAssetName('android', 'Kabmo-0.1.0-ios.ipa')).toBeNull();
     expect(versionFromAssetName('ios', 'kabmo-android-v1.2.3.apk')).toBeNull();
     expect(versionFromAssetName('android', 'kabmo-ios-v1.2.3.ipa')).toBeNull();
   });
@@ -67,15 +98,15 @@ describe('fetchShellRelease', () => {
         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',
+            name: 'Kabmo-1.2.3-android.apk',
+            browser_download_url: 'https://x/Kabmo-1.2.3-android.apk',
           },
         ],
       },
     ]);
 
     expect(await fetchShellRelease('android', impl)).toEqual({
-      url: 'https://x/kabmo-android-v1.2.3.apk',
+      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',
     });
@@ -86,8 +117,8 @@ describe('fetchShellRelease', () => {
       {
         html_url: 'https://x/app',
         assets: [
-          { name: 'kabmo-android-v0.9.0.apk', browser_download_url: 'https://x/a.apk' },
-          { name: 'kabmo-ios-v0.4.0.ipa', browser_download_url: 'https://x/i.ipa' },
+          { name: 'Kabmo-0.9.0-android.apk', browser_download_url: 'https://x/a.apk' },
+          { name: 'Kabmo-0.4.0-ios.ipa', browser_download_url: 'https://x/i.ipa' },
         ],
       },
     ]);
@@ -99,14 +130,54 @@ describe('fetchShellRelease', () => {
     });
   });
 
+  /**
+   * A release that carries BOTH spellings must answer with the current one.
+   *
+   * That state is real: a rename lands, and the previous release's asset stays
+   * beside the new one until `--clobber` replaces it (or a hand-upload adds
+   * one). Measured before the fix: a release holding both
+   * `kabmo-android-v0.4.0.apk` and `Kabmo-0.6.0-android.apk` answered `0.4.0` —
+   * the console offered an update to the version the user already had, and hid
+   * the newer one.
+   */
+  test('prefers the current scheme when a release carries both', async () => {
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://x/r',
+        assets: [
+          { name: 'kabmo-android-v0.4.0.apk', browser_download_url: 'https://x/old.apk' },
+          { name: 'Kabmo-0.6.0-android.apk', browser_download_url: 'https://x/new.apk' },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('android', impl)).toEqual({
+      url: 'https://x/new.apk',
+      latest: '0.6.0',
+      releaseUrl: 'https://x/r',
+    });
+  });
+
+  /** A release carrying ONLY the old spelling must keep answering. */
+  test('still resolves a release that only has the legacy spelling', async () => {
+    const { impl } = stubFetch([
+      {
+        html_url: 'https://x/r2',
+        assets: [{ name: 'kabmo-android-v0.4.0.apk', browser_download_url: 'https://x/old.apk' }],
+      },
+    ]);
+
+    expect((await fetchShellRelease('android', impl))?.latest).toBe('0.4.0');
+  });
+
   test('the two shells cache separately', async () => {
     // One shared slot would make the second probe answer with the first one's
     // artifact — the release list is the same read, the asset is not.
     const release = {
       html_url: 'https://x/app',
       assets: [
-        { name: 'kabmo-android-v1.0.0.apk', browser_download_url: 'https://x/a.apk' },
-        { name: 'kabmo-ios-v2.0.0.ipa', browser_download_url: 'https://x/i.ipa' },
+        { name: 'Kabmo-1.0.0-android.apk', browser_download_url: 'https://x/a.apk' },
+        { name: 'Kabmo-2.0.0-ios.ipa', browser_download_url: 'https://x/i.ipa' },
       ],
     };
     expect((await fetchShellRelease('android', stubFetch([release]).impl))?.latest).toBe('1.0.0');
@@ -129,7 +200,7 @@ describe('fetchShellRelease', () => {
       { 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' }],
+        assets: [{ name: 'Kabmo-0.3.0-android.apk', browser_download_url: 'https://x/a.apk' }],
       },
     ]);
 
@@ -145,16 +216,16 @@ describe('fetchShellRelease', () => {
       {
         draft: true,
         html_url: 'https://x/draft',
-        assets: [{ name: 'kabmo-android-v9.9.9.apk', browser_download_url: 'https://x/draft.apk' }],
+        assets: [{ name: 'Kabmo-9.9.9-android.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' }],
+        assets: [{ name: 'Kabmo-8.0.0-android.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' }],
+        assets: [{ name: 'Kabmo-0.3.0-android.apk', browser_download_url: 'https://x/a.apk' }],
       },
     ]);
 

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

@@ -17,9 +17,10 @@
  *
  * - `url` is the asset to download. It is resolved from the release's OWN asset
  *   list rather than built as `releases/latest/download/<name>`, because that
- *   path needs the asset name to match exactly and the name carries the tag
- *   (`kabmo-android-v1.2.3.apk`) — a name built here would be a second copy of
- *   the workflow's naming rule, and the first release that renames it 404s.
+ *   path needs the asset name to match exactly and the name carries the shell's
+ *   version (`Kabmo-0.5.0-android.apk`) — a name built here would be a second
+ *   copy of the workflow's naming rule, and the first release that renames it
+ *   404s.
  * - `latest` is the version that asset ships, read from the asset name. The
  *   release TAG cannot be used: the artifact is attached to the app's release,
  *   whose tag names the SERVER version, and the two move independently.
@@ -42,25 +43,67 @@ export interface ShellRelease {
   releaseUrl: string | null;
 }
 
-/** How each shell's asset is named by its publish workflow. */
-export const SHELL_ASSETS: Record<ShellKind, { prefix: string; extension: string }> = {
-  android: { prefix: 'kabmo-android-', extension: '.apk' },
-  ios: { prefix: 'kabmo-ios-', extension: '.ipa' },
+/**
+ * How each shell's asset is named by its publish workflow, plus the prefix it
+ * carried BEFORE the rename.
+ *
+ * ONE scheme for every shell in the project — `<App>-<version>-<platform>.<ext>`:
+ * `Kabmo-0.5.0-android.apk`, `Kabmo-0.1.0-ios.ipa`, and the desktop trio's
+ * `Kabmo-0.1.2-mac-arm64.dmg` / `-win-x64-setup.exe` / `-linux-x86_64.tar.gz`.
+ * The mobile pair carries no architecture because neither artifact is per-arch:
+ * the APK is one universal build (the shell is pure Kotlin with no native
+ * libraries, so there is nothing to split), and the IPA contains only the device
+ * slice (`arm64-apple-ios`). A `-arm64` in those names would claim a distinction
+ * that does not exist and would make the parser look for a second artifact.
+ *
+ * **`legacyPrefix` is not dead code.** These names are PARSED to answer "is a
+ * newer shell published", and every release already on GitHub carries the old
+ * spelling. Dropping it would make the console answer "no update" for an
+ * installed shell the moment this ships — silently, because a name that does not
+ * match reads exactly like a release with no artifact. The probe tries the
+ * current prefix first, then the old one; new releases only ever write the
+ * current one.
+ */
+export const SHELL_ASSETS: Record<
+  ShellKind,
+  { prefix: string; extension: string; legacyPrefix: string; legacyExtension: string }
+> = {
+  android: {
+    prefix: 'Kabmo-',
+    extension: '-android.apk',
+    legacyPrefix: 'kabmo-android-v',
+    legacyExtension: '.apk',
+  },
+  ios: { prefix: 'Kabmo-', extension: '-ios.ipa', legacyPrefix: 'kabmo-ios-v', legacyExtension: '.ipa' },
 };
 
 /**
- * `kabmo-android-v1.2.3.apk` → `1.2.3` (and the `.ipa` twin).
+ * `Kabmo-0.5.0-android.apk` → `0.5.0` (and the `.ipa` twin), plus the legacy
+ * `kabmo-android-v0.5.0.apk` spelling every published release still carries.
  *
- * The `v` is optional because a hand-uploaded asset may omit it, and a version
- * that cannot be read is not evidence of an update — the caller treats null as
- * "no new version".
+ * The version is the MIDDLE of the name in the current scheme and the TAIL of the
+ * legacy one, so the two are parsed by different rules rather than by one that
+ * tries to cover both.
  */
 export function versionFromAssetName(kind: ShellKind, name: string): string | null {
-  const { prefix, extension } = SHELL_ASSETS[kind];
-  if (!name.startsWith(prefix) || !name.endsWith(extension)) return null;
-  const middle = name.slice(prefix.length, -extension.length);
-  const version = middle.startsWith('v') ? middle.slice(1) : middle;
-  return /^\d+\.\d+\.\d+/.test(version) ? version : null;
+  const { prefix, extension, legacyPrefix, legacyExtension } = SHELL_ASSETS[kind];
+
+  // Current: `<prefix><version><extension>`, where the prefix is the app's name
+  // and the extension names the platform.
+  if (name.startsWith(prefix) && name.endsWith(extension)) {
+    const middle = name.slice(prefix.length, -extension.length);
+    if (/^\d+\.\d+\.\d+$/.test(middle)) return middle;
+  }
+
+  // Legacy: `kabmo-android-v<version>.apk`. Kept for the releases already
+  // published; no new release writes it.
+  if (name.startsWith(legacyPrefix) && name.endsWith(legacyExtension)) {
+    const middle = name.slice(legacyPrefix.length, -legacyExtension.length);
+    const version = middle.startsWith('v') ? middle.slice(1) : middle;
+    return /^\d+\.\d+\.\d+$/.test(version) ? version : null;
+  }
+
+  return null;
 }
 
 /**
@@ -144,17 +187,41 @@ export async function fetchShellRelease(
 /** How many releases to look back through for the artifact. */
 const RELEASE_SCAN = 20;
 
-/** The first asset of a release that names this shell's artifact, or null. */
+/**
+ * The asset of a release that names this shell's artifact, or null.
+ *
+ * The CURRENT scheme wins over the legacy one, and that is not cosmetic. A
+ * release that carries both — which happens the moment a rename lands and
+ * `--clobber` has not yet replaced the old asset, or a hand-upload adds one
+ * beside the other — would otherwise resolve to whichever the asset list
+ * happened to order first. Measured: a release holding both
+ * `kabmo-android-v0.4.0.apk` and `Kabmo-0.6.0-android.apk` answered `0.4.0`,
+ * i.e. the console offered an update to a version it already had and hid the
+ * newer one.
+ *
+ * Both schemes are still ACCEPTED (a release with only the old spelling must
+ * keep working), so the preference is a second pass rather than a filter.
+ */
 function shellAsset(kind: ShellKind, 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(kind, asset.name) !== null) return asset;
-  }
+  const named = assets.filter(
+    (entry): entry is Record<string, unknown> =>
+      entry !== null &&
+      typeof entry === 'object' &&
+      typeof (entry as Record<string, unknown>).name === 'string' &&
+      versionFromAssetName(kind, String((entry as Record<string, unknown>).name)) !== null,
+  );
 
-  return null;
+  const { prefix, extension } = SHELL_ASSETS[kind];
+  return (
+    named.find((asset) => {
+      const name = String(asset.name);
+      return name.startsWith(prefix) && name.endsWith(extension);
+    }) ??
+    named[0] ??
+    null
+  );
 }
 
 const CACHE_MS = 5 * 60_000;