@kabmo-labs/kabmo 0.0.0-stage → 0.1.0

package/src/server/routes/fs/search.test.ts

@@ -0,0 +1,210 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The search route's line parser: what a hit's text and its highlight ranges
+ * become by the time the panel sees them — plus the argument vector the route
+ * hands ripgrep, which is where a symbol query used to break.
+ *
+ * Two rules are asserted here because both fail silently on screen — the row
+ * paints the wrong word rather than erroring:
+ *
+ * - ripgrep reports submatches in BYTES, and a line with one multi-byte
+ *   character before the match shifts every range after it.
+ * - `content` is trimmed before it travels, so the ranges must be shifted onto
+ *   the trimmed text rather than left as offsets into the raw line.
+ *
+ * The `buildArgs` block is the regression net for a third: rg's positional
+ * parser reads a `-`-leading token as a FLAG, so `-webkit-transform` searched
+ * for `bkit-transform`, `--help` printed rg's help, and `->` exited 2. The
+ * assertions are on the ARGUMENT VECTOR and on a real run, because the failure
+ * mode was a plausible-looking empty result rather than an exception.
+ */
+
+import { afterAll, describe, expect, test } from 'bun:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { buildArgs, parseRgLine } from '@/server/routes/fs/search';
+import { runRipgrep } from '@/server/lib/fs/ripgrep';
+
+const tempDirs: string[] = [];
+
+function tempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kabmo-search-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+/** Run `buildArgs`' output the way the route does, collecting match frames. */
+async function runQuery(dir: string, q: string, opts: { useRegex?: boolean; wholeWord?: boolean; matchCase?: boolean; includeFiles?: string } = {}) {
+  let stdout = '';
+  let stderr = '';
+  const decoder = new TextDecoder();
+  const code = await runRipgrep(
+    buildArgs(q, opts.matchCase ?? false, opts.wholeWord ?? false, opts.useRegex ?? false, opts.includeFiles ?? ''),
+    dir,
+    {
+      onStdout(chunk) {
+        stdout += decoder.decode(chunk, { stream: true });
+      },
+      onStderr(chunk) {
+        stderr += decoder.decode(chunk, { stream: true });
+      },
+    },
+  );
+  const matches = stdout.split('\n').filter((line) => line.includes('"type":"match"'));
+  return { code, matches, stderr, jsonOnly: stdout.trim() === '' || stdout.trimStart().startsWith('{') };
+}
+
+afterAll(() => {
+  for (const dir of tempDirs) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe('buildArgs', () => {
+  test('the pattern rides the --regexp flag, never the positional slot', () => {
+    const args = buildArgs('useFoo(', false, false, false, '');
+    expect(args).toContain('--regexp=useFoo(');
+    // The positional slot is what let rg read a `-`-leading query as a flag.
+    expect(args).not.toContain('useFoo(');
+    expect(args.at(-1)).toBe('.');
+  });
+
+  test('literal mode adds -F; regex mode adds neither -F nor -e', () => {
+    expect(buildArgs('x', false, false, false, '')).toContain('-F');
+    const regex = buildArgs('x', false, false, true, '');
+    expect(regex).not.toContain('-F');
+    expect(regex).not.toContain('-e');
+    expect(regex).toContain('--regexp=x');
+  });
+
+  test('the flags still travel', () => {
+    expect(buildArgs('x', true, false, false, '')).not.toContain('-i');
+    expect(buildArgs('x', false, false, false, '')).toContain('-i');
+    expect(buildArgs('x', false, true, false, '')).toContain('-w');
+  });
+
+  test('includeFiles becomes one glob per comma-separated entry, trimmed', () => {
+    const base = buildArgs('x', false, false, false, '');
+    const args = buildArgs('x', false, false, false, '*.ts, src/*.md ,');
+    // Three exclusion globs ride every search; the two include entries add two.
+    expect(args.filter((a) => a === '--glob')).toHaveLength(base.filter((a) => a === '--glob').length + 2);
+    expect(args).toContain('*.ts');
+    expect(args).toContain('src/*.md');
+  });
+});
+
+describe('dash-leading queries reach ripgrep as a pattern', () => {
+  const dir = tempDir();
+  fs.writeFileSync(
+    path.join(dir, 'code.ts'),
+    ['const webkit = "-webkit-transform: none;",', 'const help = "--help flag",', 'const arrow = (a) -> b;', 'const flag = "-i literal";', ''].join('\n'),
+  );
+
+  for (const q of ['-webkit-transform', '--help', '->', '-i']) {
+    test(`a literal search for ${JSON.stringify(q)} returns its line`, async () => {
+      const run = await runQuery(dir, q);
+      // Exit 2 is rg refusing the vector; a non-JSON stdout is rg printing help
+      // or its version instead of match frames.
+      expect(run.jsonOnly).toBe(true);
+      expect(run.code).not.toBe(2);
+      expect(run.matches.length).toBeGreaterThan(0);
+    });
+  }
+
+  test('a query that is only dashes still searches literally', async () => {
+    const dashDir = tempDir();
+    fs.writeFileSync(path.join(dashDir, 'd.txt'), 'a - b\nc -- d\n');
+    const single = await runQuery(dashDir, '-');
+    expect(single.code).not.toBe(2);
+    expect(single.matches.length).toBeGreaterThan(0);
+  });
+});
+
+describe('symbol queries are literal by default', () => {
+  const dir = tempDir();
+  fs.writeFileSync(path.join(dir, 'code.ts'), ['const x = useFoo();', 'const y = arr[i];', 'const p = a ** b;', 'const o = obj?.field;', 'class Foo(Bar) {}', ''].join('\n'));
+
+  for (const q of ['useFoo(', 'arr[i]', '**', '?.', 'Foo(Bar)']) {
+    test(`${JSON.stringify(q)} matches without being read as a regex`, async () => {
+      const run = await runQuery(dir, q);
+      // Exit 2 here would be rg's "regex parse error" — the shape the panel
+      // used to render as "No results found.".
+      expect(run.code).not.toBe(2);
+      expect(run.jsonOnly).toBe(true);
+      expect(run.matches.length).toBeGreaterThan(0);
+    });
+  }
+
+  test('regex mode still refuses an unescaped metacharacter, quoting rg verbatim', async () => {
+    const run = await runQuery(dir, 'useFoo(', { useRegex: true });
+    expect(run.code).toBe(2);
+    expect(run.stderr).toContain('regex parse error');
+  });
+});
+
+/** One rg match frame, as `rg --json` emits it. */
+function frame(lineText: string, submatches: { start: number; end: number }[]) {
+  return JSON.stringify({
+    type: 'match',
+    data: {
+      path: { text: './src/alpha.ts' },
+      line_number: 12,
+      lines: { text: lineText },
+      submatches,
+    },
+  });
+}
+
+describe('parseRgLine', () => {
+  test('strips the leading ./ from the path and trims the line', () => {
+    const match = parseRgLine(frame('    const alpha = 1;\n', [{ start: 10, end: 15 }]));
+
+    expect(match).toEqual({
+      file: 'src/alpha.ts',
+      line: '12',
+      content: 'const alpha = 1;',
+      ranges: [{ start: 6, end: 11 }],
+    });
+  });
+
+  test('shifts ranges by the indentation the trim removed', () => {
+    const match = parseRgLine(frame('\t\talpha beta alpha\n', [{ start: 2, end: 7 }, { start: 13, end: 18 }]));
+
+    expect(match?.ranges).toEqual([{ start: 0, end: 5 }, { start: 11, end: 16 }]);
+  });
+
+  test('converts ripgrep byte offsets to character offsets', () => {
+    // `é` is two bytes, so a byte range of 3..8 is characters 2..7.
+    const raw = 'é alpha\n';
+    const match = parseRgLine(frame(raw, [{ start: 3, end: 8 }]));
+
+    expect(match?.content).toBe('é alpha');
+    expect(match?.ranges).toEqual([{ start: 2, end: 7 }]);
+  });
+
+  test('drops a range the trim left outside the text', () => {
+    // A match that was only trailing whitespace has nothing left to paint.
+    const match = parseRgLine(frame('alpha   \n', [{ start: 7, end: 8 }]));
+
+    expect(match?.content).toBe('alpha');
+    expect(match?.ranges).toEqual([]);
+  });
+
+  test('a frame with no submatches still yields the line', () => {
+    const match = parseRgLine(JSON.stringify({
+      type: 'match',
+      data: { path: { text: './a.ts' }, line_number: 1, lines: { text: 'alpha\n' } },
+    }));
+
+    expect(match).toEqual({ file: 'a.ts', line: '1', content: 'alpha', ranges: [] });
+  });
+
+  test('non-match frames are ignored', () => {
+    expect(parseRgLine(JSON.stringify({ type: 'begin', data: { path: { text: './a.ts' } } }))).toBeNull();
+    expect(parseRgLine('not json')).toBeNull();
+  });
+});

package/src/server/routes/fs/search.ts

@@ -0,0 +1,205 @@
+import { json, type ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { isMockMode } from '@/server/mock.server';
+import { getDefaultFsRoot, resolveRoot } from '@/server/lib/fs/root';
+import { scopeToRepo } from '@/server/lib/fs/repo-scope';
+import { runRipgrep } from '@/server/lib/fs/ripgrep';
+import { createSseStream } from '@/server/lib/sse';
+import { MAX_SEARCH_RESULTS } from '@/shared/lib/fs/search-list';
+
+export interface SearchMatch {
+  file: string;
+  line: string;
+  content: string;
+  /** Character ranges within `content` the query matched, in document order. */
+  ranges: { start: number; end: number }[];
+}
+
+interface RgSubmatch {
+  start?: number;
+  end?: number;
+}
+
+interface RgMatchFrame {
+  type: string;
+  data?: {
+    path?: { text?: string };
+    line_number?: number;
+    lines?: { text?: string };
+    /** Byte offsets within `lines.text`, one entry per occurrence on the line. */
+    submatches?: RgSubmatch[];
+  };
+}
+
+const UTF8_ENCODER = new TextEncoder();
+const UTF8_DECODER = new TextDecoder();
+
+/**
+ * The line as every consumer displays it, with the match ranges shifted onto
+ * it — `content` has its surrounding whitespace and line terminator dropped, so
+ * `ranges` are character offsets into exactly the string that travels beside
+ * them. Trimming on the CLIENT instead would misplace every highlight by the
+ * width of the indentation, since the ranges would still be offsets into the
+ * untrimmed line.
+ *
+ * Ripgrep's own offsets are BYTES in the raw line, and bytes are only
+ * characters when it is pure ASCII: decoding the prefix is what keeps a line
+ * with one accented character from shifting every range after it by one. A
+ * range that no longer fits the trimmed text (a whitespace-only match) is
+ * dropped — there is nothing left on screen to paint.
+ */
+function trimWithRanges(raw: string, submatches: RgSubmatch[] | undefined): { content: string; ranges: { start: number; end: number }[] } {
+  const content = raw.trim();
+  const lead = raw.length - raw.trimStart().length;
+  if (!submatches || submatches.length === 0) return { content, ranges: [] };
+  const bytes = UTF8_ENCODER.encode(raw);
+  const ranges: { start: number; end: number }[] = [];
+  for (const submatch of submatches) {
+    const start = submatch.start;
+    const end = submatch.end;
+    if (typeof start !== 'number' || typeof end !== 'number' || end <= start) continue;
+    const from = UTF8_DECODER.decode(bytes.slice(0, start)).length - lead;
+    const to = from + UTF8_DECODER.decode(bytes.slice(start, end)).length;
+    if (from < 0 || to > content.length || to <= from) continue;
+    ranges.push({ start: from, end: to });
+  }
+  return { content, ranges };
+}
+
+/**
+ * Builds the rg argument vector from the search form fields. Flag semantics
+ * match the previous `grep -r` call: literal search by default, `-e` opts into
+ * regex, `-w` whole word, `-i` case-insensitive.
+ *
+ * The pattern travels as `--regexp=<q>`, never as the bare positional. rg's
+ * positional parser reads a token starting with `-` as a FLAG, so the queries a
+ * developer most often searches for by hand were the ones that broke, and they
+ * broke silently: `-webkit-transform` was taken as flags `-w`/`-e`/`-b`… with
+ * `bkit-transform` left as the pattern (exit 1, "No results found"), `--help`
+ * printed rg's help to stdout (exit 0, no match frames), and `->` exited 2 with
+ * "unrecognized flag". Attaching the value to the flag removes the positional
+ * slot entirely, so no query can be mistaken for an option. `-F` keeps literal
+ * mode; `--regexp` is rg's long spelling of `-e`, so regex mode is unchanged.
+ */
+export function buildArgs(q: string, matchCase: boolean, wholeWord: boolean, useRegex: boolean, includeFiles: string): string[] {
+  const args: string[] = ['--json', '--glob', '!node_modules/**', '--glob', '!.git/**', '--glob', '!dist/**'];
+  if (!matchCase) args.push('-i');
+  if (wholeWord) args.push('-w');
+  if (!useRegex) args.push('-F');
+  if (includeFiles) {
+    includeFiles.split(',').map(p => p.trim()).filter(Boolean).forEach(p => args.push('--glob', p));
+  }
+  args.push(`--regexp=${q}`, '.');
+  return args;
+}
+
+/**
+ * Parses one rg `--json` line into a match; null for begin/end/summary frames.
+ *
+ * Exported because the byte→character range conversion is the part of this
+ * route a client depends on for its highlights, and it is not observable
+ * through a live ripgrep run without a fixture directory per encoding case.
+ */
+export function parseRgLine(line: string): SearchMatch | null {
+  if (!line.startsWith('{')) return null;
+  try {
+    const frame = JSON.parse(line) as RgMatchFrame;
+    if (frame.type !== 'match') return null;
+    const data = frame.data;
+    const file = data?.path?.text;
+    const text = data?.lines?.text;
+    if (!file || text === undefined || data?.line_number === undefined) return null;
+    const { content, ranges } = trimWithRanges(text, data.submatches);
+    return {
+      file: file.replace(/^\.\//, ''),
+      line: String(data.line_number),
+      content,
+      ranges,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  const formData = await request.formData();
+  const q = formData.get('q') as string;
+  const matchCase = formData.get('matchCase') === 'true';
+  const wholeWord = formData.get('wholeWord') === 'true';
+  const useRegex = formData.get('useRegex') === 'true';
+  const includeFiles = formData.get('includeFiles') as string;
+
+  if (!q) {
+    return json({ results: [] });
+  }
+
+  let targetDir: string;
+  try {
+    const baseDir = await resolveRoot(formData.get('root') as string, await getDefaultFsRoot(isMockMode()));
+    targetDir = await scopeToRepo(baseDir, formData.get('repo') as string);
+  } catch (error: unknown) {
+    console.error(error);
+    return json({ error: String(error) }, { status: 500 });
+  }
+
+  // SSE frame per flushed batch so the panel paints results while rg is still
+  // walking the tree. `--json` output is line-delimited, so newline buffering
+  // suffices to slice match frames.
+  const stream = createSseStream({
+    headers: { 'Cache-Control': 'no-cache, no-transform' },
+    async onStart(handlers) {
+      const send = (event: string, data: unknown) => handlers.send(event, data);
+
+      const decoder = new TextDecoder();
+      let pending = '';
+      let count = 0;
+      let stderrText = '';
+      // The cap is the route's, so the panel and the server describe the same
+      // limit; `truncated` is reported on `done` rather than as its own frame,
+      // since it is a property of the run as a whole.
+      let truncated = false;
+      const cap = new AbortController();
+
+      try {
+        const code = await runRipgrep(buildArgs(q, matchCase, wholeWord, useRegex, includeFiles), targetDir, {
+          signal: cap.signal,
+          onStdout(chunk) {
+            if (truncated) return;
+            pending += decoder.decode(chunk, { stream: true });
+            const lines = pending.split('\n');
+            pending = lines.pop() ?? '';
+            const batch: SearchMatch[] = [];
+            for (const line of lines) {
+              const match = parseRgLine(line);
+              if (match) batch.push(match);
+            }
+            if (!batch.length) return;
+            // One batch may cross the cap; the overflow is dropped rather than
+            // overshooting it, so the number the notice prints is the number of
+            // hits the panel holds.
+            const room = MAX_SEARCH_RESULTS - count;
+            const accepted = batch.length > room ? batch.slice(0, room) : batch;
+            count += accepted.length;
+            if (accepted.length) send('matches', accepted);
+            if (accepted.length < batch.length) {
+              truncated = true;
+              cap.abort();
+            }
+          },
+          onStderr(chunk) {
+            stderrText += decoder.decode(chunk, { stream: true });
+          },
+        });
+        // rg exit codes: 0 = matches, 1 = no matches, 2 = error (bad regex, IO failure).
+        // A capped run was killed, so its signal code is not a failure.
+        if (code === 2 && !truncated) send('error', { error: stderrText.trim() || 'ripgrep failed' });
+      } catch (error: unknown) {
+        send('error', { error: String(error) });
+      }
+
+      send('done', { count, truncated, limit: MAX_SEARCH_RESULTS });
+      handlers.close();
+    },
+  });
+
+  return stream.response;
+}

package/src/server/routes/fs/validate.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Real workspace path validation — adapted from omp-web/app/api/cwd/validate/
+ * route.ts. Checks existence, directory-ness, and git-repo-ness. Additive
+ * endpoint for programmatic use; the locked settings UI does not consume it yet.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import { childEnv } from '@/server/lib/fs/child-env';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { join, resolve } from 'path';
+import { pathExists } from '@/server/lib/omp/core/paths';
+
+async function hasGitCommand(): Promise<boolean> {
+  try {
+    return (await Bun.spawn(['git', '--version'], { env: childEnv() }).exited) === 0;
+  } catch {
+    // Bun.spawn throws ENOENT when the binary is missing from PATH.
+    return false;
+  }
+}
+
+async function isInsideGitWorkTree(target: string): Promise<boolean> {
+  try {
+    return (await Bun.spawn(['git', '-C', target, 'rev-parse', '--is-inside-work-tree'], { env: childEnv() }).exited) === 0;
+  } catch {
+    return false;
+  }
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method !== 'POST') {
+    return methodNotAllowed({ request, params });
+  }
+  try {
+    const body = await request.json();
+    if (typeof body.path !== 'string' || body.path.trim() === '') {
+      return json({ error: 'path is required' }, { status: 400 });
+    }
+    const target = resolve(body.path);
+    const file = Bun.file(target);
+    const exists = await file.exists();
+    const isDirectory = exists ? (await file.stat()).isDirectory() : false;
+    const gitInstalled = await hasGitCommand();
+    const gitRepo = isDirectory && gitInstalled ? await isInsideGitWorkTree(target) : await pathExists(join(target, '.git'));
+
+    return json({
+      valid: isDirectory,
+      exists,
+      isDirectory,
+      isGitRepo: gitRepo,
+      path: target,
+    });
+  } catch (error: any) {
+    return json({ error: error.message }, { status: 500 });
+  }
+}

package/src/server/routes/health/index.ts

@@ -0,0 +1,6 @@
+import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import * as healthProbe from '@/server/routes/health/probe';
+
+export const healthBindings: HandlerBinding[] = [
+  ...bindingsFor(healthProbe, '/api/health'),
+];

package/src/server/routes/health/probe.ts

@@ -0,0 +1,59 @@
+import { json, NO_STORE_HEADERS } from '@/server/lib/remix-compat';
+import pkg from '@/../package.json';
+import { isAuthEnabled } from '@/server/lib/auth/guard';
+import { countOpenFileDescriptors } from '@/server/lib/lifecycle/fd-pressure';
+import { resolveLaunchMode } from '@/server/lib/lifecycle/launch-mode';
+import { isTrayEnabledByArgv } from '@/server/lib/lifecycle/argv-flags';
+import { isTlsEnabledByArgv } from '@/server/lib/lifecycle/tls';
+import { isMockMode } from '@/server/mock.server';
+
+const STARTED_AT = Date.now();
+const STARTED_ISO = new Date(STARTED_AT).toISOString();
+
+/**
+ * GET /api/health — lightweight readiness probe for the `kabmo status` CLI.
+ * Dependency-light by design: never touches the database and never throws.
+ *
+ * It does sweep the descriptor table (`countOpenFileDescriptors`, ~12 ms over
+ * the real 61440-entry table; ~2 ms when capped at the old constant): a dev
+ * server walks toward the descriptor ceiling where every `Bun.spawn` in the
+ * process fails, and the sweep is the only way to say so *before* the terminal
+ * panel, the omp child and git all break at once. Null where the host cannot
+ * answer.
+ */
+export async function loader() {
+  return json(
+    {
+      ok: true,
+      service: 'kabmo',
+      version: pkg.version,
+      pid: process.pid,
+      uptime: Math.round((Date.now() - STARTED_AT) / 10) / 100,
+      startedAt: STARTED_ISO,
+      mock: isMockMode(),
+      runtime: 'bun',
+      bun: Bun.version,
+      // Identity of the listener itself, read by the CLI and by a starting
+      // server deciding whether this port belongs to Kabmo: `mode` and
+      // `launchMode` are what `status` prints, and the pair with `pid` is what
+      // separates a dev server from a stale published build.
+      mode: Bun.env.NODE_ENV === 'production' ? 'prod' : 'dev',
+      launchMode: resolveLaunchMode(),
+      port: Number(Bun.env.PORT) || 3000,
+      host: Bun.env.HOST || 'localhost',
+      // Whether a UI password is in force. `status` prints it beside the bind
+      // address, so a LAN-bound instance with no password — reachable by anyone
+      // on the network — is visible from the CLI instead of only from a browser.
+      authEnabled: isAuthEnabled(),
+      // Reported so discovery does not have to guess the scheme: `status` and
+      // `findLiveInstance` read it to build the URL they print and probe.
+      tls: isTlsEnabledByArgv(),
+      // Whether this run raises a tray icon. Reported so discovery can carry it
+      // into a replacement's argv: a restart is spawned by a different process,
+      // and the flag is not recoverable from the running server any other way.
+      tray: isTrayEnabledByArgv(),
+      fds: countOpenFileDescriptors(),
+    },
+    { headers: NO_STORE_HEADERS },
+  );
+}

package/src/server/routes/index.ts

@@ -0,0 +1,60 @@
+import { Elysia } from 'elysia';
+import { mountBindings, type HandlerBinding } from '@/server/lib/route-adapter';
+import { agentBindings } from '@/server/routes/agent';
+import { authBindings } from '@/server/routes/auth';
+import { btwBindings } from '@/server/routes/btw';
+import { consoleBindings } from '@/server/routes/console';
+import { chamberBindings } from '@/server/routes/chamber';
+import { chatBindings } from '@/server/routes/chat';
+import { sessionsBindings } from '@/server/routes/sessions';
+import { scheduleBindings } from '@/server/routes/schedule/bindings';
+import { settingsBindings } from '@/server/routes/settings';
+import { fsBindings } from '@/server/routes/fs';
+import { foldersBindings } from '@/server/routes/folders';
+import { filesBindings } from '@/server/routes/files';
+import { telemetryBindings } from '@/server/routes/telemetry';
+import { terminalBindings } from '@/server/routes/terminal';
+import { terminalWsRoutes } from '@/server/routes/terminal/ws';
+import { dictationWsRoutes } from '@/server/routes/dictation/ws';
+import { browserBindings } from '@/server/routes/browser';
+import { modelsBindings } from '@/server/routes/models';
+import { ompBindings } from '@/server/routes/omp';
+import { updatesBindings } from '@/server/routes/updates';
+import { wikiBindings } from '@/server/routes/wiki';
+import { panelsBindings } from '@/server/routes/panels/bindings';
+import { pluginsBindings } from '@/server/routes/plugins/bindings';
+import { realtimeWsRoutes } from '@/server/routes/realtime/ws';
+import { healthBindings } from '@/server/routes/health';
+import { wellKnownBindings } from '@/server/routes/well-known';
+
+const allBindings: HandlerBinding[] = [
+  ...authBindings,
+  ...consoleBindings,
+  // @deprecated pre-rename path; same handlers, kept for an old page.
+  ...chamberBindings,
+  ...agentBindings,
+  ...btwBindings,
+  ...chatBindings,
+  ...sessionsBindings,
+  ...scheduleBindings,
+  ...settingsBindings,
+  ...fsBindings,
+  ...foldersBindings,
+  ...filesBindings,
+  ...telemetryBindings,
+  ...terminalBindings,
+  ...browserBindings,
+  ...modelsBindings,
+  ...ompBindings,
+  ...updatesBindings,
+  ...wikiBindings,
+  ...panelsBindings,
+  ...pluginsBindings,
+  ...healthBindings,
+  ...wellKnownBindings,
+];
+
+export const apiRoutes = mountBindings(new Elysia(), allBindings)
+  .use(terminalWsRoutes)
+  .use(dictationWsRoutes)
+  .use(realtimeWsRoutes);

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

@@ -0,0 +1,8 @@
+import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import * as modelsRoot from '@/server/routes/models/root';
+import * as modelsRoles from '@/server/routes/models/roles';
+
+export const modelsBindings: HandlerBinding[] = [
+  ...bindingsFor(modelsRoot, '/api/models'),
+  ...bindingsFor(modelsRoles, '/api/model-roles'),
+];

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

@@ -0,0 +1,31 @@
+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';
+
+export async function loader(_args: LoaderFunctionArgs) {
+  try {
+    return json(await readModelRoles());
+  } 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 });
+  } catch (error) {
+    return json({ error: String(error) }, { status: 400 });
+  }
+}