@kabmo-labs/kabmo 0.30.1 → 0.31.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (107) hide show
  1. package/README.md +79 -21
  2. package/dist/client/index.html +1 -1
  3. package/dist/client/index.js +481 -462
  4. package/dist/client/static/js/{index-bwhhehnh.js → index-r3bhgvkt.js} +772 -773
  5. package/marketplace/plugins/stats/package.json +2 -2
  6. package/marketplace/plugins/stats/src/format.test.ts +7 -1
  7. package/package.json +2 -2
  8. package/src/client/components/common/context-usage-button/McpSection.tsx +133 -0
  9. package/src/client/components/common/context-usage-button/Ring.tsx +12 -6
  10. package/src/client/components/common/context-usage-button/index.test.tsx +24 -13
  11. package/src/client/components/common/context-usage-button/index.tsx +32 -34
  12. package/src/client/components/common/session-row/TrailingSlot.tsx +6 -2
  13. package/src/client/components/common/session-row/session-row.test.tsx +13 -0
  14. package/src/client/components/layout/desktop-layout/index.tsx +5 -1
  15. package/src/client/components/mobile/RightSidebar.tsx +2 -1
  16. package/src/client/components/settings/categories/McpSettings.tsx +10 -3
  17. package/src/client/components/settings/categories/mcp-settings/AdvancedSection.tsx +244 -0
  18. package/src/client/components/settings/categories/mcp-settings/ConnectionTest.tsx +3 -3
  19. package/src/client/components/settings/categories/mcp-settings/DetailPane.tsx +55 -97
  20. package/src/client/components/settings/categories/mcp-settings/ImportModal.tsx +12 -64
  21. package/src/client/components/settings/categories/mcp-settings/{EnvVarsSection.tsx → KeyValueSection.tsx} +42 -24
  22. package/src/client/components/settings/categories/mcp-settings/SidebarList.tsx +1 -1
  23. package/src/client/components/settings/categories/mcp-settings/TransportSection.tsx +101 -0
  24. package/src/client/components/workspace/browser-panel/EngineNotice.test.tsx +109 -0
  25. package/src/client/components/workspace/browser-panel/EngineNotice.tsx +112 -0
  26. package/src/client/components/workspace/browser-panel/index.tsx +45 -12
  27. package/src/client/components/workspace/chat-timeline/chat-input/AccessDropdown.test.ts +63 -0
  28. package/src/client/components/workspace/chat-timeline/chat-input/AccessDropdown.tsx +18 -6
  29. package/src/client/components/workspace/chat-timeline/chat-input/Toolbar.tsx +3 -1
  30. package/src/client/components/workspace/chat-timeline/chat-input/access-levels.ts +39 -1
  31. package/src/client/components/workspace/chat-timeline/tool-renderers/panels/Eval.test.tsx +13 -7
  32. package/src/client/components/workspace/editor/plugin-rail.test.tsx +6 -1
  33. package/src/client/components/workspace/terminal-panel/scroll-hold.test.ts +20 -5
  34. package/src/client/data/settings/mcp.ts +4 -2
  35. package/src/client/data/settings/omp-schema.json +22 -2
  36. package/src/client/hooks/browser/use-browser-engine.ts +99 -0
  37. package/src/client/hooks/chat/context/mcp.ts +159 -0
  38. package/src/client/hooks/chat/timeline/access-mode.ts +45 -15
  39. package/src/client/hooks/chat/timeline/index.ts +7 -3
  40. package/src/client/hooks/chat/timeline/timeline-mode-state.test.ts +33 -4
  41. package/src/client/hooks/ui/ui-listeners.test.ts +13 -18
  42. package/src/server/lib/browser/engine.test.ts +118 -0
  43. package/src/server/lib/browser/engine.ts +102 -0
  44. package/src/server/lib/db/schema.ts +4 -0
  45. package/src/server/lib/fs/toolchain-path.test.ts +87 -0
  46. package/src/server/lib/fs/toolchain-path.ts +49 -0
  47. package/src/server/lib/harness/acp/protocol.ts +9 -1
  48. package/src/server/lib/harness/auto-probe.server.ts +3 -2
  49. package/src/server/lib/harness/launch-table.ts +3 -2
  50. package/src/server/lib/harness/spawn.server.ts +5 -1
  51. package/src/server/lib/harness/update-queue.server.ts +2 -1
  52. package/src/server/lib/harness/update-state.server.ts +6 -2
  53. package/src/server/lib/mcp/probe.server.ts +71 -0
  54. package/src/server/lib/mcp/registry.server.ts +195 -46
  55. package/src/server/lib/mcp/registry.test.ts +76 -4
  56. package/src/server/lib/mcp/schema.server.ts +35 -0
  57. package/src/server/lib/mcp/session-mcp.test.ts +164 -0
  58. package/src/server/lib/mcp/session-overlay.server.ts +152 -0
  59. package/src/server/lib/mcp/session-state.server.ts +75 -0
  60. package/src/server/lib/mcp/store.server.ts +6 -1
  61. package/src/server/lib/omp/config/config-cli.ts +4 -0
  62. package/src/server/lib/omp/config/mcp-and-cli.test.ts +12 -183
  63. package/src/server/lib/omp/config/mcp-config.test.ts +277 -0
  64. package/src/server/lib/omp/config/mcp-shared.ts +36 -0
  65. package/src/server/lib/omp/config/mcp-test-protocol.ts +89 -0
  66. package/src/server/lib/omp/config/mcp-test-remote.ts +167 -0
  67. package/src/server/lib/omp/config/mcp-test.ts +21 -123
  68. package/src/server/lib/omp/config/mcp-write.ts +179 -0
  69. package/src/server/lib/omp/config/mcp.ts +138 -118
  70. package/src/server/lib/omp/core/cli.ts +4 -14
  71. package/src/server/lib/omp/rpc/manager.ts +12 -17
  72. package/src/server/lib/omp/rpc/reload-mcp.ts +39 -0
  73. package/src/server/lib/omp/rpc/session-registry.ts +6 -2
  74. package/src/server/lib/omp/rpc/spawn-mcp.ts +43 -0
  75. package/src/server/lib/omp/session/delete.server.ts +7 -0
  76. package/src/server/lib/plugins/mcp.server.ts +2 -2
  77. package/src/server/lib/realtime/topics/workspace.server.test.ts +44 -0
  78. package/src/server/lib/realtime/topics/workspace.server.ts +3 -2
  79. package/src/server/routes/browser/engine.test.ts +70 -0
  80. package/src/server/routes/browser/engine.ts +51 -0
  81. package/src/server/routes/browser/index.ts +5 -0
  82. package/src/server/routes/fs/git.ts +4 -3
  83. package/src/server/routes/harness/versions.test.ts +5 -0
  84. package/src/server/routes/sessions/index.ts +7 -0
  85. package/src/server/routes/sessions/mcp.test.ts +154 -0
  86. package/src/server/routes/sessions/mcp.ts +202 -0
  87. package/src/server/routes/settings/mcp-test.ts +5 -4
  88. package/src/server/routes/settings/mcp.test.ts +42 -1
  89. package/src/server/routes/settings/mcp.ts +80 -24
  90. package/src/shared/lib/code/highlight-memo.test.ts +18 -0
  91. package/src/shared/lib/code/highlight-memo.ts +46 -17
  92. package/src/shared/lib/mcp/import.ts +112 -0
  93. package/src/shared/lib/mcp/item.ts +61 -0
  94. package/src/shared/lib/mcp/key-value.ts +37 -0
  95. package/src/shared/lib/mcp/mcp-lib.test.ts +119 -0
  96. package/src/shared/lib/mcp/status.test.ts +36 -0
  97. package/src/shared/lib/mcp/status.ts +38 -0
  98. package/src/shared/lib/models/client.ts +27 -6
  99. package/src/shared/lib/models/provider/models.test.ts +31 -0
  100. package/src/shared/lib/omp/config/access-mode.test.ts +73 -0
  101. package/src/shared/lib/omp/config/access-mode.ts +49 -0
  102. package/src/shared/lib/workspace/right-panels.ts +13 -0
  103. package/src/shared/lib/workspace/workspace-modules.test.ts +3 -1
  104. package/src/shared/types/browser.ts +21 -0
  105. package/src/shared/types/settings/mcp.ts +73 -4
  106. package/src/test-support/pristine-globals.test.ts +53 -0
  107. package/src/test-support/pristine-globals.ts +6 -1
@@ -0,0 +1,70 @@
1
+ /**
2
+ * @license
3
+ * SPDX-License-Identifier: MIT
4
+ */
5
+
6
+ /**
7
+ * `GET/POST /api/browser/engine` — the refusals, which are the whole contract.
8
+ *
9
+ * The success path shells out to `omp config set`, so it is not exercised here
10
+ * (the resolver's own cases cover the answer). What this file pins is that a
11
+ * malformed request never reaches that write, and that MOCK mode says so
12
+ * instead of pretending a config file changed.
13
+ */
14
+
15
+ import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test';
16
+ import { action, loader } from '@/server/routes/browser/engine';
17
+
18
+ const originalMock = Bun.env.MOCK;
19
+
20
+ beforeAll(() => {
21
+ delete Bun.env.MOCK;
22
+ });
23
+
24
+ afterEach(() => {
25
+ if (originalMock === undefined) delete Bun.env.MOCK;
26
+ else Bun.env.MOCK = originalMock;
27
+ });
28
+
29
+ afterAll(() => {
30
+ delete Bun.env.MOCK;
31
+ });
32
+
33
+ function post(body: unknown): Promise<Response> {
34
+ return action({
35
+ params: {},
36
+ request: new Request('http://localhost/api/browser/engine', {
37
+ method: 'POST',
38
+ headers: { 'content-type': 'application/json' },
39
+ body: typeof body === 'string' ? body : JSON.stringify(body),
40
+ }),
41
+ } as never) as Promise<Response>;
42
+ }
43
+
44
+ describe('browser engine route', () => {
45
+ test('a non-boolean webkit is refused before any config write', async () => {
46
+ const res = await post({ webkit: 'false' });
47
+ expect(res.status).toBe(400);
48
+ expect(((await res.json()) as { error: string }).error).toContain('boolean');
49
+ });
50
+
51
+ test('a malformed body is refused', async () => {
52
+ const res = await post('{');
53
+ expect(res.status).toBe(400);
54
+ });
55
+
56
+ test('MOCK mode refuses the write instead of pretending it landed', async () => {
57
+ Bun.env.MOCK = 'true';
58
+ const res = await post({ webkit: false });
59
+ expect(res.status).toBe(503);
60
+ expect(((await res.json()) as { error: string }).error).toContain('mock mode');
61
+ });
62
+
63
+ test('the loader reports the server mode so the panel can stay quiet in MOCK', async () => {
64
+ Bun.env.MOCK = 'true';
65
+ const res = await loader();
66
+ const body = (await res.json()) as { mock: boolean; effective: string };
67
+ expect(body.mock).toBe(true);
68
+ expect(['webkit', 'chromium']).toContain(body.effective);
69
+ });
70
+ });
@@ -0,0 +1,51 @@
1
+ /**
2
+ * @license
3
+ * SPDX-License-Identifier: MIT
4
+ */
5
+
6
+ /**
7
+ * GET/POST /api/browser/engine — which engine the agent's browser will use.
8
+ *
9
+ * The Browser Agent panel mirrors the project-shared Chromium over CDP. omp's
10
+ * own WebKit engine has no CDP endpoint, so a session on WebKit can never
11
+ * appear in the panel. This route is how the panel knows to say that instead
12
+ * of waiting for a frame that cannot arrive, and how its button switches the
13
+ * agent to Chromium.
14
+ *
15
+ * The write is `browser.webkit = false` through the same `omp config set` the
16
+ * settings panel uses — one writer, so the two cannot disagree. omp reads the
17
+ * key at open time (measured: a tab opened after the write used the shared
18
+ * Chromium daemon in the same running session), so no restart is needed.
19
+ */
20
+
21
+ import { json } from '@/server/lib/remix-compat';
22
+ import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
23
+ import { methodNotAllowed, parseJsonBody } from '@/server/lib/route-adapter';
24
+ import { isMockMode } from '@/server/mock.server';
25
+ import { setOmpConfigValue } from '@/server/lib/omp/config/config-cli';
26
+ import { readBrowserEngineState } from '@/server/lib/browser/engine';
27
+
28
+ export async function loader() {
29
+ return json({ ...(await readBrowserEngineState()), mock: isMockMode() });
30
+ }
31
+
32
+ export async function action({ request, params }: ActionFunctionArgs) {
33
+ if (request.method !== 'POST') {
34
+ return methodNotAllowed({ request, params });
35
+ }
36
+ if (isMockMode()) {
37
+ return json({ error: 'config writes are unavailable in mock mode' }, { status: 503 });
38
+ }
39
+ const parsed = await parseJsonBody<{ webkit?: unknown }>(request);
40
+ if (!parsed.ok) return json({ error: 'Invalid JSON body' }, { status: 400 });
41
+ const webkit = parsed.body?.webkit;
42
+ if (typeof webkit !== 'boolean') {
43
+ return json({ error: 'webkit must be a boolean' }, { status: 400 });
44
+ }
45
+ try {
46
+ await setOmpConfigValue('browser.webkit', webkit);
47
+ return json({ ...(await readBrowserEngineState()), mock: false });
48
+ } catch (error) {
49
+ return json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
50
+ }
51
+ }
@@ -1,8 +1,13 @@
1
1
  import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
2
+ import * as browserEngine from '@/server/routes/browser/engine';
2
3
  import * as browserStream from '@/server/routes/browser/stream';
3
4
  import * as browserTabs from '@/server/routes/browser/tabs';
4
5
 
5
6
  export const browserBindings: HandlerBinding[] = [
7
+ // Static segment first: it shares the `/api/browser/…` position with the
8
+ // parameter routes below, and a parameter route winning the match would
9
+ // answer 405 for the engine probe.
10
+ ...bindingsFor(browserEngine, '/api/browser/engine'),
6
11
  ...bindingsFor(browserStream, '/api/browser/:sessionId/stream'),
7
12
  // Mutating route: `bindingsFor` adds the 405 GET fallback on its own.
8
13
  ...bindingsFor(browserTabs, '/api/browser/:sessionId/tabs/close'),
@@ -17,7 +17,8 @@
17
17
  import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
18
18
  import path from 'path';
19
19
  import { COMMIT_PAGE_SIZE } from '@/shared/lib/fs/commit-page';
20
- import { resolveRoot } from '@/server/lib/fs/root';
20
+ import { getDefaultFsRoot, resolveRoot } from '@/server/lib/fs/root';
21
+ import { isMockMode } from '@/server/mock.server';
21
22
  import { discoveredRepos, rescanRepos, startRepoScan } from '@/server/lib/fs/git-repos';
22
23
  import { readRepoDetails } from '@/server/lib/fs/git-repo-details';
23
24
  import { fetchGitCommits, readHeadCommitMessage } from '@/server/lib/fs/git-log';
@@ -33,7 +34,7 @@ import { emitRealtimeSignal } from '@/server/lib/realtime/signals.server';
33
34
 
34
35
  export async function loader({ request }: LoaderFunctionArgs) {
35
36
  const url = new URL(request.url);
36
- const rootDir = await resolveRoot(url.searchParams.get('root'), process.cwd());
37
+ const rootDir = await resolveRoot(url.searchParams.get('root'), await getDefaultFsRoot(isMockMode()));
37
38
 
38
39
  // Kick off nested-repo discovery in the background (non-blocking) and read
39
40
  // whatever is already cached. `rescan=1` invalidates the cache so a fresh
@@ -176,7 +177,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
176
177
 
177
178
  export async function action({ request }: ActionFunctionArgs) {
178
179
  const formData = await request.formData();
179
- const rootDir = await resolveRoot(formData.get('root') as string, process.cwd());
180
+ const rootDir = await resolveRoot(formData.get('root') as string, await getDefaultFsRoot(isMockMode()));
180
181
  const repo = (formData.get('repo') as string) || '.';
181
182
  const targetDir = repo === '.' ? rootDir : path.join(rootDir, repo);
182
183
  if (targetDir !== rootDir && !targetDir.startsWith(rootDir + path.sep)) {
@@ -51,6 +51,11 @@ describe('harness version rows', () => {
51
51
  const claude = await row('claude');
52
52
  // `false` here would claim "up to date" about an unknown version.
53
53
  expect(claude.agent.updateAvailable).toBe(false);
54
+ // "Not probed yet" is about an AGENT that exists and has not been asked —
55
+ // a clean Windows runner has no `claude`, and its row honestly says it is
56
+ // not installed. Guarded like every other case here, because the runner's
57
+ // toolchain is not the fact under test.
58
+ if (!claude.installed) return;
54
59
  expect(claude.note).toContain('Not probed');
55
60
  });
56
61
 
@@ -20,6 +20,7 @@ import { spawnSession } from '@/server/routes/sessions/spawn';
20
20
  import { getSessionRelations, updateSessionParent } from '@/server/routes/sessions/relations';
21
21
  import { forkSessionRoute } from '@/server/routes/sessions/fork';
22
22
  import { getSessionAnswer } from '@/server/routes/sessions/answer';
23
+ import { getSessionMcp, probeSessionMcp, setSessionMcp } from '@/server/routes/sessions/mcp';
23
24
 
24
25
  export const sessionsBindings: HandlerBinding[] = [
25
26
  ...bindingsFor(sessionsList, '/api/sessions/list'),
@@ -41,6 +42,12 @@ export const sessionsBindings: HandlerBinding[] = [
41
42
  { method: 'POST', path: '/api/sessions/:sessionId/parent', handler: updateSessionParent },
42
43
  { method: 'POST', path: '/api/sessions/:sessionId/fork', handler: forkSessionRoute },
43
44
  { method: 'GET', path: '/api/sessions/:sessionId/answer', handler: getSessionAnswer },
45
+ // The MCP list this session has, and the per-session switch. A static suffix
46
+ // under the same `:sessionId` position, so the parameter name must stay
47
+ // `sessionId` (Elysia requires one name per position).
48
+ { method: 'GET', path: '/api/sessions/:sessionId/mcp', handler: getSessionMcp },
49
+ { method: 'POST', path: '/api/sessions/:sessionId/mcp', handler: setSessionMcp },
50
+ { method: 'POST', path: '/api/sessions/:sessionId/mcp/probe', handler: probeSessionMcp },
44
51
  // DELETE-only on the same path the folder loader answers GET on: mounting it
45
52
  // through `actionBindings` would register a 405 GET fallback that Elysia
46
53
  // applies after the loader, replacing the workspace listing with it.
@@ -0,0 +1,154 @@
1
+ /**
2
+ * @license
3
+ * SPDX-License-Identifier: MIT
4
+ */
5
+
6
+ /**
7
+ * `GET/POST /api/sessions/:sessionId/mcp` — the list a session has and the
8
+ * per-session switch.
9
+ *
10
+ * The route is called directly, as the other route tests do. The database is a
11
+ * temp SQLite file and `PI_CODING_AGENT_DIR` a temp tree, so the merge and the
12
+ * override store are exercised for real while nothing outside `/tmp` is read.
13
+ */
14
+
15
+ import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
16
+ import fs from 'fs';
17
+ import os from 'os';
18
+ import path from 'path';
19
+ import { isolateDb, releaseDb } from '@/test-support/isolated-db';
20
+ import { removeDir } from '@/test-support/remove-dir';
21
+ import { saveHarnessSession } from '@/server/lib/harness/session-store.server';
22
+ import { getSessionMcp, probeSessionMcp, setSessionMcp } from '@/server/routes/sessions/mcp';
23
+ import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
24
+ import type { SessionMcpPayload } from '@/shared/types';
25
+
26
+ const ROOT = path.join(os.tmpdir(), `kabmo-session-mcp-route-${process.pid}`);
27
+ const AGENT = path.join(ROOT, 'agent');
28
+ const PROJECT = path.join(ROOT, 'project');
29
+ const SESSION = '11111111-2222-3333-4444-555555555555';
30
+ const previousAgentDir = Bun.env.PI_CODING_AGENT_DIR;
31
+
32
+ /** The POST answer: the list plus what the server did with the change. */
33
+ interface SetSessionMcpResponse extends SessionMcpPayload {
34
+ success: boolean;
35
+ applied: boolean;
36
+ appliesOnNextSpawn: boolean;
37
+ }
38
+
39
+ beforeAll(async () => {
40
+ removeDir(ROOT);
41
+ fs.mkdirSync(AGENT, { recursive: true });
42
+ fs.mkdirSync(path.join(PROJECT, '.omp'), { recursive: true });
43
+ Bun.env.PI_CODING_AGENT_DIR = AGENT;
44
+ fs.writeFileSync(
45
+ path.join(AGENT, 'mcp.json'),
46
+ JSON.stringify({
47
+ mcpServers: {
48
+ alpha: { command: 'alpha-cmd' },
49
+ beta: { command: 'beta-cmd' },
50
+ },
51
+ }),
52
+ );
53
+ fs.writeFileSync(
54
+ path.join(PROJECT, '.omp', 'mcp.json'),
55
+ JSON.stringify({ mcpServers: { gamma: { command: 'gamma-cmd' } } }),
56
+ );
57
+ });
58
+
59
+ afterAll(async () => {
60
+ await releaseDb();
61
+ if (previousAgentDir === undefined) delete Bun.env.PI_CODING_AGENT_DIR;
62
+ else Bun.env.PI_CODING_AGENT_DIR = previousAgentDir;
63
+ removeDir(ROOT);
64
+ });
65
+
66
+ beforeEach(async () => {
67
+ await isolateDb();
68
+ await saveHarnessSession({ sessionId: SESSION, harness: 'omp-rpc', agentSessionId: '', cwd: PROJECT });
69
+ });
70
+
71
+ function loaderArgs(): LoaderFunctionArgs {
72
+ return {
73
+ params: { sessionId: SESSION },
74
+ request: new Request(`http://localhost/api/sessions/${SESSION}/mcp`),
75
+ } as LoaderFunctionArgs;
76
+ }
77
+
78
+ function actionArgs(body: unknown, method = 'POST'): ActionFunctionArgs {
79
+ return {
80
+ params: { sessionId: SESSION },
81
+ request: new Request(`http://localhost/api/sessions/${SESSION}/mcp`, {
82
+ method,
83
+ headers: { 'Content-Type': 'application/json' },
84
+ body: method === 'POST' ? JSON.stringify(body) : undefined,
85
+ }),
86
+ } as ActionFunctionArgs;
87
+ }
88
+
89
+ async function readList(): Promise<SessionMcpPayload> {
90
+ const response = await getSessionMcp(loaderArgs());
91
+ expect(response.status).toBe(200);
92
+ return (await response.json()) as SessionMcpPayload;
93
+ }
94
+
95
+ describe('GET /api/sessions/:sessionId/mcp', () => {
96
+ test('lists the file-backed servers with their configured state', async () => {
97
+ const data = await readList();
98
+ expect(data.delivery).toBe('omp-config');
99
+ expect(data.harness).toBe('omp-rpc');
100
+ expect(data.servers.map((server) => server.name)).toEqual(['alpha', 'beta', 'gamma']);
101
+ expect(data.servers.every((server) => server.enabled)).toBe(true);
102
+ // Nothing has been probed yet: the status is unknown, never a green dot.
103
+ expect(data.servers.every((server) => server.probe === null)).toBe(true);
104
+ expect(data.servers.find((server) => server.name === 'gamma')?.source).toBe('project');
105
+ });
106
+ });
107
+
108
+ describe('POST /api/sessions/:sessionId/mcp', () => {
109
+ test('disables one server for this session and persists the override', async () => {
110
+ const response = await setSessionMcp(actionArgs({ name: 'beta', enabled: false }));
111
+ expect(response.status).toBe(200);
112
+ const data = (await response.json()) as SetSessionMcpResponse;
113
+ expect(data.overrides).toEqual({ beta: false });
114
+ expect(data.servers.find((server) => server.name === 'beta')?.enabled).toBe(false);
115
+
116
+ const reread = await readList();
117
+ expect(reread.servers.find((server) => server.name === 'beta')?.enabled).toBe(false);
118
+ });
119
+
120
+ test('toggling back to the configured state removes the override', async () => {
121
+ await setSessionMcp(actionArgs({ name: 'beta', enabled: false }));
122
+ const response = await setSessionMcp(actionArgs({ name: 'beta', enabled: true }));
123
+ const data = (await response.json()) as SetSessionMcpResponse;
124
+ expect(data.overrides).toEqual({});
125
+ });
126
+
127
+ test('an unknown server is refused by name', async () => {
128
+ const response = await setSessionMcp(actionArgs({ name: 'nope', enabled: false }));
129
+ expect(response.status).toBe(404);
130
+ const data = (await response.json()) as { error: string };
131
+ expect(data.error).toContain('nope');
132
+ });
133
+
134
+ test('a non-POST verb is a 405', async () => {
135
+ const response = await setSessionMcp(actionArgs(null, 'GET'));
136
+ expect(response.status).toBe(405);
137
+ });
138
+ });
139
+
140
+ describe('POST /api/sessions/:sessionId/mcp/probe', () => {
141
+ test('a disabled server is refused without spawning it', async () => {
142
+ await setSessionMcp(actionArgs({ name: 'beta', enabled: false }));
143
+ const response = await probeSessionMcp(actionArgs({ name: 'beta' }));
144
+ expect(response.status).toBe(200);
145
+ const data = (await response.json()) as { ok: boolean; error?: string };
146
+ expect(data.ok).toBe(false);
147
+ expect(data.error).toBe('Disabled for this session');
148
+ });
149
+
150
+ test('an unknown server is refused by name', async () => {
151
+ const response = await probeSessionMcp(actionArgs({ name: 'nope' }));
152
+ expect(response.status).toBe(404);
153
+ });
154
+ });
@@ -0,0 +1,202 @@
1
+ /**
2
+ * @license
3
+ * SPDX-License-Identifier: MIT
4
+ */
5
+
6
+ /**
7
+ * The MCP servers one session has, the switch that changes them for THAT
8
+ * session only, and the connection probe behind the status icon.
9
+ *
10
+ * The list is the same merge the spawn path uses (`mcpServerEntriesFor`), so
11
+ * the navbar cannot show a server the session did not receive. The delivery
12
+ * decides which sources are real: omp's RPC mode reads its own `mcp.json`
13
+ * files, while an ACP agent receives the full merged list on the handshake.
14
+ *
15
+ * Applying a toggle is transport-specific and the response says which happened:
16
+ *
17
+ * - `omp-rpc` with an overlay: rewrite the session's `mcp.json` and send
18
+ * `/mcp reload` — live, no respawn (measured on 18.20.0).
19
+ * - `omp-rpc` without one: the child read the real file at spawn, so an idle
20
+ * child is destroyed and the next command respawns it with the overlay. A
21
+ * busy child keeps its list until the next spawn.
22
+ * - ACP: the list is a handshake argument. An idle session is destroyed and
23
+ * the next command respawns it through `resumeRecordedHarnessSession` with
24
+ * the filtered list. `omp-acp` is excluded because `session/load` on omp
25
+ * forks the conversation, so it waits for the next spawn.
26
+ *
27
+ * Status is a PROBE, not a guess: omp publishes no MCP state over RPC, so the
28
+ * only honest answer is a real handshake (`probe.server.ts`), run on demand and
29
+ * cached for a minute.
30
+ */
31
+
32
+ import { json } from '@/server/lib/remix-compat';
33
+ import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
34
+ import { methodNotAllowedResponse } from '@/server/lib/route-adapter';
35
+ import { resolveSessionRef } from '@/server/lib/sessions/resolve.server';
36
+ import { asOmpSession, getLiveSession, harnessOfSession } from '@/server/lib/omp/rpc/session-registry';
37
+ import { reloadChildMcp } from '@/server/lib/omp/rpc/reload-mcp';
38
+ import { mcpServerEntriesFor, type McpServerSource } from '@/server/lib/mcp/registry.server';
39
+ import { readSessionMcpOverrides, writeSessionMcpOverrides } from '@/server/lib/mcp/session-state.server';
40
+ import { ensureSessionMcpOverlay } from '@/server/lib/mcp/session-overlay.server';
41
+ import { cachedMcpProbe, probeMcpServer } from '@/server/lib/mcp/probe.server';
42
+ import { mcpDelivery } from '@/shared/lib/harness/mcp-facts';
43
+ import { isRecord } from '@/shared/lib/util/guards';
44
+
45
+ /** The sources omp's RPC mode can actually read: its own `mcp.json` files. */
46
+ const FILE_SOURCES: readonly McpServerSource[] = ['user', 'project'];
47
+
48
+ export async function getSessionMcp({ params }: LoaderFunctionArgs) {
49
+ const sessionId = params.sessionId;
50
+ if (!sessionId) return json({ error: 'Missing session id' }, { status: 400 });
51
+
52
+ const ref = await resolveSessionRef(sessionId);
53
+ const overrides = await readSessionMcpOverrides(sessionId);
54
+ const delivery = ref.harness ? mcpDelivery(ref.harness) : null;
55
+ const servers = ref.cwd
56
+ ? await mcpServerEntriesFor(ref.cwd, {
57
+ overrides,
58
+ sources: delivery === 'omp-config' ? FILE_SOURCES : undefined,
59
+ })
60
+ : [];
61
+
62
+ return json({
63
+ sessionId,
64
+ harness: ref.harness,
65
+ delivery,
66
+ live: ref.live,
67
+ servers: servers.map(({ name, transport, source, enabled }) => ({
68
+ name,
69
+ transport,
70
+ source,
71
+ enabled,
72
+ // A fresh cached handshake, so a reopened popover paints the last answer
73
+ // without spawning the server again.
74
+ probe: cachedMcpProbe(sessionId, name) ?? null,
75
+ })),
76
+ overrides,
77
+ });
78
+ }
79
+
80
+ export async function setSessionMcp({ request, params }: ActionFunctionArgs) {
81
+ if (request.method !== 'POST') return methodNotAllowedResponse();
82
+ const sessionId = params.sessionId;
83
+ if (!sessionId) return json({ error: 'Missing session id' }, { status: 400 });
84
+
85
+ const body: unknown = await request.json().catch(() => null);
86
+ const name = isRecord(body) && typeof body.name === 'string' ? body.name.trim() : '';
87
+ const enabled = isRecord(body) && body.enabled === true;
88
+ if (!name) return json({ error: 'name is required' }, { status: 400 });
89
+
90
+ const ref = await resolveSessionRef(sessionId);
91
+ if (!ref.cwd) return json({ error: 'Session has no working directory' }, { status: 400 });
92
+ const delivery = ref.harness ? mcpDelivery(ref.harness) : null;
93
+ const sources = delivery === 'omp-config' ? FILE_SOURCES : undefined;
94
+
95
+ // The configured state is the baseline: a toggle back to it removes the
96
+ // override instead of pinning the old answer forever.
97
+ const base = await mcpServerEntriesFor(ref.cwd, { sources });
98
+ const target = base.find((entry) => entry.name === name);
99
+ if (!target) {
100
+ return json({ error: `MCP server "${name}" is not configured for this session` }, { status: 404 });
101
+ }
102
+
103
+ const overrides = await readSessionMcpOverrides(sessionId);
104
+ const next = { ...overrides };
105
+ if (enabled === target.enabled) delete next[name];
106
+ else next[name] = enabled;
107
+ await writeSessionMcpOverrides(sessionId, next);
108
+
109
+ const applied = await applySessionMcpChange(sessionId, ref.cwd, next);
110
+ const servers = await mcpServerEntriesFor(ref.cwd, { overrides: next, sources });
111
+ return json({
112
+ success: true,
113
+ sessionId,
114
+ servers: servers.map(({ name: serverName, transport, source, enabled: isEnabled }) => ({
115
+ name: serverName,
116
+ transport,
117
+ source,
118
+ enabled: isEnabled,
119
+ probe: cachedMcpProbe(sessionId, serverName) ?? null,
120
+ })),
121
+ overrides: next,
122
+ ...applied,
123
+ });
124
+ }
125
+
126
+ /**
127
+ * `POST /api/sessions/:sessionId/mcp/probe` — run a real handshake for one
128
+ * server and answer with the result. The body is `{ name }`.
129
+ */
130
+ export async function probeSessionMcp({ request, params }: ActionFunctionArgs) {
131
+ if (request.method !== 'POST') return methodNotAllowedResponse();
132
+ const sessionId = params.sessionId;
133
+ if (!sessionId) return json({ error: 'Missing session id' }, { status: 400 });
134
+
135
+ const body: unknown = await request.json().catch(() => null);
136
+ const name = isRecord(body) && typeof body.name === 'string' ? body.name.trim() : '';
137
+ if (!name) return json({ error: 'name is required' }, { status: 400 });
138
+
139
+ const ref = await resolveSessionRef(sessionId);
140
+ if (!ref.cwd) return json({ error: 'Session has no working directory' }, { status: 400 });
141
+ const delivery = ref.harness ? mcpDelivery(ref.harness) : null;
142
+ const overrides = await readSessionMcpOverrides(sessionId);
143
+ const entries = await mcpServerEntriesFor(ref.cwd, {
144
+ overrides,
145
+ sources: delivery === 'omp-config' ? FILE_SOURCES : undefined,
146
+ });
147
+ const entry = entries.find((candidate) => candidate.name === name);
148
+ if (!entry) {
149
+ return json({ error: `MCP server "${name}" is not configured for this session` }, { status: 404 });
150
+ }
151
+ if (!entry.enabled) {
152
+ return json({ ok: false, error: 'Disabled for this session', toolCount: 0, durationMs: 0, checkedAt: Date.now() });
153
+ }
154
+
155
+ // A click within the cache window is answered from the last handshake, so
156
+ // reopening the popover does not spawn the server again.
157
+ const cached = cachedMcpProbe(sessionId, name);
158
+ if (cached) return json(cached);
159
+
160
+ const probe = await probeMcpServer(sessionId, entry, ref.cwd);
161
+ return json(probe);
162
+ }
163
+
164
+ /** Apply the new overrides to a live child, or say when they will land. */
165
+ async function applySessionMcpChange(
166
+ sessionId: string,
167
+ cwd: string,
168
+ overrides: Record<string, boolean>,
169
+ ): Promise<{ applied: boolean; appliesOnNextSpawn: boolean }> {
170
+ const live = getLiveSession(sessionId);
171
+ if (!live?.isAlive()) return { applied: false, appliesOnNextSpawn: true };
172
+
173
+ const harness = harnessOfSession(live);
174
+ if (harness === 'omp-rpc') {
175
+ const wrapper = asOmpSession(live);
176
+ if (!wrapper) return { applied: false, appliesOnNextSpawn: true };
177
+ if (wrapper.mcpOverlay) {
178
+ // `keep`: the child's `PI_CODING_AGENT_DIR` points here, so the directory
179
+ // must survive even when the last override was removed.
180
+ const overlay = await ensureSessionMcpOverlay(sessionId, cwd, overrides, { keep: true });
181
+ if (!overlay) return { applied: false, appliesOnNextSpawn: true };
182
+ const reloaded = await reloadChildMcp(wrapper).catch(() => false);
183
+ return { applied: reloaded, appliesOnNextSpawn: !reloaded };
184
+ }
185
+ // No overlay: this child read the real `mcp.json` at spawn. An idle child
186
+ // is cheap to replace — the next command respawns it with the overlay.
187
+ if (!wrapper.isBusy()) {
188
+ await wrapper.destroyAndWait();
189
+ return { applied: true, appliesOnNextSpawn: false };
190
+ }
191
+ return { applied: false, appliesOnNextSpawn: true };
192
+ }
193
+
194
+ // ACP: `session/load` on omp forks the conversation, so an `omp-acp` chat
195
+ // keeps its list until the next spawn rather than losing its id.
196
+ if (harness === 'omp-acp') return { applied: false, appliesOnNextSpawn: true };
197
+ if (!live.isBusy()) {
198
+ await live.destroyAndWait();
199
+ return { applied: true, appliesOnNextSpawn: false };
200
+ }
201
+ return { applied: false, appliesOnNextSpawn: true };
202
+ }
@@ -11,7 +11,7 @@ import type { McpServerItem } from '@/shared/types';
11
11
  * handshake, not a 500) and 400 on malformed input.
12
12
  */
13
13
 
14
- function isMcpEnvVar(value: unknown): value is { id: string; key: string; value: string } {
14
+ function isMcpKeyValue(value: unknown): value is { id: string; key: string; value: string } {
15
15
  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
16
16
  const v = value as Record<string, unknown>;
17
17
  return typeof v.id === 'string' && typeof v.key === 'string' && typeof v.value === 'string';
@@ -25,12 +25,13 @@ function isMcpServerItem(value: unknown): value is McpServerItem {
25
25
  typeof v.name === 'string' &&
26
26
  (v.scope === 'every-project' || v.scope === 'this-project') &&
27
27
  typeof v.enabled === 'boolean' &&
28
- (v.reachType === 'command' || v.reachType === 'link') &&
28
+ (v.transport === 'stdio' || v.transport === 'http' || v.transport === 'sse') &&
29
29
  Array.isArray(v.commandArgs) &&
30
30
  v.commandArgs.every((arg) => typeof arg === 'string') &&
31
31
  (v.linkUrl === undefined || typeof v.linkUrl === 'string') &&
32
32
  Array.isArray(v.envVars) &&
33
- v.envVars.every(isMcpEnvVar)
33
+ v.envVars.every(isMcpKeyValue) &&
34
+ (v.headers === undefined || (Array.isArray(v.headers) && v.headers.every(isMcpKeyValue)))
34
35
  );
35
36
  }
36
37
 
@@ -64,7 +65,7 @@ export async function action({ request, params }: ActionFunctionArgs) {
64
65
  } catch {
65
66
  // Truly unexpected internal error — never leak env, secrets, or stack.
66
67
  return json(
67
- { ok: false, transport: server.reachType, durationMs: 0, error: 'Internal error during MCP test' },
68
+ { ok: false, transport: server.transport, durationMs: 0, error: 'Internal error during MCP test' },
68
69
  { status: 500 },
69
70
  );
70
71
  }
@@ -76,9 +76,10 @@ function server(name: string): McpServerItem {
76
76
  name,
77
77
  scope: 'every-project',
78
78
  enabled: true,
79
- reachType: 'command',
79
+ transport: 'stdio',
80
80
  commandArgs: ['bunx', '@modelcontextprotocol/server-everything'],
81
81
  envVars: [],
82
+ headers: [],
82
83
  };
83
84
  }
84
85
 
@@ -132,4 +133,44 @@ describe('MCP route write answers', () => {
132
133
  expect(body.servers.map((item: McpServerItem) => item.name)).toEqual(['after']);
133
134
  expect(Object.keys(JSON.parse(fs.readFileSync(MCP_JSON, 'utf8')).mcpServers)).toEqual(['after']);
134
135
  });
136
+
137
+ test('a remote server writes type, url and headers — never env', async () => {
138
+ const res = await call(mcpAction, send('POST', {
139
+ server: {
140
+ ...server('remote'),
141
+ transport: 'sse',
142
+ commandArgs: [],
143
+ linkUrl: 'https://x/sse',
144
+ headers: [{ id: 'h1', key: 'Authorization', value: 'Bearer t' }],
145
+ envVars: [{ id: 'e1', key: 'LEFTOVER', value: 'x' }],
146
+ timeout: 2500,
147
+ },
148
+ }));
149
+ expect(res.status).toBe(200);
150
+ expect(JSON.parse(fs.readFileSync(MCP_JSON, 'utf8')).mcpServers.remote).toEqual({
151
+ type: 'sse',
152
+ url: 'https://x/sse',
153
+ headers: { Authorization: 'Bearer t' },
154
+ timeout: 2500,
155
+ });
156
+ });
157
+
158
+ test('disabling a native server writes enabled:false and the denylist, and re-enabling clears both', async () => {
159
+ await call(mcpAction, send('POST', { server: server('toggle') }));
160
+
161
+ const off = await call(mcpAction, send('POST', { server: { ...server('toggle'), id: 'omp-user-toggle', enabled: false } }));
162
+ expect(off.status).toBe(200);
163
+ const written = JSON.parse(fs.readFileSync(MCP_JSON, 'utf8'));
164
+ expect(written.mcpServers.toggle.enabled).toBe(false);
165
+ expect(written.disabledServers).toEqual(['toggle']);
166
+
167
+ // The list the pane receives reflects the toggle instead of flipping back.
168
+ const listed = await (await call(mcpLoader, new Request(`${API}/mcp`))).json();
169
+ expect(listed.servers.find((item: McpServerItem) => item.name === 'toggle').enabled).toBe(false);
170
+
171
+ await call(mcpAction, send('POST', { server: { ...server('toggle'), id: 'omp-user-toggle', enabled: true } }));
172
+ const after = JSON.parse(fs.readFileSync(MCP_JSON, 'utf8'));
173
+ expect(after.mcpServers.toggle.enabled).toBeUndefined();
174
+ expect(after.disabledServers).toBeUndefined();
175
+ });
135
176
  });