@player-devtools/mcp 0.13.1--canary.16.915

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/bin/run ADDED
@@ -0,0 +1,19 @@
1
+ #!/usr/bin/env node
2
+
3
+ const { FlipperServerTransport, MCPServer } = require("@player-devtools/mcp");
4
+
5
+ const transport = new FlipperServerTransport();
6
+ const server = new MCPServer(transport);
7
+
8
+ server.start().catch((err) => {
9
+ console.error("Failed to start MCP server:", err);
10
+ process.exit(1);
11
+ });
12
+
13
+ process.on("SIGINT", () => {
14
+ server.stop().then(() => process.exit(0));
15
+ });
16
+
17
+ process.on("SIGTERM", () => {
18
+ server.stop().then(() => process.exit(0));
19
+ });
@@ -0,0 +1,592 @@
1
+ "use strict";
2
+ var __create = Object.create;
3
+ var __defProp = Object.defineProperty;
4
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
+ var __getOwnPropNames = Object.getOwnPropertyNames;
6
+ var __getProtoOf = Object.getPrototypeOf;
7
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
8
+ var __export = (target, all) => {
9
+ for (var name in all)
10
+ __defProp(target, name, { get: all[name], enumerable: true });
11
+ };
12
+ var __copyProps = (to, from, except, desc) => {
13
+ if (from && typeof from === "object" || typeof from === "function") {
14
+ for (let key of __getOwnPropNames(from))
15
+ if (!__hasOwnProp.call(to, key) && key !== except)
16
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
17
+ }
18
+ return to;
19
+ };
20
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
21
+ // If the importer is in node compatibility mode or this is not an ESM
22
+ // file that has been converted to a CommonJS file using a Babel-
23
+ // compatible transform (i.e. "__esModule" has not been set), then set
24
+ // "default" to the CommonJS "module.exports" for node compatibility.
25
+ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
26
+ mod
27
+ ));
28
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
29
+
30
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/index.ts
31
+ var src_exports = {};
32
+ __export(src_exports, {
33
+ FlipperServerTransport: () => FlipperServerTransport,
34
+ MCPServer: () => MCPServer
35
+ });
36
+ module.exports = __toCommonJS(src_exports);
37
+
38
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/server.ts
39
+ var import_client = require("@player-devtools/client");
40
+ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
41
+ var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
42
+
43
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/tools/flow.ts
44
+ var import_zod = require("zod");
45
+ var playerIdShape = {
46
+ playerId: import_zod.z.string().optional().describe("Player ID. Defaults to the currently selected player.")
47
+ };
48
+ var PlayerInput = import_zod.z.object(playerIdShape);
49
+ function resolvePlayer(client, playerId) {
50
+ const { players, current } = client.getState();
51
+ const id = playerId ?? current.player;
52
+ if (!id) return { error: "no player selected" };
53
+ const player = players[id];
54
+ if (!player) return { error: `player not found: ${id}` };
55
+ return { id, player };
56
+ }
57
+ function resolveBasicPlugin(client, playerId) {
58
+ const resolved = resolvePlayer(client, playerId);
59
+ if ("error" in resolved) return resolved;
60
+ const { id, player } = resolved;
61
+ const [basicPlugin] = Object.values(player.plugins);
62
+ if (!basicPlugin) return { error: "no plugin registered for this player" };
63
+ return { id, player, basicPlugin };
64
+ }
65
+ function ok(value) {
66
+ return { content: [{ type: "text", text: JSON.stringify(value) }] };
67
+ }
68
+ function err(message) {
69
+ return {
70
+ content: [{ type: "text", text: JSON.stringify({ error: message }) }]
71
+ };
72
+ }
73
+ function handleGetFlow(client, input) {
74
+ const { playerId } = PlayerInput.parse(input);
75
+ const resolved = resolveBasicPlugin(client, playerId);
76
+ if ("error" in resolved) return err(resolved.error);
77
+ return ok(resolved.basicPlugin.flow);
78
+ }
79
+ function handleGetData(client, input) {
80
+ const { playerId } = PlayerInput.parse(input);
81
+ const resolved = resolveBasicPlugin(client, playerId);
82
+ if ("error" in resolved) return err(resolved.error);
83
+ return ok(resolved.basicPlugin.flow?.data ?? null);
84
+ }
85
+ function handleGetLogs(client, input) {
86
+ const { playerId } = PlayerInput.parse(input);
87
+ const resolved = resolveBasicPlugin(client, playerId);
88
+ if ("error" in resolved) return err(resolved.error);
89
+ return ok(
90
+ resolved.basicPlugin.flow?.data?.logs ?? []
91
+ );
92
+ }
93
+ var getPluginDataShape = {
94
+ ...playerIdShape,
95
+ pluginId: import_zod.z.string().describe("Plugin ID."),
96
+ dataKey: import_zod.z.string().describe("Key to retrieve from the plugin's data.")
97
+ };
98
+ var GetPluginDataInput = import_zod.z.object(getPluginDataShape);
99
+ function handleGetPluginData(client, input) {
100
+ const { playerId, pluginId, dataKey } = GetPluginDataInput.parse(input);
101
+ const resolved = resolvePlayer(client, playerId);
102
+ if ("error" in resolved) return err(resolved.error);
103
+ const plugin = resolved.player.plugins[pluginId];
104
+ if (!plugin) return err(`plugin not found: ${pluginId}`);
105
+ const value = plugin.flow?.data?.[dataKey];
106
+ return ok(value ?? null);
107
+ }
108
+ var getFlowDef = {
109
+ name: "get_flow",
110
+ description: "Get the current flow from the basic devtools plugin for a Player instance.",
111
+ inputSchema: playerIdShape,
112
+ handle: handleGetFlow
113
+ };
114
+ var getDataDef = {
115
+ name: "get_data",
116
+ description: "Get the current flow data model from the basic devtools plugin for a Player instance.",
117
+ inputSchema: playerIdShape,
118
+ handle: handleGetData
119
+ };
120
+ var getLogsDef = {
121
+ name: "get_logs",
122
+ description: "Get the logs from the basic devtools plugin for a Player instance.",
123
+ inputSchema: playerIdShape,
124
+ handle: handleGetLogs
125
+ };
126
+ var getPluginDataDef = {
127
+ name: "get_plugin_data",
128
+ description: "Get a specific data key from any plugin for a Player instance.",
129
+ inputSchema: getPluginDataShape,
130
+ handle: handleGetPluginData
131
+ };
132
+
133
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/tools/players.ts
134
+ var import_zod2 = require("zod");
135
+ var playerIdShape2 = {
136
+ playerId: import_zod2.z.string().optional().describe("Player ID. Defaults to the currently selected player.")
137
+ };
138
+ var GetPlayerStatusInput = import_zod2.z.object(playerIdShape2);
139
+ function handleListPlayers(client) {
140
+ const { players, current } = client.getState();
141
+ return {
142
+ content: [
143
+ {
144
+ type: "text",
145
+ text: JSON.stringify({
146
+ players: Object.keys(players),
147
+ current: current.player
148
+ })
149
+ }
150
+ ]
151
+ };
152
+ }
153
+ function handleGetPlayerStatus(client, input) {
154
+ const { playerId } = GetPlayerStatusInput.parse(input);
155
+ const { players, current } = client.getState();
156
+ const id = playerId ?? current.player;
157
+ if (!id) return errorResult("no player selected");
158
+ const player = players[id];
159
+ if (!player) return errorResult(`player not found: ${id}`);
160
+ return {
161
+ content: [
162
+ {
163
+ type: "text",
164
+ text: JSON.stringify({
165
+ active: player.active,
166
+ plugins: Object.keys(player.plugins)
167
+ })
168
+ }
169
+ ]
170
+ };
171
+ }
172
+ function errorResult(message) {
173
+ return {
174
+ content: [{ type: "text", text: JSON.stringify({ error: message }) }]
175
+ };
176
+ }
177
+ var listPlayersDef = {
178
+ name: "list_players",
179
+ description: "List all Player instances known to the devtools, and which one is currently selected.",
180
+ inputSchema: {},
181
+ handle: (client) => handleListPlayers(client)
182
+ };
183
+ var getPlayerStatusDef = {
184
+ name: "get_player_status",
185
+ description: "Get the active status and registered plugin IDs for a Player instance.",
186
+ inputSchema: playerIdShape2,
187
+ handle: handleGetPlayerStatus
188
+ };
189
+
190
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/tools/plugins.ts
191
+ var import_zod3 = require("zod");
192
+ var describePluginShape = {
193
+ playerId: import_zod3.z.string().optional().describe("Player ID. Defaults to the currently selected player."),
194
+ pluginId: import_zod3.z.string().describe("Plugin ID.")
195
+ };
196
+ var DescribePluginInput = import_zod3.z.object(describePluginShape);
197
+ function err2(message) {
198
+ return {
199
+ content: [{ type: "text", text: JSON.stringify({ error: message }) }]
200
+ };
201
+ }
202
+ function ok2(value) {
203
+ return { content: [{ type: "text", text: JSON.stringify(value) }] };
204
+ }
205
+ function handleDescribePlugin(client, input) {
206
+ const { playerId, pluginId } = DescribePluginInput.parse(input);
207
+ const { players, current } = client.getState();
208
+ const id = playerId ?? current.player;
209
+ if (!id) return err2("no player selected");
210
+ const player = players[id];
211
+ if (!player) return err2(`player not found: ${id}`);
212
+ const plugin = player.plugins[pluginId];
213
+ if (!plugin) return err2(`plugin not found: ${pluginId}`);
214
+ if (!plugin.capabilities)
215
+ return err2(`plugin "${pluginId}" has no capabilities declared`);
216
+ return ok2(plugin.capabilities);
217
+ }
218
+ var describePluginDef = {
219
+ name: "describe_plugin",
220
+ description: "Get the capability descriptor declared by a plugin at registration time. Use this to discover what data keys and actions the plugin exposes.",
221
+ inputSchema: describePluginShape,
222
+ handle: handleDescribePlugin
223
+ };
224
+
225
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/tools/select.ts
226
+ var import_zod4 = require("zod");
227
+ var selectPlayerShape = {
228
+ playerId: import_zod4.z.string().describe("The Player ID to select.")
229
+ };
230
+ var invokeActionShape = {
231
+ playerId: import_zod4.z.string().optional().describe("Player ID. Defaults to the currently selected player."),
232
+ pluginId: import_zod4.z.string().describe("Plugin ID."),
233
+ action: import_zod4.z.string().describe("Action name."),
234
+ payload: import_zod4.z.string().optional().describe("Optional stringified payload.")
235
+ };
236
+ var SelectPlayerInput = import_zod4.z.object(selectPlayerShape);
237
+ var InvokeActionInput = import_zod4.z.object(invokeActionShape);
238
+ function err3(message) {
239
+ return {
240
+ content: [{ type: "text", text: JSON.stringify({ error: message }) }]
241
+ };
242
+ }
243
+ function ok3(value) {
244
+ return { content: [{ type: "text", text: JSON.stringify(value) }] };
245
+ }
246
+ function handleSelectPlayer(client, input) {
247
+ const { playerId } = SelectPlayerInput.parse(input);
248
+ const { players } = client.getState();
249
+ if (!players[playerId]) return err3(`player not found: ${playerId}`);
250
+ client.selectPlayer(playerId);
251
+ return ok3({ selected: playerId });
252
+ }
253
+ function handleInvokeAction(client, input) {
254
+ const { playerId, pluginId, action, payload } = InvokeActionInput.parse(input);
255
+ const { players, current } = client.getState();
256
+ const id = playerId ?? current.player;
257
+ if (!id) return err3("no player selected");
258
+ const player = players[id];
259
+ if (!player) return err3(`player not found: ${id}`);
260
+ const plugin = player.plugins[pluginId];
261
+ if (!plugin) return err3(`plugin not found: ${pluginId}`);
262
+ if (plugin.capabilities?.actions && !(action in plugin.capabilities.actions)) {
263
+ return err3(`action "${action}" not declared in plugin capabilities`);
264
+ }
265
+ client.handleInteraction({ type: action, payload, target: id });
266
+ return ok3({ invoked: action });
267
+ }
268
+ var selectPlayerDef = {
269
+ name: "select_player",
270
+ description: "Select a Player instance as the active target for subsequent tool calls.",
271
+ inputSchema: selectPlayerShape,
272
+ handle: handleSelectPlayer
273
+ };
274
+ var invokeActionDef = {
275
+ name: "invoke_action",
276
+ description: "Invoke a named action on a plugin. Use describe_plugin first to discover available actions.",
277
+ inputSchema: invokeActionShape,
278
+ handle: handleInvokeAction
279
+ };
280
+
281
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/tools/index.ts
282
+ var TOOL_DEFS = [
283
+ listPlayersDef,
284
+ getPlayerStatusDef,
285
+ getFlowDef,
286
+ getDataDef,
287
+ getLogsDef,
288
+ getPluginDataDef,
289
+ describePluginDef,
290
+ selectPlayerDef,
291
+ invokeActionDef
292
+ ];
293
+
294
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/server.ts
295
+ var MCPServer = class {
296
+ constructor(transport) {
297
+ this.transport = transport;
298
+ this.client = (0, import_client.createExtensionClient)(transport);
299
+ this.server = new import_mcp.McpServer({ name: "player-devtools", version: "0.0.1" });
300
+ this.registerTools();
301
+ }
302
+ registerTools() {
303
+ for (const def of TOOL_DEFS) {
304
+ const register = this.server.registerTool.bind(this.server);
305
+ register(
306
+ def.name,
307
+ { description: def.description, inputSchema: def.inputSchema },
308
+ (args) => def.handle(this.client, args)
309
+ );
310
+ }
311
+ }
312
+ async start() {
313
+ const stdioTransport = new import_stdio.StdioServerTransport();
314
+ await this.server.connect(stdioTransport);
315
+ try {
316
+ await this.transport.connect();
317
+ } catch (err4) {
318
+ console.warn(
319
+ "[MCPServer] Transport connect failed (will operate in disconnected mode):",
320
+ err4 instanceof Error ? err4.message : err4
321
+ );
322
+ }
323
+ }
324
+ async stop() {
325
+ this.client.destroy();
326
+ await this.transport.close();
327
+ await this.server.close();
328
+ }
329
+ };
330
+
331
+ // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/mcp/src/transport.ts
332
+ var import_flipper_server_client = require("flipper-server-client");
333
+ var import_child_process = require("child_process");
334
+ var net = __toESM(require("net"));
335
+ var fs = __toESM(require("fs"));
336
+ var os = __toESM(require("os"));
337
+ var path = __toESM(require("path"));
338
+ var PLUGIN_API = "player-ui-devtools";
339
+ function waitForPort(host, port, timeoutMs = 3e4) {
340
+ return new Promise((resolve, reject) => {
341
+ const deadline = Date.now() + timeoutMs;
342
+ const attempt = () => {
343
+ const socket = net.connect(port, host);
344
+ socket.once("connect", () => {
345
+ socket.destroy();
346
+ resolve();
347
+ });
348
+ socket.once("error", () => {
349
+ socket.destroy();
350
+ if (Date.now() >= deadline) {
351
+ reject(new Error(`Timed out waiting for ${host}:${port}`));
352
+ } else {
353
+ setTimeout(attempt, 500);
354
+ }
355
+ });
356
+ };
357
+ attempt();
358
+ });
359
+ }
360
+ var FlipperRefcount = class {
361
+ constructor() {
362
+ this.dir = path.join(os.tmpdir(), "player-devtools-mcp");
363
+ this.file = path.join(this.dir, "flipper-server.refcount");
364
+ this.lock = path.join(this.dir, "flipper-server.lock");
365
+ }
366
+ /** Acquire the cross-process lock, run `fn`, then release — even on throw. */
367
+ withLock(fn) {
368
+ fs.mkdirSync(this.dir, { recursive: true });
369
+ const deadline = Date.now() + 5e3;
370
+ for (; ; ) {
371
+ try {
372
+ fs.mkdirSync(this.lock);
373
+ break;
374
+ } catch (err4) {
375
+ if (err4.code !== "EEXIST") throw err4;
376
+ if (Date.now() >= deadline) {
377
+ try {
378
+ fs.rmdirSync(this.lock);
379
+ } catch {
380
+ }
381
+ }
382
+ }
383
+ }
384
+ try {
385
+ return fn();
386
+ } finally {
387
+ try {
388
+ fs.rmdirSync(this.lock);
389
+ } catch {
390
+ }
391
+ }
392
+ }
393
+ read() {
394
+ try {
395
+ return JSON.parse(fs.readFileSync(this.file, "utf8"));
396
+ } catch {
397
+ return null;
398
+ }
399
+ }
400
+ write(state) {
401
+ fs.writeFileSync(this.file, JSON.stringify(state));
402
+ }
403
+ clear() {
404
+ try {
405
+ fs.unlinkSync(this.file);
406
+ } catch {
407
+ }
408
+ }
409
+ /** Is the recorded daemon PID still alive? */
410
+ isAlive(pid) {
411
+ try {
412
+ process.kill(pid, 0);
413
+ return true;
414
+ } catch {
415
+ return false;
416
+ }
417
+ }
418
+ /**
419
+ * Register interest in the daemon. Returns whether this caller is the one
420
+ * responsible for starting it (because no live daemon was recorded).
421
+ * `recordPid` is called with the started PID once the daemon is up.
422
+ */
423
+ acquire() {
424
+ return this.withLock(() => {
425
+ const state = this.read();
426
+ if (state && this.isAlive(state.pid)) {
427
+ this.write({ pid: state.pid, refs: state.refs + 1 });
428
+ return { shouldStart: false, commit: () => {
429
+ } };
430
+ }
431
+ return {
432
+ shouldStart: true,
433
+ commit: (pid) => this.withLock(() => this.write({ pid, refs: 1 }))
434
+ };
435
+ });
436
+ }
437
+ /**
438
+ * Drop this caller's interest. Returns the PID to kill if this was the last
439
+ * reference, otherwise null.
440
+ */
441
+ release() {
442
+ return this.withLock(() => {
443
+ const state = this.read();
444
+ if (!state) return null;
445
+ if (state.refs <= 1) {
446
+ this.clear();
447
+ return state.pid;
448
+ }
449
+ this.write({ pid: state.pid, refs: state.refs - 1 });
450
+ return null;
451
+ });
452
+ }
453
+ };
454
+ var FlipperServerTransport = class {
455
+ constructor(options = {}) {
456
+ this.options = options;
457
+ this.server = null;
458
+ this.refcount = new FlipperRefcount();
459
+ this.listeners = /* @__PURE__ */ new Set();
460
+ /**
461
+ * Client IDs that have sent at least one message through the devtools
462
+ * plugin — these are the clients we send outbound messages to.
463
+ */
464
+ this.activeClientIds = /* @__PURE__ */ new Set();
465
+ this.sendMessage = async (message) => {
466
+ if (!this.server) return;
467
+ const payload = {
468
+ method: "execute",
469
+ params: {
470
+ api: PLUGIN_API,
471
+ method: "message::flipper",
472
+ params: message
473
+ }
474
+ };
475
+ await Promise.all(
476
+ [...this.activeClientIds].map(
477
+ (clientId) => this.server.exec("client-request-response", clientId, payload).catch(
478
+ (err4) => {
479
+ console.warn(
480
+ `[FlipperServerTransport] Failed to send to client ${clientId}:`,
481
+ err4
482
+ );
483
+ this.activeClientIds.delete(clientId);
484
+ }
485
+ )
486
+ )
487
+ );
488
+ };
489
+ this.addListener = (callback) => {
490
+ this.listeners.add(callback);
491
+ };
492
+ this.removeListener = (callback) => {
493
+ this.listeners.delete(callback);
494
+ };
495
+ }
496
+ async connect() {
497
+ const host = this.options.host ?? "localhost";
498
+ const port = this.options.port ?? 52342;
499
+ const { shouldStart, commit } = this.refcount.acquire();
500
+ if (shouldStart) {
501
+ console.log("[FlipperServerTransport] Starting flipper-server...");
502
+ const serverScript = require.resolve("flipper-server/server.js");
503
+ const child = (0, import_child_process.spawn)(process.execPath, [serverScript, "--open=true"], {
504
+ stdio: "inherit",
505
+ detached: true
506
+ });
507
+ child.on("error", (err4) => {
508
+ console.error(
509
+ "[FlipperServerTransport] flipper-server process error:",
510
+ err4
511
+ );
512
+ });
513
+ child.unref();
514
+ await waitForPort(host, port);
515
+ commit(child.pid);
516
+ console.log("[FlipperServerTransport] flipper-server ready.");
517
+ } else {
518
+ await waitForPort(host, port);
519
+ console.log("[FlipperServerTransport] Attached to flipper-server.");
520
+ }
521
+ const { getAuthToken } = (
522
+ // eslint-disable-next-line @typescript-eslint/no-require-imports
523
+ require("flipper-server/lib/app-connectivity/certificate-exchange/certificate-utils")
524
+ );
525
+ let cachedToken = null;
526
+ try {
527
+ cachedToken = await getAuthToken();
528
+ } catch (err4) {
529
+ console.warn("[FlipperServerTransport] Could not read auth token:", err4);
530
+ }
531
+ this.server = await (0, import_flipper_server_client.createFlipperServer)(
532
+ host,
533
+ port,
534
+ () => cachedToken,
535
+ (state) => {
536
+ if (state === import_flipper_server_client.FlipperServerState.DISCONNECTED) {
537
+ console.warn("[FlipperServerTransport] Disconnected from server");
538
+ }
539
+ }
540
+ );
541
+ await this.server.connect();
542
+ this.server.on("client-connected", (info) => {
543
+ console.log(
544
+ "[FlipperServerTransport] client-connected:",
545
+ JSON.stringify(info)
546
+ );
547
+ });
548
+ this.server.on("client-disconnected", ({ id }) => {
549
+ console.log("[FlipperServerTransport] client-disconnected:", id);
550
+ this.activeClientIds.delete(id);
551
+ });
552
+ this.server.on("client-message", ({ id, message }) => {
553
+ let parsed;
554
+ try {
555
+ parsed = JSON.parse(message);
556
+ } catch {
557
+ return;
558
+ }
559
+ console.debug(
560
+ `[FlipperServerTransport] client-message from ${id}: method=${parsed.method} api=${parsed.params?.api} pluginMethod=${parsed.params?.method}`
561
+ );
562
+ if (parsed.method !== "execute" || parsed.params?.api !== PLUGIN_API || parsed.params?.method !== "message::plugin") {
563
+ return;
564
+ }
565
+ this.activeClientIds.add(id);
566
+ const payload = parsed.params.params;
567
+ for (const listener of this.listeners) {
568
+ listener(payload);
569
+ }
570
+ });
571
+ }
572
+ async close() {
573
+ this.listeners.clear();
574
+ this.activeClientIds.clear();
575
+ this.server?.close();
576
+ this.server = null;
577
+ const pidToKill = this.refcount.release();
578
+ if (pidToKill !== null) {
579
+ try {
580
+ process.kill(pidToKill);
581
+ console.log("[FlipperServerTransport] Shut down flipper-server.");
582
+ } catch {
583
+ }
584
+ }
585
+ }
586
+ };
587
+ // Annotate the CommonJS export names for ESM import in node:
588
+ 0 && (module.exports = {
589
+ FlipperServerTransport,
590
+ MCPServer
591
+ });
592
+ //# sourceMappingURL=index.cjs.map