@kabmo-labs/kabmo 0.5.2 → 0.6.0

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

@@ -0,0 +1,184 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { beforeEach, describe, expect, test } from 'bun:test';
+
+import { fetchShellRelease, resetShellReleaseCache, versionFromAssetName } from '@/server/lib/updates/shell-release';
+
+/**
+ * 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-android-v1.2.3.apk')).toBe('1.2.3');
+    expect(versionFromAssetName('ios', 'kabmo-ios-v1.2.3.ipa')).toBe('1.2.3');
+  });
+
+  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');
+  });
+
+  test('ignores anything that is not that shell’s artifact', () => {
+    expect(versionFromAssetName('android', 'kabmo-android-v1.2.3.apk.zip')).toBeNull();
+    expect(versionFromAssetName('android', 'source.tar.gz')).toBeNull();
+    expect(versionFromAssetName('android', 'kabmo-android-latest.apk')).toBeNull();
+    expect(versionFromAssetName('android', '')).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-android-v1.2.3.apk')).toBeNull();
+    expect(versionFromAssetName('android', 'kabmo-ios-v1.2.3.ipa')).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('fetchShellRelease', () => {
+  // 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());
+
+  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',
+          },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('android', impl)).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('picks the IPA asset for the iOS probe', async () => {
+    const { impl } = stubFetch([
+      {
+        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' },
+        ],
+      },
+    ]);
+
+    expect(await fetchShellRelease('ios', impl)).toEqual({
+      url: 'https://x/i.ipa',
+      latest: '0.4.0',
+      releaseUrl: 'https://x/app',
+    });
+  });
+
+  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' },
+      ],
+    };
+    expect((await fetchShellRelease('android', stubFetch([release]).impl))?.latest).toBe('1.0.0');
+    expect((await fetchShellRelease('ios', stubFetch([release]).impl))?.latest).toBe('2.0.0');
+
+    // …and a reset of one leaves the other's answer in place.
+    resetShellReleaseCache('android');
+    const { impl, calls } = stubFetch([release]);
+    expect((await fetchShellRelease('ios', impl))?.latest).toBe('2.0.0');
+    expect(calls, 'a cached answer must not re-read GitHub').toHaveLength(0);
+  });
+
+  test('skips a newer release that carries no artifact', 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 shell. Asking `/releases/latest` answered the package release and
+    // the button vanished while the artifact 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 fetchShellRelease('android', 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 fetchShellRelease('android', impl))?.latest).toBe('0.3.0');
+  });
+
+  test('answers an empty result for a list with no artifact anywhere', async () => {
+    const { impl } = stubFetch([
+      { 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 });
+  });
+
+  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 fetchShellRelease('android', impl)).toBeNull();
+  });
+
+  test('answers null when the body is malformed', async () => {
+    const { impl } = stubFetch({ assets: 'nope' });
+    expect(await fetchShellRelease('android', impl)).toBeNull();
+  });
+});

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

@@ -0,0 +1,215 @@
+/**
+ * Which published native-shell artifact a browser or an installed shell should
+ * download, and whether the installed one is behind.
+ *
+ * Neither shell is an npm package (see `.github/workflows/publish-android.yml`
+ * and `publish-ios.yml`), so the npm probe that answers for the app and for
+ * `omp` cannot answer here. The only record of a published shell 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
+ * `fetchShellRelease`).
+ *
+ * ONE module for both shells, because the question is identical and only the
+ * asset naming differs. Two copies is how one of them starts reading the release
+ * tag, or caching under a slot the other overwrites.
+ *
+ * Two facts travel back, and they answer different questions:
+ *
+ * - `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.
+ * - `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.
+ *
+ * Failure is a normal answer here (`null`), never a throw: an offline box or a
+ * rate-limited GitHub must not take the sidebar down, and a button that appears
+ * because a probe failed would offer a download that does not exist.
+ */
+
+import { REPO } from '@/server/lib/updates/release-url';
+import type { ShellKind } from '@/shared/lib/updates/shell-ua';
+
+/** One published shell artifact, as the console needs it. */
+export interface ShellRelease {
+  /** Asset download URL, or null when the release carries no artifact. */
+  url: string | null;
+  /** Version the asset name declares (`v1.2.3` → `1.2.3`), or null. */
+  latest: string | null;
+  /** The release page, for a "what changed" link. */
+  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' },
+};
+
+/**
+ * `kabmo-android-v1.2.3.apk` → `1.2.3` (and the `.ipa` twin).
+ *
+ * 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".
+ */
+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;
+}
+
+/**
+ * The newest release that actually carries this shell's artifact.
+ *
+ * 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 → apk-build → app` in
+ * `release.yml`), so their `kabmo-sdk/v*` / `kabmo-ui/v*` releases are newer
+ * than the app release that carries the shell. `@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 per shell, cached for five minutes on `globalThis` for the same
+ * reason the database handle is anchored there: `bun --hot` re-evaluates this
+ * module while the cache it would otherwise hold lives on. GitHub allows 60
+ * unauthenticated reads an hour per address, and the sidebar asks on every
+ * mount.
+ */
+export async function fetchShellRelease(
+  kind: ShellKind,
+  fetchImpl: typeof fetch = fetch,
+): Promise<ShellRelease | null> {
+  const cache = cacheSlot(kind);
+  const now = Date.now();
+  if (cache.entry && now - cache.at < CACHE_MS) return cache.entry;
+
+  try {
+    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.
+        'user-agent': 'kabmo-console',
+      },
+    });
+    if (!response.ok) return cache.entry ?? 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 artifact", 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 shell — 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: shellAsset(kind, entry.assets) }))
+      .find((candidate) => candidate.asset !== null);
+
+    if (!release?.asset) {
+      const fallback: ShellRelease = { url: null, latest: null, releaseUrl: null };
+      cache.entry = fallback;
+      cache.at = now;
+      return fallback;
+    }
+
+    const resolved: ShellRelease = {
+      url: typeof release.asset.browser_download_url === 'string' ? release.asset.browser_download_url : null,
+      latest: versionFromAssetName(kind, String(release.asset.name)),
+      releaseUrl: typeof release.entry.html_url === 'string' ? release.entry.html_url : null,
+    };
+
+    cache.entry = resolved;
+    cache.at = now;
+    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.
+    return cache.entry ?? null;
+  }
+}
+
+/** 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. */
+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;
+  }
+
+  return null;
+}
+
+const CACHE_MS = 5 * 60_000;
+
+/**
+ * Where the release read goes.
+ *
+ * Overridable for the same reason the npm probe honours `NPM_CONFIG_REGISTRY`: a
+ * test and a rehearsal need to exercise the real parsing against a stub instead
+ * of a live GitHub call, and hardcoding the host makes that impossible without
+ * intercepting `fetch` globally.
+ */
+function githubApiBase(): string {
+  const configured = Bun.env.KABMO_GITHUB_API ?? '';
+  return configured.trim().replace(/\/+$/, '') || 'https://api.github.com';
+}
+
+interface CacheSlot {
+  entry: ShellRelease | null;
+  at: number;
+}
+
+type ShellCacheHost = typeof globalThis & {
+  __kabmoShellRelease?: Partial<Record<ShellKind, CacheSlot>>;
+};
+
+/**
+ * The cache slot for one shell.
+ *
+ * PER SHELL, not one shared slot: both probes read the same release list but
+ * resolve different assets, so one slot would make the second shell answer with
+ * the first one's artifact.
+ */
+function cacheSlot(kind: ShellKind): CacheSlot {
+  const host = globalThis as ShellCacheHost;
+  host.__kabmoShellRelease ??= {};
+  host.__kabmoShellRelease[kind] ??= { entry: null, at: 0 };
+  return host.__kabmoShellRelease[kind] as CacheSlot;
+}
+
+/**
+ * Drop the cached answer for one shell (or every shell, with no argument).
+ *
+ * The cache lives on `globalThis` so `bun --hot` cannot orphan it, which also
+ * means it outlives a test file: without this seam the second case in a suite
+ * reads the first case's answer and passes for the wrong reason (measured — the
+ * "malformed body" case returned the previous test's release). Production has
+ * no caller; it exists because the cache is process-wide by design.
+ */
+export function resetShellReleaseCache(kind?: ShellKind): void {
+  const host = globalThis as ShellCacheHost;
+  if (!kind) {
+    host.__kabmoShellRelease = {};
+    return;
+  }
+  host.__kabmoShellRelease ??= {};
+  host.__kabmoShellRelease[kind] = { entry: null, at: 0 };
+}

package/src/server/lib/waiting/store.server.test.ts

@@ -38,11 +38,11 @@ const ROOT = path.join(os.tmpdir(), `kabmo-waiting-store-${process.pid}`);
 
 beforeAll(async () => {
   fs.mkdirSync(ROOT, { recursive: true });
-  isolateDb();
+  await isolateDb();
 });
 
 afterAll(async () => {
-  releaseDb();
+  await releaseDb();
   fs.rmSync(ROOT, { recursive: true, force: true });
 });
 

package/src/server/plugins/ssr.ts

@@ -16,7 +16,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, isAndroidDevice } from '@/shared/lib/updates/shell-ua';
+import { isAndroidDevice, shellVersion } from '@/shared/lib/updates/shell-ua';
 
 /** HTML-escape a string for interpolation into the failure page's `<pre>`. */
 function escapeHtmlText(value: string): string {
@@ -157,15 +157,18 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
   const theme = resolveTheme(settingsBlob.theme);
   const userAgent = request.headers.get('user-agent') ?? '';
   const initialIsMobile = MOBILE_UA.test(userAgent);
-  // Which APK is asking, when the request came from the Android shell. Read
-  // 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.
+  // Which shell is asking, and which build of it. Read HERE because the shell
+  // is rendered per request and the client's download control 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);
+  // `isAndroid` is the wider fact and it exists for the Android 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. There is
+  // no `isIos`: an IPA cannot be installed from a browser, so only an installed
+  // iOS shell is ever offered an update.
+  const androidVersion = shellVersion(userAgent, 'android');
+  const iosVersion = shellVersion(userAgent, 'ios');
   const isAndroid = isAndroidDevice(userAgent);
 
   const rendered = await renderShell();
@@ -178,7 +181,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, isAndroid, authenticated, authEnabled: isAuthEnabled(), production: !DEV_ASSETS_ENABLED, appSettings: settings }).replace(/</g, '\\u003c');
+  const bootstrap = JSON.stringify({ initialIsMobile, shellVersion: androidVersion, iosShellVersion: iosVersion, 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/server/routes/chat/stream.test.ts

@@ -33,16 +33,16 @@ import { action } from '@/server/routes/chat/stream';
 
 const savedMock = Bun.env.MOCK;
 
-beforeEach(() => {
-  isolateDb();
+beforeEach(async () => {
+  await isolateDb();
   localRuns().clear();
   Bun.env.MOCK = 'true';
 });
 
-afterEach(() => {
+afterEach(async () => {
   Bun.env.MOCK = savedMock;
   localRuns().clear();
-  releaseDb();
+  await releaseDb();
 });
 
 /** Resolve on the next `stream-status` write — the write's own signal. */

package/src/server/routes/fs/git-merge.test.ts

@@ -254,17 +254,6 @@ describe('continue_operation', () => {
 });
 
 describe('abort_operation', () => {
-  test('restores the pre-merge state', async () => {
-    const repo = makeConflictingRepo();
-    await post({ actionType: 'merge_branch', repo: '.', root: repo, branch: 'feature' });
-
-    const res = await post({ actionType: 'abort_operation', repo: '.', root: repo });
-    expect(res.body.success).toBe(true);
-    expect((await readGitState(repo)).operation).toBeNull();
-    expect(fs.readFileSync(path.join(repo, 'f.txt'), 'utf8')).toBe('a\nMAIN\n');
-    expect(git(repo, 'status', '--porcelain')).toBe('');
-  });
-
   test('refuses when nothing is in progress', async () => {
     const repo = makeConflictingRepo();
     const res = await post({ actionType: 'abort_operation', repo: '.', root: repo });

package/src/server/routes/models/roles.ts

@@ -2,30 +2,89 @@ import { json } from '@/server/lib/remix-compat';
 import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
 import { methodNotAllowed } from '@/server/lib/route-adapter';
 import { readModelRoles, writeModelRoles } from '@/server/lib/omp/config/roles';
+import { readModelRoleCandidates } from '@/server/lib/model-roles/catalog.server';
+import {
+  deleteModelRolePreset,
+  listModelRolePresets,
+  saveModelRolePreset,
+  seedPresetFromCurrentRoles,
+} from '@/server/lib/model-roles/store.server';
+import { normalizeRoleMap } from '@/shared/lib/omp/config/model-roles';
+import type { ModelRolesPayload } from '@/shared/types/model-roles';
 
+/**
+ * Model roles: the live `modelRoles` map from config.yml, the presets Kabmo
+ * stores for it, and the catalog the role dropdowns offer.
+ *
+ * Three verbs, each with one job:
+ *   - `GET`    → everything the panel renders (roles, presets, candidates), and
+ *                the ONE-SHOT seed that snapshots an install's existing roles
+ *                into a preset the first time the panel is opened.
+ *   - `PUT`    → replace the whole `modelRoles` map. This is what applying a
+ *                preset does, and what the per-row editors do with one entry
+ *                changed; there is no per-role verb, because config.yml's map is
+ *                written whole either way.
+ *   - `POST`   → save a preset (`{ preset: { id?, name, roles } }`).
+ *   - `DELETE` → remove a preset by `?id=`.
+ */
 export async function loader(_args: LoaderFunctionArgs) {
   try {
-    return json(await readModelRoles());
+    // Roles first: the seed snapshots them, and the presets list is read after
+    // it so the seeded row is in the very first payload the panel renders.
+    const [{ path, roles }, catalog] = await Promise.all([
+      readModelRoles(),
+      readModelRoleCandidates(),
+    ]);
+    await seedPresetFromCurrentRoles(roles);
+    const presets = await listModelRolePresets();
+    const payload: ModelRolesPayload = {
+      path,
+      roles,
+      presets,
+      candidates: catalog.candidates,
+      candidatesError: catalog.error,
+    };
+    return json(payload);
   } catch (error) {
     return json({ error: String(error) }, { status: 400 });
   }
 }
 
 export async function action({ request, params }: ActionFunctionArgs) {
-  if (request.method !== 'PUT') {
-    return methodNotAllowed({ request, params });
-  }
   try {
-    const body = await request.json() as { roles?: unknown };
-    if (!body.roles || typeof body.roles !== 'object' || Array.isArray(body.roles)) {
-      return json({ error: 'roles must be an object' }, { status: 400 });
-    }
-    const roles = Object.fromEntries(Object.entries(body.roles).filter((entry): entry is [string, string] =>
-      typeof entry[1] === 'string' && entry[0].trim().length > 0 && entry[1].trim().length > 0,
-    ));
-    await writeModelRoles(roles);
-    return json({ success: true, roles });
+    if (request.method === 'PUT') return await saveRoles(request);
+    if (request.method === 'POST') return await savePreset(request);
+    if (request.method === 'DELETE') return await removePreset(request);
+    return methodNotAllowed({ request, params });
   } catch (error) {
-    return json({ error: String(error) }, { status: 400 });
+    return json({ error: error instanceof Error ? error.message : String(error) }, { status: 400 });
   }
 }
+
+async function saveRoles(request: Request): Promise<Response> {
+  const body = await request.json() as { roles?: unknown };
+  const roles = normalizeRoleMap(body.roles);
+  await writeModelRoles(roles);
+  return json({ success: true, roles });
+}
+
+async function savePreset(request: Request): Promise<Response> {
+  const body = await request.json() as { preset?: unknown };
+  const preset = typeof body.preset === 'object' && body.preset !== null ? body.preset : null;
+  if (!preset) return json({ error: 'preset is required' }, { status: 400 });
+  const draft = preset as Record<string, unknown>;
+  const stored = await saveModelRolePreset({
+    id: typeof draft.id === 'string' && draft.id ? draft.id : null,
+    name: draft.name,
+    roles: draft.roles,
+  });
+  return json({ success: true, preset: stored, presets: await listModelRolePresets() });
+}
+
+async function removePreset(request: Request): Promise<Response> {
+  const id = new URL(request.url).searchParams.get('id');
+  if (!id) return json({ error: 'id is required' }, { status: 400 });
+  const removed = await deleteModelRolePreset(id);
+  if (!removed) return json({ error: 'Preset not found' }, { status: 404 });
+  return json({ success: true, presets: await listModelRolePresets() });
+}

package/src/server/routes/panels/css.test.ts

@@ -60,19 +60,19 @@ function call(loader: (args: never) => unknown, params: Record<string, string>)
   return loader({ params, request: new Request('http://local/') } as never) as Promise<Response>;
 }
 
-beforeEach(() => {
+beforeEach(async () => {
   root = fs.mkdtempSync(join(tmpdir(), 'omc-panel-css-'));
   bundled = fs.mkdtempSync(join(tmpdir(), 'omc-panel-store-'));
   process.env.KABMO_MARKETPLACE_DIR = root;
   process.env.KABMO_BUNDLED_MARKETPLACE_DIR = bundled;
   // A database of this suite's own, BEFORE the first scan: the scan reads the
   // disabled set, and a path set while a cached handle exists is never read.
-  isolateDb();
+  await isolateDb();
   invalidatePanelScan();
 });
 
-afterEach(() => {
-  releaseDb();
+afterEach(async () => {
+  await releaseDb();
   delete process.env.KABMO_MARKETPLACE_DIR;
   delete process.env.KABMO_BUNDLED_MARKETPLACE_DIR;
   invalidatePanelScan();

package/src/server/routes/panels/panel-routes.test-util.ts

@@ -104,19 +104,19 @@ export { getMarketplacePluginsDir };
  *   entry makes a later "no errors" assertion pass or fail for the wrong reason.
  */
 export function usePanelRouteFixtures(): void {
-  beforeEach(() => {
+  beforeEach(async () => {
     dirs.root = fs.mkdtempSync(join(tmpdir(), 'omc-panel-routes-'));
     dirs.bundled = fs.mkdtempSync(join(tmpdir(), 'omc-panel-store-'));
     process.env.KABMO_MARKETPLACE_DIR = dirs.root;
     process.env.KABMO_BUNDLED_MARKETPLACE_DIR = dirs.bundled;
-    isolateDb();
+    await isolateDb();
     invalidatePanelScan();
   });
 
   afterEach(async () => {
     await disposeAllPlugins();
     globalThis.__kabmoPluginLoadErrors = undefined;
-    releaseDb();
+    await releaseDb();
     delete process.env.KABMO_MARKETPLACE_DIR;
     delete process.env.KABMO_BUNDLED_MARKETPLACE_DIR;
     invalidatePanelScan();

package/src/server/routes/panels/routes.test.ts

@@ -132,13 +132,6 @@ describe('the README route', () => {
 
     expect((await call(readmeLoader, { plugin: 'demo', '*': '../outside.md' })).status).toBe(403);
   });
-
-  test('404s a plugin that ships no README', async () => {
-    const dir = writePlugin('demo', getMarketplacePluginsDir());
-    fs.rmSync(join(dir, 'README.md'));
-    invalidatePanelScan();
-    expect((await call(readmeLoader, { plugin: 'demo', '*': 'README.md' })).status).toBe(404);
-  });
 });
 
 describe('the install route', () => {