ompchamber 0.3.0

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

@@ -0,0 +1,328 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { getDb } from '@/server/db.server';
+import { INITIAL_MODELS_CATALOG } from '@/client/data/models/catalog';
+import { isMockMode } from '@/server/mock.server';
+import type { AIModelOption, ModelEntry, ModelsData, ProviderItem } from '@/shared/types';
+import { readSettingsJson, writeSettingsJson } from '@/server/lib/db/settings-store';
+import { runUtilityCommand, type OmpModel } from '@/server/lib/omp/rpc/utility';
+import { readDisabledProviders } from '@/server/lib/omp/config/roles';
+import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+
+const MODELS_CATALOG_KEY = 'omp_models_catalog';
+const SELECTED_MODEL_KEY = 'omp_selected_model';
+const PROVIDERS_CONFIG_KEY = 'omp_providers_config';
+
+const MODELS_CACHE_TTL_MS = 60_000;
+const SAFE_MODEL_LOAD_FAILURE_MESSAGE = 'Model list is temporarily unavailable. Check your configuration and try again.';
+
+const modelNameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+
+function compareModelEntries(a: { id: string; name: string; provider: string }, b: { id: string; name: string; provider: string }): number {
+  return modelNameCollator.compare(a.name || a.id, b.name || b.id)
+    || modelNameCollator.compare(a.provider, b.provider)
+    || modelNameCollator.compare(a.id, b.id);
+}
+
+// "off" is always a valid selector; the concrete efforts come from the model's
+// baked thinking metadata (omp: getSupportedEfforts = reasoning ? efforts : []).
+function thinkingLevelsFor(model: OmpModel): string[] {
+  if (!model.reasoning) return ['off'];
+  return ['off', ...(model.thinking?.efforts ?? [])];
+}
+
+function supportsFastMode(model: OmpModel): boolean {
+  return model.provider === 'anthropic' || model.provider === 'openai' || model.provider === 'google';
+}
+
+/**
+ * Disabled providers recorded in the chamber's own provider overlay. Used only
+ * by the MOCK path of `/api/models`, which has no config.yml `disabledProviders`
+ * to read — real mode gets the same answer natively.
+ */
+async function readStoredProvidersForModels(): Promise<ProviderItem[]> {
+  try {
+    const db = await getDb();
+    const parsed = await readSettingsJson<unknown>(db, PROVIDERS_CONFIG_KEY, null);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((provider): provider is ProviderItem => (
+      typeof provider === 'object' && provider !== null
+      && typeof (provider as ProviderItem).slug === 'string'
+      && (provider as ProviderItem).disabled === true
+    ));
+  } catch {
+    return [];
+  }
+}
+
+function hiddenModelKey(provider: string, modelId: string): string {
+  return `${provider.trim().toLowerCase()}:${modelId}`;
+}
+
+async function readHiddenModelKeys(): Promise<Set<string>> {
+  try {
+    const db = await getDb();
+    const parsed = await readSettingsJson<unknown>(db, PROVIDERS_CONFIG_KEY, null);
+    if (!Array.isArray(parsed)) return new Set();
+    const hidden = new Set<string>();
+    for (const provider of parsed) {
+      if (typeof provider?.slug !== 'string' || !Array.isArray(provider.models)) continue;
+      for (const model of provider.models) {
+        if (typeof model?.id === 'string' && model.isVisible === false) {
+          hidden.add(hiddenModelKey(provider.slug, model.id));
+        }
+      }
+    }
+    return hidden;
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * A model is offered only when its provider is neither disabled in omp's
+ * config.yml (`disabledProviders`) nor carrying a per-model hide in the
+ * chamber overlay. Disabling the provider is the coarse switch — Settings →
+ * Providers flips it so the whole provider leaves the chat picker.
+ */
+function filterSelectableModels(
+  available: OmpModel[],
+  disabledProviders: Set<string>,
+  hiddenModelKeys: Set<string>,
+): OmpModel[] {
+  return available.filter((model) => (
+    !disabledProviders.has(model.provider)
+    && !hiddenModelKeys.has(hiddenModelKey(model.provider, model.id))
+  ));
+}
+
+async function loadModels(): Promise<ModelsData> {
+  const availableResponse = await runUtilityCommand<{ models?: unknown }>(
+    { type: 'get_available_models' },
+    120_000,
+  );
+  const available = Array.isArray(availableResponse.models)
+    ? availableResponse.models
+        .filter((model): model is OmpModel => (
+          typeof model === 'object' && model !== null
+          && typeof (model as OmpModel).id === 'string'
+          && typeof (model as OmpModel).provider === 'string'
+        ))
+        .map((model) => ({
+          ...model,
+          name: typeof model.name === 'string' && model.name.trim().length > 0 ? model.name : model.id,
+        }))
+    : [];
+
+  const disabledProviders = await readDisabledProviders();
+  const hiddenModelKeys = await readHiddenModelKeys();
+  const nameMap: Record<string, string> = {};
+  const thinkingLevels: Record<string, string[]> = {};
+  const modelList: ModelEntry[] = filterSelectableModels(available, disabledProviders, hiddenModelKeys)
+    .map((m) => ({
+      id: m.id,
+      name: m.name,
+      provider: m.provider,
+      thinkingLevels: thinkingLevelsFor(m),
+      supportsFastMode: supportsFastMode(m),
+      contextWindow: m.contextWindow ?? undefined,
+      maxTokens: m.maxTokens ?? undefined,
+      cost: m.cost,
+    }))
+    .sort(compareModelEntries);
+
+  const loginResponse = await runUtilityCommand<{ providers?: unknown }>(
+    { type: 'get_login_providers' },
+    30_000,
+  );
+  const loginProviders = Array.isArray(loginResponse.providers)
+    ? loginResponse.providers.filter((provider): provider is { id: string; name: string; authenticated: boolean } => (
+      typeof provider === 'object' && provider !== null
+      && typeof (provider as { id?: unknown }).id === 'string'
+      && typeof (provider as { name?: unknown }).name === 'string'
+      && typeof (provider as { authenticated?: unknown }).authenticated === 'boolean'
+    ))
+    : [];
+  const connectedProviders = loginProviders
+    .filter((provider) => provider.authenticated)
+    .map((provider) => ({ id: provider.id, name: provider.name, disabled: disabledProviders.has(provider.id) }));
+  for (const m of available) {
+    const key = `${m.provider}:${m.id}`;
+    nameMap[key] = m.name;
+    thinkingLevels[key] = thinkingLevelsFor(m);
+  }
+
+  let defaultModel: { provider: string; modelId: string } | null = null;
+  try {
+    const state = await runUtilityCommand<{ model?: { provider?: string; id?: string } }>(
+      { type: 'get_state' },
+      30_000,
+    );
+    const provider = state.model?.provider;
+    const modelId = state.model?.id;
+    if (provider && modelId && available.some((m) => m.provider === provider && m.id === modelId)) {
+      defaultModel = { provider, modelId };
+    }
+  } catch {
+    // Default model is cosmetic — the models list is still useful without it.
+  }
+
+  return { models: nameMap, modelList, defaultModel, thinkingLevels, connectedProviders };
+}
+
+const EMPTY_MODELS: ModelsData = {
+  models: {},
+  modelList: [],
+  defaultModel: null,
+  thinkingLevels: {},
+};
+
+async function loadModelsWithCache(): Promise<ModelsData> {
+  const cached = globalThis.__ompChamberModelsCache;
+  if (cached && cached.expiresAt > Date.now()) return cached.data;
+  const data = await loadModels();
+  globalThis.__ompChamberModelsCache = { data, expiresAt: Date.now() + MODELS_CACHE_TTL_MS };
+  return data;
+}
+
+function invalidateModelsCache(): void {
+  invalidateModelsCaches();
+}
+
+/** Parse a persisted { provider, modelId|id } reference without trusting the JSON shape. */
+function readSelectedModelRef(value: unknown): { provider: string; modelId: string } | null {
+  if (typeof value !== 'object' || value === null) return null;
+  const candidate = value as { provider?: unknown; modelId?: unknown; id?: unknown };
+  if (typeof candidate.provider !== 'string' || candidate.provider.length === 0) return null;
+  const modelId = candidate.modelId ?? candidate.id;
+  if (typeof modelId !== 'string' || modelId.length === 0) return null;
+  return { provider: candidate.provider, modelId };
+}
+
+/** The user's persisted pick resolved against the live registry; null when stale or unparseable. */
+async function loadPersistedModelOption(modelList: ModelEntry[]): Promise<AIModelOption | null> {
+  try {
+    const db = await getDb();
+    const selected = readSelectedModelRef(await readSettingsJson<unknown>(db, SELECTED_MODEL_KEY, null));
+    if (!selected) return null;
+    const match = modelList.find(m => m.id === selected.modelId && m.provider === selected.provider);
+    if (!match) return null;
+    return {
+      id: match.id,
+      name: match.name,
+      provider: match.provider,
+      contextWindow: match.contextWindow,
+      thinkingLevels: match.thinkingLevels,
+      thinkingLevel: match.thinkingLevels?.[0],
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const mock = isMockMode();
+
+  // MOCK mode keeps the SQLite-backed catalog (chamber demo behavior).
+  if (mock) {
+    try {
+      const db = await getDb();
+      const catalog = await readSettingsJson<unknown>(db, MODELS_CATALOG_KEY, null);
+      const stored: AIModelOption[] = Array.isArray(catalog) && catalog.length > 0 ? catalog : INITIAL_MODELS_CATALOG;
+      // Demo mode has no config.yml to read, so the disable flag lives on the
+      // stored provider overlay. Filtering here keeps the model picker honest
+      // in MOCK=true too — the settings page must be able to prove the switch.
+      const disabledSlugs = new Set(
+        (await readStoredProvidersForModels()).map((provider) => provider.slug.trim().toLowerCase()),
+      );
+      const models = stored.filter((model) => !disabledSlugs.has(model.provider.trim().toLowerCase()));
+      const persisted = await readSettingsJson<AIModelOption | null>(db, SELECTED_MODEL_KEY, null);
+      // Every provider disabled ⇒ empty list and no selection; the composer must
+      // see that honestly instead of holding on to a hidden provider's model.
+      let selectedModel: AIModelOption | null = models[5] || models[0] || null;
+      if (persisted && persisted.id && persisted.provider) {
+        const match = models.find(m => m.id === persisted.id && m.provider === persisted.provider);
+        if (match) selectedModel = match;
+      }
+      return json({ models, selectedModel, isMock: mock });
+    } catch (error: any) {
+      return json({
+        error: error.message,
+        models: INITIAL_MODELS_CATALOG,
+        selectedModel: INITIAL_MODELS_CATALOG[5] || INITIAL_MODELS_CATALOG[0] || null,
+        isMock: mock,
+      }, { status: 500 });
+    }
+  }
+
+  // Real mode: read the omp model registry via the shared utility RPC process.
+  // The ?cwd= query param is accepted for client compatibility but ignored —
+  // the omp model registry (auth + models.yml) is global, not per-cwd.
+  void request;
+  try {
+    const data = await loadModelsWithCache();
+    // The selection changes independently of the 60s registry cache.
+    return json({ ...data, selectedModel: await loadPersistedModelOption(data.modelList) });
+  } catch {
+    return json({ ...EMPTY_MODELS, modelError: SAFE_MODEL_LOAD_FAILURE_MESSAGE });
+  }
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    const db = await getDb();
+    const body = await request.json();
+
+    const catalog = await readSettingsJson<unknown>(db, MODELS_CATALOG_KEY, null);
+    let models: AIModelOption[] = Array.isArray(catalog) ? catalog : INITIAL_MODELS_CATALOG;
+
+    const { actionType, modelId, provider, thinkingLevel, model, models: newModels } = body;
+
+    // Model-scoped mutations must match provider + id: the registry serves the
+    // same model id from several providers, so an id-only match rewrites the
+    // first provider's entry instead of the one the user acted on.
+    if (actionType === 'toggleFavorite' && modelId && provider) {
+      models = models.map(m => m.id === modelId && m.provider === provider ? { ...m, isFavorite: !m.isFavorite } : m);
+      await writeSettingsJson(db, MODELS_CATALOG_KEY, models);
+      return json({ success: true, models });
+    }
+
+    if (actionType === 'setThinking' && modelId && provider && thinkingLevel) {
+      models = models.map(m => m.id === modelId && m.provider === provider ? { ...m, thinkingLevel } : m);
+      await writeSettingsJson(db, MODELS_CATALOG_KEY, models);
+      return json({ success: true, models });
+    }
+
+    if (actionType === 'toggleCmd' && modelId && provider) {
+      models = models.map(m => m.id === modelId && m.provider === provider ? { ...m, isCmdAgent: !m.isCmdAgent } : m);
+      await writeSettingsJson(db, MODELS_CATALOG_KEY, models);
+      return json({ success: true, models });
+    }
+
+    if (actionType === 'selectModel' && model) {
+      await writeSettingsJson(db, SELECTED_MODEL_KEY, model);
+      const parsedModel = readSelectedModelRef(model);
+      if (parsedModel) {
+        invalidateModelsCache();
+        // Live set_model against the current session is handled by the agent
+        // RPC bridge; here we only persist the selection for session spawn.
+      }
+      return json({ success: true, selectedModel: model });
+    }
+
+    if (actionType === 'addModel' && model) {
+      models.push(model);
+      await writeSettingsJson(db, MODELS_CATALOG_KEY, models);
+      return json({ success: true, models });
+    }
+
+    if (actionType === 'saveAll' && Array.isArray(newModels)) {
+      await writeSettingsJson(db, MODELS_CATALOG_KEY, newModels);
+      return json({ success: true, models: newModels });
+    }
+
+    return json({ error: 'Invalid action or parameters' }, { status: 400 });
+  } catch (error: any) {
+    return json({ error: error.message }, { status: 500 });
+  }
+}

package/src/server/routes/omp/commands.ts

@@ -0,0 +1,29 @@
+import { json } from '@/server/lib/remix-compat';
+import type { LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { isMockMode } from '@/server/mock.server';
+import { runUtilityCommand } from '@/server/lib/omp/rpc/utility';
+
+/**
+ * Live slash-command/skill/extension discovery from the omp agent
+ * (get_available_commands). Each command carries its source
+ * (builtin | skill | extension | custom | mcp_prompt | file), so the skills
+ * and commands settings tabs can merge real agent-registered entries.
+ */
+export async function loader({ request }: LoaderFunctionArgs) {
+  const mock = isMockMode();
+  if (mock) {
+    return json({ commands: [], isMock: true });
+  }
+  const url = new URL(request.url);
+  const source = url.searchParams.get('source');
+  try {
+    const data = await runUtilityCommand<{ commands?: unknown }>({ type: 'get_available_commands' }, 30_000);
+    const commands = Array.isArray(data.commands) ? data.commands : [];
+    const filtered = source
+      ? commands.filter((c) => (c as { source?: string })?.source === source)
+      : commands;
+    return json({ commands: filtered, isMock: false });
+  } catch (error: any) {
+    return json({ commands: [], isMock: false, error: error.message });
+  }
+}

package/src/server/routes/omp/extensions.ts

@@ -0,0 +1,34 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { isMockMode } from '@/server/mock.server';
+import { discoverExtensions, setExtensionDisabled } from '@/server/lib/omp/config/extensions';
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const mock = isMockMode();
+  if (mock) {
+    return json({ extensions: [], isMock: true });
+  }
+  const url = new URL(request.url);
+  const cwd = url.searchParams.get('cwd') ?? undefined;
+  return json({ extensions: await discoverExtensions(cwd), isMock: 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.id !== 'string' || typeof body.disabled !== 'boolean') {
+      return json({ error: 'id and disabled are required' }, { status: 400 });
+    }
+    if (isMockMode()) {
+      return json({ error: 'Extension toggles are unavailable in mock mode' }, { status: 400 });
+    }
+    const changed = await setExtensionDisabled(body.id, body.disabled);
+    return json({ success: true, changed });
+  } catch (error: any) {
+    return json({ error: error.message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,20 @@
+import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import * as ompState from '@/server/routes/omp/state';
+import * as ompSidebar from '@/server/routes/omp/sidebar';
+import * as ompSessionStats from '@/server/routes/omp/session-stats';
+import * as ompCommands from '@/server/routes/omp/commands';
+import * as ompExtensions from '@/server/routes/omp/extensions';
+import * as ompLogin from '@/server/routes/omp/login';
+import * as ompPlugins from '@/server/routes/omp/plugins';
+import * as ompPricing from '@/server/routes/omp/pricing';
+
+export const ompBindings: HandlerBinding[] = [
+  ...bindingsFor(ompState, '/api/omp/state'),
+  ...bindingsFor(ompSidebar, '/api/omp/sidebar'),
+  ...bindingsFor(ompSessionStats, '/api/omp/session-stats'),
+  ...bindingsFor(ompCommands, '/api/omp/commands'),
+  ...bindingsFor(ompExtensions, '/api/omp/extensions'),
+  ...bindingsFor(ompLogin, '/api/omp/login'),
+  ...bindingsFor(ompPlugins, '/api/omp/plugins'),
+  ...bindingsFor(ompPricing, '/api/omp/pricing'),
+];

package/src/server/routes/omp/login.ts

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Provider login flow over a dedicated throwaway omp RPC process.
+ *
+ * POST returns an SSE stream of `extension_ui_request` frames (open_url for
+ * OAuth, input/confirm for API keys, notify for status). The client replies
+ * by POSTing `extension_ui_response` frames to the same endpoint; they are
+ * forwarded into the running login process. The stream ends when the login
+ * command resolves, fails, or the client disconnects.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { RpcProcess } from '@/server/lib/omp/rpc/process';
+import { isMockMode } from '@/server/mock.server';
+import { createSseStream } from '@/server/lib/sse';
+
+const READY_TIMEOUT_MS = 30_000;
+const LOGIN_TIMEOUT_MS = 300_000;
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method !== 'POST') {
+    return methodNotAllowed({ request, params });
+  }
+  const body = await request.json().catch(() => null);
+
+  // Response forwarding: an in-flight login posts an extension_ui_response frame.
+  const isUiResponse = body && typeof body.id === 'string' && body.type === 'extension_ui_response';
+  const forward = isUiResponse
+    ? (globalThis.__ompChamberLoginResponseSink as ((frame: { type: string; [key: string]: unknown }) => void) | undefined)
+    : undefined;
+  if (forward) {
+    forward(body as { type: string; [key: string]: unknown });
+    return json({ success: true });
+  }
+
+  if (!body || typeof body.providerId !== 'string' || !body.providerId.trim()) {
+    return json({ error: 'providerId is required' }, { status: 400 });
+  }
+  if (isMockMode()) {
+    return json({ error: 'Login is unavailable in mock mode' }, { status: 400 });
+  }
+
+  const providerId = body.providerId;
+
+  const stream = createSseStream({
+    async onStart(handlers) {
+      let closed = false;
+      let sink: ((frame: Record<string, unknown>) => void) | null = null;
+
+      const cleanup = () => {
+        if (closed) return;
+        closed = true;
+        globalThis.__ompChamberLoginResponseSink = undefined;
+        handlers.close();
+      };
+      const send = (data: unknown) => {
+        if (closed) return;
+        handlers.send('', data);
+      };
+
+      globalThis.__ompChamberLoginResponseSink = (frame) => sink?.(frame);
+
+      const proc = new RpcProcess({ cwd: '/', extraArgs: ['--no-session', '--no-skills', '--no-lsp'] });
+      const onAbort = () => { void proc.dispose(); cleanup(); };
+      request.signal?.addEventListener('abort', onAbort, { once: true });
+
+      try {
+        const ready = await proc.waitReady(READY_TIMEOUT_MS);
+        await proc.negotiateProtocol(ready);
+        const unsubscribe = proc.onFrame((frame) => {
+          if (frame.type === 'extension_ui_request') send(frame);
+        });
+
+        sink = (frame) => proc.sendFrame({ type: 'extension_ui_response', ...frame });
+
+        let loginOk = false;
+        let loginError: string | undefined;
+        try {
+          await proc.sendCommand({ type: 'login', providerId }, LOGIN_TIMEOUT_MS);
+          loginOk = true;
+        } catch (error) {
+          loginError = error instanceof Error ? error.message : String(error);
+        } finally {
+          unsubscribe();
+          send({ type: 'login_result', providerId, success: loginOk, ...(loginError ? { error: loginError } : {}) });
+          cleanup();
+        }
+      } catch (error) {
+        send({ type: 'login_result', providerId, success: false, error: error instanceof Error ? error.message : String(error) });
+        cleanup();
+      } finally {
+        request.signal?.removeEventListener('abort', onAbort);
+        void proc.dispose();
+      }
+
+      return cleanup;
+    },
+  });
+
+  return stream.response;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberLoginResponseSink: ((frame: Record<string, unknown>) => void) | undefined;
+}

package/src/server/routes/omp/plugins.ts

@@ -0,0 +1,82 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { isMockMode } from '@/server/mock.server';
+
+/**
+ * omp plugin CLI bridge — list/install/uninstall/enable/disable through the
+ * real `omp plugin` command. The CLI is authoritative (own lockfile, npm/link
+ * installs) so shelling out beats reimplementing its registry logic.
+ */
+
+const TIMEOUT_MS = 120_000;
+
+function runPlugin(args: string[]): Promise<string> {
+  return (async () => {
+    const proc = Bun.spawn({
+      cmd: ['omp', 'plugin', ...args],
+      stdout: 'pipe',
+      stderr: 'pipe',
+      timeout: TIMEOUT_MS,
+      maxBuffer: 4 * 1024 * 1024,
+      windowsHide: true,
+    });
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) throw new Error(stderr.trim() || `omp plugin ${args[0]} exited with code ${exitCode}`);
+    return stdout;
+  })();
+}
+
+export async function loader({ request: _request }: LoaderFunctionArgs) {
+  const mock = isMockMode();
+  if (mock) {
+    return json({ plugins: [], raw: '', isMock: true });
+  }
+  try {
+    const raw = await runPlugin(['list']);
+    return json({ plugins: parsePluginList(raw), raw, isMock: false });
+  } catch (error: any) {
+    return json({ plugins: [], raw: '', isMock: false, error: error.message }, { status: 500 });
+  }
+}
+
+/** Parse `omp plugin list` text lines: "name  <detail>" per installed plugin. */
+function parsePluginList(raw: string): Array<{ name: string; detail: string }> {
+  return raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0 && !/^no plugins installed/i.test(line) && !/^install plugins with:/i.test(line))
+    .map((line) => {
+      const match = /^(\S+)\s*(.*)$/.exec(line);
+      return match ? { name: match[1], detail: match[2] ?? '' } : { name: line, detail: '' };
+    });
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method !== 'POST') {
+    return methodNotAllowed({ request, params });
+  }
+  try {
+    const body = await request.json();
+    const action = typeof body.action === 'string' ? body.action : '';
+    const allowed = ['install', 'uninstall', 'upgrade', 'enable', 'disable'];
+    if (!allowed.includes(action)) {
+      return json({ error: `action must be one of: ${allowed.join(', ')}` }, { status: 400 });
+    }
+    if (typeof body.source !== 'string' || !body.source.trim()) {
+      return json({ error: 'source (plugin package name) is required' }, { status: 400 });
+    }
+    if (isMockMode()) {
+      return json({ error: 'Plugin actions are unavailable in mock mode' }, { status: 400 });
+    }
+    const output = await runPlugin([action, body.source]);
+    const list = await runPlugin(['list']);
+    return json({ success: true, action, output, plugins: parsePluginList(list) });
+  } catch (error: any) {
+    return json({ error: error.message }, { status: 500 });
+  }
+}

package/src/server/routes/omp/pricing.ts

@@ -0,0 +1,65 @@
+import { json } from '@/server/lib/remix-compat';
+import type { LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { isMockMode } from '@/server/mock.server';
+import { loadModelsDevCatalog } from '@/shared/lib/models/catalog';
+
+/**
+ * Model pricing catalog from https://models.dev/api.json (shared 1h in-memory
+ * cache), the same source ompweb uses. Cost values are per million tokens.
+ * Query `?provider=<id>` to filter, or `?id=<provider>/<model>` for one entry.
+ *
+ * Pricing keeps a longer 20s fetch timeout than the default catalog loader and
+ * surfaces failures through its own error envelope, so it opts into both.
+ */
+const PRICING_TIMEOUT_MS = 20_000;
+
+interface CatalogModel {
+  id?: string;
+  name?: string;
+  cost?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number };
+  limit?: { context?: number; output?: number };
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const mock = isMockMode();
+  if (mock) {
+    return json({ providers: {}, isMock: true });
+  }
+  try {
+    const catalog = await loadModelsDevCatalog({
+      timeoutMs: PRICING_TIMEOUT_MS,
+      strict: true,
+    });
+    const url = new URL(request.url);
+    const providerFilter = url.searchParams.get('provider');
+    const modelId = url.searchParams.get('id');
+
+    if (modelId) {
+      const [providerSlug, ...rest] = modelId.split('/');
+      const provider = catalog[providerSlug] as Record<string, unknown> | undefined;
+      const models = (provider?.models ?? {}) as Record<string, CatalogModel>;
+      const wanted = rest.join('/');
+      const match = Object.entries(models).find(([key, model]) => key === wanted || model?.id === wanted);
+      return json({ found: match ? { provider: providerSlug, modelKey: match[0], ...match[1] } : null, isMock: false });
+    }
+
+    const providers: Record<string, unknown> = {};
+    for (const [slug, value] of Object.entries(catalog)) {
+      if (providerFilter && slug !== providerFilter) continue;
+      if (typeof value !== 'object' || value === null) continue;
+      const record = value as Record<string, unknown>;
+      const models = record.models as Record<string, CatalogModel> | undefined;
+      if (!models || typeof models !== 'object') continue;
+      providers[slug] = Object.fromEntries(
+        Object.entries(models).map(([key, model]) => [key, {
+          name: model?.name ?? key,
+          cost: model?.cost ?? null,
+          limit: model?.limit ?? null,
+        }]),
+      );
+    }
+    return json({ providers, isMock: false });
+  } catch (error: any) {
+    return json({ providers: {}, isMock: false, error: error.message }, { status: 200 });
+  }
+}