@kabmo-labs/kabmo 0.7.0 → 0.9.0

package/src/server/lib/panels/sync.server.ts

@@ -12,14 +12,22 @@
  * on the old copy. Nothing else would ever notice: the install is a directory of
  * ordinary files, and the scan has no notion of a store version.
  *
- * The sync runs at boot, after the listener is up, and it is VERSION-GATED — the
- * store copy is written over the install only when its manifest version is
- * strictly newer. That is what makes the pass safe to run unconditionally: a
- * user's plugin that happens to share an id with a store entry but was installed
- * from a git URL carries no `.git` ONLY if it was copied by hand, and a
- * hand-copied directory keeps working because its version is compared rather
- * than its provenance. A plugin installed from a git URL is skipped outright,
- * because the store's copy is not its source of truth.
+ * The sync runs at boot, after the listener is up. For an install KABMO WROTE —
+ * one carrying a baseline — the store's TREE is the gate, not its version: the
+ * copy is written whenever the two tracked trees differ, in either direction.
+ * A version gate cannot be the whole answer, and believing it was is what left
+ * every bundled plugin un-updatable after the product rename: that release
+ * rewrote the store's files and reset every bundled version to `0.0.1`, so the
+ * store was never "newer" than the install and the pass skipped forever —
+ * measured on a real install, where the only way to get the new code was to
+ * remove the plugin and install it again. Content is also the honest test for a
+ * shipped fix that forgot its bump.
+ *
+ * A directory with NO baseline is of unknown provenance (hand-copied, or
+ * installed by a build that predates the baseline), so it keeps the conservative
+ * version gate: a copy the user made themselves must not be replaced by a store
+ * entry that merely shares its id. A git clone is skipped outright, because the
+ * store's copy is not its source of truth.
  *
  * The install's `node_modules` and `dist` are left alone until the copy lands:
  * the sync copies the store's SOURCES, then rebuilds, exactly as an install
@@ -36,14 +44,21 @@ import { readPluginManifest, subdirectories } from '@/server/lib/panels/files.se
 import { toManifest } from '@/server/lib/panels/manifest';
 import { buildPanelPlugin } from '@/server/lib/panels/build.server';
 import { readGitOrigin } from '@/server/lib/panels/git-clone.server';
-import { changedPaths, hashTrackedFiles } from '@/server/lib/panels/local-edits.server';
-import { readBaseline, clearBaseline, writeBaseline, writeBlockedSync } from '@/server/lib/panels/baseline.server';
+import { baselineDescribesInstall, changedPaths, hashTrackedFiles, type TrackedFileHashes } from '@/server/lib/panels/local-edits.server';
+import { readBaseline, writeBaseline, writeBlockedSync } from '@/server/lib/panels/baseline.server';
 import { emitRealtimeSignal } from '@/server/lib/realtime/signals.server';
 
 export interface BundledSyncOutcome {
   pluginId: string;
   from: string;
   to: string;
+  /**
+   * True when the store's files changed but its manifest version did not.
+   *
+   * The common case after a shipped fix whose bump was missed, and the reason
+   * the gate is content: reporting it as `1.0.0 → 1.0.0` reads as a no-op.
+   */
+  contentOnly?: boolean;
   /** A rebuild that failed after the files were replaced. */
   warning?: string;
 }
@@ -81,9 +96,13 @@ async function manifestVersion(dir: string): Promise<string | null> {
  * that says otherwise. When the store has no `dist`, nothing is removed and the
  * rebuild regenerates it from the new sources.
  */
-async function replaceFromStore(source: string, destination: string): Promise<void> {
+async function replaceFromStore(
+  source: string,
+  destination: string,
+  knownInstallFiles?: TrackedFileHashes,
+): Promise<void> {
   const storeFiles = await hashTrackedFiles(source);
-  const installFiles = await hashTrackedFiles(destination);
+  const installFiles = knownInstallFiles ?? (await hashTrackedFiles(destination));
   for (const path of Object.keys(installFiles)) {
     if (path in storeFiles) continue;
     await rm(join(destination, path), { force: true });
@@ -100,7 +119,49 @@ async function replaceFromStore(source: string, destination: string): Promise<vo
 }
 
 /**
- * Bring every installed bundled plugin up to the store's version.
+ * Write the store's copy over an install and rebuild it.
+ *
+ * Shared by the boot pass and the override, because everything after the gate is
+ * identical and the parts that matter are the ones a second copy gets wrong: the
+ * replacement is a MIRROR, the manifest is re-read from what landed, and the
+ * baseline is re-taken AFTER the build so the next pass compares against the
+ * tree this one produced.
+ */
+async function applyStoreCopy(
+  pluginId: string,
+  storeDir: string,
+  destination: string,
+  from: string,
+  to: string,
+  installFiles: TrackedFileHashes,
+): Promise<{ outcome: BundledSyncOutcome } | { error: string }> {
+  await replaceFromStore(storeDir, destination, installFiles);
+
+  const read = await readPluginManifest(destination);
+  const manifest = read.kind === 'manifest' ? toManifest(read.value, destination) : null;
+  if (!manifest || 'error' in manifest) return { error: 'the store copy has no valid manifest' };
+
+  const build = await buildPanelPlugin(destination, manifest);
+  invalidatePanelScan();
+  // The new files are the baseline now — taken AFTER the build so the tree the
+  // next pass compares against is the one this pass produced.
+  await writeBaseline(pluginId, await hashTrackedFiles(destination));
+  await writeBlockedSync(pluginId, null);
+  return {
+    outcome: {
+      pluginId,
+      from,
+      to,
+      // The store changed but its manifest version did not. Naming it keeps a
+      // `1.0.0 → 1.0.0` line from reading as a no-op when a real fix landed.
+      ...(from === to ? { contentOnly: true } : {}),
+      ...(build.status === 'failed' ? { warning: build.reason ?? 'the plugin did not build' } : {}),
+    },
+  };
+}
+
+/**
+ * Bring every installed bundled plugin up to the store's copy.
  *
  * Never throws: one plugin that cannot be replaced must not stop the others, and
  * a failure is reported per plugin. Returns what actually moved.
@@ -132,9 +193,10 @@ export async function syncBundledPlugins(): Promise<{
     try {
       const storeVersion = await manifestVersion(join(storeRoot, pluginId));
       const installedVersion = await manifestVersion(destination);
-      if (!storeVersion || !installedVersion || !isNewer(storeVersion, installedVersion)) {
-        // Nothing to apply, so any earlier refusal no longer describes anything
-        // the user has to act on.
+      // A manifest that cannot be read on either side means there is no
+      // comparison to make at all — the scan reports it, and the sync leaves the
+      // directory alone rather than guessing which side is wrong.
+      if (!storeVersion || !installedVersion) {
         await writeBlockedSync(pluginId, null);
         continue;
       }
@@ -143,9 +205,48 @@ export async function syncBundledPlugins(): Promise<{
       // differs from it is the user's. A plugin with no baseline predates this
       // check (or was installed by an older build), and running is the only
       // useful answer: refusing would freeze it forever with no way to say why.
-      const baseline = await readBaseline(pluginId);
-      if (baseline) {
-        const changed = changedPaths(baseline, await hashTrackedFiles(destination));
+      //
+      // PROVENANCE and EVIDENCE are separate answers. A recorded baseline is what
+      // proves Kabmo wrote this directory, so the content gate below applies
+      // either way; only a baseline that still DESCRIBES the install may say a
+      // file is the user's — see `baselineDescribesInstall`. Obeying a stale one
+      // is what made the update unrecoverable: the rename rewrote every bundled
+      // file while an older baseline was recorded, so every path read as the
+      // user's edit and the only way out was removing the plugin.
+      const recorded = await readBaseline(pluginId);
+      const installFiles = await hashTrackedFiles(destination);
+      const storeFiles = await hashTrackedFiles(join(storeRoot, pluginId));
+      const trusted = recorded !== null && baselineDescribesInstall(recorded, installFiles, storeFiles);
+
+      // WHICH GATE APPLIES IS DECIDED BY PROVENANCE, and the two answer
+      // different questions:
+      //
+      // - A directory Kabmo wrote is compared by CONTENT. The store's tree is
+      //   the source of truth for it, so any difference is an update — including
+      //   a fix shipped without a version bump, and including the case that made
+      //   this a bug: the product rename rewrote every bundled file AND reset the
+      //   versions to 0.0.1, so a version gate could never see the store as
+      //   newer and the plugin was stuck until it was removed and reinstalled
+      //   (measured on a real install).
+      // - A directory with no recorded baseline is of unknown provenance, so the
+      //   conservative version gate stays: a hand-copied directory that happens
+      //   to share a store id must not be overwritten by a store entry that is
+      //   merely newer than it.
+      const contentDiffers = changedPaths(installFiles, storeFiles).length > 0;
+      const versionIsNewer = isNewer(storeVersion, installedVersion);
+      const shouldApply = recorded ? contentDiffers : versionIsNewer;
+      if (!shouldApply) {
+        // Nothing to apply, so any earlier refusal no longer describes anything
+        // the user has to act on.
+        await writeBlockedSync(pluginId, null);
+        // A stale baseline is replaced by what is on disk, so the next release's
+        // update compares against reality rather than against history.
+        if (recorded && !trusted) await writeBaseline(pluginId, installFiles);
+        continue;
+      }
+
+      if (trusted) {
+        const changed = changedPaths(recorded, installFiles);
         if (changed.length > 0) {
           blocked.push({ pluginId, from: installedVersion, to: storeVersion, changed });
           await writeBlockedSync(pluginId, { at: Date.now(), changed });
@@ -153,26 +254,19 @@ export async function syncBundledPlugins(): Promise<{
         }
       }
 
-      await replaceFromStore(join(storeRoot, pluginId), destination);
-
-      const read = await readPluginManifest(destination);
-      const manifest = read.kind === 'manifest' ? toManifest(read.value, destination) : null;
-      if (!manifest || 'error' in manifest) {
-        failed.push({ pluginId, error: 'the store copy has no valid manifest' });
+      const applied = await applyStoreCopy(
+        pluginId,
+        join(storeRoot, pluginId),
+        destination,
+        installedVersion,
+        storeVersion,
+        installFiles,
+      );
+      if ('error' in applied) {
+        failed.push({ pluginId, error: applied.error });
         continue;
       }
-      const build = await buildPanelPlugin(destination, manifest);
-      invalidatePanelScan();
-      // The new files are the baseline now — taken AFTER the build so the tree
-      // the next pass compares against is the one this pass produced.
-      await writeBaseline(pluginId, await hashTrackedFiles(destination));
-      await writeBlockedSync(pluginId, null);
-      updated.push({
-        pluginId,
-        from: installedVersion,
-        to: storeVersion,
-        ...(build.status === 'failed' ? { warning: build.reason ?? 'the plugin did not build' } : {}),
-      });
+      updated.push(applied.outcome);
     } catch (error) {
       failed.push({ pluginId, error: error instanceof Error ? error.message : String(error) });
     }
@@ -187,9 +281,11 @@ export async function syncBundledPlugins(): Promise<{
  *
  * The escape hatch for a refusal: the user has seen which files differ and asked
  * for the store's copy anyway, which is the only way past a baseline Kabmo
- * cannot reconcile. The baseline is dropped first, so the pass that follows takes
- * the store's files and re-records what it wrote — the same end state a clean
- * install reaches.
+ * cannot reconcile. It applies the copy DIRECTLY rather than clearing the
+ * baseline and re-running the pass: a cleared baseline makes the plugin read as
+ * "unknown provenance", which is exactly the state the conservative version gate
+ * governs — so the override silently became a no-op whenever the store's version
+ * was not newer, which is the case it most often exists for.
  *
  * Deliberately addressed by id and refusing anything that is not a bundled
  * install: this must never be a way to overwrite a git clone.
@@ -201,12 +297,21 @@ export async function forceSyncBundledPlugin(pluginId: string): Promise<{ ok: bo
   if (!(await pathExists(destination))) return { ok: false, error: `${pluginId} is not installed.` };
   if (await readGitOrigin(destination)) return { ok: false, error: `${pluginId} is a git clone; its own Update is the way to change it.` };
 
-  await clearBaseline(pluginId);
-  await writeBlockedSync(pluginId, null);
-  const result = await syncBundledPlugins();
-  const failed = result.failed.find((entry) => entry.pluginId === pluginId);
-  if (failed) return { ok: false, error: failed.error };
-  const outcome = result.updated.find((entry) => entry.pluginId === pluginId);
-  if (!outcome) return { ok: false, error: `${pluginId} is already at the store's version.` };
-  return { ok: true, ...(outcome.warning ? { warning: outcome.warning } : {}) };
+  const from = (await manifestVersion(destination)) ?? 'unknown';
+  const to = (await manifestVersion(storeDir)) ?? 'unknown';
+  try {
+    const applied = await applyStoreCopy(
+      pluginId,
+      storeDir,
+      destination,
+      from,
+      to,
+      await hashTrackedFiles(destination),
+    );
+    if ('error' in applied) return { ok: false, error: applied.error };
+    emitRealtimeSignal('panels-changed');
+    return { ok: true, ...(applied.outcome.warning ? { warning: applied.outcome.warning } : {}) };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
 }

package/src/server/lib/realtime/signals.server.ts

@@ -22,6 +22,16 @@ export type RealtimeSignal =
   | 'stream-status'
   /** The sidebar's structure changed (a session or folder was added/removed). */
   | 'sidebar-structure'
+  /**
+   * A RUNNING session's transcript grew, so its last-activity stamp moved.
+   *
+   * Raised per tool call, which is the whole reason it is not
+   * `sidebar-structure`: that payload is every folder and session (216 KB over
+   * 731 sessions, measured), while only a running session's stamp can move
+   * between turn boundaries. Republishing the structure here is what made a
+   * phone's stream feel slow — one full list per tool call.
+   */
+  | 'sidebar-activity'
   /** An omp child for `sessionId` became reachable, or was torn down. */
   | 'session-attached'
   /** A scheduled task was created, edited, paused, deleted or fired. */

package/src/server/lib/realtime/topics/catalog.server.ts

@@ -20,6 +20,7 @@ import {
   TOPIC_PANELS,
   TOPIC_SCHEDULE,
   TOPIC_SIDEBAR,
+  TOPIC_SIDEBAR_ACTIVITY,
   TOPIC_SIDEBAR_STATUS,
   TOPIC_USAGE,
   TOPIC_WAITING,
@@ -28,10 +29,11 @@ import {
   sessionTelemetryTopic,
   sessionTodosTopic,
 } from '@/shared/lib/realtime/protocol';
-import type { SidebarPayload, SidebarStatusPayload } from '@/shared/types/realtime';
+import type { SidebarActivityPayload, SidebarPayload, SidebarStatusPayload } from '@/shared/types/realtime';
 import { isValidPluginId } from '@/shared/lib/plugins/protocol';
 import type { TopicDescriptor } from '@/server/lib/realtime/hub.types';
 import { loadSidebarStatus, loadSidebarStructure } from '@/server/lib/omp/session/sidebar-data.server';
+import { loadSidebarActivity } from '@/server/lib/omp/session/sidebar-activity.server';
 import { sessionDescriptor } from '@/server/lib/realtime/topics/session.server';
 import { btwDescriptor } from '@/server/lib/realtime/topics/btw.server';
 import { SESSION_DATA_TOPICS } from '@/server/lib/realtime/topics/session-data.server';
@@ -64,6 +66,7 @@ export const SCOPED_FAMILIES: Record<string, (scope: string) => TopicDescriptor>
 export const EXACT_TOPICS = new Map<string, TopicDescriptor>([
   [TOPIC_SIDEBAR, { resolve: async (): Promise<SidebarPayload> => loadSidebarStructure() }],
   [TOPIC_SIDEBAR_STATUS, { resolve: async (): Promise<SidebarStatusPayload> => loadSidebarStatus() }],
+  [TOPIC_SIDEBAR_ACTIVITY, { resolve: async (): Promise<SidebarActivityPayload> => loadSidebarActivity() }],
   [TOPIC_SCHEDULE, { resolve: () => globalDescriptor(TOPIC_SCHEDULE).resolve(TOPIC_SCHEDULE) }],
   [TOPIC_USAGE, { resolve: () => globalDescriptor(TOPIC_USAGE).resolve(TOPIC_USAGE) }],
   [TOPIC_PANELS, { resolve: () => globalDescriptor(TOPIC_PANELS).resolve(TOPIC_PANELS) }],

package/src/server/lib/realtime/topics.server.ts

@@ -18,6 +18,7 @@ import {
   TOPIC_PANELS,
   TOPIC_SCHEDULE,
   TOPIC_SIDEBAR,
+  TOPIC_SIDEBAR_ACTIVITY,
   TOPIC_SIDEBAR_STATUS,
   TOPIC_USAGE,
   TOPIC_WAITING,
@@ -29,6 +30,7 @@ import { getRealtimeHub, registerTopics, type TopicDescriptor } from '@/server/l
 import { onRealtimeSignal } from '@/server/lib/realtime/signals.server';
 import { invalidateOmpSidebarData } from '@/server/lib/omp/session/reader';
 import { loadSidebarStatus, loadSidebarStructure } from '@/server/lib/omp/session/sidebar-data.server';
+import { loadSidebarActivity } from '@/server/lib/omp/session/sidebar-activity.server';
 import { EXACT_TOPICS, descriptorFor, isKnownTopicName } from '@/server/lib/realtime/topics/catalog.server';
 
 declare global {
@@ -78,6 +80,7 @@ export function initRealtimeTopics(): void {
   onRealtimeSignal(({ signal, sessionId, root }) => {
     if (signal === 'stream-status') publishSidebarStatus();
     else if (signal === 'sidebar-structure') publishSidebarStructure();
+    else if (signal === 'sidebar-activity') publishSidebarActivity();
     else if (signal === 'session-attached' && sessionId) publishSessionState(sessionId);
     else if (signal === 'schedule-changed') publishTopic(TOPIC_SCHEDULE);
     else if (signal === 'panels-changed') publishTopic(TOPIC_PANELS);
@@ -244,6 +247,19 @@ export function publishSidebarStatus(): void {
   schedulePublish(TOPIC_SIDEBAR_STATUS, loadSidebarStatus);
 }
 
+/**
+ * A RUNNING session's transcript grew: republish its activity stamps.
+ *
+ * Called per tool call (see `handleToolExecutionEnd`), so it must never be the
+ * structure publish: that one invalidates the discovery scan and re-serializes
+ * every folder and session. This payload carries one ISO string per live run
+ * and re-reads nothing but those files' own summaries (each memoized on
+ * `(size, mtimeMs)`, measured 0.1 ms on a cache miss).
+ */
+export function publishSidebarActivity(): void {
+  schedulePublish(TOPIC_SIDEBAR_ACTIVITY, loadSidebarActivity);
+}
+
 /**
  * The sidebar's STRUCTURE changed: a session was created, deleted, renamed, a
  * folder was added or removed, or a JSONL grew a new session.

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

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { versionFromAssetName } from '@/server/lib/updates/shell-assets';
+
+/**
+ * The asset name is the only place a shell artifact's version exists: the
+ * release TAG names the SERVER version, and the two move independently. A parser
+ * that read the tag would compare a server version against a shell version.
+ *
+ * Both shells are pinned here, because they share the parser and differ only by
+ * prefix/extension — the shape that silently accepts the other shell's asset.
+ */
+describe('versionFromAssetName', () => {
+  test('reads the version the release workflows write', () => {
+    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');
+  });
+
+  /**
+   * 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-1.2.3-android.apk.zip')).toBeNull();
+    expect(versionFromAssetName('android', 'source.tar.gz')).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 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();
+  });
+
+  /**
+   * The desktop trio, one entry each.
+   *
+   * A desktop release carries SEVERAL files per platform (two arches × two
+   * macOS shapes, four Linux formats), so the match is on the segment after the
+   * version rather than the whole name: any one of them answers the same
+   * version, and the download the console offers is the release page.
+   */
+  test('reads every desktop spelling, and only its own platform', () => {
+    for (const name of ['Kabmo-0.2.0-mac-arm64.zip', 'Kabmo-0.2.0-mac-x64.dmg']) {
+      expect(versionFromAssetName('macos', name), name).toBe('0.2.0');
+      expect(versionFromAssetName('windows', name), name).toBeNull();
+      expect(versionFromAssetName('linux', name), name).toBeNull();
+    }
+    for (const name of ['Kabmo-0.2.0-win-x64-setup.exe', 'Kabmo-0.2.0-win-arm64-setup.exe']) {
+      expect(versionFromAssetName('windows', name), name).toBe('0.2.0');
+      expect(versionFromAssetName('macos', name), name).toBeNull();
+    }
+    for (const name of [
+      'Kabmo-0.2.0-linux-x86_64.tar.gz',
+      'Kabmo-0.2.0-linux-arm64.tar.gz',
+      'Kabmo-0.2.0-linux-amd64.deb',
+      'Kabmo-0.2.0-linux-arm64.rpm',
+      'Kabmo-0.2.0-linux-x86_64.AppImage',
+    ]) {
+      expect(versionFromAssetName('linux', name), name).toBe('0.2.0');
+      expect(versionFromAssetName('macos', name), name).toBeNull();
+    }
+  });
+
+  test('a desktop shell reads no mobile asset, and vice versa', () => {
+    // The `Kabmo-` prefix is shared by all five, so a scheme that matched on the
+    // prefix alone would offer an APK to a Mac.
+    expect(versionFromAssetName('macos', 'Kabmo-0.6.0-android.apk')).toBeNull();
+    expect(versionFromAssetName('windows', 'Kabmo-0.2.0-ios.ipa')).toBeNull();
+    expect(versionFromAssetName('linux', 'Kabmo-0.6.0-android.apk')).toBeNull();
+    expect(versionFromAssetName('android', 'Kabmo-0.2.0-linux-x86_64.tar.gz')).toBeNull();
+    expect(versionFromAssetName('ios', 'Kabmo-0.2.0-win-x64-setup.exe')).toBeNull();
+  });
+});