@foldkit/devtools-mcp 0.24.1 → 0.25.0

package/dist/tools.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import type { WebSocketClient } from './webSocketClient.js';
+import { type RelayClient } from './relayClient.js';
 type ToolResult = Readonly<{
     content: ReadonlyArray<Readonly<{
         type: 'text';
@@ -19,6 +19,6 @@ export type ToolDefinition = Readonly<{
  * input via Effect Schema, dispatches a typed `Request` through the WebSocket
  * relay, and formats the typed `Response` as MCP tool content.
  */
-export declare const buildTools: (wsClient: WebSocketClient) => ReadonlyArray<ToolDefinition>;
+export declare const buildTools: (relayClient: RelayClient) => ReadonlyArray<ToolDefinition>;
 export {};
 //# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAyB,MAAM,QAAQ,CAAA;AAO7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AA0L3D,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAA;IAChE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAC,CAAA;AAEF,8HAA8H;AAC9H,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;CACzD,CAAC,CAAA;AAsHF;;;;GAIG;AACH,eAAO,MAAM,UAAU,aACX,eAAe,KACxB,aAAa,CAAC,cAAc,CAsM9B,CAAA"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAkB,MAAM,QAAQ,CAAA;AAOtD,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,kBAAkB,CAAA;AA0LzB,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAA;IAChE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAC,CAAA;AAEF,8HAA8H;AAC9H,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;CACzD,CAAC,CAAA;AAyEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,gBACR,WAAW,KACvB,aAAa,CAAC,cAAc,CAsM9B,CAAA"}

package/dist/tools.js

@@ -1,6 +1,7 @@
-import { Array, Effect, Match, Option, Schema } from 'effect';
+import { Array, Effect, Option, Schema } from 'effect';
 import { MAX_DISPATCH_BATCH_SIZE, Request, } from 'foldkit/devtools-protocol';
-const RUNTIME_ID_DESCRIPTION = 'Optional connection id of a specific Foldkit runtime. Defaults to the most recently connected runtime.';
+import { errorReason, } from './relayClient.js';
+const RUNTIME_ID_DESCRIPTION = 'Optional connection id of a specific Foldkit runtime. Defaults to the most recently connected runtime of the most recently started dev server. Call `foldkit_list_runtimes` to find runtimes in other applications, each with its `projectRoot`.';
 const DEFAULT_LIST_MESSAGES_LIMIT = 50;
 const RuntimeIdField = Schema.optional(Schema.String.annotate({ description: RUNTIME_ID_DESCRIPTION }));
 const ListLimit = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 500 })).annotate({
@@ -129,40 +130,20 @@ const formatError = (reason) => ({
     content: [{ type: 'text', text: `Error: ${reason}` }],
     isError: true,
 });
-/**
- * Read a display string from a caught error. Effect's `TimeoutError` carries no
- * `message`, so `error.message` is `undefined` on a relay timeout; fall back to
- * the error's string form (its tag) rather than surfacing `Error: undefined`.
- */
-const errorReason = (error) => error.message ? error.message : String(error);
 /**
  * Decode a tool's raw input against its Effect Schema. Failure surfaces as an
  * `Error` for the outer handler's `catchAll` to convert into a `ToolResult`.
  */
 const decodeInput = (schema, rawInput) => Schema.decodeUnknownEffect(schema)(rawInput).pipe(Effect.mapError(error => new Error(`Invalid input: ${error.message}`)));
-/**
- * Resolve a runtime id, defaulting to the most recently connected runtime when
- * the caller did not specify one. Failures (no runtimes connected, relay
- * error) surface as `Error` for the outer handler's `catchAll` to convert.
- */
-const resolveRuntimeId = (wsClient, explicit) => {
-    if (explicit !== undefined) {
-        return Effect.succeed(explicit);
-    }
-    return Effect.gen(function* () {
-        const response = yield* wsClient.sendRequest(Request.RequestListRuntimes(), Option.none());
-        return yield* Match.value(response).pipe(Match.tag('ResponseRuntimes', ({ runtimes }) => Array.last(runtimes).pipe(Option.match({
-            onNone: () => Effect.fail(new Error('No connected Foldkit runtimes. Open a Foldkit dev page and try again.')),
-            onSome: runtime => Effect.succeed(runtime.connectionId),
-        }))), Match.tag('ResponseError', ({ reason }) => Effect.fail(new Error(reason))), Match.orElse(({ _tag }) => Effect.fail(new Error(`Unexpected response from RequestListRuntimes: ${_tag}`))));
-    });
-};
+const listedRuntimeOutput = ({ runtime, maybeProjectRoot }) => Option.match(maybeProjectRoot, {
+    onNone: () => runtime,
+    onSome: projectRoot => ({ ...runtime, projectRoot }),
+});
 const responseToToolResult = (response) => response._tag === 'ResponseError'
     ? formatError(response.reason)
     : formatResult(response);
-const callRuntimeRequest = (wsClient, explicitRuntimeId, buildRequest) => Effect.gen(function* () {
-    const runtimeId = yield* resolveRuntimeId(wsClient, explicitRuntimeId);
-    const response = yield* wsClient.sendRequest(buildRequest(), Option.some(runtimeId));
+const callRuntimeRequest = (relayClient, explicitRuntimeId, buildRequest) => Effect.gen(function* () {
+    const response = yield* relayClient.sendRequest(buildRequest(), Option.fromNullishOr(explicitRuntimeId));
     return responseToToolResult(response);
 }).pipe(Effect.catch(error => Effect.succeed(formatError(errorReason(error)))));
 /**
@@ -170,16 +151,16 @@ const callRuntimeRequest = (wsClient, explicitRuntimeId, buildRequest) => Effect
  * issues a typed `Request`, and formats the response. Used for every tool
  * except `foldkit_list_runtimes`, which does not target a specific runtime.
  */
-const runRuntimeTool = (inputSchema, buildRequest, wsClient) => (rawInput) => Effect.gen(function* () {
+const runRuntimeTool = (inputSchema, buildRequest, relayClient) => (rawInput) => Effect.gen(function* () {
     const input = yield* decodeInput(inputSchema, rawInput);
-    return yield* callRuntimeRequest(wsClient, input.runtime_id, () => buildRequest(input));
+    return yield* callRuntimeRequest(relayClient, input.runtime_id, () => buildRequest(input));
 }).pipe(Effect.catch(error => Effect.succeed(formatError(errorReason(error)))));
 /**
  * Build the read-only Foldkit DevTools tool definitions. Each tool decodes its
  * input via Effect Schema, dispatches a typed `Request` through the WebSocket
  * relay, and formats the typed `Response` as MCP tool content.
  */
-export const buildTools = (wsClient) => [
+export const buildTools = (relayClient) => [
     {
         name: 'foldkit_get_model',
         description: "Snapshot the current Model from a connected Foldkit runtime. By default the response is summarized (large arrays/records/strings collapse to `_summary` placeholders) to keep payloads small for AI agents. Pass `path` (e.g. 'root.session.user') to narrow to a subtree, and `expand: true` to receive the literal value at that path. Returns `{ value, atPath, summarized }`.",
@@ -187,7 +168,7 @@ export const buildTools = (wsClient) => [
         handle: runRuntimeTool(GetModelInput, ({ path, expand }) => Request.RequestGetModel({
             maybePath: Option.fromNullishOr(path),
             expand: expand ?? false,
-        }), wsClient),
+        }), relayClient),
     },
     {
         name: 'foldkit_get_model_at',
@@ -197,7 +178,7 @@ export const buildTools = (wsClient) => [
             index,
             maybePath: Option.fromNullishOr(path),
             expand: expand ?? false,
-        }), wsClient),
+        }), relayClient),
     },
     {
         name: 'foldkit_list_messages',
@@ -208,7 +189,7 @@ export const buildTools = (wsClient) => [
             maybeSinceIndex: Option.fromNullishOr(since_index),
             maybeChangedPathsMatch: Option.fromNullishOr(changed_paths_match),
             fromEnd: from_end ?? false,
-        }), wsClient),
+        }), relayClient),
     },
     {
         name: 'foldkit_count_messages_by_tag',
@@ -217,7 +198,7 @@ export const buildTools = (wsClient) => [
         handle: runRuntimeTool(CountMessagesByTagInput, ({ since_index, changed_paths_match }) => Request.RequestCountMessagesByTag({
             maybeSinceIndex: Option.fromNullishOr(since_index),
             maybeChangedPathsMatch: Option.fromNullishOr(changed_paths_match),
-        }), wsClient),
+        }), relayClient),
     },
     {
         name: 'foldkit_diff_models',
@@ -227,43 +208,43 @@ export const buildTools = (wsClient) => [
             fromIndex: from_index,
             toIndex: to_index,
             maybeChangedPathsMatch: Option.fromNullishOr(changed_paths_match),
-        }), wsClient),
+        }), relayClient),
     },
     {
         name: 'foldkit_get_message',
         description: 'Read a single Message history entry by absolute index. The response carries the SerializedEntry (tag, message body, commands, mountStarts, mountEnds, timestamp, `isModelChanged`, `changedPaths` for leaf-level mutations, `affectedPaths` adding their ancestor paths). Each entry in `commands` carries the Command name, `args` (`Some(record)` when the Command declared an args schema, `None` otherwise), and `maybeSubmodelPath` (`None` before the result resolves, `Some([])` for a resolved top-level Command, or `Some(tags)` for a resolved Submodel Command). `mountStarts` lists Mounts that fired during the render after this Message; `mountEnds` lists Mounts whose elements were unmounted during that render. Each Mount carries its `name` and `args` (`Some(record)` when the Mount declared an args schema, `None` otherwise). For Submodel-routed entries (tag matches `Got*Message`), the entry also carries `submodelPath` listing wrapper tags from outer to inner and `maybeLeafTag` naming the innermost child Message. Model snapshots are not included; call foldkit_get_model_at with `index - 1` (before) and `index` (after) to inspect Model state around the entry.',
         inputSchema: toInputSchema(GetMessageInput),
-        handle: runRuntimeTool(GetMessageInput, ({ index }) => Request.RequestGetMessage({ index }), wsClient),
+        handle: runRuntimeTool(GetMessageInput, ({ index }) => Request.RequestGetMessage({ index }), relayClient),
     },
     {
         name: 'foldkit_get_init',
         description: "Read the runtime's initial Model, the Commands returned from the application's `init` function, and the Mounts that fired during the first render. The init entry is the synthetic row at index -1 in the DevTools panel; this tool exposes the same data without time-travelling the runtime. `maybeModel` is `None` until the runtime has finished its first render and recorded init, then stays `Some` for the rest of the runtime's life. `commands` lists init-time Commands in the order they were produced, each with its name, `args` (`Some(record)` when the Command declared an args schema, `None` otherwise), and `maybeSubmodelPath` (`None` before the result resolves, `Some([])` for a resolved top-level Command, or `Some(tags)` for a resolved Submodel Command); `mountStarts` lists Mounts whose elements appeared in the initial render, each with its name and `args` (`Some(record)` when the Mount declared an args schema, `None` otherwise).",
         inputSchema: toInputSchema(GetInitInput),
-        handle: runRuntimeTool(GetInitInput, () => Request.RequestGetInit(), wsClient),
+        handle: runRuntimeTool(GetInitInput, () => Request.RequestGetInit(), relayClient),
     },
     {
         name: 'foldkit_get_runtime_state',
         description: "Snapshot the runtime's DevTools state: history bounds, current paused/live status, and whether init is recorded. Returns `currentIndex` (the absolute index of the most recent Message, or -1 when none), `startIndex` (the earliest absolute index still retained in the rolling buffer), `totalEntries` (count of retained entries), `isPaused`, `maybePausedAtIndex` (`Some(index)` when paused, `None` otherwise), and `hasInitModel`. Use it to reason about what `foldkit_list_messages` and `foldkit_get_message` will see, and to detect whether the runtime is currently paused at a replayed snapshot.",
         inputSchema: toInputSchema(GetRuntimeStateInput),
-        handle: runRuntimeTool(GetRuntimeStateInput, () => Request.RequestGetRuntimeState(), wsClient),
+        handle: runRuntimeTool(GetRuntimeStateInput, () => Request.RequestGetRuntimeState(), relayClient),
     },
     {
         name: 'foldkit_list_keyframes',
         description: 'List the available keyframes (replayable Model snapshots) from a Foldkit runtime.',
         inputSchema: toInputSchema(ListKeyframesInput),
-        handle: runRuntimeTool(ListKeyframesInput, () => Request.RequestListKeyframes(), wsClient),
+        handle: runRuntimeTool(ListKeyframesInput, () => Request.RequestListKeyframes(), relayClient),
     },
     {
         name: 'foldkit_replay_to_keyframe',
         description: 'Time-travel a Foldkit runtime back to a previous Model snapshot. Pass `keyframe_index: -1` for the initial Model, or a non-negative index for the state right after that history entry. The runtime is paused at the snapshot until foldkit_resume is called.',
         inputSchema: toInputSchema(ReplayToKeyframeInput),
-        handle: runRuntimeTool(ReplayToKeyframeInput, ({ keyframe_index }) => Request.RequestReplayToKeyframe({ keyframeIndex: keyframe_index }), wsClient),
+        handle: runRuntimeTool(ReplayToKeyframeInput, ({ keyframe_index }) => Request.RequestReplayToKeyframe({ keyframeIndex: keyframe_index }), relayClient),
     },
     {
         name: 'foldkit_resume',
         description: 'Resume normal execution of a Foldkit runtime that was paused by foldkit_replay_to_keyframe.',
         inputSchema: toInputSchema(ResumeInput),
-        handle: runRuntimeTool(ResumeInput, () => Request.RequestResume(), wsClient),
+        handle: runRuntimeTool(ResumeInput, () => Request.RequestResume(), relayClient),
     },
     {
         name: 'foldkit_get_message_schema',
@@ -271,27 +252,27 @@ export const buildTools = (wsClient) => [
         inputSchema: toInputSchema(GetMessageSchemaInput),
         handle: runRuntimeTool(GetMessageSchemaInput, ({ variant_tag }) => Request.RequestGetMessageSchema({
             maybeVariantTag: Option.fromNullishOr(variant_tag),
-        }), wsClient),
+        }), relayClient),
     },
     {
         name: 'foldkit_dispatch_message',
         description: "Dispatch a Message into a Foldkit runtime, as if the application itself produced it. Requires the runtime to have configured DevToolsConfig.Message; without it, dispatch is rejected. Call `foldkit_get_message_schema` with no arguments to enumerate the variants, then with `variant_tag` to learn one variant's exact payload shape, before constructing the Message object. The runtime decodes the payload and returns a clean error if it doesn't match. To dispatch several Messages in order with one call, use foldkit_dispatch_messages.",
         inputSchema: toInputSchema(DispatchMessageInput),
-        handle: runRuntimeTool(DispatchMessageInput, ({ message }) => Request.RequestDispatchMessage({ message }), wsClient),
+        handle: runRuntimeTool(DispatchMessageInput, ({ message }) => Request.RequestDispatchMessage({ message }), relayClient),
     },
     {
         name: 'foldkit_dispatch_messages',
         description: `Dispatch an ordered batch of Messages into a Foldkit runtime in one call, first to last, as if the application produced them in quick succession. Prefer this over repeated foldkit_dispatch_message calls when staging state that takes several Messages: reproducing a bug, filling a form, or building a history fixture. Takes 1 to ${MAX_DISPATCH_BATCH_SIZE} Messages. Validation is all-or-nothing: the runtime decodes every payload against the Message Schema before dispatching any of them, and one invalid entry rejects the whole batch with an error naming its zero-based position, so there is never a partially applied prefix to clean up. On success the response carries acceptedAtIndices, the predicted history index for each Message in request order; the runtime may still record its own Messages between entries (for example a Command completing mid-burst), exactly as with rapid user input, and Messages excluded from history via excludeFromHistory are dispatched but never recorded, so entries after one land below their predicted index. Requires DevToolsConfig.Message, like foldkit_dispatch_message.`,
         inputSchema: toInputSchema(DispatchMessagesInput),
-        handle: runRuntimeTool(DispatchMessagesInput, ({ messages }) => Request.RequestDispatchMessages({ messages }), wsClient),
+        handle: runRuntimeTool(DispatchMessagesInput, ({ messages }) => Request.RequestDispatchMessages({ messages }), relayClient),
     },
     {
         name: 'foldkit_list_runtimes',
-        description: 'List Foldkit runtimes (browser tabs) currently connected to the dev server.',
+        description: 'List Foldkit runtimes (browser tabs) connected to every Foldkit dev server under the project root, or else to every dev server at the nearest root that encloses the project root, oldest dev server first. Each runtime carries `projectRoot`, the root of the dev server it belongs to, unless the MCP server uses a fixed relay address.',
         inputSchema: NO_INPUT_SCHEMA,
-        handle: () => Effect.gen(function* () {
-            const response = yield* wsClient.sendRequest(Request.RequestListRuntimes(), Option.none());
-            return responseToToolResult(response);
-        }).pipe(Effect.catch(error => Effect.succeed(formatError(errorReason(error))))),
+        handle: () => relayClient.listRuntimes.pipe(Effect.map(listed => formatResult({
+            _tag: 'ResponseRuntimes',
+            runtimes: Array.map(listed, listedRuntimeOutput),
+        })), Effect.catch(error => Effect.succeed(formatError(errorReason(error))))),
     },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/devtools-mcp",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "MCP server exposing Foldkit DevTools to AI agents (Claude Code, Cursor, etc.)",
   "type": "module",
   "main": "./dist/server.js",
@@ -25,16 +25,16 @@
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0",
+    "@foldkit/vite-plugin": "0.28.0",
     "@types/node": "26.4.0",
     "@types/ws": "^8.18.1",
     "effect": "4.0.0",
+    "foldkit": "0.169.0",
     "rimraf": "^6.1.3",
     "rolldown": "^1.2.11",
     "typescript": "^7.0.2",
     "vite": "^8.3.1",
-    "vitest": "^4.1.11",
-    "@foldkit/vite-plugin": "0.26.1",
-    "foldkit": "0.166.0"
+    "vitest": "^4.1.11"
   },
   "files": [
     "dist"

package/dist/webSocketClient.d.ts

@@ -1,28 +0,0 @@
-import { type Cause, Effect, Option } from 'effect';
-import { type Request, type Response } from 'foldkit/devtools-protocol';
-/**
- * A WebSocket client to the Foldkit Vite plugin's DevTools relay.
- *
- * Sends typed `Request`s and resolves with the matching `Response`. The
- * `sendRequest` Effect fails with `TimeoutException` when no response arrives
- * within the request timeout window, or with `Error` when no relay is
- * connected or the send throws. Either way, no pending entry leaks.
- *
- * The client manages its own connection lifecycle in a background fiber:
- * the initial connect is retried with exponential backoff, and any later
- * disconnect (e.g. when the user restarts the Vite dev server) reconnects
- * via the same loop. The MCP server can stay live across dev-server
- * restarts and even when no dev server has started yet — `sendRequest`
- * returns a clear "not connected" error in that window, and tools should
- * surface it to the agent so the user can start a dev server and retry.
- *
- * Pending response correlators live in a client-owned Ref, not on the
- * socket, so they survive reconnects: in-flight requests time out and
- * future requests succeed once the new socket is open.
- */
-export type WebSocketClient = Readonly<{
-    sendRequest: (request: typeof Request.Type, maybeRuntimeId: Option.Option<string>) => Effect.Effect<typeof Response.Type, Cause.TimeoutError | Error>;
-    close: Effect.Effect<void>;
-}>;
-export declare const connectWebSocketClient: <Services>(resolveUrl: Effect.Effect<string, never, Services>) => Effect.Effect<WebSocketClient, never, Services>;
-//# sourceMappingURL=webSocketClient.d.ts.map

package/dist/webSocketClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webSocketClient.d.ts","sourceRoot":"","sources":["../src/webSocketClient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,KAAK,EAIV,MAAM,EAIN,MAAM,EAKP,MAAM,QAAQ,CAAA;AACf,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,QAAQ,EAEd,MAAM,2BAA2B,CAAA;AAgBlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,WAAW,EAAE,CACX,OAAO,EAAE,OAAO,OAAO,CAAC,IAAI,EAC5B,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAClC,MAAM,CAAC,MAAM,CAAC,OAAO,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,YAAY,GAAG,KAAK,CAAC,CAAA;IACpE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAC3B,CAAC,CAAA;AA2DF,eAAO,MAAM,sBAAsB,GAAI,QAAQ,cACjC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,KACjD,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,EAAE,QAAQ,CAoI7C,CAAA"}

package/dist/webSocketClient.js

@@ -1,134 +0,0 @@
-import { Console, Deferred, Duration, Effect, Exit, Fiber, HashMap, Option, Ref, Schedule, Schema, pipe, } from 'effect';
-import { RequestFrame, ResponseFrame, } from 'foldkit/devtools-protocol';
-import { WebSocket } from 'ws';
-const REQUEST_TIMEOUT = Duration.seconds(10);
-const INITIAL_RECONNECT_DELAY = Duration.millis(500);
-const MAX_RECONNECT_DELAY = Duration.seconds(30);
-const encodeRequestFrameToJson = Schema.encodeUnknownSync(Schema.fromJsonString(RequestFrame));
-const generateRequestId = () => `req-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-const reconnectSchedule = Schedule.exponential(INITIAL_RECONNECT_DELAY).pipe(Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.min(duration, MAX_RECONNECT_DELAY))));
-const relayUrlForLog = (url) => {
-    const parsed = new URL(url);
-    parsed.search = '';
-    return parsed.toString();
-};
-const attemptOpen = (url) => Effect.callback(resume => {
-    const socket = new WebSocket(url);
-    let settled = false;
-    socket.once('open', () => {
-        if (settled)
-            return;
-        settled = true;
-        resume(Effect.succeed(socket));
-    });
-    socket.once('error', error => {
-        if (settled)
-            return;
-        settled = true;
-        resume(Effect.fail(error));
-    });
-    return Effect.sync(() => {
-        if (!settled) {
-            socket.removeAllListeners();
-            socket.close();
-        }
-    });
-});
-const waitForClose = (socket) => Effect.callback(resume => {
-    const isAlreadyClosing = socket.readyState === WebSocket.CLOSED ||
-        socket.readyState === WebSocket.CLOSING;
-    if (isAlreadyClosing) {
-        resume(Effect.void);
-        return undefined;
-    }
-    else {
-        const handler = () => {
-            resume(Effect.void);
-        };
-        socket.once('close', handler);
-        return Effect.sync(() => {
-            socket.off('close', handler);
-        });
-    }
-});
-export const connectWebSocketClient = (resolveUrl) => Effect.gen(function* () {
-    const pendingResponsesRef = yield* Ref.make(HashMap.empty());
-    const currentSocketRef = yield* Ref.make(Option.none());
-    const isManuallyClosedRef = yield* Ref.make(false);
-    const capturedContext = yield* Effect.context();
-    const attachMessageHandler = (socket) => {
-        socket.on('message', raw => {
-            Effect.runForkWith(capturedContext)(handleIncomingMessage(raw, pendingResponsesRef));
-        });
-        socket.on('error', error => {
-            console.error(`[foldkit-devtools-mcp] socket error: ${error.message}`);
-        });
-    };
-    const openWithBackoff = pipe(resolveUrl, Effect.flatMap(url => attemptOpen(url).pipe(Effect.map(socket => ({ socket, url })), Effect.tapError(error => Console.error(`[foldkit-devtools-mcp] connect attempt to ${relayUrlForLog(url)} failed: ${error.message}`)))), Effect.retry(reconnectSchedule), Effect.orDie);
-    const maintainConnection = Effect.gen(function* () {
-        const { socket, url } = yield* openWithBackoff;
-        yield* Console.error(`[foldkit-devtools-mcp] connected to ${relayUrlForLog(url)}`);
-        attachMessageHandler(socket);
-        yield* Ref.set(currentSocketRef, Option.some(socket));
-        yield* waitForClose(socket);
-        const isManual = yield* Ref.get(isManuallyClosedRef);
-        if (isManual) {
-            return;
-        }
-        yield* Ref.set(currentSocketRef, Option.none());
-        yield* Console.error('[foldkit-devtools-mcp] connection lost, reconnecting');
-        yield* maintainConnection;
-    });
-    const connectionFiber = yield* Effect.forkDetach(maintainConnection);
-    const sendRequest = (request, maybeRuntimeId) => Effect.gen(function* () {
-        const maybeSocket = yield* Ref.get(currentSocketRef);
-        const socket = yield* Option.match(maybeSocket, {
-            onNone: () => Effect.fail(new Error('Not connected to a Foldkit dev server. Start your Foldkit Vite dev server and retry the tool call.')),
-            onSome: candidate => candidate.readyState === WebSocket.OPEN
-                ? Effect.succeed(candidate)
-                : Effect.fail(new Error('Foldkit dev server connection is reconnecting. Retry the tool call in a moment.')),
-        });
-        const id = generateRequestId();
-        const deferred = yield* Deferred.make();
-        yield* Ref.update(pendingResponsesRef, HashMap.set(id, deferred));
-        const frame = {
-            id,
-            maybeConnectionId: maybeRuntimeId,
-            request,
-        };
-        yield* Effect.try({
-            try: () => socket.send(encodeRequestFrameToJson(frame)),
-            catch: error => error instanceof Error
-                ? error
-                : new Error(`Failed to send request: ${String(error)}`),
-        }).pipe(Effect.tapError(() => Ref.update(pendingResponsesRef, HashMap.remove(id))));
-        return yield* Deferred.await(deferred).pipe(Effect.timeout(REQUEST_TIMEOUT), Effect.onError(() => Ref.update(pendingResponsesRef, HashMap.remove(id))));
-    });
-    const close = Effect.gen(function* () {
-        yield* Ref.set(isManuallyClosedRef, true);
-        const maybeSocket = yield* Ref.get(currentSocketRef);
-        yield* Option.match(maybeSocket, {
-            onNone: () => Effect.void,
-            onSome: socket => Effect.sync(() => socket.close()),
-        });
-        yield* Fiber.interrupt(connectionFiber);
-    });
-    return { sendRequest, close };
-});
-const handleIncomingMessage = (raw, pendingResponsesRef) => {
-    const decoded = Schema.decodeUnknownExit(Schema.fromJsonString(ResponseFrame))(raw.toString());
-    return Exit.match(decoded, {
-        onFailure: error => Effect.sync(() => console.error('[foldkit-devtools-mcp] failed to decode frame', error)),
-        onSuccess: responseFrame => Effect.gen(function* () {
-            const map = yield* Ref.get(pendingResponsesRef);
-            const maybeDeferred = HashMap.get(map, responseFrame.id);
-            yield* Option.match(maybeDeferred, {
-                onNone: () => Effect.void,
-                onSome: deferred => Effect.gen(function* () {
-                    yield* Ref.update(pendingResponsesRef, HashMap.remove(responseFrame.id));
-                    yield* Deferred.succeed(deferred, responseFrame.response);
-                }),
-            });
-        }),
-    });
-};