@kabmo-labs/kabmo 0.30.0 → 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.
- package/README.md +79 -21
- package/dist/client/index.html +1 -1
- package/dist/client/index.js +481 -462
- package/dist/client/static/js/{index-5vjbp04s.js → index-r3bhgvkt.js} +882 -883
- package/marketplace/plugins/stats/package.json +2 -2
- package/marketplace/plugins/stats/src/format.test.ts +7 -1
- package/package.json +2 -2
- package/src/client/components/common/context-usage-button/McpSection.tsx +133 -0
- package/src/client/components/common/context-usage-button/Ring.tsx +12 -6
- package/src/client/components/common/context-usage-button/index.test.tsx +24 -13
- package/src/client/components/common/context-usage-button/index.tsx +32 -34
- package/src/client/components/common/session-row/TrailingSlot.tsx +6 -2
- package/src/client/components/common/session-row/session-row.test.tsx +13 -0
- package/src/client/components/layout/desktop-layout/index.tsx +5 -1
- package/src/client/components/mobile/RightSidebar.tsx +2 -1
- package/src/client/components/settings/categories/McpSettings.tsx +10 -3
- package/src/client/components/settings/categories/mcp-settings/AdvancedSection.tsx +244 -0
- package/src/client/components/settings/categories/mcp-settings/ConnectionTest.tsx +3 -3
- package/src/client/components/settings/categories/mcp-settings/DetailPane.tsx +55 -97
- package/src/client/components/settings/categories/mcp-settings/ImportModal.tsx +12 -64
- package/src/client/components/settings/categories/mcp-settings/{EnvVarsSection.tsx → KeyValueSection.tsx} +42 -24
- package/src/client/components/settings/categories/mcp-settings/SidebarList.tsx +1 -1
- package/src/client/components/settings/categories/mcp-settings/TransportSection.tsx +101 -0
- package/src/client/components/workspace/browser-panel/EngineNotice.test.tsx +109 -0
- package/src/client/components/workspace/browser-panel/EngineNotice.tsx +112 -0
- package/src/client/components/workspace/browser-panel/index.tsx +45 -12
- package/src/client/components/workspace/chat-timeline/chat-input/AccessDropdown.test.ts +63 -0
- package/src/client/components/workspace/chat-timeline/chat-input/AccessDropdown.tsx +18 -6
- package/src/client/components/workspace/chat-timeline/chat-input/Toolbar.tsx +3 -1
- package/src/client/components/workspace/chat-timeline/chat-input/access-levels.ts +39 -1
- package/src/client/components/workspace/chat-timeline/tool-renderers/panels/Eval.test.tsx +13 -7
- package/src/client/components/workspace/editor/plugin-rail.test.tsx +6 -1
- package/src/client/components/workspace/terminal-panel/scroll-hold.test.ts +20 -5
- package/src/client/data/settings/mcp.ts +4 -2
- package/src/client/data/settings/omp-schema.json +22 -2
- package/src/client/hooks/browser/use-browser-engine.ts +99 -0
- package/src/client/hooks/chat/context/mcp.ts +159 -0
- package/src/client/hooks/chat/timeline/access-mode.ts +45 -15
- package/src/client/hooks/chat/timeline/index.ts +7 -3
- package/src/client/hooks/chat/timeline/timeline-mode-state.test.ts +33 -4
- package/src/client/hooks/ui/ui-listeners.test.ts +13 -18
- package/src/server/lib/browser/engine.test.ts +118 -0
- package/src/server/lib/browser/engine.ts +102 -0
- package/src/server/lib/db/schema.ts +4 -0
- package/src/server/lib/fs/toolchain-path.test.ts +87 -0
- package/src/server/lib/fs/toolchain-path.ts +49 -0
- package/src/server/lib/harness/acp/protocol.ts +9 -1
- package/src/server/lib/harness/auto-probe.server.ts +3 -2
- package/src/server/lib/harness/launch-table.ts +3 -2
- package/src/server/lib/harness/spawn.server.ts +5 -1
- package/src/server/lib/harness/update-queue.server.ts +2 -1
- package/src/server/lib/harness/update-state.server.ts +6 -2
- package/src/server/lib/mcp/probe.server.ts +71 -0
- package/src/server/lib/mcp/registry.server.ts +195 -46
- package/src/server/lib/mcp/registry.test.ts +76 -4
- package/src/server/lib/mcp/schema.server.ts +35 -0
- package/src/server/lib/mcp/session-mcp.test.ts +164 -0
- package/src/server/lib/mcp/session-overlay.server.ts +152 -0
- package/src/server/lib/mcp/session-state.server.ts +75 -0
- package/src/server/lib/mcp/store.server.ts +6 -1
- package/src/server/lib/omp/config/config-cli.ts +4 -0
- package/src/server/lib/omp/config/mcp-and-cli.test.ts +12 -183
- package/src/server/lib/omp/config/mcp-config.test.ts +277 -0
- package/src/server/lib/omp/config/mcp-shared.ts +36 -0
- package/src/server/lib/omp/config/mcp-test-protocol.ts +89 -0
- package/src/server/lib/omp/config/mcp-test-remote.ts +167 -0
- package/src/server/lib/omp/config/mcp-test.ts +21 -123
- package/src/server/lib/omp/config/mcp-write.ts +179 -0
- package/src/server/lib/omp/config/mcp.ts +138 -118
- package/src/server/lib/omp/core/cli.ts +4 -14
- package/src/server/lib/omp/rpc/manager.ts +12 -17
- package/src/server/lib/omp/rpc/reload-mcp.ts +39 -0
- package/src/server/lib/omp/rpc/session-registry.ts +6 -2
- package/src/server/lib/omp/rpc/spawn-mcp.ts +43 -0
- package/src/server/lib/omp/session/delete.server.ts +7 -0
- package/src/server/lib/plugins/mcp.server.ts +2 -2
- package/src/server/lib/realtime/topics/workspace.server.test.ts +44 -0
- package/src/server/lib/realtime/topics/workspace.server.ts +3 -2
- package/src/server/routes/browser/engine.test.ts +70 -0
- package/src/server/routes/browser/engine.ts +51 -0
- package/src/server/routes/browser/index.ts +5 -0
- package/src/server/routes/fs/git.ts +4 -3
- package/src/server/routes/harness/versions.test.ts +5 -0
- package/src/server/routes/sessions/index.ts +7 -0
- package/src/server/routes/sessions/mcp.test.ts +154 -0
- package/src/server/routes/sessions/mcp.ts +202 -0
- package/src/server/routes/settings/mcp-test.ts +5 -4
- package/src/server/routes/settings/mcp.test.ts +42 -1
- package/src/server/routes/settings/mcp.ts +80 -24
- package/src/shared/lib/code/highlight-memo.test.ts +18 -0
- package/src/shared/lib/code/highlight-memo.ts +46 -17
- package/src/shared/lib/fonts/nerd-symbols.css +14 -0
- package/src/shared/lib/fonts/nerd-symbols.test.ts +86 -0
- package/src/shared/lib/fonts/symbols-nerd-font-mono.woff2 +0 -0
- package/src/shared/lib/mcp/import.ts +112 -0
- package/src/shared/lib/mcp/item.ts +61 -0
- package/src/shared/lib/mcp/key-value.ts +37 -0
- package/src/shared/lib/mcp/mcp-lib.test.ts +119 -0
- package/src/shared/lib/mcp/status.test.ts +36 -0
- package/src/shared/lib/mcp/status.ts +38 -0
- package/src/shared/lib/models/client.ts +27 -6
- package/src/shared/lib/models/provider/models.test.ts +31 -0
- package/src/shared/lib/omp/config/access-mode.test.ts +73 -0
- package/src/shared/lib/omp/config/access-mode.ts +49 -0
- package/src/shared/lib/workspace/right-panels.ts +13 -0
- package/src/shared/lib/workspace/workspace-modules.test.ts +3 -1
- package/src/shared/types/browser.ts +21 -0
- package/src/shared/types/settings/mcp.ts +73 -4
- package/src/test-support/pristine-globals.test.ts +53 -0
- 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'),
|
|
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,
|
|
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
|
|
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.
|
|
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(
|
|
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.
|
|
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
|
-
|
|
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
|
});
|