@kabmo-labs/kabmo 0.5.2 → 0.6.0

package/src/client/components/layout/desktop-layout/left-column.test.tsx

@@ -1,192 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * The left column draws ONE separator, and its chrome spans the WHOLE column.
- *
- * Both `LeftColumn` and `DesktopLayout` rendered a `ResizeHandle` after the
- * dock, and both were mounted — so the column boundary drew two hairlines 3px
- * apart and a reader saw a double rule between the session list and the chat.
- * It was reproduced only when the rail was ON, because that is the layout a
- * screenshotted report came from, though the extra handle was there in both
- * states.
- *
- * A geometry test cannot catch the separator (happy-dom computes no layout), so
- * that assertion is on the STRUCTURE: the group's direct children, in order. The
- * second handle was a sibling — `LeftColumn`'s own sits between the dock and
- * whatever follows — which is exactly what an order comparison shows.
- *
- * The chrome half is structural too, and both cases were reported. The strip
- * lived inside the dock BODY while the rail was a sibling panel, so with the
- * rail on it stopped at the body's left edge and left an empty strip under the
- * rail. And the rail started at the column's top, running up past the title row
- * and under the app's own titlebar. The column is three ROWS — title, then
- * (rail | view), then strip — so both are asserted by the row each one lives in.
- */
-
-import { afterAll, afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Window } from 'happy-dom';
-import { h, render } from 'preact';
-import { act } from 'preact/test-utils';
-import { Group } from '@/client/components/layout/desktop-layout/resizer';
-import { LeftColumn } from '@/client/components/layout/desktop-layout/LeftColumn';
-import { SessionStateProvider } from '@/client/components/common/session-state-provider/index';
-import { primeKabmoSettings } from '@/shared/lib/settings/client';
-import { realtimeClient, resetRealtimeClient } from '@/shared/lib/realtime/client';
-import { installDomGlobals, restoreDomGlobals } from '@/test-support/pristine-globals';
-
-let container: HTMLElement | null = null;
-
-/**
- * A socket that never dials.
- *
- * The rail subscribes to the Source Control topic on mount. Left to a REAL
- * socket, its close lands after this file has restored the globals and surfaces
- * as `Unhandled error. (ErrorEvent …)` attributed to whichever suite ran next —
- * measured. This column's subject is its own structure, so the channel is
- * silenced rather than served.
- */
-class SilentSocket {
-  static readonly CLOSING = 2;
-  static readonly CLOSED = 3;
-  readyState = SilentSocket.CLOSED;
-  onopen: (() => void) | null = null;
-  onclose: (() => void) | null = null;
-  onmessage: ((event: { data: string }) => void) | null = null;
-  onerror: (() => void) | null = null;
-  send(): void {}
-  close(): void {}
-}
-
-beforeEach(() => {
-  installDomGlobals(new Window({ url: 'http://127.0.0.1:1' }));
-  realtimeClient.setSocketConstructor(SilentSocket as unknown as typeof WebSocket);
-  primeKabmoSettings({});
-});
-
-afterAll(() => {
-  realtimeClient.setSocketConstructor(null);
-  restoreDomGlobals();
-});
-
-afterEach(() => {
-  // The rail's Source Control dot subscribes to a realtime topic, so the render
-  // opens a socket. Left open, its close lands in the NEXT file's globals once
-  // this one has restored them — measured as `Unhandled error. (ErrorEvent …)`
-  // between tests, attributed to whichever suite happened to run next.
-  resetRealtimeClient();
-  if (container) {
-    render(null, container);
-    container.remove();
-    container = null;
-  }
-  primeKabmoSettings({});
-});
-
-async function mountColumn(railEnabled: boolean) {
-  const host = document.createElement('div');
-  document.body.appendChild(host);
-  container = host;
-
-  await act(async () => {
-    render(
-      h(SessionStateProvider, {
-        sessionId: 'new-separator',
-        children: h(Group, {
-        orientation: 'horizontal',
-        id: 'kabmo-main',
-        children: [
-          h(LeftColumn, {
-            panelRef: { current: null },
-            open: true,
-            railEnabled,
-            view: 'sessions',
-            onSelectView: () => {},
-            onCollapse: () => {},
-            width: 280,
-            minWidth: 264,
-            hasActiveContext: true,
-            refreshKey: 0,
-            onRefresh: () => {},
-            onOpenFile: () => {},
-          }),
-          h('div', { 'data-panel-id': 'main-right-stack' }),
-        ],
-        }),
-      }),
-      host,
-    );
-  });
-  // The dock's view is `lazy()`, so the boundary matters before it resolves:
-  // the separator is a SIBLING of the panel, not part of its content.
-  for (let i = 0; i < 5; i += 1) await act(async () => {});
-}
-
-/** The group's DIRECT children, in order — a separator appears once per entry. */
-const children = (): string[] =>
-  [...(container!.querySelector('[data-panel-group-id="kabmo-main"]')?.children ?? [])].map((child) =>
-    child.hasAttribute('data-separator') ? 'separator' : (child.getAttribute('data-panel-id') ?? child.tagName),
-  );
-
-describe('left column separators', () => {
-  test('one separator with the rail on', async () => {
-    await mountColumn(true);
-    expect(children().filter((entry) => entry === 'separator')).toHaveLength(1);
-  });
-
-  test('one separator with the rail off', async () => {
-    await mountColumn(false);
-    expect(children().filter((entry) => entry === 'separator')).toHaveLength(1);
-  });
-
-  test('the separator is the column boundary — after the dock, not before it', async () => {
-    await mountColumn(true);
-    const kids = children();
-    expect(kids.at(-1)).toBe('main-right-stack');
-    expect(kids.at(-2)).toBe('separator');
-  });
-});
-
-describe('left column chrome', () => {
-  const panel = () => container!.querySelector('[data-panel-id="left-panel"]') as HTMLElement;
-  const rail = () => panel().querySelector('nav[aria-label="Left panel views"]');
-  const title = () => panel().querySelector('.h-10.flex-shrink-0.flex.items-center.justify-between');
-  const footer = () => panel().querySelector('button[aria-label="Settings"]');
-
-  test('the title row, the rail and the strip are three rows, in that order', async () => {
-    await mountColumn(true);
-    const column = panel().firstElementChild as HTMLElement;
-    const rows = [...column.children];
-    expect(rows).toHaveLength(3);
-    // Row 0 is the title, row 1 holds the rail beside the view, row 2 the strip.
-    expect(rows[0].contains(title())).toBe(true);
-    expect(rows[1].contains(rail())).toBe(true);
-    expect(rows[2].contains(footer())).toBe(true);
-  });
-
-  test('the rail starts BELOW the title, never above it', async () => {
-    await mountColumn(true);
-    const column = panel().firstElementChild as HTMLElement;
-    expect(column.children[0].contains(rail())).toBe(false);
-    expect(column.children[1].contains(rail())).toBe(true);
-  });
-
-  test('the strip spans the column, so the rail does not outlive it', async () => {
-    await mountColumn(true);
-    const column = panel().firstElementChild as HTMLElement;
-    expect(column.children[2].contains(rail())).toBe(false);
-    expect(column.children[2].contains(footer())).toBe(true);
-    // Same row container for title and strip: both are full-width rows of the
-    // column, which is what makes the strip run under the rail too.
-    expect(column.children[0].parentElement).toBe(column.children[2].parentElement);
-  });
-
-  test('the strip survives a view that is not the session list', async () => {
-    await mountColumn(true);
-    // The column's furniture is rendered outside `LeftDockView` entirely, so it
-    // is present even while the lazy view is still resolving.
-    expect(footer()).not.toBeNull();
-  });
-});

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

@@ -1,112 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  androidDownloadLabel,
-  parseAndroidRelease,
-  shouldOfferAndroidDownload,
-  type AndroidDownload,
-} from '@/client/hooks/ui/updates/android-download';
-
-/** 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',
-  latest: '1.2.3',
-  releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v1.2.3',
-};
-
-const UPDATE: AndroidDownload = { ...RELEASE, kind: 'update' };
-const INSTALL: AndroidDownload = { ...RELEASE, kind: 'install' };
-
-describe('parseAndroidRelease', () => {
-  test('reads a complete payload', () => {
-    expect(parseAndroidRelease(RELEASE)).toEqual(RELEASE);
-  });
-
-  test('refuses a payload with no asset', () => {
-    // The route answers this on a failed probe. A version without a URL would be
-    // a button that downloads nothing.
-    expect(parseAndroidRelease({ url: null, latest: '1.2.3', releaseUrl: null })).toBeNull();
-    expect(parseAndroidRelease({ url: 'https://x/a.apk', latest: null, releaseUrl: null })).toBeNull();
-  });
-
-  test('refuses a non-object', () => {
-    expect(parseAndroidRelease(null)).toBeNull();
-    expect(parseAndroidRelease('nope')).toBeNull();
-    expect(parseAndroidRelease({})).toBeNull();
-  });
-
-  test('keeps a missing releaseUrl as null', () => {
-    expect(parseAndroidRelease({ url: 'https://x/a.apk', latest: '1.0.0' })?.releaseUrl).toBeNull();
-  });
-});
-
-describe('the offer inside the installed app', () => {
-  test('offers an UPDATE when a newer APK is published', () => {
-    expect(shouldOfferAndroidDownload('1.2.2', true, RELEASE)).toEqual(UPDATE);
-  });
-
-  test('offers nothing when the app is already current', () => {
-    expect(shouldOfferAndroidDownload('1.2.3', true, RELEASE)).toBeNull();
-  });
-
-  test('offers nothing when the app is ahead', () => {
-    // A sideloaded build newer than the published asset: downloading it would be
-    // a downgrade.
-    expect(shouldOfferAndroidDownload('1.3.0', true, RELEASE)).toBeNull();
-  });
-
-  test('offers nothing when the probe failed', () => {
-    expect(shouldOfferAndroidDownload('1.0.0', true, null)).toBeNull();
-  });
-});
-
-describe('the offer to an Android browser', () => {
-  test('offers an INSTALL, because there is no installed version to compare', () => {
-    // The reported gap: a reader on Chrome or Brave for Android was told
-    // nothing, and the shell is exactly what they do not know exists.
-    expect(shouldOfferAndroidDownload(null, true, RELEASE)).toEqual(INSTALL);
-  });
-
-  test('offers an install even when the published APK is older than some build', () => {
-    // Nothing is installed here, so "newer than" has no left-hand side — the
-    // published asset is simply what the button names.
-    expect(shouldOfferAndroidDownload(undefined, true, { ...RELEASE, latest: '0.0.1' })).toEqual({
-      ...INSTALL,
-      latest: '0.0.1',
-    });
-  });
-
-  test('offers nothing when no APK is published', () => {
-    expect(shouldOfferAndroidDownload(null, true, null)).toBeNull();
-  });
-});
-
-describe('everywhere else', () => {
-  test('a desktop browser is offered nothing', () => {
-    // An APK cannot be installed there, and the app's own update badge already
-    // covers the server.
-    expect(shouldOfferAndroidDownload(null, false, RELEASE)).toBeNull();
-    expect(shouldOfferAndroidDownload(null, null, RELEASE)).toBeNull();
-    expect(shouldOfferAndroidDownload(null, undefined, RELEASE)).toBeNull();
-    expect(shouldOfferAndroidDownload('', false, RELEASE)).toBeNull();
-  });
-
-  test('the shell token alone is enough, even if the wider flag is missing', () => {
-    // `isAndroid` is derived from the same UA, so a stale bootstrap that predates
-    // the field must not silently drop the update offer.
-    expect(shouldOfferAndroidDownload('1.2.2', false, RELEASE)).toEqual(UPDATE);
-    expect(shouldOfferAndroidDownload('1.2.2', undefined, RELEASE)).toEqual(UPDATE);
-  });
-});
-
-describe('androidDownloadLabel', () => {
-  test('names the verb the reader needs', () => {
-    expect(androidDownloadLabel(UPDATE)).toBe('Update Kabmo 1.2.3 for Android');
-    expect(androidDownloadLabel(INSTALL)).toBe('Install Kabmo 1.2.3 for Android');
-  });
-});

package/src/client/hooks/ui/updates/android-download.ts

@@ -1,143 +0,0 @@
-/**
- * What the sidebar should offer for the Android shell, and why.
- *
- * Two DIFFERENT offers, from two different facts:
- *
- * - **`update`** — this page is running inside the APK (`shellVersion` from the
- *   bootstrap) and a newer one is published. An up-to-date app offers nothing:
- *   a button that downloads the build already installed is worse than no button.
- * - **`install`** — this page is an Android BROWSER (Chrome, Brave, Firefox) and
- *   an APK is published. The reader may not know a native shell exists, and
- *   telling them is the whole point of the offer; there is no installed version
- *   to compare against, so the newest published one is what it names.
- *
- * A desktop browser gets neither: `isAndroid` is false, an APK cannot be
- * installed there, and the app's own update badge already covers the server.
- *
- * The probe is lazy: it runs only on an Android device, never on a desktop, so a
- * console that can never show the button makes no request for it.
- */
-
-import { useEffect, useState } from 'preact/hooks';
-import { isNewer } from '@/shared/lib/updates/semver';
-
-/** Which offer this is — the two carry different wording. */
-export type AndroidOfferKind = 'update' | 'install';
-
-export interface AndroidDownload {
-  /** The asset to download. */
-  url: string;
-  /** The version that asset ships. */
-  latest: string;
-  /** The release page, for a "what changed" link. */
-  releaseUrl: string | null;
-  /** An update to an installed APK, or a first install from a browser. */
-  kind: AndroidOfferKind;
-}
-
-interface ReleasePayload {
-  url?: unknown;
-  latest?: unknown;
-  releaseUrl?: unknown;
-}
-
-/**
- * Read the release payload defensively.
- *
- * The route answers `{url: null, latest: null, releaseUrl: null}` on a failed
- * probe, so a shape check that only looks at the version would offer a button
- * with no link.
- */
-export function parseAndroidRelease(payload: unknown): Omit<AndroidDownload, 'kind'> | null {
-  if (typeof payload !== 'object' || payload === null) return null;
-  const body = payload as ReleasePayload;
-  if (typeof body.url !== 'string' || !body.url) return null;
-  if (typeof body.latest !== 'string' || !body.latest) return null;
-  return {
-    url: body.url,
-    latest: body.latest,
-    releaseUrl: typeof body.releaseUrl === 'string' ? body.releaseUrl : null,
-  };
-}
-
-/**
- * The offer, or null.
- *
- * `shellVersion` is null in every browser — that is what makes the two branches
- * mutually exclusive — and `isAndroid` is the wider fact that admits a browser
- * ON ANDROID. Both come from the bootstrap rather than a client-side UA sniff:
- * the server already parsed them for the very request that served the page.
- *
- * An `install` needs no version comparison, because nothing is installed. It
- * does require a published APK: `release` being null is a failed probe, and a
- * button the console cannot back with a link must not appear.
- */
-export function shouldOfferAndroidDownload(
-  shellVersion: string | null | undefined,
-  isAndroid: boolean | null | undefined,
-  release: Omit<AndroidDownload, 'kind'> | null,
-): AndroidDownload | null {
-  if (!release) return null;
-
-  // Inside the APK: an update, and only when one exists.
-  if (shellVersion) {
-    return isNewer(release.latest, shellVersion) ? { ...release, kind: 'update' } : null;
-  }
-
-  // A browser on an Android device: the app is something to install.
-  if (isAndroid) return { ...release, kind: 'install' };
-
-  return null;
-}
-
-/**
- * The wording of the offer, in one place.
- *
- * Both layouts draw this control and they must say the same thing: an installed
- * app that is behind is an UPDATE, and a browser on Android is an INSTALL —
- * "Download" for both would leave a first-time reader unsure whether they
- * already have the app. The version is in the label because the asset is a
- * specific build, not "the app".
- */
-export function androidDownloadLabel(download: AndroidDownload): string {
-  const verb = download.kind === 'update' ? 'Update' : 'Install';
-  return `${verb} Kabmo ${download.latest} for Android`;
-}
-
-/**
- * Fetch the published APK and decide what to offer.
- *
- * `fetchImpl` is a seam for the tests: the cases that matter (no release, a
- * failed probe, a version equal to the installed one) cannot be produced by a
- * live GitHub call.
- */
-export function useAndroidDownload(
-  shellVersion: string | null | undefined,
-  isAndroid: boolean | null | undefined,
-  fetchImpl: typeof fetch = fetch,
-): AndroidDownload | null {
-  const [release, setRelease] = useState<Omit<AndroidDownload, 'kind'> | null>(null);
-  const wanted = Boolean(shellVersion) || Boolean(isAndroid);
-
-  useEffect(() => {
-    if (!wanted) return;
-
-    let cancelled = false;
-    void (async () => {
-      try {
-        const response = await fetchImpl('/api/updates/android');
-        if (!response.ok) return;
-        const payload: unknown = await response.json();
-        if (!cancelled) setRelease(parseAndroidRelease(payload));
-      } catch {
-        // A probe that cannot answer is a button that must not appear.
-      }
-    })();
-
-    return () => {
-      cancelled = true;
-    };
-  }, [wanted, fetchImpl]);
-
-  return shouldOfferAndroidDownload(shellVersion, isAndroid, release);
-}

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

@@ -1,138 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { beforeEach, describe, expect, test } from 'bun:test';
-
-import {
-  fetchAndroidRelease,
-  resetAndroidReleaseCache,
-  versionFromAssetName,
-} from '@/server/lib/updates/android-release';
-
-/**
- * The asset name is the only place the APK'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 an APK version.
- */
-describe('versionFromAssetName', () => {
-  test('reads the version the release workflow writes', () => {
-    expect(versionFromAssetName('kabmo-android-v1.2.3.apk')).toBe('1.2.3');
-  });
-
-  test('accepts a hand-uploaded name without the v', () => {
-    expect(versionFromAssetName('kabmo-android-1.2.3.apk')).toBe('1.2.3');
-  });
-
-  test('ignores anything that is not the APK', () => {
-    expect(versionFromAssetName('kabmo-android-v1.2.3.apk.zip')).toBeNull();
-    expect(versionFromAssetName('source.tar.gz')).toBeNull();
-    expect(versionFromAssetName('kabmo-android-latest.apk')).toBeNull();
-    expect(versionFromAssetName('')).toBeNull();
-  });
-});
-
-/** A fetch double that answers one body, and counts its calls. */
-function stubFetch(body: unknown, ok = true) {
-  const calls: string[] = [];
-  const impl = (async (input: string | URL | Request) => {
-    calls.push(String(input));
-    return {
-      ok,
-      json: async () => body,
-    } as Response;
-  }) as unknown as typeof fetch;
-  return { impl, calls };
-}
-
-describe('fetchAndroidRelease', () => {
-  // The cache is process-wide (see `resetAndroidReleaseCache`), so every case
-  // starts from a cold one or it reads the previous case's answer.
-  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 release = await fetchAndroidRelease(impl);
-    expect(release).toEqual({
-      url: 'https://x/kabmo-android-v1.2.3.apk',
-      latest: '1.2.3',
-      releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v9.9.9',
-    });
-  });
-
-  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 () => {
-    // An offline box or a rate-limited GitHub must not take the sidebar down,
-    // and a failure must not be read as "no newer version" either — it is
-    // simply no offer.
-    const { impl } = stubFetch({}, false);
-    expect(await fetchAndroidRelease(impl)).toBeNull();
-  });
-
-  test('answers null when the body is malformed', async () => {
-    const { impl } = stubFetch({ assets: 'nope' });
-    expect(await fetchAndroidRelease(impl)).toBeNull();
-  });
-});