ompchamber 0.3.0

package/src/server/routes/settings/agents.ts

@@ -0,0 +1,128 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { getDb } from '@/server/db.server';
+import { DEFAULT_AGENTS_LIST } from '@/client/data/agent-data';
+import { isMockMode } from '@/server/mock.server';
+import type { AgentItem } from '@/shared/types';
+import { createSettingsListStore } from '@/server/lib/db/settings-store';
+import { deleteAgentDefinition, discoverNativeAgents, writeAgentDefinition, type DiscoveredAgent } from '@/server/lib/omp/config/agents';
+
+const agentsStore = createSettingsListStore<AgentItem>({
+  key: 'omp_agents',
+  mockDefaults: DEFAULT_AGENTS_LIST,
+  idOf: (agent) => agent.id,
+  singular: 'agent',
+  plural: 'agents',
+});
+
+/**
+ * Convert a natively discovered omp agent into the chamber AgentItem shape.
+ * Native agents are surfaced as read-only built-ins (isBuiltIn) so the UI
+ * lists them alongside app-local custom agents without offering edits that
+ * would silently not persist.
+ */
+function nativeToAgentItem(agent: DiscoveredAgent): AgentItem & { sourceRoot: string } {
+  return {
+    id: agent.id,
+    name: agent.name,
+    description: agent.description || `Native omp agent (${agent.sourceRoot})`,
+    scope: agent.sourceRoot === 'user' ? 'user' : 'project',
+    mode: agent.mode,
+    overrideModel: agent.overrideModel,
+    thinkingVariant: agent.thinkingVariant,
+    temperature: agent.temperature,
+    topP: agent.topP,
+    systemPrompt: agent.systemPrompt,
+    isBuiltIn: true,
+    sourceRoot: agent.sourceRoot,
+  };
+}
+
+/** Merge native omp agents (disk discovery) with app-local custom agents. */
+async function mergeAgents(custom: AgentItem[]): Promise<Array<AgentItem & { sourceRoot?: string }>> {
+  const native = (await discoverNativeAgents()).map(nativeToAgentItem);
+  const nativeNames = new Set(native.map((a) => a.name.toLowerCase()));
+  return [...native, ...custom.filter((a) => !nativeNames.has(a.name.toLowerCase()))];
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  try {
+    const db = await getDb();
+    const url = new URL(request.url);
+    const includeNative = url.searchParams.get('native') === '1' || !isMockMode();
+    const mock = isMockMode();
+    const agents = await agentsStore.read(db);
+
+    if (includeNative && !mock) {
+      return json({ agents: await mergeAgents(agents), isMock: mock });
+    }
+
+    return json({ agents, isMock: mock });
+  } catch (error: any) {
+    return json({ error: error.message, agents: isMockMode() ? DEFAULT_AGENTS_LIST : [], isMock: isMockMode() }, { status: 500 });
+  }
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  try {
+    const db = await getDb();
+
+    if (request.method === 'DELETE') {
+      const url = new URL(request.url);
+      const id = url.searchParams.get('id');
+      if (!id) {
+        return json({ error: 'id is required' }, { status: 400 });
+      }
+      if (id.startsWith('omp-')) {
+        return json({ error: 'Native omp agents are read-only in chamber' }, { status: 403 });
+      }
+
+      const list = await agentsStore.remove(db, id);
+      return json({ success: true, agents: list });
+    }
+
+    if (request.method === 'POST' || request.method === 'PUT') {
+      const body = await request.json();
+
+      // Native agent file write: { type: "write_native", fileName, ...definition }
+      if (body.type === 'write_native') {
+        if (isMockMode()) return json({ error: 'Native agent writes are unavailable in mock mode' }, { status: 400 });
+        const written = await writeAgentDefinition({
+          fileName: String(body.fileName ?? ''),
+          name: typeof body.name === 'string' ? body.name : undefined,
+          description: typeof body.description === 'string' ? body.description : undefined,
+          mode: typeof body.mode === 'string' ? body.mode : undefined,
+          model: typeof body.model === 'string' ? body.model : undefined,
+          thinking: typeof body.thinking === 'string' ? body.thinking : undefined,
+          temperature: typeof body.temperature === 'number' ? body.temperature : null,
+          topP: typeof body.topP === 'number' ? body.topP : null,
+          tools: Array.isArray(body.tools) ? body.tools.map(String) : undefined,
+          systemPrompt: String(body.systemPrompt ?? ''),
+        });
+        return json({ success: true, path: written.path, agents: await mergeAgents([]) });
+      }
+
+      // Native agent file delete: { type: "delete_native", fileName }
+      if (body.type === 'delete_native') {
+        if (isMockMode()) return json({ error: 'Native agent deletes are unavailable in mock mode' }, { status: 400 });
+        const removed = await deleteAgentDefinition(String(body.fileName ?? ''));
+        if (!removed) return json({ error: 'Native agent file not found' }, { status: 404 });
+        return json({ success: true, agents: await mergeAgents([]) });
+      }
+
+      if (!Array.isArray(body) && !Array.isArray(body.agents) && body.agent
+        && typeof body.agent.id === 'string' && body.agent.id.startsWith('omp-')) {
+        return json({ error: 'Native omp agents are read-only in chamber' }, { status: 403 });
+      }
+
+      const updatedAgents = await agentsStore.upsert(db, body);
+      await agentsStore.write(db, updatedAgents);
+      return json({ success: true, agents: updatedAgents });
+    }
+
+    return methodNotAllowed({ request, params });
+  } catch (error: any) {
+    return json({ error: error.message }, { status: 500 });
+  }
+}

package/src/server/routes/settings/behavior.ts

@@ -0,0 +1,125 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { getDb } from '@/server/db.server';
+import { DEFAULT_BEHAVIOR_RULES } from '@/client/data/settings/behavior';
+import { isMockMode } from '@/server/mock.server';
+import { parseApprovalRules, writeToolsApproval } from '@/server/lib/omp/config/behavior';
+import { isInstructionFileKind, readInstructionFile, saveInstructionFile } from '@/server/lib/omp/config/instructions';
+import type { InstructionFileKind } from '@/shared/types';
+
+/**
+ * Preset stores for MOCK mode only. In real mode the Behavior panel is bound to
+ * the native user instruction files (~/.omp/agent/AGENTS.md and RULES.md), so
+ * the chamber never keeps a second copy of them; the `agents` key keeps its
+ * historical name from when the panel only edited behavior rules.
+ */
+const MOCK_KEYS: Record<InstructionFileKind, string> = {
+  agents: 'omp_behavior_rules',
+  rules: 'omp_rules_md',
+};
+
+/** MOCK preset per file: shipped rules for AGENTS.md, nothing for RULES.md. */
+const MOCK_PRESETS: Record<InstructionFileKind, string> = {
+  agents: DEFAULT_BEHAVIOR_RULES,
+  rules: '',
+};
+
+function readKind(value: unknown): InstructionFileKind | null {
+  const kind = value ?? 'agents';
+  return isInstructionFileKind(kind) ? kind : null;
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const mock = isMockMode();
+  const kind = readKind(new URL(request.url).searchParams.get('file'));
+  if (!kind) {
+    return json({ error: 'file must be "agents" or "rules"' }, { status: 400 });
+  }
+
+  try {
+    if (mock) {
+      const db = await getDb();
+      const row = await db.get('SELECT value FROM app_settings WHERE key = ?', [MOCK_KEYS[kind]]);
+      const stored = typeof row?.value === 'string' ? row.value : undefined;
+      if (stored === undefined && MOCK_PRESETS[kind]) {
+        await db.run('INSERT OR REPLACE INTO app_settings (key, value) VALUES (?, ?)', [MOCK_KEYS[kind], MOCK_PRESETS[kind]]);
+      }
+      return json({ kind, rules: stored ?? MOCK_PRESETS[kind], path: null, exists: false, isMock: true });
+    }
+
+    const file = await readInstructionFile(kind);
+    return json({ kind, rules: file.content, path: file.path, exists: file.exists, isMock: false });
+  } catch (error) {
+    return json(
+      {
+        error: error instanceof Error ? error.message : String(error),
+        kind,
+        rules: MOCK_PRESETS[kind],
+        path: null,
+        exists: false,
+        isMock: mock,
+      },
+      { status: 500 },
+    );
+  }
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  try {
+    if (request.method !== 'POST' && request.method !== 'PUT') {
+      return methodNotAllowed({ request, params });
+    }
+
+    const body = await request.json();
+    const kind = readKind(body.file);
+    if (!kind) {
+      return json({ error: 'file must be "agents" or "rules"' }, { status: 400 });
+    }
+
+    // Resetting AGENTS.md restores the shipped default rules; RULES.md has no
+    // shipped default, so resetting it clears the file.
+    const rules = body.action === 'reset' ? MOCK_PRESETS[kind] : body.rules;
+    if (typeof rules !== 'string') {
+      return json({ error: 'rules must be a string' }, { status: 400 });
+    }
+
+    const mock = isMockMode();
+    if (mock) {
+      const db = await getDb();
+      await db.run('INSERT OR REPLACE INTO app_settings (key, value) VALUES (?, ?)', [MOCK_KEYS[kind], rules]);
+      return json({ success: true, kind, rules, path: null, exists: rules.trim().length > 0, isMock: true, nativeSynced: false });
+    }
+
+    const saved = await saveInstructionFile(kind, rules);
+
+    // Best-effort, AGENTS.md only: recognizable approval directives in the
+    // behavior rules also land in config.yml tools.approval. RULES.md holds
+    // hard constraints, so mirroring approvals out of it would be surprising,
+    // and a YAML failure must not fail the file save either way.
+    let nativeSynced = false;
+    let nativeError: string | undefined;
+    const approval = kind === 'agents' ? parseApprovalRules(rules) : null;
+    if (approval) {
+      try {
+        await writeToolsApproval(approval);
+        nativeSynced = true;
+      } catch (error) {
+        nativeError = error instanceof Error ? error.message : String(error);
+      }
+    }
+
+    return json({
+      success: true,
+      kind,
+      rules: saved.content,
+      path: saved.path,
+      exists: saved.exists,
+      isMock: false,
+      nativeSynced,
+      ...(nativeError ? { nativeError } : {}),
+    });
+  } catch (error) {
+    return json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,89 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { getDb } from '@/server/db.server';
+import { DEFAULT_COMMANDS_LIST } from '@/client/data/settings/command';
+import { isMockMode } from '@/server/mock.server';
+import type { CommandItem } from '@/shared/types';
+import { createSettingsListStore } from '@/server/lib/db/settings-store';
+import { runUtilityCommand } from '@/server/lib/omp/rpc/utility';
+
+const commandsStore = createSettingsListStore<CommandItem>({
+  key: 'omp_commands_settings',
+  mockDefaults: DEFAULT_COMMANDS_LIST,
+  idOf: (command) => command.id,
+  singular: 'command',
+  plural: 'commands',
+});
+
+/** Read live agent commands (skill/custom/extension/file sources) via RPC. */
+async function loadAgentCommands(): Promise<CommandItem[]> {
+  try {
+    const data = await runUtilityCommand<{ commands?: unknown }>({ type: 'get_available_commands' }, 30_000);
+    const available = Array.isArray(data.commands) ? data.commands : [];
+    const agentSources = new Set(['skill', 'custom', 'extension', 'file']);
+    return available
+      .filter((c) => agentSources.has((c as { source?: string })?.source ?? ''))
+      .map((c) => {
+        const command = c as { name?: string; description?: string; source?: string };
+        const name = typeof command.name === 'string' ? command.name : '';
+        return {
+          id: `omp-live-${name}`,
+          name,
+          description: typeof command.description === 'string' ? command.description : '',
+          scope: 'user' as const,
+          template: `/${name}`,
+          isBuiltIn: true,
+        };
+      })
+      .filter((c) => c.name.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+/** Merge live agent commands ahead of app-local custom commands. */
+async function mergeCommands(custom: CommandItem[]): Promise<CommandItem[]> {
+  const live = await loadAgentCommands();
+  const liveNames = new Set(live.map((c) => c.name.toLowerCase()));
+  return [...live, ...custom.filter((c) => !liveNames.has(c.name.toLowerCase()))];
+}
+
+export async function loader({ request: _request }: LoaderFunctionArgs) {
+  try {
+    const db = await getDb();
+    const mock = isMockMode();
+    const commands = await commandsStore.read(db);
+    const merged = mock ? commands : await mergeCommands(commands);
+    return json({ commands: merged, isMock: mock });
+  } catch (error: any) {
+    const mock = isMockMode();
+    return json({ error: error.message, commands: mock ? DEFAULT_COMMANDS_LIST : [], isMock: mock }, { status: 500 });
+  }
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  try {
+    const db = await getDb();
+
+    if (request.method === 'DELETE') {
+      const url = new URL(request.url);
+      const id = url.searchParams.get('id');
+      if (!id) return json({ error: 'id is required' }, { status: 400 });
+
+      const list = await commandsStore.remove(db, id);
+      return json({ success: true, commands: list });
+    }
+
+    if (request.method === 'POST' || request.method === 'PUT') {
+      const body = await request.json();
+      const updatedCommands = await commandsStore.upsert(db, body);
+      await commandsStore.write(db, updatedCommands);
+      return json({ success: true, commands: updatedCommands });
+    }
+
+    return methodNotAllowed({ request, params });
+  } catch (error: any) {
+    return json({ error: error.message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,28 @@
+import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import * as settingsRoot from '@/server/routes/settings/root';
+import * as settingsAgents from '@/server/routes/settings/agents';
+import * as settingsBehavior from '@/server/routes/settings/behavior';
+import * as settingsCommands from '@/server/routes/settings/commands';
+import * as settingsMcp from '@/server/routes/settings/mcp';
+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 settingsProviders from '@/server/routes/settings/providers';
+import * as settingsSkills from '@/server/routes/settings/skills';
+import * as settingsUsage from '@/server/routes/settings/usage';
+
+export const settingsBindings: HandlerBinding[] = [
+  ...bindingsFor(settingsRoot, '/api/settings'),
+  ...bindingsFor(settingsAgents, '/api/settings/agents'),
+  ...bindingsFor(settingsBehavior, '/api/settings/behavior'),
+  ...bindingsFor(settingsCommands, '/api/settings/commands'),
+  ...bindingsFor(settingsMcp, '/api/settings/mcp'),
+  ...bindingsFor(settingsMcpTest, '/api/settings/mcp-test'),
+  ...bindingsFor(settingsOmpConfig, '/api/settings/omp-config'),
+  ...bindingsFor(settingsProjects, '/api/settings/projects'),
+  ...bindingsFor(settingsProviderModels, '/api/settings/provider-models'),
+  ...bindingsFor(settingsProviders, '/api/settings/providers'),
+  ...bindingsFor(settingsSkills, '/api/settings/skills'),
+  ...bindingsFor(settingsUsage, '/api/settings/usage'),
+];

package/src/server/routes/settings/mcp-test.ts

@@ -0,0 +1,71 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { testMcpServer } from '@/server/lib/omp/config/mcp-test';
+import type { McpServerItem } from '@/shared/types';
+
+/**
+ * POST /api/settings/mcp-test — runs a real MCP JSON-RPC 2.0 handshake
+ * against the supplied server configuration. Body: { server: McpServerItem,
+ * cwd?: string }. Returns 200 with a `McpTestResult` (ok:false on a failed
+ * handshake, not a 500) and 400 on malformed input.
+ */
+
+function isMcpEnvVar(value: unknown): value is { id: string; key: string; value: string } {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const v = value as Record<string, unknown>;
+  return typeof v.id === 'string' && typeof v.key === 'string' && typeof v.value === 'string';
+}
+
+function isMcpServerItem(value: unknown): value is McpServerItem {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const v = value as Record<string, unknown>;
+  return (
+    typeof v.id === 'string' &&
+    typeof v.name === 'string' &&
+    (v.scope === 'every-project' || v.scope === 'this-project') &&
+    typeof v.enabled === 'boolean' &&
+    (v.reachType === 'command' || v.reachType === 'link') &&
+    Array.isArray(v.commandArgs) &&
+    v.commandArgs.every((arg) => typeof arg === 'string') &&
+    (v.linkUrl === undefined || typeof v.linkUrl === 'string') &&
+    Array.isArray(v.envVars) &&
+    v.envVars.every(isMcpEnvVar)
+  );
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method !== 'POST') {
+    return methodNotAllowed({ request, params });
+  }
+
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+    return json({ error: 'Invalid request body' }, { status: 400 });
+  }
+
+  const { server, cwd } = body as { server?: unknown; cwd?: unknown };
+  if (!isMcpServerItem(server)) {
+    return json({ error: 'Malformed server input' }, { status: 400 });
+  }
+  if (cwd !== undefined && typeof cwd !== 'string') {
+    return json({ error: 'cwd must be a string' }, { status: 400 });
+  }
+
+  try {
+    const result = await testMcpServer({ server, cwd });
+    return json(result);
+  } catch {
+    // Truly unexpected internal error — never leak env, secrets, or stack.
+    return json(
+      { ok: false, transport: server.reachType, durationMs: 0, error: 'Internal error during MCP test' },
+      { status: 500 },
+    );
+  }
+}