npm - ompchamber - Versions diffs - 2.0.2 → 3.0.0 - Mend

ompchamber 2.0.2 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (329) hide show

package/src/server/plugins/ssr.ts CHANGED Viewed

@@ -1,42 +1,26 @@
 import { Elysia } from 'elysia';
-import { join } from 'path';
 import { getDb } from '@/server/db.server';
 import { tryServeStatic } from '@/server/plugins/static';
-import { tryProxyDevAsset } from '@/server/plugins/dev-assets';
+import { renderShell } from '@/server/plugins/shell.server';
+import { FONT_STYLESHEET_ROUTE } from '@/server/lib/assets/font-css.server';
 import { resolveTheme } from '@/shared/lib/theme/catalog';
 import { THEME_STYLE_ELEMENT_ID, themeStyleSheet } from '@/shared/lib/theme/css';
-const CLIENT_INDEX = join(process.cwd(), 'dist/client/index.html');
-let cachedTemplate: string | null = null;
-let cachedMtimeMs = 0;
 /**
- * Cached, but invalidated on mtime so `rsbuild build --watch` (the dev loop)
- * picks up a new asset manifest without restarting the server.
+ * Actionable message instead of a bare 500 when the shell cannot be rendered.
+ *
+ * The shell is a Bun HTML route now, not a file on disk, so "not found" is no
+ * longer the failure mode — a bundle error is, and Bun renders its own error
+ * page for that. This covers the remaining path: the bundle is fine but the
+ * markup could not be read back.
  */
-async function readTemplate(): Promise<string> {
-  const file = Bun.file(CLIENT_INDEX);
-  if (!(await file.exists())) {
-    throw new Error(`Client build not found at ${CLIENT_INDEX}. Run \`bun run build\` first.`);
-  }
-  const { mtimeMs } = await file.stat();
-  if (cachedTemplate !== null && mtimeMs === cachedMtimeMs) return cachedTemplate;
-  cachedTemplate = await file.text();
-  cachedMtimeMs = mtimeMs;
-  return cachedTemplate;
-}
-/** Actionable message instead of a bare 500 when the client build is absent. */
-function missingBuildResponse(): Response {
+function shellUnavailableResponse(reason: string): Response {
   return new Response(
     `<!doctype html><meta charset="utf-8"><title>OMPChamber</title>
 <body style="font:14px/1.6 ui-monospace,monospace;padding:2rem">
-<h1 style="font-size:1.1rem">Client build not found</h1>
-<p>The server needs <code>dist/client</code> before it can render pages.</p>
-<pre style="background:#f4f1ea;padding:1rem;border-radius:6px">bun run build</pre>
-<p>For a rebuild-on-change loop while developing:</p>
-<pre style="background:#f4f1ea;padding:1rem;border-radius:6px">bunx rsbuild build --watch</pre>
+<h1 style="font-size:1.1rem">Shell not available</h1>
+<p>The server could not render its HTML shell.</p>
+<pre style="background:#f4f1ea;padding:1rem;border-radius:6px">${reason}</pre>
 </body>`,
     { status: 503, headers: HTML_HEADERS },
   );
@@ -102,11 +86,6 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
   const asset = await tryServeStatic(pathname);
   if (asset) return asset;
-  const devAsset = await tryProxyDevAsset(request, pathname);
-  if (devAsset) return devAsset;
-  if (!(await Bun.file(CLIENT_INDEX).exists())) return missingBuildResponse();
   const settings = await readSettings();
   const chamberSettings = (settings.omp_chamber_settings ?? {}) as { theme?: string };
   // Resolved through the catalog: an id this build no longer ships (a
@@ -115,19 +94,28 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
   const theme = resolveTheme(chamberSettings.theme);
   const initialIsMobile = MOBILE_UA.test(request.headers.get('user-agent') ?? '');
-  const template = await readTemplate();
+  const rendered = await renderShell();
+  if (!rendered.ok) return shellUnavailableResponse(rendered.reason);
   const bootstrap = JSON.stringify({ initialIsMobile, 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.
   const themeStyle = `<style id="${THEME_STYLE_ELEMENT_ID}">${themeStyleSheet()}</style>`;
+  // The font faces are a stylesheet the bundler cannot carry: Bun resolves every
+  // local `url()` in CSS, so a bundled face is either base64 or an absolute
+  // filesystem path. `lib/bundler/css.ts` lifts the blocks out and the route
+  // below serves them, which is why the link is injected here — a
+  // `<link href="/fonts.css">` in index.html would be resolved by the HTML
+  // loader and fail the same way.
+  const fontLink = `<link rel="stylesheet" href="${FONT_STYLESHEET_ROUTE}">`;
   return new Response(
-    template
+    rendered.html
       .replace('data-theme="paper"', `data-theme="${theme.id}"`)
       .replace('data-theme-variant="light"', `data-theme-variant="${theme.variant}"`)
       .replace('<meta name="theme-color" content="#faf8f3" />', `<meta name="theme-color" content="${theme.canvas}" />`)
-      .replace('<!--app-head-->', themeStyle)
+      .replace('<!--app-head-->', themeStyle + fontLink)
       .replace('<!--app-bootstrap-->', `<script>window.__OMP_BOOTSTRAP__=${bootstrap}</script>`),
     { headers: HTML_HEADERS },
   );

package/src/server/plugins/static.test.ts CHANGED Viewed

@@ -5,40 +5,37 @@ import { join } from 'path';
 import { servePublicAsset } from '@/server/plugins/static';
-// Two roots, as they exist in real life: `public/` is the source folder a
-// checkout has, `dist/client` is the build output an installed package ships.
-const CHECKOUT_PUBLIC = join(mkdtempSync(join(tmpdir(), 'omp-static-')), 'public');
-const BUILD_OUTPUT = join(mkdtempSync(join(tmpdir(), 'omp-static-')), 'dist/client');
-const ROOTS = [CHECKOUT_PUBLIC, BUILD_OUTPUT] as const;
+// `public/` is the only asset root now: the client bundle is served by Bun's own
+// routing table (`/_bun/*` in dev, `/chunk-*` in production), so there is no
+// second build-output root to fall back to.
+const PUBLIC_DIR = join(mkdtempSync(join(tmpdir(), 'omp-static-')), 'public');
+const ROOTS = [PUBLIC_DIR] as const;
 beforeAll(() => {
-  mkdirSync(CHECKOUT_PUBLIC, { recursive: true });
-  mkdirSync(BUILD_OUTPUT, { recursive: true });
-  writeFileSync(join(CHECKOUT_PUBLIC, 'icon.svg'), '<svg id="checkout"/>');
-  writeFileSync(join(BUILD_OUTPUT, 'icon.svg'), '<svg id="build"/>');
-  writeFileSync(join(BUILD_OUTPUT, 'manifest.webmanifest'), '{"name":"OMPChamber"}');
-  writeFileSync(join(BUILD_OUTPUT, 'index.html'), '<!doctype html><title>shell</title>');
+  mkdirSync(PUBLIC_DIR, { recursive: true });
+  writeFileSync(join(PUBLIC_DIR, 'icon.svg'), '<svg id="public"/>');
+  writeFileSync(join(PUBLIC_DIR, 'manifest.webmanifest'), '{"name":"OMPChamber"}');
+  writeFileSync(join(PUBLIC_DIR, 'sw.js'), 'self.addEventListener("fetch", () => {});');
+  writeFileSync(join(PUBLIC_DIR, 'index.html'), '<!doctype html><title>shell</title>');
 });
 afterAll(() => {
-  rmSync(CHECKOUT_PUBLIC, { recursive: true, force: true });
-  rmSync(BUILD_OUTPUT, { recursive: true, force: true });
+  rmSync(PUBLIC_DIR, { recursive: true, force: true });
 });
 describe('servePublicAsset', () => {
-  // The bug this guards: an installed `ompchamber` has no `public/` folder, so a
-  // lookup confined to it answered the HTML shell for `/icon.svg` and the About
-  // modal rendered a broken image.
-  test('falls back to the build output when the source folder has no copy', async () => {
-    const response = await servePublicAsset('/manifest.webmanifest', ROOTS);
-    expect(response?.headers.get('content-type')).toBe('application/manifest+json');
-    expect(await response?.text()).toBe('{"name":"OMPChamber"}');
-  });
-  test('prefers the source folder so a dev edit lands without a rebuild', async () => {
+  test('serves a public asset with its own content type', async () => {
     const response = await servePublicAsset('/icon.svg', ROOTS);
     expect(response?.headers.get('content-type')).toBe('image/svg+xml');
-    expect(await response?.text()).toBe('<svg id="checkout"/>');
+    expect(await response?.text()).toBe('<svg id="public"/>');
+  });
+  test('serves the web manifest and the service worker', async () => {
+    expect((await servePublicAsset('/manifest.webmanifest', ROOTS))?.headers.get('content-type'))
+      .toBe('application/manifest+json');
+    // The service worker is only referenced from an inline script in the shell,
+    // so the HTML loader never copies it — this route is what serves it.
+    expect(await (await servePublicAsset('/sw.js', ROOTS))?.text()).toContain('addEventListener');
   });
   test('leaves the HTML shell to the SSR route', async () => {
@@ -46,14 +43,14 @@ describe('servePublicAsset', () => {
   });
   test('keeps a sibling of the root unreachable', async () => {
-    const outside = join(BUILD_OUTPUT, '..', 'secret.txt');
+    const outside = join(PUBLIC_DIR, '..', 'secret.txt');
     writeFileSync(outside, 'not an asset');
-    expect(await servePublicAsset('/../secret.txt', [BUILD_OUTPUT])).toBeNull();
-    expect(await servePublicAsset('/%2e%2e/secret.txt', [BUILD_OUTPUT])).toBeNull();
+    expect(await servePublicAsset('/../secret.txt', ROOTS)).toBeNull();
+    expect(await servePublicAsset('/%2e%2e/secret.txt', ROOTS)).toBeNull();
   });
-  test('short-caches the fallback, whose filename carries no content hash', async () => {
-    const response = await servePublicAsset('/manifest.webmanifest', ROOTS);
+  test('short-caches, because these filenames carry no content hash', async () => {
+    const response = await servePublicAsset('/icon.svg', ROOTS);
     expect(response?.headers.get('cache-control')).toBe('public, max-age=3600');
   });

package/src/server/plugins/static.ts CHANGED Viewed

@@ -1,21 +1,35 @@
 import { extname, join, normalize, resolve, sep } from 'path';
+import { FONT_STYLESHEET_ROUTE, serveFontFile, serveFontStylesheet } from '@/server/lib/assets/font-css.server';
+import { FONT_ROUTE_PREFIX, packageRoot } from '@/server/lib/assets/fonts.server';
 /**
- * File serving for `dist/client` (hashed, immutable) and `public/`.
+ * File serving for `public/` and the font routes.
+ *
+ * The client bundle is NOT served from here any more. Bun's own routing owns
+ * the assets it emits — `/_bun/asset/*` and `/_bun/client/*` in development,
+ * `/chunk-*` in production — and answers them from its bundle table before a
+ * request reaches Elysia. `dist/client` no longer exists, so the `/static/`
+ * branch and its content-hashed caching went with it.
  *
  * Hand-rolled rather than `@elysiajs/static`: that plugin registers its own
  * catch-all, which would shadow this app's SSR route. Exposing one lookup
  * function lets the web catch-all try a file first and fall back to the shell.
  */
-const CLIENT_ROOT = resolve('dist/client');
-const PUBLIC_ROOT = resolve('public');
+// Resolved from the package root, not the cwd: `serve --prod` may run the built
+// server from anywhere, and a cwd-relative `public` would not exist — every
+// icon, the manifest and the service worker would 404.
+const PUBLIC_ROOT = resolve(packageRoot(), 'public');
+/** Where `scripts/build-client.ts` writes the production bundle and its chunks. */
+const CLIENT_ROOT = resolve(packageRoot(), 'dist', 'client');
 const IMMUTABLE = 'public, max-age=31536000, immutable';
 const SHORT = 'public, max-age=3600';
-// Only production output carries content hashes in its filenames. Dev output
-// keeps stable names (`static/js/index.js`), so an immutable response there
-// pins a stale bundle in the browser and the dev loop silently stops updating.
+// Production output carries content hashes in its filenames, so it can be
+// cached hard. In development these paths are served by Bun's own table and
+// this branch is not reached at all — a stable-name dev asset must never be
+// pinned, which is why the distinction is kept here.
 const ASSET_CACHE = Bun.env.NODE_ENV === 'production' ? IMMUTABLE : 'no-store';
 const MIME: Record<string, string> = {
@@ -68,22 +82,13 @@ async function serveFile(filePath: string, cacheControl: string): Promise<Respon
   });
 }
-/** Roots searched for a non-`/static/` asset, in preference order. */
-const PUBLIC_ROOTS = [PUBLIC_ROOT, CLIENT_ROOT] as const;
 /**
  * The first readable copy of `pathname` under `roots`, or null.
  *
  * Non-`/static/` paths are the public assets (`icon.svg`, the web manifest, the
- * service worker, the touch icons). They exist twice: `public/` in a checkout
- * and `dist/client/` in the build — and only the latter ships, because
- * `package.json#files` lists `src`, `dist/client` and `tsconfig.json`. Serving
- * `public/` alone therefore 404s every one of them into the SSR shell when the
- * chamber runs from an installed package. The source folder is tried first so a
- * dev edit lands without a rebuild; the build output is the fallback. HTML is
- * excluded so `/index.html` keeps going through the SSR route that injects the
- * theme and bootstrap, and the cache stays short because these filenames carry
- * no content hash.
+ * service worker, the touch icons). HTML is excluded so `/index.html` keeps
+ * going through the SSR route that injects the theme and bootstrap, and the
+ * cache stays short because these filenames carry no content hash.
  */
 export async function servePublicAsset(pathname: string, roots: readonly string[]): Promise<Response | null> {
   for (const root of roots) {
@@ -97,9 +102,25 @@ export async function servePublicAsset(pathname: string, roots: readonly string[
 /** A file for `pathname`, or null when the request should reach the app. */
 export async function tryServeStatic(pathname: string): Promise<Response | null> {
+  // The production bundle's own assets. `scripts/build-client.ts` emits the
+  // server into `dist/client` with its chunks under `dist/client/static`, and
+  // the generated HTML references them as `./static/...` — a page URL of `/`
+  // makes that `/static/...`, which is this branch. In development the same
+  // files are served by Bun's own routing table (`/_bun/asset/*`,
+  // `/_bun/client/*`) and never reach here.
   if (pathname.startsWith('/static/')) {
     const filePath = resolveWithin(CLIENT_ROOT, pathname);
     return filePath ? serveFile(filePath, ASSET_CACHE) : null;
   }
-  return servePublicAsset(pathname, PUBLIC_ROOTS);
+  // The extracted `@font-face` stylesheet and the files it names. Bun's CSS
+  // loader cannot carry either — every local `url()` is resolved, so a bundled
+  // face is base64 or an absolute path — which is why they are served rather
+  // than emitted. Both live outside `public/`: the stylesheet is assembled from
+  // the faces `lib/bundler/css.ts` wrote, and the files come from the installed
+  // packages.
+  if (pathname === FONT_STYLESHEET_ROUTE) return serveFontStylesheet();
+  if (pathname.startsWith(FONT_ROUTE_PREFIX)) {
+    return serveFontFile(decodeURIComponent(pathname.slice(FONT_ROUTE_PREFIX.length)));
+  }
+  return servePublicAsset(pathname, [PUBLIC_ROOT]);
 }

package/src/server/routes/settings/index.ts CHANGED Viewed

@@ -9,6 +9,7 @@ import * as settingsMcpTest from '@/server/routes/settings/mcp-test';
 import * as settingsOmpConfig from '@/server/routes/settings/omp-config';
 import * as settingsProjects from '@/server/routes/settings/projects';
 import * as settingsProviderModels from '@/server/routes/settings/provider-models';
+import * as settingsProviderModel from '@/server/routes/settings/provider-model';
 import * as settingsProviders from '@/server/routes/settings/providers';
 import * as settingsSkills from '@/server/routes/settings/skills';
 import * as settingsUsage from '@/server/routes/settings/usage';
@@ -24,6 +25,7 @@ export const settingsBindings: HandlerBinding[] = [
   ...bindingsFor(settingsOmpConfig, '/api/settings/omp-config'),
   ...bindingsFor(settingsProjects, '/api/settings/projects'),
   ...bindingsFor(settingsProviderModels, '/api/settings/provider-models'),
+  ...bindingsFor(settingsProviderModel, '/api/settings/provider-model'),
   ...bindingsFor(settingsProviders, '/api/settings/providers'),
   ...bindingsFor(settingsSkills, '/api/settings/skills'),
   ...bindingsFor(settingsUsage, '/api/settings/usage'),

package/src/server/routes/settings/provider-model.ts ADDED Viewed

@@ -0,0 +1,107 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { isMockMode } from '@/server/mock.server';
+import { upsertOmpProviderModels } from '@/server/lib/omp/config/providers';
+import { manualModelSeed } from '@/server/lib/omp/config/provider-seeds';
+import { readNativeProviders } from '@/server/lib/omp/config/models-config';
+import { isProviderAuthMode, isProviderThinkingEffort } from '@/shared/lib/models/provider/dialect';
+import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+/**
+ * POST /api/settings/provider-model — register ONE model by hand.
+ *
+ * A provider endpoint does not have to be listable to be usable: a gateway may
+ * serve a model its `/models` route omits, a deployment may be named locally
+ * (Azure), or the endpoint may have no listing route at all (Bedrock, Vertex).
+ * The "Add model" dialog is that path, and it writes the same models.yml entry
+ * the auto-fetch would.
+ *
+ * Body: { provider, id, name?, contextWindow?, maxTokens?, reasoning?,
+ *   imageInput?, efforts?, costInput?, costOutput?, costCacheRead?,
+ *   costCacheWrite?, baseUrl?, apiKey?, auth? }
+ *   → { success, written, addedModels, alreadyKnown, reason? }
+ *
+ * `baseUrl`/`apiKey`/`auth` are only used when the provider has no models.yml
+ * entry yet — an existing entry keeps its own endpoint and credential (the
+ * writer is add-only). Registering the FIRST model under a provider omp only
+ * knows from its bundled catalog therefore needs a real endpoint and key; the
+ * refusal says so instead of writing half an entry.
+ */
+/** Context/output limits arrive as token counts; anything unusable is dropped. */
+function positiveInt(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.round(value) : undefined;
+}
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method !== 'POST') {
+    return methodNotAllowed({ request, params });
+  }
+  try {
+    const body = await request.json() as Record<string, unknown>;
+    const provider = typeof body.provider === 'string' ? body.provider.trim() : '';
+    const id = typeof body.id === 'string' ? body.id.trim() : '';
+    if (!provider || !id) {
+      return json({ error: 'provider and model id are required' }, { status: 400 });
+    }
+    const rawEfforts = Array.isArray(body.efforts) ? body.efforts : [];
+    const seed = manualModelSeed({
+      id,
+      name: typeof body.name === 'string' ? body.name : undefined,
+      contextWindow: positiveInt(body.contextWindow),
+      maxTokens: positiveInt(body.maxTokens),
+      reasoning: body.reasoning === true,
+      imageInput: body.imageInput === true,
+      // An effort outside omp's vocabulary is dropped rather than written: the
+      // schema rejects the whole file over one unknown level.
+      efforts: rawEfforts.filter(isProviderThinkingEffort),
+      costInput: typeof body.costInput === 'number' ? body.costInput : undefined,
+      costOutput: typeof body.costOutput === 'number' ? body.costOutput : undefined,
+      costCacheRead: typeof body.costCacheRead === 'number' ? body.costCacheRead : undefined,
+      costCacheWrite: typeof body.costCacheWrite === 'number' ? body.costCacheWrite : undefined,
+    });
+    // Mock mode has no models.yml; the caller's own overlay row is the store.
+    if (isMockMode()) {
+      return json({ success: true, written: false, isMock: true, addedModels: [seed.id] });
+    }
+    // Read the registry BEFORE writing: `skippedModels` means "not added", not
+    // "already there" — the writer also skips when it refuses to create a
+    // provider it has no endpoint or credential for. The pre-write file is what
+    // tells a genuine duplicate apart from that refusal, and reading it after
+    // the write would count the model this call just added.
+    const registeredBefore = await readNativeProviders();
+    const alreadyKnown = registeredBefore
+      .find((info) => info.slug === provider)
+      ?.modelIds.includes(seed.id) === true;
+    const result = await upsertOmpProviderModels(provider, {
+      baseUrl: typeof body.baseUrl === 'string' ? body.baseUrl.trim() : '',
+      // A provider the chamber overlay knows but models.yml does not needs the
+      // credential to be created; a provider already in the file keeps its own
+      // (the writer is add-only). A masked placeholder is dropped by the writer
+      // rather than persisted as a credential.
+      apiKey: typeof body.apiKey === 'string' && body.apiKey.trim() ? body.apiKey.trim() : undefined,
+      ...(isProviderAuthMode(body.auth) ? { auth: body.auth } : {}),
+      overrideOnly: false,
+      models: [seed],
+    });
+    if (result.written) invalidateModelsCaches();
+    return json({
+      success: result.written || alreadyKnown,
+      written: result.written,
+      addedModels: result.addedModels,
+      backfilledModels: result.backfilledModels,
+      alreadyKnown,
+      reason: alreadyKnown
+        ? `${seed.id} is already registered under "${provider}" in models.yml`
+        : result.reason,
+    }, { status: result.written || alreadyKnown ? 200 : 400 });
+  } catch (error) {
+    return json({ error: error instanceof Error ? error.message : String(error) }, { status: 400 });
+  }
+}