Skip to content

Commit 319a8eb

Browse files
fix(mcp): harden preview close state
1 parent b0e301b commit 319a8eb

5 files changed

Lines changed: 308 additions & 52 deletions

File tree

‎apps/server/src/mcp/PreviewAutomationBroker.test.ts‎

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -173,6 +173,57 @@ it.effect("does not let an older response replace a newer explicit tab target",
173173
),
174174
);
175175

176+
it.effect("blocks a closed in-flight tab without discarding another selected tab", () =>
177+
Effect.scoped(
178+
Effect.gen(function* () {
179+
const broker = yield* makeBroker;
180+
const selectedTabId = PreviewTabId.make("tab-selected-b");
181+
const closingTabId = PreviewTabId.make("tab-closing-a");
182+
const connected = yield* Deferred.make<void>();
183+
const closingRequest = yield* Deferred.make<void>();
184+
const releaseClosingResponse = yield* Deferred.make<void>();
185+
const routedRequests: RoutedRequest[] = [];
186+
const events = yield* broker.connect(makeHost());
187+
yield* Stream.runForEach(events, (event) => {
188+
if (event.type === "connected") return Deferred.succeed(connected, undefined);
189+
const request = { ...event.request, connectionId: event.connectionId };
190+
routedRequests.push(request);
191+
return Effect.gen(function* () {
192+
if (request.tabId === closingTabId) {
193+
yield* Deferred.succeed(closingRequest, undefined);
194+
yield* Deferred.await(releaseClosingResponse);
195+
}
196+
yield* broker.respond({
197+
clientId: "client-1",
198+
connectionId: request.connectionId,
199+
requestId: request.requestId,
200+
ok: true,
201+
result:
202+
request.operation === "open"
203+
? { available: true, tabId: selectedTabId }
204+
: request.tabId === closingTabId
205+
? { available: true, tabId: closingTabId }
206+
: { url: "http://localhost:3200" },
207+
});
208+
}).pipe(Effect.forkScoped, Effect.asVoid);
209+
}).pipe(Effect.forkScoped);
210+
yield* Deferred.await(connected);
211+
212+
yield* broker.invoke({ scope, operation: "open", input: {} });
213+
const delayed = yield* broker
214+
.invoke({ scope, operation: "status", input: {}, tabId: closingTabId })
215+
.pipe(Effect.forkScoped);
216+
yield* Deferred.await(closingRequest);
217+
yield* broker.forgetClosedTab(scope, closingTabId);
218+
yield* Deferred.succeed(releaseClosingResponse, undefined);
219+
yield* Fiber.join(delayed);
220+
yield* broker.invoke({ scope, operation: "snapshot", input: {} });
221+
222+
expect(routedRequests.at(-1)?.tabId).toBe(selectedTabId);
223+
}),
224+
),
225+
);
226+
176227
it.effect("tracks the tab returned by a targeted recording stop", () =>
177228
Effect.scoped(
178229
Effect.gen(function* () {

‎apps/server/src/mcp/PreviewAutomationBroker.ts‎

Lines changed: 49 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -76,6 +76,8 @@ interface PendingRequest {
7676
readonly queue: ClientConnection["queue"];
7777
readonly deferred: Deferred.Deferred<unknown, PreviewAutomationError>;
7878
readonly context: PreviewAutomationRequestErrorContext;
79+
readonly assignmentKey: string;
80+
readonly requestSequence: number;
7981
}
8082

8183
/**
@@ -92,6 +94,7 @@ interface HostAssignment {
9294
readonly queue: ClientConnection["queue"];
9395
readonly tabId?: PreviewTabId;
9496
readonly tabSequence?: number;
97+
readonly closedTabSequences?: ReadonlyMap<PreviewTabId, number>;
9598
}
9699

97100
interface PreviewAutomationRequestErrorContext {
@@ -433,13 +436,20 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
433436
yield* SynchronizedRef.update(state, (current) => {
434437
const assignmentKey = hostAssignmentKey(scope);
435438
const assignment = current.assignments.get(assignmentKey);
436-
if (assignment?.tabId !== tabId) return current;
439+
if (assignment === undefined) return current;
437440
const assignments = new Map(current.assignments);
438-
const { tabId: _tabId, ...withoutTabId } = assignment;
439-
assignments.set(assignmentKey, {
440-
...withoutTabId,
441-
tabSequence: current.requestSequence,
442-
});
441+
const closedTabSequences = new Map(assignment.closedTabSequences);
442+
closedTabSequences.set(tabId, current.requestSequence);
443+
if (assignment.tabId === tabId) {
444+
const { tabId: _tabId, ...withoutTabId } = assignment;
445+
assignments.set(assignmentKey, {
446+
...withoutTabId,
447+
tabSequence: current.requestSequence,
448+
closedTabSequences,
449+
});
450+
} else {
451+
assignments.set(assignmentKey, { ...assignment, closedTabSequences });
452+
}
443453
return {
444454
...current,
445455
assignments,
@@ -506,6 +516,9 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
506516
...(canReuseAssignedTab && assigned.tabSequence !== undefined
507517
? { tabSequence: assigned.tabSequence }
508518
: {}),
519+
...(canReuseAssignedTab && assigned.closedTabSequences !== undefined
520+
? { closedTabSequences: assigned.closedTabSequences }
521+
: {}),
509522
});
510523

511524
const requestSequence = current.requestSequence;
@@ -526,7 +539,13 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
526539
...selectorDiagnostics,
527540
};
528541
const pending = new Map(current.pending);
529-
pending.set(requestId, { queue: connection.queue, deferred, context });
542+
pending.set(requestId, {
543+
queue: connection.queue,
544+
deferred,
545+
context,
546+
assignmentKey,
547+
requestSequence,
548+
});
530549
return [
531550
{ connection, requestId, requestContext: context, requestSequence },
532551
{ ...current, assignments, pending, requestSequence: current.requestSequence + 1 },
@@ -591,16 +610,38 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
591610
return current;
592611
}
593612
const assignments = new Map(current.assignments);
613+
const closedAt =
614+
resultTabId === null ? undefined : assignment.closedTabSequences?.get(resultTabId);
615+
const responsePredatesClose = closedAt !== undefined && requestSequence < closedAt;
594616
if (resultTabId === null) {
595617
const { tabId: _tabId, ...withoutTabId } = assignment;
596618
assignments.set(assignmentKey, { ...withoutTabId, tabSequence: requestSequence });
597-
} else {
619+
} else if (!responsePredatesClose) {
598620
assignments.set(assignmentKey, {
599621
...assignment,
600622
...(resultTabId === undefined ? {} : { tabId: resultTabId }),
601623
tabSequence: requestSequence,
602624
});
603625
}
626+
const nextAssignment = assignments.get(assignmentKey);
627+
if (nextAssignment?.closedTabSequences !== undefined) {
628+
const closedTabSequences = new Map(nextAssignment.closedTabSequences);
629+
for (const [closedTabId, barrier] of closedTabSequences) {
630+
const olderRequestPending = Array.from(current.pending.values()).some(
631+
(pending) =>
632+
pending.assignmentKey === assignmentKey && pending.requestSequence < barrier,
633+
);
634+
if (!olderRequestPending) closedTabSequences.delete(closedTabId);
635+
}
636+
const { closedTabSequences: _closedTabSequences, ...withoutClosedTabSequences } =
637+
nextAssignment;
638+
assignments.set(
639+
assignmentKey,
640+
closedTabSequences.size === 0
641+
? withoutClosedTabSequences
642+
: { ...withoutClosedTabSequences, closedTabSequences },
643+
);
644+
}
604645
return { ...current, assignments };
605646
});
606647
return result;

‎apps/server/src/mcp/PreviewMcpService.test.ts‎

Lines changed: 132 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,20 @@
11
import * as NodeServices from "@effect/platform-node/NodeServices";
22
import {
33
EnvironmentId,
4+
PREVIEW_MCP_NAV_DIAGNOSTIC_MAX_LENGTH,
5+
PreviewMcpListResult,
46
ProviderInstanceId,
57
ThreadId,
68
type PreviewAutomationRequest,
79
} from "@t3tools/contracts";
810
import { expect, it } from "@effect/vitest";
911
import * as Effect from "effect/Effect";
12+
import * as Deferred from "effect/Deferred";
13+
import * as Fiber from "effect/Fiber";
1014
import * as Layer from "effect/Layer";
1115
import * as PubSub from "effect/PubSub";
12-
import * as Result from "effect/Result";
16+
import * as Ref from "effect/Ref";
17+
import * as Schema from "effect/Schema";
1318
import * as Stream from "effect/Stream";
1419

1520
import * as PreviewManager from "../preview/Manager.ts";
@@ -18,6 +23,7 @@ import * as PreviewAutomationBroker from "./PreviewAutomationBroker.ts";
1823
import * as PreviewMcpService from "./PreviewMcpService.ts";
1924

2025
const environmentId = EnvironmentId.make("environment-preview-mcp");
26+
const decodePreviewMcpListResult = Schema.decodeUnknownSync(PreviewMcpListResult);
2127
const scopeFor = (
2228
threadId: ThreadId,
2329
capabilities: McpInvocationContext.McpInvocationScope["capabilities"] = new Set(["preview"]),
@@ -70,6 +76,56 @@ it.layer(TestLayer)("PreviewMcpService", (it) => {
7076
}),
7177
);
7278

79+
it.effect("keeps long thread ids out of cursors and bounds failed-navigation diagnostics", () =>
80+
Effect.gen(function* () {
81+
const manager = yield* PreviewManager.PreviewManager;
82+
const service = yield* PreviewMcpService.PreviewMcpService;
83+
const currentThreadId = ThreadId.make(`thread-preview-long-${"x".repeat(4_000)}`);
84+
const scope = scopeFor(currentThreadId);
85+
const opened = yield* Effect.all([
86+
manager.open({ threadId: currentThreadId }),
87+
manager.open({ threadId: currentThreadId }),
88+
]);
89+
const failed = opened[0]!;
90+
yield* manager.reportStatus({
91+
threadId: currentThreadId,
92+
tabId: failed.tabId,
93+
navStatus: {
94+
_tag: "LoadFailed",
95+
url: "http://localhost:3000",
96+
title: "Failed preview",
97+
code: -2,
98+
description: "diagnostic".repeat(1_000),
99+
},
100+
canGoBack: false,
101+
canGoForward: false,
102+
});
103+
104+
const first = yield* service.list(scope, { limit: 1 });
105+
expect(first.nextCursor?.length).toBeLessThanOrEqual(512);
106+
const second = yield* service.list(scope, { limit: 1, cursor: first.nextCursor! });
107+
expect([...first.sessions, ...second.sessions]).toHaveLength(2);
108+
const failedResult = [...first.sessions, ...second.sessions].find(
109+
(session) => session.tabId === failed.tabId,
110+
);
111+
expect(failedResult?.navStatus._tag).toBe("LoadFailed");
112+
if (failedResult?.navStatus._tag === "LoadFailed") {
113+
expect(failedResult.navStatus.description).toHaveLength(
114+
PREVIEW_MCP_NAV_DIAGNOSTIC_MAX_LENGTH,
115+
);
116+
expect(failedResult.navStatus.descriptionTruncated).toBe(true);
117+
}
118+
expect(() => decodePreviewMcpListResult(first)).not.toThrow();
119+
expect(() => decodePreviewMcpListResult(second)).not.toThrow();
120+
121+
const foreignLongThreadId = ThreadId.make(`thread-preview-other-${"x".repeat(4_000)}`);
122+
const foreign = yield* service
123+
.list(scopeFor(foreignLongThreadId), { cursor: first.nextCursor! })
124+
.pipe(Effect.flip);
125+
expect(foreign._tag).toBe("PreviewMcpInvalidCursorError");
126+
}),
127+
);
128+
73129
it.effect("closes through manager events and clears the broker's current-tab lease", () =>
74130
Effect.scoped(
75131
Effect.gen(function* () {
@@ -81,34 +137,41 @@ it.layer(TestLayer)("PreviewMcpService", (it) => {
81137
const opened = yield* manager.open({ threadId: currentThreadId });
82138
const events = yield* manager.subscribeEvents;
83139
const requests: PreviewAutomationRequest[] = [];
140+
const connected = yield* Deferred.make<void>();
141+
const targetedRequest = yield* Deferred.make<void>();
142+
const releaseTargetedResponse = yield* Deferred.make<void>();
84143
const hostEvents = yield* broker.connect({ clientId: "preview-host", environmentId });
85-
const requestEvents = hostEvents.pipe(
86-
Stream.filterMap((event) =>
87-
event.type === "request"
88-
? Result.succeed({ ...event.request, connectionId: event.connectionId })
89-
: Result.failVoid,
90-
),
91-
);
92-
yield* Stream.runForEach(requestEvents, (request) => {
144+
yield* Stream.runForEach(hostEvents, (event) => {
145+
if (event.type === "connected") return Deferred.succeed(connected, undefined);
146+
const request = { ...event.request, connectionId: event.connectionId };
93147
requests.push(request);
94-
return broker.respond({
95-
clientId: "preview-host",
96-
connectionId: request.connectionId,
97-
requestId: request.requestId,
98-
ok: true,
99-
result: {
100-
available: true,
101-
visible: false,
102-
tabId: request.tabId ?? null,
103-
url: null,
104-
title: null,
105-
loading: false,
106-
},
107-
});
148+
return Effect.gen(function* () {
149+
if (request.tabId === opened.tabId) {
150+
yield* Deferred.succeed(targetedRequest, undefined);
151+
yield* Deferred.await(releaseTargetedResponse);
152+
}
153+
yield* broker.respond({
154+
clientId: "preview-host",
155+
connectionId: request.connectionId,
156+
requestId: request.requestId,
157+
ok: true,
158+
result: {
159+
available: true,
160+
visible: false,
161+
tabId: request.tabId ?? null,
162+
url: null,
163+
title: null,
164+
loading: false,
165+
},
166+
});
167+
}).pipe(Effect.forkScoped, Effect.asVoid);
108168
}).pipe(Effect.forkScoped);
109-
yield* Effect.yieldNow;
169+
yield* Deferred.await(connected);
110170

111-
yield* broker.invoke({ scope, operation: "status", input: {}, tabId: opened.tabId });
171+
const delayedStatus = yield* broker
172+
.invoke({ scope, operation: "status", input: {}, tabId: opened.tabId })
173+
.pipe(Effect.forkScoped);
174+
yield* Deferred.await(targetedRequest);
112175
expect(requests.at(-1)?.tabId).toBe(opened.tabId);
113176

114177
expect(yield* service.close(scope, { tabId: opened.tabId })).toEqual({
@@ -122,6 +185,9 @@ it.layer(TestLayer)("PreviewMcpService", (it) => {
122185
tabId: opened.tabId,
123186
});
124187

188+
yield* Deferred.succeed(releaseTargetedResponse, undefined);
189+
yield* Fiber.join(delayedStatus);
190+
125191
yield* broker.invoke({ scope, operation: "status", input: {} });
126192
expect(requests.at(-1)?.tabId).toBeUndefined();
127193
const repeated = yield* service.close(scope, { tabId: opened.tabId }).pipe(Effect.flip);
@@ -154,3 +220,44 @@ it.layer(TestLayer)("PreviewMcpService", (it) => {
154220
}),
155221
);
156222
});
223+
224+
it.effect("finishes broker cleanup when close is interrupted after manager removal", () =>
225+
Effect.scoped(
226+
Effect.gen(function* () {
227+
const cleanupEntered = yield* Deferred.make<void>();
228+
const releaseCleanup = yield* Deferred.make<void>();
229+
const cleanupCompleted = yield* Ref.make(false);
230+
const manager = yield* PreviewManager.make;
231+
const broker = PreviewAutomationBroker.PreviewAutomationBroker.of({
232+
connect: () => Effect.die("unused"),
233+
focusHost: () => Effect.die("unused"),
234+
respond: () => Effect.die("unused"),
235+
invoke: () => Effect.die("unused"),
236+
forgetClosedTab: () =>
237+
Deferred.succeed(cleanupEntered, undefined).pipe(
238+
Effect.andThen(Deferred.await(releaseCleanup)),
239+
Effect.andThen(Ref.set(cleanupCompleted, true)),
240+
),
241+
});
242+
const service = yield* PreviewMcpService.make.pipe(
243+
Effect.provideService(PreviewManager.PreviewManager, manager),
244+
Effect.provideService(PreviewAutomationBroker.PreviewAutomationBroker, broker),
245+
);
246+
const threadId = ThreadId.make("thread-preview-interrupted-close");
247+
const scope = scopeFor(threadId);
248+
const opened = yield* manager.open({ threadId });
249+
const closeFiber = yield* service
250+
.close(scope, { tabId: opened.tabId })
251+
.pipe(Effect.forkScoped);
252+
yield* Deferred.await(cleanupEntered);
253+
expect((yield* manager.list({ threadId })).sessions).toHaveLength(0);
254+
255+
const interruption = yield* Fiber.interrupt(closeFiber).pipe(Effect.forkScoped);
256+
yield* Deferred.succeed(releaseCleanup, undefined);
257+
yield* Fiber.join(interruption);
258+
expect(yield* Ref.get(cleanupCompleted)).toBe(true);
259+
const repeated = yield* service.close(scope, { tabId: opened.tabId }).pipe(Effect.flip);
260+
expect(repeated._tag).toBe("PreviewSessionLookupError");
261+
}),
262+
),
263+
);

0 commit comments

Comments
 (0)