ompchamber 0.3.0

package/src/server/lib/omp/config/mcp.ts

@@ -0,0 +1,258 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Native OMP MCP config access — faithful adaptation of omp-web/lib/omp/mcp-config.ts.
+ *
+ * Reads and writes the native configs the omp agent actually loads:
+ * - user scope:    ~/.omp/agent/mcp.json
+ * - project scope: <projectRoot>/.omp/mcp.json (first existing of the
+ *   MCP_FILENAMES candidates, else `.omp/mcp.json`)
+ *
+ * Every read-modify-write runs under a cross-process lockfile so concurrent
+ * writers cannot lose each other's mutations. Credentials (env/headers) are
+ * never exposed to the browser and are preserved when an edit omits them.
+ */
+
+import fs from 'fs';
+import { dirname, join, resolve } from 'path';
+import { getAgentDir, pathExists } from '@/server/lib/omp/core/paths';
+import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+import { isRecord } from '@/shared/lib/util/guards';
+
+const MAX_MCP_CONFIG_BYTES = 512 * 1024;
+const SERVER_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+
+/** Project-level config candidates, in omp preference order. */
+export const MCP_FILENAMES = [join('.omp', 'mcp.json'), join('.omp', '.mcp.json'), 'mcp.json', '.mcp.json'];
+
+export type McpServer = Record<string, unknown>;
+export type McpFile = Record<string, unknown> & { mcpServers?: Record<string, McpServer> };
+
+export interface McpUserConfig {
+  path: string;
+  servers: Array<{ name: string; config: McpServer }>;
+  disabledServers: string[];
+  error?: string;
+}
+
+function serverEntries(config: McpFile): Array<{ name: string; config: McpServer }> {
+  return Object.entries(config.mcpServers ?? {})
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([name, server]) => ({ name, config: server }));
+}
+
+async function readMcpFile(path: string): Promise<McpUserConfig> {
+  if (!(await Bun.file(path).exists())) return { path, servers: [], disabledServers: [] };
+  try {
+    const file = Bun.file(path);
+    if ((await file.stat()).size > MAX_MCP_CONFIG_BYTES) throw new Error('configuration is too large to inspect');
+    const parsed: unknown = JSON.parse(await file.text());
+    if (!isRecord(parsed)) throw new Error('configuration must contain a JSON object');
+    if (parsed.mcpServers !== undefined && !isRecord(parsed.mcpServers)) throw new Error('mcpServers must be an object');
+    return {
+      path,
+      servers: serverEntries(parsed as McpFile),
+      disabledServers: Array.isArray(parsed.disabledServers)
+        ? parsed.disabledServers.filter((name): name is string => typeof name === 'string')
+        : [],
+    };
+  } catch (error) {
+    return { path, servers: [], disabledServers: [], error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+/** Read ~/.omp/agent/mcp.json (user scope) without throwing. */
+export async function readUserMcpConfig(path = join(getAgentDir(), 'mcp.json')): Promise<McpUserConfig> {
+  return readMcpFile(path);
+}
+
+/** Resolve a project's config file: first existing candidate, else `.omp/mcp.json`.
+ *  Probes through `pathExists`, not `Bun.file(p).exists()` — a candidate can
+ *  exist as a directory, which the latter reports false for. */
+export async function resolveProjectMcpConfig(projectRoot: string): Promise<{ root: string; path: string }> {
+  const root = resolve(projectRoot);
+  for (const filename of MCP_FILENAMES) {
+    const candidate = join(root, filename);
+    if (await pathExists(candidate)) return { root, path: candidate };
+  }
+  return { root, path: join(root, MCP_FILENAMES[0]) };
+}
+
+/** Read <projectRoot>/.omp/mcp.json (project scope) without throwing. */
+export async function readProjectMcpConfig(projectRoot: string): Promise<McpUserConfig> {
+  return readMcpFile((await resolveProjectMcpConfig(projectRoot)).path);
+}
+
+// Two writers (e.g. the dev server and the installed app) editing the same
+// mcp.json would otherwise silently lose the earlier mutation when the later
+// rename wins. A lockfile with exclusive create (`wx`) is atomic on every
+// platform; the holder writes its PID and deletes the file on completion.
+// Stale locks (writer crashed) are broken after a grace period.
+const MCP_LOCK_TIMEOUT_MS = 3_000;
+const MCP_LOCK_STALE_MS = 10_000;
+const MCP_LOCK_RETRY_MS = 25;
+
+export async function withMcpConfigLock<T>(configPath: string, fn: () => T | Promise<T>): Promise<T> {
+  const lockPath = `${configPath}.lock`;
+  // The config file may not exist yet (first write) — the lockfile needs its
+  // parent dir to exist before exclusive-create can succeed.
+  await fs.promises.mkdir(dirname(lockPath), { recursive: true });
+  const deadline = Date.now() + MCP_LOCK_TIMEOUT_MS;
+  for (;;) {
+    let handle: fs.promises.FileHandle | null = null;
+    try {
+      handle = await fs.promises.open(lockPath, 'wx');
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      // Held by another process — break it if stale, otherwise wait and retry.
+      try {
+        if (Date.now() - (await fs.promises.stat(lockPath)).mtimeMs > MCP_LOCK_STALE_MS) {
+          await fs.promises.unlink(lockPath);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for ${lockPath} (another process holds the MCP config lock)`);
+      }
+      await Bun.sleep(MCP_LOCK_RETRY_MS);
+      continue;
+    }
+    try {
+      await handle.writeFile(String(process.pid));
+    } finally {
+      await handle.close();
+    }
+    try {
+      return await fn();
+    } finally {
+      try {
+        await fs.promises.unlink(lockPath);
+      } catch {
+        // Already removed (e.g. by cleanup) — the critical section is done.
+      }
+    }
+  }
+}
+
+async function readConfigFile(path: string): Promise<McpFile> {
+  if (!(await Bun.file(path).exists())) return { mcpServers: {} };
+  const parsed: unknown = JSON.parse(await Bun.file(path).text());
+  if (!isRecord(parsed)) throw new Error(`${path} must contain a JSON object`);
+  if (parsed.mcpServers !== undefined && !isRecord(parsed.mcpServers)) throw new Error('mcpServers must be an object');
+  return parsed as McpFile;
+}
+
+async function writeConfigFile(path: string, config: McpFile): Promise<void> {
+  await writeFileAtomic(path, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+async function writeServerAt(path: string, name: string, server: McpServer, previousName?: string): Promise<{ path: string }> {
+  return withMcpConfigLock(path, async () => {
+    const config = await readConfigFile(path);
+    const servers = { ...(config.mcpServers ?? {}) };
+    // Capture the old entry before any rename: a rename must retain
+    // credentials the browser intentionally redacts from its payload.
+    const previous = servers[previousName ?? name];
+    if (previousName && previousName !== name) delete servers[previousName];
+    // The browser never receives existing credentials. Preserve them when an
+    // edited server omits those fields, rather than deleting them on save.
+    servers[name] = {
+      ...server,
+      ...(previous?.env !== undefined && server.env === undefined ? { env: previous.env } : {}),
+      ...(previous?.headers !== undefined && server.headers === undefined ? { headers: previous.headers } : {}),
+    };
+    await writeConfigFile(path, { ...config, mcpServers: servers });
+    return { path };
+  });
+}
+
+async function deleteServerAt(path: string, name: string): Promise<{ path: string }> {
+  if (!(await Bun.file(path).exists())) throw new Error('MCP server was not found');
+  return withMcpConfigLock(path, async () => {
+    const config = await readConfigFile(path);
+    const servers = { ...(config.mcpServers ?? {}) };
+    if (!(name in servers)) throw new Error('MCP server was not found');
+    delete servers[name];
+    await writeConfigFile(path, { ...config, mcpServers: servers });
+    return { path };
+  });
+}
+
+/** Atomic read-modify-write of one server entry in the user mcp.json. */
+export async function writeUserMcpServer(
+  name: string,
+  server: McpServer,
+  path = join(getAgentDir(), 'mcp.json'),
+  previousName?: string,
+): Promise<{ path: string }> {
+  if (!SERVER_NAME.test(name)) throw new Error('Invalid server name');
+  if (!isRecord(server)) throw new Error('Server configuration must be an object');
+  return writeServerAt(path, name, server, previousName);
+}
+
+/** Atomic removal of one server entry from the user mcp.json. */
+export async function deleteUserMcpServer(name: string, path = join(getAgentDir(), 'mcp.json')): Promise<{ path: string }> {
+  if (!SERVER_NAME.test(name)) throw new Error('Invalid server name');
+  return deleteServerAt(path, name);
+}
+
+/** Atomic read-modify-write of one server entry in a project's mcp.json. */
+export async function writeProjectMcpServer(
+  projectRoot: string,
+  name: string,
+  server: McpServer,
+  previousName?: string,
+): Promise<{ path: string }> {
+  if (!SERVER_NAME.test(name)) throw new Error('Invalid server name');
+  if (!isRecord(server)) throw new Error('Server configuration must be an object');
+  return writeServerAt((await resolveProjectMcpConfig(projectRoot)).path, name, server, previousName);
+}
+
+/** Atomic removal of one server entry from a project's mcp.json. */
+export async function deleteProjectMcpServer(projectRoot: string, name: string): Promise<{ path: string }> {
+  if (!SERVER_NAME.test(name)) throw new Error('Invalid server name');
+  return deleteServerAt((await resolveProjectMcpConfig(projectRoot)).path, name);
+}
+
+/** Convert a native omp server config into the chamber McpServerItem shape.
+ *  Pass `project` to produce a project-scoped item (id omp-project-<name>). */
+export function nativeToServerItem(
+  name: string,
+  config: McpServer,
+  index: number,
+  enabled: boolean,
+  project?: { path: string },
+) {
+  const isHttp = typeof config.url === 'string';
+  const envRecord = isRecord(config.env) ? (config.env as Record<string, unknown>) : {};
+  return {
+    id: `${project ? 'omp-project' : 'omp-user'}-${name}`,
+    name,
+    scope: project ? ('this-project' as const) : ('every-project' as const),
+    ...(project ? { projectPath: project.path } : {}),
+    enabled,
+    reachType: isHttp ? ('link' as const) : ('command' as const),
+    commandArgs: isHttp
+      ? [String(config.url)]
+      : [String(config.command ?? ''), ...(Array.isArray(config.args) ? config.args.map(String) : [])].filter(Boolean),
+    linkUrl: isHttp ? String(config.url) : undefined,
+    envVars: Object.entries(envRecord).map(([key, value], i) => ({
+      id: `env-${index}-${i}`,
+      key,
+      value: typeof value === 'string' ? value : String(value),
+    })),
+    status: undefined,
+  };
+}
+
+const SENSITIVE_KEY = /(key|token|secret|password|credential)/i;
+
+/** Redact env var values for display — the browser never sees raw credentials. */
+export function redactEnvVars<T extends { key: string; value: string }>(envVars: T[]): T[] {
+  return envVars.map((item) => (SENSITIVE_KEY.test(item.key) ? { ...item, value: '••••••••' } : item));
+}

package/src/server/lib/omp/config/providers.ts

@@ -0,0 +1,276 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Native OMP provider access — models.yml discovery + config.yml
+ * disabledProviders writes. Faithful adaptation of omp-web/lib/omp/models-config.ts
+ * and omp-web/app/api/providers/enable/route.ts.
+ */
+
+import { join } from 'path';
+import { getAgentDir } from '@/server/lib/omp/core/paths';
+import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+import { asMapping } from '@/server/lib/omp/config/yaml';
+import { isRecord } from '@/shared/lib/util/guards';
+
+/** Path of the native OMP models config (~/.omp/agent/models.yml). */
+export async function getModelsConfigPath(): Promise<string> {
+  const yml = join(getAgentDir(), 'models.yml');
+  return (await Bun.file(yml).exists()) ? yml : join(getAgentDir(), 'models.yaml');
+}
+
+export interface NativeProviderInfo {
+  /** Provider slug, e.g. "deepseek" or "custom/my-gateway". */
+  slug: string;
+  /** Base URL of the provider API, when configured. */
+  baseUrl?: string;
+  /** Model ids registered under this provider in models.yml. */
+  modelIds: string[];
+  models: NativeModelInfo[];
+}
+
+export interface NativeModelInfo {
+  id: string;
+  name?: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  reasoning?: boolean;
+  imageInput?: boolean;
+}
+
+/**
+ * Read custom providers/models registered in models.yml. Returns [] when the
+ * file is missing or has no providers — never throws for absent files.
+ */
+export async function readNativeProviders(): Promise<NativeProviderInfo[]> {
+  const path = await getModelsConfigPath();
+  if (!(await Bun.file(path).exists())) return [];
+  try {
+    const data = Bun.YAML.parse(await Bun.file(path).text());
+    if (!isRecord(data)) return [];
+    const providers = data.providers;
+    if (typeof providers !== 'object' || providers === null || Array.isArray(providers)) return [];
+    return Object.entries(providers as Record<string, unknown>).map(([slug, value]) => {
+      const info: NativeProviderInfo = { slug, modelIds: [], models: [] };
+      if (isRecord(value)) {
+        const record = value as Record<string, unknown>;
+        if (typeof record.baseUrl === 'string') info.baseUrl = record.baseUrl;
+        if (isRecord(record.models)) {
+          info.models = Object.entries(record.models as Record<string, unknown>).flatMap(([id, model]) => {
+            if (typeof model !== 'object' || model === null || Array.isArray(model)) return [{ id }];
+            const value = model as Record<string, unknown>;
+            return [{
+              id,
+              ...(typeof value.name === 'string' ? { name: value.name } : {}),
+              ...(typeof value.contextWindow === 'number' ? { contextWindow: value.contextWindow } : {}),
+              ...(typeof value.maxTokens === 'number' ? { maxTokens: value.maxTokens } : {}),
+              ...(value.reasoning === true ? { reasoning: true } : {}),
+              ...(Array.isArray(value.input) && value.input.includes('image') ? { imageInput: true } : {}),
+            }];
+          });
+        } else if (Array.isArray(record.models)) {
+          info.models = record.models.flatMap((model) => {
+            if (typeof model === 'string') return [{ id: model }];
+            if (typeof model !== 'object' || model === null || Array.isArray(model)) return [];
+            const value = model as Record<string, unknown>;
+            if (typeof value.id !== 'string') return [];
+            return [{
+              id: value.id,
+              ...(typeof value.name === 'string' ? { name: value.name } : {}),
+              ...(typeof value.contextWindow === 'number' ? { contextWindow: value.contextWindow } : {}),
+              ...(typeof value.maxTokens === 'number' ? { maxTokens: value.maxTokens } : {}),
+              ...(value.reasoning === true ? { reasoning: true } : {}),
+              ...(Array.isArray(value.input) && value.input.includes('image') ? { imageInput: true } : {}),
+            }];
+          });
+        }
+        info.modelIds = info.models.map((model) => model.id);
+      }
+      return info;
+    });
+  } catch {
+    return [];
+  }
+}
+
+/** One model entry destined for models.yml (cost numbers are USD per 1M tokens). */
+export interface OmpProviderModelSeed {
+  id: string;
+  name?: string;
+  reasoning?: boolean;
+  imageInput?: boolean;
+  contextWindow?: number;
+  maxTokens?: number;
+  cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
+}
+
+export interface OmpProviderUpsertInput {
+  baseUrl: string;
+  apiKey?: string;
+  api?: 'openai-completions' | 'anthropic-messages' | 'google-generative-ai';
+  models: OmpProviderModelSeed[];
+}
+
+export interface OmpProviderUpsertResult {
+  written: boolean;
+  addedModels: string[];
+  /** Existing bare entries whose missing metadata got filled from this fetch. */
+  backfilledModels: string[];
+  skippedModels: string[];
+  reason?: string;
+}
+
+/**
+ * Add-only upsert of a provider (and its models) into the native omp
+ * models.yml — the agent's own registry, where per-model cost feeds usage
+ * tracking. Existing provider fields (apiKey, baseUrl) and existing model
+ * entries are never modified; only models whose id is not yet registered are
+ * appended. Merges use an atomic temp-file write preserving unrelated keys
+ * (full-document Bun.YAML round-trip). Provider creation requires an
+ * apiKey — omp rejects models-cfg providers without one unless auth is "none"
+ * or "oauth"; existing providers keep whatever credential they already have.
+ */
+export async function upsertOmpProviderModels(
+  slug: string,
+  input: OmpProviderUpsertInput,
+): Promise<OmpProviderUpsertResult> {
+  const path = await getModelsConfigPath();
+  const doc: Record<string, unknown> = (await Bun.file(path).exists())
+    ? asMapping(Bun.YAML.parse(await Bun.file(path).text()), path)
+    : {};
+  let providers: Record<string, unknown> | undefined = isRecord(doc.providers) ? doc.providers : undefined;
+  if (!providers) {
+    providers = {};
+    doc.providers = providers;
+  }
+
+  const existingPojo = isRecord(providers[slug]) ? (providers[slug] as Record<string, unknown>) : undefined;
+  const existingModels = Array.isArray(existingPojo?.models) ? existingPojo.models : [];
+  const knownIds = new Set<string>(
+    existingModels.map((m) => (isRecord(m) && typeof m.id === 'string' ? m.id : '')).filter(Boolean),
+  );
+
+  const incomingById = new Map(input.models.map((m) => [m.id, m]));
+  const additions = input.models.filter((m) => m.id && !knownIds.has(m.id));
+  // Existing entries with bare ids (no context, no capabilities) get the
+  // fetched metadata filled in — values already present are never touched.
+  const backfillIds: string[] = existingPojo
+    ? existingModels
+      .filter((m) => {
+        const entry = isRecord(m) ? m : {};
+        const seed = incomingById.get(String(entry.id));
+        if (!seed) return false;
+        const missingContext = typeof entry.contextWindow !== 'number' || !entry.contextWindow;
+        const missingCost = !entry.cost;
+        return Boolean(
+          (missingContext && (seed.contextWindow || seed.maxTokens))
+          || (missingCost && seed.cost)
+          || (seed.reasoning !== undefined && entry.reasoning === undefined)
+          || (typeof entry.input !== 'object' && seed.imageInput),
+        );
+      })
+      .map((m) => String((isRecord(m) ? m : {}).id ?? ''))
+      .filter(Boolean)
+    : [];
+  if (additions.length === 0 && backfillIds.length === 0) {
+    return {
+      written: false,
+      addedModels: [],
+      backfilledModels: [],
+      skippedModels: input.models.map((m) => m.id),
+      reason: existingPojo ? 'all models already registered' : undefined,
+    };
+  }
+
+  let targetApiValue: string | undefined;
+
+  if (!existingPojo && !input.apiKey) {
+    return {
+      written: false,
+      addedModels: [],
+      backfilledModels: [],
+      skippedModels: input.models.map((m) => m.id),
+      reason: 'provider not yet in models.yml and no api key available to register it',
+    };
+  }
+
+  if (!existingPojo) {
+    providers[slug] = {
+      baseUrl: input.baseUrl,
+      apiKey: input.apiKey,
+      // omp disables every custom provider when a models-carrying provider
+      // lacks "api" (provider or model level) — always set one.
+      api: input.api ?? 'openai-completions',
+      models: [] as unknown[],
+    };
+  } else if (!existingPojo.api) {
+    // Existing provider without an api: adding models without one would make
+    // the whole models.yml fail omp validation, so fill it.
+    targetApiValue = input.api ?? 'openai-completions';
+  }
+
+  const target = providers[slug] as Record<string, unknown>;
+  if (targetApiValue) target.api = targetApiValue;
+  if (!Array.isArray(target.models)) target.models = [];
+  const targetModels = target.models as Record<string, unknown>[];
+  for (const model of additions) {
+    targetModels.push({
+      id: model.id,
+      ...(model.name ? { name: model.name } : {}),
+      ...(model.reasoning !== undefined ? { reasoning: model.reasoning } : {}),
+      ...(model.imageInput ? { input: ['text', 'image'] } : { input: ['text'] }),
+      ...(model.contextWindow && model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {}),
+      ...(model.maxTokens && model.maxTokens > 0 ? { maxTokens: model.maxTokens } : {}),
+      ...(model.cost ? {
+        cost: {
+          input: model.cost.input,
+          output: model.cost.output,
+          cacheRead: model.cost.cacheRead,
+          cacheWrite: model.cost.cacheWrite,
+        },
+      } : {}),
+    });
+  }
+
+  for (const entry of targetModels) {
+    const entryId = typeof entry?.id === 'string' ? entry.id : '';
+    if (!entryId || !backfillIds.includes(entryId)) continue;
+    const seed = incomingById.get(entryId);
+    if (!seed) continue;
+    if (seed.name && !entry.name) entry.name = seed.name;
+    if (seed.reasoning !== undefined && entry.reasoning === undefined) {
+      entry.reasoning = seed.reasoning;
+    }
+    const currentInput = entry.input;
+    if (seed.imageInput && !Array.isArray(currentInput)) {
+      entry.input = ['text', 'image'];
+    } else if (seed.imageInput && Array.isArray(currentInput) && !(currentInput as unknown[]).includes('image')) {
+      entry.input = ['text', 'image'];
+    }
+    if (seed.contextWindow && seed.contextWindow > 0 && !entry.contextWindow) {
+      entry.contextWindow = seed.contextWindow;
+    }
+    if (seed.maxTokens && seed.maxTokens > 0 && !entry.maxTokens) {
+      entry.maxTokens = seed.maxTokens;
+    }
+    if (seed.cost && !entry.cost) {
+      entry.cost = {
+        input: seed.cost.input,
+        output: seed.cost.output,
+        cacheRead: seed.cost.cacheRead,
+        cacheWrite: seed.cost.cacheWrite,
+      };
+    }
+  }
+
+  await writeFileAtomic(path, Bun.YAML.stringify(doc, null, 2));
+
+  return {
+    written: true,
+    addedModels: additions.map((m) => m.id),
+    backfilledModels: backfillIds,
+    skippedModels: input.models.filter((m) => knownIds.has(m.id)).map((m) => m.id),
+  };
+}

package/src/server/lib/omp/config/roles.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read/write of the native OMP role selectors (`modelRoles`) in
+ * ~/.omp/agent/config.yml — the access-control mapping of role → model
+ * selector used by omp (e.g. the advisor role). Faithful port of
+ * omp-web/lib/omp/model-roles.ts.
+ */
+
+import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+import { asMapping, getOmpConfigPath } from '@/server/lib/omp/config/yaml';
+import { isRecord } from '@/shared/lib/util/guards';
+
+export type ModelRoles = Record<string, string>;
+
+/** Reads the native OMP role selectors from config.yml without touching other settings. */
+export async function readModelRoles(): Promise<{ path: string; roles: ModelRoles }> {
+  const path = getOmpConfigPath();
+  if (!(await Bun.file(path).exists())) return { path, roles: {} };
+  const data = Bun.YAML.parse(await Bun.file(path).text());
+  if (!isRecord(data) || !isRecord(data.modelRoles)) return { path, roles: {} };
+  return {
+    path,
+    roles: Object.fromEntries(Object.entries(data.modelRoles).filter((entry): entry is [string, string] => typeof entry[1] === 'string')),
+  };
+}
+
+/** Updates only modelRoles, preserving the user's remaining native OMP config. */
+export async function writeModelRoles(roles: ModelRoles): Promise<void> {
+  const path = getOmpConfigPath();
+  const source = (await Bun.file(path).exists()) ? await Bun.file(path).text() : '';
+  const doc = asMapping(Bun.YAML.parse(source), path);
+  doc.modelRoles = roles;
+  await writeFileAtomic(path, Bun.YAML.stringify(doc, null, 2));
+}
+
+export async function readDisabledProviders(): Promise<Set<string>> {
+  const path = getOmpConfigPath();
+  if (!(await Bun.file(path).exists())) return new Set();
+  const data = Bun.YAML.parse(await Bun.file(path).text());
+  if (!isRecord(data) || !Array.isArray(data.disabledProviders)) return new Set();
+  return new Set(data.disabledProviders.filter((provider): provider is string => typeof provider === 'string'));
+}

package/src/server/lib/omp/config/skills-catalog.ts

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Skills.sh catalog bridge — real search via https://skills.sh/api/search and
+ * install via `bunx skills add <package>` (same surfaces ompweb uses).
+ * Search failures degrade to an empty list so the catalog tab still renders.
+ */
+
+import { isMockMode } from '@/server/mock.server';
+import type { CatalogSkillItem } from '@/shared/types';
+
+const SEARCH_API_BASE = Bun.env.SKILLS_API_URL || 'https://skills.sh';
+const SEARCH_TIMEOUT_MS = 15_000;
+const INSTALL_TIMEOUT_MS = 180_000;
+
+export interface CatalogSearchResult {
+  package: string;
+  name: string;
+  source: string;
+  installs: number;
+}
+
+/** Search the skills.sh catalog; returns [] on any failure. */
+export async function searchSkillCatalog(query: string, limit = 24): Promise<CatalogSearchResult[]> {
+  if (isMockMode()) return [];
+  const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=${Math.min(50, Math.max(1, limit))}`;
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS) });
+    if (!response.ok) return [];
+    const data = (await response.json()) as { skills?: Array<{ id?: string; name?: string; source?: string; installs?: number }> };
+    return (data.skills ?? [])
+      .filter((skill) => typeof skill.id === 'string' && skill.id.length > 0)
+      .map((skill) => ({
+        package: skill.id as string,
+        name: typeof skill.name === 'string' ? skill.name : (skill.id as string),
+        source: typeof skill.source === 'string' ? skill.source : '',
+        installs: typeof skill.installs === 'number' ? skill.installs : 0,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+/** Map catalog search results into the CatalogSkillItem contract of the UI.
+ * instructions carries the package name so a later install POST can resolve
+ * it back to a skills.sh package without extra component fields. */
+export function toCatalogSkills(results: CatalogSearchResult[], sourceId: string): CatalogSkillItem[] {
+  return results.map((result) => ({
+    id: `catalog-${result.package}`,
+    sourceId,
+    name: result.name,
+    description: result.source ? `From ${result.source}` : '',
+    repoTag: result.package,
+    githubUrl: result.source ? `https://github.com/${result.source}` : undefined,
+    instructions: result.package,
+  }));
+}
+
+async function runBunxSkills(args: string[]): Promise<string> {
+  const proc = Bun.spawn({
+    cmd: ['bunx', 'skills', ...args],
+    stdout: 'pipe',
+    stderr: 'pipe',
+    timeout: INSTALL_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() || `bunx skills ${args[0]} exited with code ${exitCode}`);
+  return stdout;
+}
+
+/** Install a catalog skill into the omp agent skill root. */
+export async function installCatalogSkill(pkg: string): Promise<{ output: string }> {
+  if (!/^[\w.\-]+\/[\w.\-@:]+$/.test(pkg)) throw new Error('Invalid skill package');
+  if (isMockMode()) throw new Error('Skill install is unavailable in mock mode');
+  const output = await runBunxSkills(['add', pkg, '--agent', 'universal', '-g', '-y']);
+  return { output: output.slice(-4000) };
+}
+
+/** Check for updates on an installed catalog skill. */
+export async function checkCatalogSkillUpdate(pkg: string): Promise<{ output: string }> {
+  if (!/^[\w.\-]+\/[\w.\-@:]+$/.test(pkg)) throw new Error('Invalid skill package');
+  const output = await runBunxSkills(['check', pkg]);
+  return { output: output.slice(-4000) };
+}