figma-prototype-mcp 0.30.0

package/dist/server/index.js

@@ -0,0 +1,1155 @@
+#!/usr/bin/env node
+
+// src/server/index.ts
+import express from "express";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+
+// src/server/sessions.ts
+import { randomUUID } from "crypto";
+var PluginSession = class {
+  active = null;
+  pending = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Set();
+  commandTimeoutMs;
+  connectWaitMs;
+  constructor(opts = {}) {
+    this.commandTimeoutMs = opts.commandTimeoutMs ?? 3e4;
+    this.connectWaitMs = opts.connectWaitMs ?? 3e3;
+  }
+  isConnected() {
+    return this.active !== null && this.active.readyState === 1;
+  }
+  setActive(ws) {
+    if (this.active && this.active !== ws) {
+      try {
+        this.active.send(JSON.stringify({ type: "system", message: "Replaced by newer connection" }));
+      } catch {
+      }
+      try {
+        this.active.close();
+      } catch {
+      }
+      this.failAllPending(new Error("Plugin connection replaced by newer connection"));
+    }
+    this.active = ws;
+    try {
+      ws.send(JSON.stringify({ type: "ready" }));
+    } catch {
+    }
+    this.notifyWaiters();
+  }
+  clearActive(ws) {
+    if (this.active === ws) {
+      this.active = null;
+      this.failAllPending(new Error("Plugin disconnected"));
+    }
+  }
+  handleResponse(msg) {
+    const p = this.pending.get(msg.id);
+    if (!p) return;
+    this.pending.delete(msg.id);
+    clearTimeout(p.timer);
+    if (msg.status === "ok") p.resolve(msg.result);
+    else p.reject(new Error(msg.error?.message ?? "plugin error"));
+  }
+  async sendCommand(command, params) {
+    if (!this.isConnected()) {
+      await this.waitForConnection(this.connectWaitMs);
+      if (!this.isConnected()) {
+        throw new Error("\uD53C\uADF8\uB9C8 \uD50C\uB7EC\uADF8\uC778 \uC5F0\uACB0\uC744 \uD655\uC778\uD574\uC8FC\uC138\uC694");
+      }
+    }
+    const id = randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Command ${command} timed out after ${this.commandTimeoutMs}ms`));
+      }, this.commandTimeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.active.send(JSON.stringify({ type: "command", id, command, params }));
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    });
+  }
+  waitForConnection(timeoutMs) {
+    if (this.isConnected()) return Promise.resolve();
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.waiters.delete(waiter);
+        resolve();
+      }, timeoutMs);
+      const waiter = () => {
+        clearTimeout(timer);
+        this.waiters.delete(waiter);
+        resolve();
+      };
+      this.waiters.add(waiter);
+    });
+  }
+  notifyWaiters() {
+    for (const w of [...this.waiters]) w();
+  }
+  failAllPending(err) {
+    for (const [id, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+      this.pending.delete(id);
+    }
+  }
+};
+
+// src/server/plugin-ws.ts
+import { WebSocketServer } from "ws";
+var PLUGIN_PATH = "/ws";
+function attachPluginWebSocket(httpServer2, session2) {
+  const wss = new WebSocketServer({ noServer: true });
+  httpServer2.on("upgrade", (req, socket, head) => {
+    if (req.url === PLUGIN_PATH) {
+      wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
+    } else {
+      socket.destroy();
+    }
+  });
+  wss.on("connection", (ws) => {
+    session2.setActive(ws);
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      if (typeof msg === "object" && msg !== null && msg.type === "response") {
+        session2.handleResponse(msg);
+      }
+    });
+    ws.on("close", () => session2.clearActive(ws));
+    ws.on("error", () => session2.clearActive(ws));
+  });
+  return wss;
+}
+
+// src/server/tools.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/mcp-server/tools.ts
+import { z } from "zod";
+
+// src/shared/wire-vocabulary.ts
+var TRIGGER_SHORTCUTS = ["ON_CLICK", "ON_HOVER", "ON_PRESS", "AFTER_TIMEOUT"];
+var TRIGGER_NOPARAM_TYPES = ["ON_CLICK", "ON_HOVER", "ON_PRESS", "ON_DRAG", "ON_MEDIA_END"];
+var MOUSE_CLICK_TYPES = ["MOUSE_UP", "MOUSE_DOWN"];
+var MOUSE_HOVER_TYPES = ["MOUSE_ENTER", "MOUSE_LEAVE"];
+var KEYBOARD_DEVICES = ["KEYBOARD", "XBOX_ONE", "PS4", "SWITCH_PRO", "UNKNOWN_CONTROLLER"];
+var TRANSITION_SHORTCUTS = ["INSTANT", "DISSOLVE", "SMART_ANIMATE"];
+var SIMPLE_TRANSITION_TYPES = ["DISSOLVE", "SMART_ANIMATE", "SCROLL_ANIMATE"];
+var DIRECTIONAL_TRANSITION_TYPES = ["MOVE_IN", "MOVE_OUT", "PUSH", "SLIDE_IN", "SLIDE_OUT"];
+var NAMED_EASINGS = [
+  "LINEAR",
+  "EASE_IN",
+  "EASE_OUT",
+  "EASE_IN_AND_OUT",
+  "EASE_IN_BACK",
+  "EASE_OUT_BACK",
+  "EASE_IN_AND_OUT_BACK",
+  "GENTLE",
+  "QUICK",
+  "BOUNCY",
+  "SLOW"
+];
+var DIRECTIONS = ["LEFT", "RIGHT", "TOP", "BOTTOM"];
+var COMPARISON_OPERATORS = ["==", "!=", "<", "<=", ">", ">="];
+var OVERFLOW_DIRECTIONS = ["NONE", "HORIZONTAL", "VERTICAL", "BOTH"];
+
+// src/mcp-server/tools.ts
+var GetCanvasOverviewInput = z.object({
+  pageId: z.string().optional()
+});
+var GetPrototypeFlowInput = z.object({
+  pageId: z.string().optional(),
+  limit: z.number().int().positive().max(2e3).default(500)
+});
+var FindNodesInput = z.object({
+  query: z.string().min(1),
+  nodeTypes: z.array(z.string()).optional(),
+  scope: z.enum(["page", "document"]).default("page"),
+  limit: z.number().int().positive().max(500).default(50)
+});
+var ListVariablesInput = z.object({
+  resolvedType: z.enum(["BOOLEAN", "FLOAT", "STRING", "COLOR"]).optional().describe("Filter to one variable type (BOOLEAN, FLOAT, STRING, or COLOR)."),
+  includeRemote: z.boolean().default(true).describe(
+    "Enumerate library (remote) variables in addition to local ones. Can be slow on files with large connected libraries; set false to list local only."
+  ),
+  nameQuery: z.string().optional().describe("Case-insensitive substring filter on the variable name.")
+}).strict();
+var TriggerEnum = z.enum(TRIGGER_SHORTCUTS);
+var KeyboardDeviceEnum = z.enum(KEYBOARD_DEVICES);
+var TriggerObjectNoParam = z.object({
+  type: z.enum(TRIGGER_NOPARAM_TYPES)
+});
+var TriggerObjectAfterTimeout = z.object({
+  type: z.literal("AFTER_TIMEOUT"),
+  timeout: z.number().positive().max(60)
+});
+var TriggerObjectMouseClick = z.object({
+  type: z.enum(MOUSE_CLICK_TYPES),
+  delay: z.number().nonnegative().max(60).optional()
+});
+var TriggerObjectMouseHover = z.object({
+  type: z.enum(MOUSE_HOVER_TYPES),
+  delay: z.number().nonnegative().max(60).optional()
+});
+var TriggerObjectKeyDown = z.object({
+  type: z.literal("ON_KEY_DOWN"),
+  device: KeyboardDeviceEnum,
+  keyCodes: z.array(z.number().int().nonnegative()).min(1)
+});
+var TriggerObjectMediaHit = z.object({
+  type: z.literal("ON_MEDIA_HIT"),
+  mediaHitTime: z.number().nonnegative()
+});
+var TriggerInput = z.union([
+  TriggerEnum,
+  TriggerObjectNoParam,
+  TriggerObjectAfterTimeout,
+  TriggerObjectMouseClick,
+  TriggerObjectMouseHover,
+  TriggerObjectKeyDown,
+  TriggerObjectMediaHit
+]).describe(
+  "When the interaction fires. Default ON_CLICK. Natural-language cues (KO/EN): ON_CLICK=\uD074\uB9AD/\uD0ED/\uB204\uB974\uBA74/click,tap; ON_HOVER=\uD638\uBC84/\uB9C8\uC6B0\uC2A4 \uC62C\uB9AC\uBA74/'~\uD558\uB294 \uB3D9\uC548'/while hovering (round-trip: auto-reverts when cursor leaves); ON_PRESS=\uAFB9/\uAE38\uAC8C \uB204\uB974\uBA74/\uB204\uB974\uACE0 \uC788\uC73C\uBA74/long-press (round-trip: reverts on release); ON_DRAG=\uB4DC\uB798\uADF8/\uC2A4\uC640\uC774\uD504/\uB04C\uBA74/\uBC00\uBA74/swipe; MOUSE_ENTER=\uB9C8\uC6B0\uC2A4 \uB4E4\uC5B4\uC624\uBA74/'\uD55C\uBC88 \uD638\uBC84\uD558\uBA74 \uC720\uC9C0'/permanent hover (one-way, stays \u2014 distinct from ON_HOVER); MOUSE_LEAVE=\uB9C8\uC6B0\uC2A4 \uB098\uAC00\uBA74/\uCEE4\uC11C \uBE60\uC9C0\uBA74; MOUSE_DOWN=\uB204\uB974\uB294 \uC21C\uAC04; MOUSE_UP=\uB5BC\uBA74; AFTER_TIMEOUT=N\uCD08 \uD6C4/\uC7A0\uC2DC \uD6C4/\uC790\uB3D9\uC73C\uB85C (requires timeout in seconds; \uC7A0\uAE50\u22480.5, \uC7A0\uC2DC\u22481, \uBA87 \uCD08\u22483); ON_KEY_DOWN=\uC5D4\uD130/\uB2E8\uCD95\uD0A4/Cmd+K (requires device + keyCodes, e.g. Cmd+K=[91,75]); ON_MEDIA_END=\uC601\uC0C1 \uB05D\uB098\uBA74; ON_MEDIA_HIT=\uC601\uC0C1 N\uCD08 \uC2DC\uC810 (requires mediaHitTime in seconds). Decision rules: '\uB204\uB974\uBA74/press' alone \u2192 ON_CLICK, with '\uAFB9/\uAE38\uAC8C/hold' \u2192 ON_PRESS; '\uD638\uBC84/hover' alone \u2192 ON_HOVER, with '\uC720\uC9C0/\uACC4\uC18D/stays' \u2192 MOUSE_ENTER. Full vocabulary: docs/dictionaries/trigger-dictionary."
+);
+var TransitionEnum = z.enum(TRANSITION_SHORTCUTS);
+var NamedEasingEnum = z.enum(NAMED_EASINGS);
+var CustomCubicBezierEasing = z.object({
+  type: z.literal("CUSTOM_CUBIC_BEZIER"),
+  x1: z.number().min(0).max(1),
+  y1: z.number(),
+  x2: z.number().min(0).max(1),
+  y2: z.number()
+});
+var CustomSpringEasing = z.object({
+  type: z.literal("CUSTOM_SPRING"),
+  mass: z.number().positive(),
+  stiffness: z.number().positive(),
+  damping: z.number().positive()
+});
+var EasingInputUnion = z.union([NamedEasingEnum, CustomCubicBezierEasing, CustomSpringEasing]);
+var SimpleTransitionObject = z.object({
+  type: z.enum(SIMPLE_TRANSITION_TYPES),
+  duration: z.number().positive().max(10).optional(),
+  easing: EasingInputUnion.optional()
+});
+var DirectionEnum = z.enum(DIRECTIONS);
+var DirectionalTransitionObject = z.object({
+  type: z.enum(DIRECTIONAL_TRANSITION_TYPES),
+  direction: DirectionEnum,
+  matchLayers: z.boolean().optional(),
+  duration: z.number().positive().max(10).optional(),
+  easing: EasingInputUnion.optional()
+});
+var TransitionInput = z.union([TransitionEnum, SimpleTransitionObject, DirectionalTransitionObject]);
+var NavigateActionInput = z.object({
+  type: z.literal("navigate"),
+  targetFrameId: z.string().min(1),
+  resetScrollPosition: z.boolean().optional()
+});
+var ScrollActionInput = z.object({
+  type: z.literal("scroll"),
+  targetNodeId: z.string().min(1),
+  resetScrollPosition: z.boolean().optional()
+});
+var OverlayActionInput = z.object({
+  type: z.literal("overlay"),
+  targetFrameId: z.string().min(1),
+  resetScrollPosition: z.boolean().optional()
+});
+var CloseActionInput = z.object({
+  type: z.literal("close")
+});
+var BackActionInput = z.object({
+  type: z.literal("back")
+});
+var UrlActionInput = z.object({
+  type: z.literal("url"),
+  url: z.string().min(1),
+  openInNewTab: z.boolean().optional()
+});
+var SwapOverlayActionInput = z.object({
+  type: z.literal("swap_overlay"),
+  targetFrameId: z.string().min(1),
+  resetScrollPosition: z.boolean().optional()
+});
+var ComparisonOperator = z.enum(COMPARISON_OPERATORS);
+var ConditionComparison = z.object({
+  variable: z.string().min(1),
+  collection: z.string().min(1).optional(),
+  operator: ComparisonOperator,
+  value: z.union([z.boolean(), z.number(), z.string()])
+});
+var ConditionInput = z.union([
+  ConditionComparison,
+  z.object({ all: z.array(ConditionComparison).min(2) }).strict(),
+  z.object({ any: z.array(ConditionComparison).min(2) }).strict()
+]);
+var SetVariableActionInput = z.object({
+  type: z.literal("set_variable"),
+  variable: z.string().min(1),
+  collection: z.string().min(1).optional(),
+  value: z.union([z.boolean(), z.number(), z.string()])
+});
+var ToggleVariableActionInput = z.object({
+  type: z.literal("toggle_variable"),
+  variable: z.string().min(1),
+  collection: z.string().min(1).optional()
+});
+var ChangeToActionInput = z.object({
+  type: z.literal("change_to"),
+  targetVariantId: z.string().min(1)
+});
+var NonConditionalActionInput = z.discriminatedUnion("type", [
+  NavigateActionInput,
+  ScrollActionInput,
+  OverlayActionInput,
+  CloseActionInput,
+  BackActionInput,
+  UrlActionInput,
+  SwapOverlayActionInput,
+  SetVariableActionInput,
+  ChangeToActionInput
+]);
+var ConditionalActionInput = z.object({
+  type: z.literal("conditional"),
+  condition: ConditionInput,
+  then: z.array(NonConditionalActionInput).min(1),
+  else: z.array(NonConditionalActionInput).min(1).optional()
+});
+var ActionInput = z.discriminatedUnion("type", [
+  NavigateActionInput,
+  ScrollActionInput,
+  OverlayActionInput,
+  CloseActionInput,
+  BackActionInput,
+  UrlActionInput,
+  SwapOverlayActionInput,
+  ConditionalActionInput,
+  SetVariableActionInput,
+  ToggleVariableActionInput,
+  ChangeToActionInput
+]);
+var ConnectionInput = z.object({
+  sourceNodeId: z.string().min(1),
+  trigger: TriggerInput.default("ON_CLICK"),
+  afterTimeoutSeconds: z.number().positive().optional(),
+  transition: TransitionInput.default("INSTANT"),
+  degradeTo: z.enum(["DISSOLVE", "INSTANT"]).optional(),
+  action: ActionInput
+}).refine(
+  (v) => v.trigger !== "AFTER_TIMEOUT" || typeof v.afterTimeoutSeconds === "number",
+  { message: 'afterTimeoutSeconds is required when trigger is the string "AFTER_TIMEOUT" (object form uses { type: "AFTER_TIMEOUT", timeout })' }
+);
+var CreateReactionsInput = z.object({
+  connections: z.array(ConnectionInput).min(1),
+  replaceExisting: z.boolean().default(false)
+});
+var ListReactionsInput = z.object({
+  nodeId: z.string().min(1)
+});
+var ClearReactionsInput = z.object({
+  nodeIds: z.array(z.string().min(1)).min(1),
+  indices: z.array(z.number().int().nonnegative()).optional()
+}).refine(
+  (v) => !v.indices || v.nodeIds.length === 1,
+  { message: "indices may only be specified when nodeIds has exactly 1 entry" }
+);
+var OverflowDirectionEnum = z.enum(OVERFLOW_DIRECTIONS);
+var SetFrameScrollEntry = z.object({
+  frameId: z.string().min(1),
+  direction: OverflowDirectionEnum.optional(),
+  fixedChildren: z.number().int().min(0).optional()
+}).refine(
+  (v) => v.direction !== void 0 || v.fixedChildren !== void 0,
+  { message: "Each entry must include at least one of `direction` or `fixedChildren`" }
+);
+var SetFrameScrollInput = z.object({
+  frames: z.array(SetFrameScrollEntry).min(1)
+});
+
+// src/mcp-server/protoTools.ts
+import { z as z2 } from "zod";
+
+// src/shared/motionPresets.ts
+var PRESET_NAMES = [
+  "M3_EMPHASIZED",
+  "M3_EMPHASIZED_DECELERATE",
+  "M3_EMPHASIZED_ACCELERATE",
+  "M3_STANDARD",
+  "M3_STANDARD_DECELERATE",
+  "M3_STANDARD_ACCELERATE",
+  "HIG_DEFAULT",
+  "HIG_SMOOTH",
+  "HIG_SNAPPY",
+  "HIG_BOUNCY"
+];
+var PRESETS = {
+  M3_EMPHASIZED: {
+    type: "SMART_ANIMATE",
+    duration: 0.5,
+    easing: { type: "CUSTOM_CUBIC_BEZIER", x1: 0.2, y1: 0, x2: 0, y2: 1 }
+  },
+  M3_EMPHASIZED_DECELERATE: {
+    type: "SMART_ANIMATE",
+    duration: 0.4,
+    easing: { type: "CUSTOM_CUBIC_BEZIER", x1: 0.05, y1: 0.7, x2: 0.1, y2: 1 }
+  },
+  M3_EMPHASIZED_ACCELERATE: {
+    type: "SMART_ANIMATE",
+    duration: 0.2,
+    easing: { type: "CUSTOM_CUBIC_BEZIER", x1: 0.3, y1: 0, x2: 0.8, y2: 0.15 }
+  },
+  M3_STANDARD: {
+    type: "SMART_ANIMATE",
+    duration: 0.3,
+    easing: { type: "CUSTOM_CUBIC_BEZIER", x1: 0.2, y1: 0, x2: 0, y2: 1 }
+  },
+  M3_STANDARD_DECELERATE: {
+    type: "SMART_ANIMATE",
+    duration: 0.25,
+    easing: { type: "CUSTOM_CUBIC_BEZIER", x1: 0, y1: 0, x2: 0, y2: 1 }
+  },
+  M3_STANDARD_ACCELERATE: {
+    type: "SMART_ANIMATE",
+    duration: 0.2,
+    easing: { type: "CUSTOM_CUBIC_BEZIER", x1: 0.3, y1: 0, x2: 1, y2: 1 }
+  },
+  HIG_DEFAULT: { type: "SMART_ANIMATE", easing: "GENTLE" },
+  HIG_SMOOTH: { type: "SMART_ANIMATE", easing: "SLOW" },
+  HIG_SNAPPY: { type: "SMART_ANIMATE", easing: "QUICK" },
+  HIG_BOUNCY: { type: "SMART_ANIMATE", easing: "BOUNCY" }
+};
+function isPresetName(s) {
+  return PRESET_NAMES.includes(s);
+}
+function resolveMotion(m) {
+  if (m === void 0) return PRESETS["M3_EMPHASIZED"];
+  if (typeof m === "string" && isPresetName(m)) return PRESETS[m];
+  return m;
+}
+
+// src/mcp-server/protoTools.ts
+var PresetNameEnum = z2.enum(PRESET_NAMES);
+var MotionInputSchema = z2.union([PresetNameEnum, TransitionInput]).describe(
+  "How it animates: a preset name OR a full TransitionInput. Natural-language \u2192 preset (KO/EN): \uBD80\uB4DC\uB7FD\uAC8C/\uC790\uC5F0\uC2A4\uB7FD\uAC8C/smooth \u2192 M3_STANDARD; \uAC15\uC870/\uBB35\uC9C1/emphasized \u2192 M3_EMPHASIZED (default); \uD280\uB294/\uD1B5\uD1B5/\uC2A4\uD504\uB9C1/bouncy \u2192 HIG_BOUNCY; \uBE60\uB974\uAC8C/\uC2A4\uB0C5/snappy \u2192 HIG_SNAPPY; \uB290\uB9AC\uAC8C/\uC5EC\uC720/slow \u2192 HIG_SMOOTH; iOS/\uC560\uD50C \u2192 HIG_DEFAULT; Material/\uC548\uB4DC\uB85C\uC774\uB4DC \u2192 M3_*. All 10 presets are SMART_ANIMATE (morph). A directional feel (\uC606\uC73C\uB85C/\uC2AC\uB77C\uC774\uB4DC/\uB2E4\uC74C\uC73C\uB85C/\uB118\uAE30\uB4EF/push,slide) or a fade (\uC11C\uC11C\uD788/\uD750\uB824\uC9C0\uBA70/fade) is NOT a preset \u2014 pass a TransitionInput instead: {type:'PUSH'|'SLIDE_IN'|'SLIDE_OUT', direction} or {type:'DISSOLVE'}. Duration cues (for a custom TransitionInput, not presets): \uBE60\uB974\uAC8C\u22480.1\u20130.15s, \uBCF4\uD1B5\u22480.15s, \uBD80\uB4DC\uB7FD\uAC8C\u22480.25s, \uB290\uB9AC\uAC8C\u22480.4s. Spatial cues map to a directional TransitionInput, not a preset: \uBC00\uACE0 \uB4E4\uC5B4\uC624\uB294/\uB4E4\uC5B4\uC640 \u2192 {type:'MOVE_IN', direction}; \uBC00\uC5B4\uB0B4\uBA70/\uB098\uAC00\uBA70/\uB0B4\uBCF4\uB0B4\uBA70 \u2192 {type:'MOVE_OUT', direction}; \uC62C\uB77C\uC624\uB294/\uC62C\uB77C\uC640 \u2192 {type:'MOVE_IN', direction:'BOTTOM'}; \uB0B4\uB824\uC624\uB294 \u2192 {type:'MOVE_IN', direction:'TOP'}. (A DISSOLVE cannot carry matching layers \u2014 Figma runtime rejects matchLayers on DISSOLVE. For a fade that also morphs shared layers, use a directional transition with matchLayers, e.g. {type:'PUSH', direction, matchLayers:true}.) Full vocabulary: docs/dictionaries/."
+);
+var DEGRADE_TO_FIELD = z2.enum(["DISSOLVE", "INSTANT"]).optional().describe(
+  "Fallback transition used ONLY when a SMART_ANIMATE motion (the default, and every M3/HIG preset) connects two frames that share no matching layer names \u2014 there is nothing to morph, so it degrades. DISSOLVE (default) keeps a soft fade; INSTANT cuts immediately. Ignored for non-SMART_ANIMATE motion."
+);
+var ProtoWireEntry = z2.object({
+  from: z2.string().min(1).describe('Source node ID (e.g. "1404:1947"), NOT a frame name \u2014 resolve names via find_nodes/get_canvas_overview first.'),
+  to: z2.string().min(1).describe('Destination frame node ID (e.g. "1404:1950"), NOT a frame name.'),
+  trigger: TriggerInput.optional(),
+  motion: MotionInputSchema.optional(),
+  resetScrollPosition: z2.boolean().optional(),
+  degradeTo: DEGRADE_TO_FIELD
+});
+var ProtoWireInput = z2.object({
+  wires: z2.array(ProtoWireEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var ProtoChangeToEntry = z2.object({
+  from: z2.string().min(1).describe("Source node ID \u2014 a component instance (or a node inside one), NOT a name. Resolve via find_nodes."),
+  to: z2.string().min(1).describe("Target variant node ID \u2014 a COMPONENT inside the same component set, NOT a name. Resolve via find_nodes."),
+  trigger: TriggerInput.optional(),
+  motion: MotionInputSchema.optional()
+});
+var ProtoChangeToInput = z2.object({
+  changes: z2.array(ProtoChangeToEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var ProtoOverlayOpenEntry = z2.object({
+  mode: z2.literal("open"),
+  from: z2.string().min(1),
+  overlay: z2.string().min(1),
+  trigger: TriggerInput.optional(),
+  motion: MotionInputSchema.optional()
+}).strict();
+var ProtoOverlaySwapEntry = z2.object({
+  mode: z2.literal("swap"),
+  from: z2.string().min(1),
+  overlay: z2.string().min(1),
+  trigger: TriggerInput.optional(),
+  motion: MotionInputSchema.optional()
+}).strict();
+var ProtoOverlayCloseEntry = z2.object({
+  mode: z2.literal("close"),
+  from: z2.string().min(1),
+  trigger: TriggerInput.optional(),
+  motion: MotionInputSchema.optional()
+}).strict();
+var ProtoOverlayEntry = z2.discriminatedUnion("mode", [
+  ProtoOverlayOpenEntry,
+  ProtoOverlaySwapEntry,
+  ProtoOverlayCloseEntry
+]);
+var ProtoOverlayInput = z2.object({
+  overlays: z2.array(ProtoOverlayEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var ProtoScrollEntry = z2.object({
+  from: z2.string().min(1),
+  to: z2.string().min(1),
+  trigger: TriggerInput.optional(),
+  motion: MotionInputSchema.optional(),
+  resetScrollPosition: z2.boolean().optional()
+});
+var ProtoScrollInput = z2.object({
+  scrolls: z2.array(ProtoScrollEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var ProtoBackEntry = z2.object({
+  from: z2.string().min(1),
+  trigger: TriggerInput.optional(),
+  motion: MotionInputSchema.optional()
+});
+var ProtoBackInput = z2.object({
+  backs: z2.array(ProtoBackEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var ProtoUrlEntry = z2.object({
+  from: z2.string().min(1),
+  url: z2.string().min(1),
+  openInNewTab: z2.boolean().optional(),
+  trigger: TriggerInput.optional()
+}).strict();
+var ProtoUrlInput = z2.object({
+  urls: z2.array(ProtoUrlEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var COLLECTION_FIELD = z2.string().min(1).optional().describe(
+  "Only needed when the same variable name exists in multiple collections. Use list_variables to find the collection name and pass it here. Omitting it on a collision returns an error."
+);
+var ProtoSetVariableEntry = z2.object({
+  from: z2.string().min(1),
+  variable: z2.string().min(1),
+  collection: COLLECTION_FIELD,
+  value: z2.union([z2.boolean(), z2.number(), z2.string()]),
+  trigger: TriggerInput.optional()
+}).strict();
+var ProtoSetVariableInput = z2.object({
+  sets: z2.array(ProtoSetVariableEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var ProtoToggleVariableEntry = z2.object({
+  from: z2.string().min(1),
+  variable: z2.string().min(1),
+  collection: COLLECTION_FIELD,
+  trigger: TriggerInput.optional()
+}).strict();
+var ProtoToggleVariableInput = z2.object({
+  toggles: z2.array(ProtoToggleVariableEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var ComparisonOperator2 = z2.enum(COMPARISON_OPERATORS);
+var ProtoConditionIf = z2.object({
+  variable: z2.string().min(1),
+  collection: COLLECTION_FIELD,
+  operator: ComparisonOperator2.default("=="),
+  value: z2.union([z2.boolean(), z2.number(), z2.string()])
+}).strict();
+var ProtoConditionExpr = z2.union([
+  ProtoConditionIf,
+  z2.object({ all: z2.array(ProtoConditionIf).min(2) }).strict(),
+  z2.object({ any: z2.array(ProtoConditionIf).min(2) }).strict()
+]);
+var BranchNavigate = z2.object({
+  navigate: z2.string().min(1),
+  resetScrollPosition: z2.boolean().optional()
+}).strict();
+var BranchScroll = z2.object({
+  scroll: z2.string().min(1),
+  resetScrollPosition: z2.boolean().optional()
+}).strict();
+var BranchOverlay = z2.object({
+  overlay: z2.string().min(1)
+}).strict();
+var BranchSwap = z2.object({
+  swap: z2.string().min(1)
+}).strict();
+var BranchClose = z2.object({
+  close: z2.literal(true)
+}).strict();
+var BranchBack = z2.object({
+  back: z2.literal(true)
+}).strict();
+var BranchUrl = z2.object({
+  url: z2.string().min(1),
+  openInNewTab: z2.boolean().optional()
+}).strict();
+var BranchSet = z2.object({
+  set: z2.object({
+    variable: z2.string().min(1),
+    collection: COLLECTION_FIELD,
+    value: z2.union([z2.boolean(), z2.number(), z2.string()])
+  }).strict()
+}).strict();
+var BranchAction = z2.union([
+  BranchNavigate,
+  BranchScroll,
+  BranchOverlay,
+  BranchSwap,
+  BranchClose,
+  BranchBack,
+  BranchUrl,
+  BranchSet
+]);
+var ProtoConditionalEntry = z2.object({
+  from: z2.string().min(1),
+  trigger: TriggerInput.optional(),
+  motion: MotionInputSchema.optional(),
+  degradeTo: DEGRADE_TO_FIELD,
+  if: ProtoConditionExpr,
+  then: BranchAction,
+  else: BranchAction.optional()
+}).strict();
+var ProtoConditionalInput = z2.object({
+  conditions: z2.array(ProtoConditionalEntry).min(1),
+  replaceExisting: z2.boolean().default(false)
+});
+var ProtoGetLastHistoryInput = z2.object({
+  count: z2.number().int().min(1).max(10).default(1)
+});
+var DEFAULT_TRIGGER = "ON_CLICK";
+function buildConnection(from, triggerArg, motionArg, action, transformTransition) {
+  const baseTransition = resolveMotion(motionArg);
+  return {
+    sourceNodeId: from,
+    trigger: triggerArg ?? DEFAULT_TRIGGER,
+    transition: transformTransition ? transformTransition(baseTransition) : baseTransition,
+    action
+  };
+}
+function rewriteForOverlay(t) {
+  if (t === "SMART_ANIMATE") return "DISSOLVE";
+  if (typeof t !== "string" && t.type === "SMART_ANIMATE") {
+    return { ...t, type: "DISSOLVE" };
+  }
+  return t;
+}
+function compileProtoWire(input) {
+  const connections = input.wires.map((w) => {
+    const action = w.resetScrollPosition === void 0 ? { type: "navigate", targetFrameId: w.to } : { type: "navigate", targetFrameId: w.to, resetScrollPosition: w.resetScrollPosition };
+    return {
+      ...buildConnection(w.from, w.trigger, w.motion, action),
+      ...w.degradeTo !== void 0 && { degradeTo: w.degradeTo }
+    };
+  });
+  return { connections, replaceExisting: input.replaceExisting };
+}
+function compileProtoChangeTo(input) {
+  const connections = input.changes.map(
+    (w) => buildConnection(w.from, w.trigger, w.motion, { type: "change_to", targetVariantId: w.to })
+  );
+  return { connections, replaceExisting: input.replaceExisting };
+}
+function compileProtoOverlay(input) {
+  const connections = input.overlays.map((o) => {
+    let action;
+    if (o.mode === "open") {
+      action = { type: "overlay", targetFrameId: o.overlay };
+    } else if (o.mode === "swap") {
+      action = { type: "swap_overlay", targetFrameId: o.overlay };
+    } else {
+      action = { type: "close" };
+    }
+    return buildConnection(o.from, o.trigger, o.motion, action, rewriteForOverlay);
+  });
+  return { connections, replaceExisting: input.replaceExisting };
+}
+function compileProtoScroll(input) {
+  const connections = input.scrolls.map((s) => {
+    const action = s.resetScrollPosition === void 0 ? { type: "scroll", targetNodeId: s.to } : { type: "scroll", targetNodeId: s.to, resetScrollPosition: s.resetScrollPosition };
+    return buildConnection(s.from, s.trigger, s.motion, action);
+  });
+  return { connections, replaceExisting: input.replaceExisting };
+}
+function compileProtoBack(input) {
+  const connections = input.backs.map((b) => {
+    const action = { type: "back" };
+    return buildConnection(b.from, b.trigger, b.motion, action);
+  });
+  return { connections, replaceExisting: input.replaceExisting };
+}
+function compileProtoUrl(input) {
+  const connections = input.urls.map((u) => {
+    const action = {
+      type: "url",
+      url: u.url,
+      openInNewTab: u.openInNewTab ?? false
+    };
+    return {
+      sourceNodeId: u.from,
+      trigger: u.trigger ?? DEFAULT_TRIGGER,
+      action
+    };
+  });
+  return { connections, replaceExisting: input.replaceExisting };
+}
+function compileProtoSetVariable(input) {
+  const connections = input.sets.map((s) => {
+    const action = {
+      type: "set_variable",
+      variable: s.variable,
+      ...s.collection !== void 0 && { collection: s.collection },
+      value: s.value
+    };
+    return {
+      sourceNodeId: s.from,
+      trigger: s.trigger ?? DEFAULT_TRIGGER,
+      action
+    };
+  });
+  return { connections, replaceExisting: input.replaceExisting };
+}
+function compileProtoToggleVariable(input) {
+  const connections = input.toggles.map((t) => {
+    const action = {
+      type: "toggle_variable",
+      variable: t.variable,
+      ...t.collection !== void 0 && { collection: t.collection }
+    };
+    return {
+      sourceNodeId: t.from,
+      trigger: t.trigger ?? DEFAULT_TRIGGER,
+      action
+    };
+  });
+  return { connections, replaceExisting: input.replaceExisting };
+}
+function compileBranchAction(b) {
+  if ("navigate" in b) {
+    return b.resetScrollPosition === void 0 ? { type: "navigate", targetFrameId: b.navigate } : { type: "navigate", targetFrameId: b.navigate, resetScrollPosition: b.resetScrollPosition };
+  }
+  if ("scroll" in b) {
+    return b.resetScrollPosition === void 0 ? { type: "scroll", targetNodeId: b.scroll } : { type: "scroll", targetNodeId: b.scroll, resetScrollPosition: b.resetScrollPosition };
+  }
+  if ("overlay" in b) return { type: "overlay", targetFrameId: b.overlay };
+  if ("swap" in b) return { type: "swap_overlay", targetFrameId: b.swap };
+  if ("close" in b) return { type: "close" };
+  if ("back" in b) return { type: "back" };
+  if ("url" in b) return { type: "url", url: b.url, openInNewTab: b.openInNewTab ?? false };
+  if ("set" in b) return {
+    type: "set_variable",
+    variable: b.set.variable,
+    ...b.set.collection !== void 0 && { collection: b.set.collection },
+    value: b.set.value
+  };
+  throw new Error("unreachable: zod parse guarantees BranchAction coverage");
+}
+function branchUsesOverlayOrSwap(b) {
+  return "overlay" in b || "swap" in b;
+}
+function compileLeaf(leaf) {
+  return {
+    variable: leaf.variable,
+    ...leaf.collection !== void 0 && { collection: leaf.collection },
+    operator: leaf.operator,
+    // zod already applied default "=="
+    value: leaf.value
+  };
+}
+function compileConditionExpr(cond) {
+  if ("all" in cond) return { all: cond.all.map(compileLeaf) };
+  if ("any" in cond) return { any: cond.any.map(compileLeaf) };
+  return compileLeaf(cond);
+}
+function compileProtoConditional(input) {
+  const connections = input.conditions.map((c) => {
+    const baseTransition = resolveMotion(c.motion);
+    const needsOverlayRewrite = branchUsesOverlayOrSwap(c.then) || c.else !== void 0 && branchUsesOverlayOrSwap(c.else);
+    const transition = needsOverlayRewrite ? rewriteForOverlay(baseTransition) : baseTransition;
+    const action = {
+      type: "conditional",
+      condition: compileConditionExpr(c.if),
+      then: [compileBranchAction(c.then)],
+      ...c.else !== void 0 && { else: [compileBranchAction(c.else)] }
+    };
+    return {
+      sourceNodeId: c.from,
+      trigger: c.trigger ?? DEFAULT_TRIGGER,
+      transition,
+      ...c.degradeTo !== void 0 && { degradeTo: c.degradeTo },
+      action
+    };
+  });
+  return { connections, replaceExisting: input.replaceExisting };
+}
+
+// src/server/history.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var HistoryStore = class {
+  buffer = [];
+  capacity;
+  constructor(capacity = 10) {
+    this.capacity = capacity;
+  }
+  record(tool, input, result) {
+    if (result.successCount === 0) return null;
+    const entry = {
+      historyId: randomUUID2(),
+      timestamp: Date.now(),
+      tool,
+      input,
+      result
+    };
+    this.buffer.push(entry);
+    if (this.buffer.length > this.capacity) this.buffer.shift();
+    return entry;
+  }
+  /**
+   * Return up to `count` most-recent entries in oldest-to-newest order
+   * (so `arr.at(-1)` is the most recent). Empty array if count < 1.
+   * Clamped to `buffer.length` when count exceeds it.
+   */
+  getLast(count = 1) {
+    if (count < 1) return [];
+    return this.buffer.slice(-Math.min(count, this.buffer.length));
+  }
+  size() {
+    return this.buffer.length;
+  }
+};
+function summarizeResult(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return { successCount: 0, errorCount: 0, warningCount: 0 };
+  }
+  const r = raw;
+  return {
+    successCount: typeof r.successCount === "number" ? r.successCount : 0,
+    errorCount: typeof r.errorCount === "number" ? r.errorCount : 0,
+    warningCount: typeof r.warningCount === "number" ? r.warningCount : 0
+  };
+}
+
+// src/server/tools.ts
+async function recordedHandler(store, tool, parsedInput, send) {
+  const result = await send();
+  store.record(tool, parsedInput, summarizeResult(result));
+  return result;
+}
+function makeTools(historyStore2) {
+  return [
+    {
+      name: "get_canvas_overview",
+      description: "Return the current Figma page, its top-level frames, and currently selected nodes. Use as the first call in any scenario to understand context.",
+      schema: GetCanvasOverviewInput,
+      command: "GET_CANVAS_OVERVIEW"
+    },
+    {
+      name: "get_prototype_flow",
+      description: "Return the whole prototype interaction graph of a page in ONE call: its frames (each with `isStartFrame`) and every wired interaction \u2014 `{ frameId, frameName, sourceNodeId, sourceNodeName, trigger, action }`. `action` is decoded exactly as `list_reactions` returns it (navigate / scroll / overlay / swap / close / back / url / change_to / set_variable / toggle_variable / conditional incl. all/any compound). Use this to see what is ALREADY wired before adding more (avoid duplicates, check what a screen connects to); for a single node use list_reactions. Page-scoped \u2014 optional `pageId` (defaults to current page); `limit` caps interactions (default 500) and sets `truncated`.",
+      schema: GetPrototypeFlowInput,
+      command: "GET_PROTOTYPE_FLOW"
+    },
+    {
+      name: "find_nodes",
+      description: "Search nodes on the current page (or document) by name substring, with optional type filter.",
+      schema: FindNodesInput,
+      command: "FIND_NODES"
+    },
+    {
+      name: "list_variables",
+      description: "List Figma variables usable by name in set/toggle/conditional tools. Returns `local` variables (in this file) and `library` variables (from connected libraries) \u2014 library variables are usable directly in set/toggle/conditional and are auto-imported on first use. Call this BEFORE proto_set_variable / proto_toggle_variable / proto_conditional instead of guessing a variable name. `remoteEnumerated:false` means library enumeration was unavailable (local list still valid).",
+      schema: ListVariablesInput,
+      command: "LIST_VARIABLES"
+    },
+    {
+      name: "create_reactions",
+      description: "Create prototype reactions in batch. Each connection's action picks between Navigate To (action.type=navigate, targetFrameId) and Scroll To (action.type=scroll, targetNodeId). Each connection succeeds or fails independently. Low-level escape hatch \u2014 proto_wire/overlay/scroll cover the common cases with named motion presets.",
+      schema: CreateReactionsInput,
+      command: "CREATE_REACTIONS"
+    },
+    {
+      name: "list_reactions",
+      description: "List existing prototype reactions on a single node.",
+      schema: ListReactionsInput,
+      command: "LIST_REACTIONS"
+    },
+    {
+      name: "clear_reactions",
+      description: "Remove reactions from one or more nodes. If `indices` is given, exactly one nodeId is allowed.",
+      schema: ClearReactionsInput,
+      command: "CLEAR_REACTIONS"
+    },
+    {
+      name: "set_frame_scroll",
+      description: "Configure a frame's scroll behavior (overflowDirection) for prototype mode. Accepts a batch of { frameId, direction }; each succeeds or fails independently. Direction values: NONE (no scrolling), HORIZONTAL, VERTICAL, BOTH.",
+      schema: SetFrameScrollInput,
+      command: "SET_FRAME_SCROLL"
+    },
+    {
+      name: "proto_wire",
+      description: "\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Wire one or more source nodes to destination frames with Navigate To. `from`/`to` are node IDs (e.g. \"1404:1947\"), NOT frame names \u2014 resolve names to IDs with find_nodes or get_canvas_overview first. Use when the WHOLE screen changes to the destination. For a modal/popup/dialog/toast/sheet that appears ON TOP of the current screen ('\uB5A0/\uD31D\uC5C5/\uBAA8\uB2EC'), use proto_overlay (open) instead. Accepts a `motion` preset name (e.g. \"M3_EMPHASIZED\") or a full TransitionInput. Defaults: trigger=ON_CLICK, motion=M3_EMPHASIZED (a SMART_ANIMATE preset). SMART_ANIMATE only morphs layers shared by name between the two frames; when they share none it auto-degrades to the connection's `degradeTo` (DISSOLVE by default). For a spatial 'slides/pushes in' feel between distinct screens, pass a directional TransitionInput (PUSH/MOVE_IN/MOVE_OUT) as `motion`. Compiles to create_reactions internally.",
+      schema: ProtoWireInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_wire",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoWire(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_change_to",
+      description: "\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Switch a component INSTANCE to a sibling VARIANT on interaction (Figma's 'Change to'). This is a ONE-SHOT switch to a SPECIFIC target variant (\u2192 selected, \u2192 highlight, \u2192 on), NOT an alternating flip \u2014 for tabs, segmented controls, and 'set this to its <state> state' changes driven by variants of one component. KO cues: '\uC120\uD0DD \uC0C1\uD0DC\uB85C', 'highlight \uC0C1\uD0DC\uB85C \uBC14\uAFD4', 'variant \uBC14\uAFD4', '~\uC0C1\uD0DC\uB85C \uBC14\uAFD4'. `from` = a component instance node ID (or a node inside one); `to` = the target variant node ID (a COMPONENT inside the same component set, and NOT the instance's current variant) \u2014 both are node IDs, NOT names; resolve names via find_nodes first. Boundaries: a whole-screen change \u2192 proto_wire; a data value \u2192 proto_set_variable; an on/off that flips BACK on every tap ('\uCF1C\uACE0 \uB044\uAE30', a repeating toggle) must be driven by a BOOLEAN variable \u2192 use proto_toggle_variable (a single change_to only goes one direction, it cannot alternate). Defaults: trigger=ON_CLICK, motion=M3_EMPHASIZED (SMART_ANIMATE morph between variants). Compiles to create_reactions internally.",
+      schema: ProtoChangeToInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_change_to",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoChangeTo(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_overlay",
+      description: `\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Create overlay reactions in batch. Each entry has mode = "open" | "swap" | "close". open/swap require an \`overlay\` frameId; close has none. 'open' = content floating above the current screen (modal/popup/dialog/toast/bottom-sheet); for a full screen change use proto_wire. 'close' = dismiss an open overlay, revealing the screen underneath it. If the user says 'go back / \uB3CC\uC544\uAC00 / \uB4A4\uB85C' while on an overlay, that is AMBIGUOUS between close (reveal the underlying screen) and proto_back (history pop) \u2014 ask the user which they mean rather than guessing. Defaults: trigger=ON_CLICK, motion=M3_EMPHASIZED. Compiles to create_reactions internally. Note: Figma's runtime rejects SMART_ANIMATE on overlay/swap/close navigation, so any SMART_ANIMATE-based motion (including all M3/HIG presets) is silently rewritten to DISSOLVE while preserving duration + easing.`,
+      schema: ProtoOverlayInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_overlay",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoOverlay(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_scroll",
+      description: "\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Wire source nodes to scroll targets \u2014 Figma's SCROLL_TO action: clicking the source jumps the prototype view to a target NODE inside the same scrollable frame (the target frame must have overflowDirection set, e.g. via set_frame_scroll). NOT for the general 'scroll feel' between pages ('\uC2A4\uD06C\uB864 \uB290\uB08C\uC73C\uB85C \uD654\uBA74\uC774 \uBD80\uB4DC\uB7FD\uAC8C \uB118\uC5B4\uAC00\uAC8C') \u2014 for that effect, use a directional transition (PUSH or SLIDE_*) via proto_wire instead. Defaults: trigger=ON_CLICK, motion=M3_EMPHASIZED. Compiles to create_reactions internally.",
+      schema: ProtoScrollInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_scroll",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoScroll(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_back",
+      description: "\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Wire source nodes to the Back navigation action (pops the prototype history stack \u2014 no destination). Use for 'go back / \uB4A4\uB85C' = return to whatever screen the user came from (dynamic, no fixed destination). To navigate to a SPECIFIC previous frame, use proto_wire instead. Choosing the source node: for an abstract request ('\uB4A4\uB85C\uAC00\uAE30 \uB2EC\uC544\uC918/add back to each screen') FIRST look for a visible back affordance in each frame \u2014 a small top-left icon, or a node whose name contains back/arrow/chevron/prev, or a '<'/'\u2039' glyph \u2014 and wire THAT with ON_CLICK. Only use a frame-level ON_DRAG swipe-back when the request names a gesture ('\uC2A4\uC640\uC774\uD504/\uBC00\uC5B4\uC11C \uB4A4\uB85C'). If the intent is abstract AND no back-affordance node exists, ASK the user ('\uBC31\uBC84\uD2BC\uC774 \uC548 \uBCF4\uC774\uB294\uB370 \uC2A4\uC640\uC774\uD504 \uC81C\uC2A4\uCC98\uB85C \uD560\uAE4C\uC694?') rather than silently wiring a swipe \u2014 do not create a node (this tool only wires). \u26A0\uFE0F If the source is on an OVERLAY (popup/modal/dialog/sheet shown on top of another screen), 'go back / \uB3CC\uC544\uAC00 / \uB4A4\uB85C' is AMBIGUOUS \u2014 it may mean dismiss the overlay to reveal the screen underneath (= proto_overlay close) or pop the navigation history (= Back, which on an overlay often lands on an unexpected earlier frame). Ask the user which they mean before wiring. Defaults: trigger=ON_CLICK, motion=M3_EMPHASIZED. Compiles to create_reactions internally.",
+      schema: ProtoBackInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_back",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoBack(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_url",
+      description: "\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Wire source nodes to the Open URL action. Input `{ urls: [{ from, url, openInNewTab? }] }`. Defaults: trigger=ON_CLICK, openInNewTab=false. No `motion` field \u2014 URL is a terminal event and the underlying reaction's transition defaults to INSTANT. Compiles to create_reactions internally.",
+      schema: ProtoUrlInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_url",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoUrl(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_set_variable",
+      description: '\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Wire source nodes to the Set Variable action \u2014 clicking the source assigns a literal value to a Figma variable (resolved by NAME \u2014 local or library/remote; library variables are auto-imported on use). Input `{ sets: [{ from, variable, value }] }`. `value` is boolean / number / string and must match the variable\'s resolvedType; for COLOR variables, pass `value` as a hex string ("#RRGGBB" or "#RRGGBBAA"). To flip a BOOLEAN without naming the target value (\'\uD1A0\uAE00/\uCF1C\uACE0 \uB044\uAE30\'), use proto_toggle_variable \u2014 this tool assigns a SPECIFIC value. Defaults: trigger=ON_CLICK. No `motion` field \u2014 variable changes are instant (transition defaults to INSTANT). Compiles to create_reactions internally.',
+      schema: ProtoSetVariableInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_set_variable",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoSetVariable(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_toggle_variable",
+      description: "\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Wire source nodes to the Toggle Variable action \u2014 clicking the source flips a BOOLEAN variable (resolved by NAME \u2014 local or library/remote, auto-imported on use). Input `{ toggles: [{ from, variable }] }`. The variable's resolvedType MUST be BOOLEAN (plugin rejects otherwise). Use to flip/switch a boolean ('\uD1A0\uAE00', '\uCF1C\uACE0 \uB044\uAE30') with no named target value; to assign a specific value (true/false/number/string/color) use proto_set_variable instead. This is the right tool for a REPEATING on/off that flips back on every tap. If the on/off is a VISUAL component built from variants and NOT backed by a boolean variable, a one-directional switch to a specific state is proto_change_to instead; toggle_variable requires a BOOLEAN variable to flip. Defaults: trigger=ON_CLICK. No `motion` field \u2014 variable changes are instant. Compiles to create_reactions internally (desugars to CONDITIONAL + 2 SET_VARIABLE under the hood; list_reactions round-trips to toggle_variable shape).",
+      schema: ProtoToggleVariableInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_toggle_variable",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoToggleVariable(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_conditional",
+      description: "\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Wire a conditional reaction (if/then/else) on a source node based on a variable comparison. Use for '~\uBA74 ~\uD558\uACE0 \uC544\uB2C8\uBA74 ~' / '\uC870\uAC74\uC5D0 \uB530\uB77C' branching interactions. The variable is referenced by NAME; the plugin resolves it at runtime \u2014 local variables match directly, library/remote variables are auto-imported on use. Use list_variables to find exact names. Input `{ conditions: [{ from, if, then, else? }] }`. `if` is a single comparison `{ variable, operator?, value }`, OR a one-level compound: `{ all: [<comparison>, \u2026] }` (AND \u2014 \uBAA8\uB450 \uCC38\uC77C \uB54C; cues: '\uADF8\uB9AC\uACE0 / \uC774\uACE0 / \uB458 \uB2E4 / \uBAA8\uB450') or `{ any: [<comparison>, \u2026] }` (OR \u2014 \uD558\uB098\uB77C\uB3C4 \uCC38\uC77C \uB54C; cues: '\uB610\uB294 / \uAC70\uB098 / \uD558\uB098\uB77C\uB3C4'). Each array needs \u22652 comparisons; `all` and `any` cannot be mixed or nested (one level only) \u2014 for multi-way branching use separate reactions (Figma has no else-if). `if.operator` defaults to \"==\" if omitted (most common case); other operators: !=, <, <=, >, >=. `then` / `else` each take exactly ONE branch action (single sugar entry). Branch sugar keys: `navigate` / `scroll` / `overlay` / `swap` / `close` / `back` / `url` / `set`. `toggle_variable` is not available inside conditional (toggle itself desugars to CONDITIONAL \u2014 nesting is meaningless). For multi-action branches, use low-level `create_reactions` (escape hatch). Overlay/swap branches: if either branch is `{ overlay }` or `{ swap }`, SMART_ANIMATE auto-rewrites to DISSOLVE (Figma's overlay transition constraint); the motion intent (duration/easing) is preserved. Variable type must match `if.value` (BOOLEAN/FLOAT/STRING); COLOR variables are NOT comparable. `trigger` / `motion` apply at the conditional level (shared across branches); branch sugars do NOT accept them.",
+      schema: ProtoConditionalInput,
+      handler: async (input, session2) => {
+        const parsedInput = input;
+        return recordedHandler(
+          historyStore2,
+          "proto_conditional",
+          parsedInput,
+          () => session2.sendCommand("CREATE_REACTIONS", compileProtoConditional(parsedInput))
+        );
+      }
+    },
+    {
+      name: "proto_get_last_history",
+      description: '\uC774 \uB3C4\uAD6C\uB294 \uC624\uC9C1 \uD53C\uADF8\uB9C8\uC758 \uD504\uB85C\uD1A0\uD0C0\uC785 \uC778\uD130\uB799\uC158/\uC560\uB2C8\uBA54\uC774\uC158 \uC0DD\uC131\xB7\uC218\uC815 \uBAA9\uC801\uC73C\uB85C\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4. Returns the most-recent successful proto_* tool calls as an array of HistoryEntry objects, newest-last. Use when the user references "the last thing I made" / "\uBC29\uAE08 \uB9CC\uB4E0 \uAC70" to recover the source/target IDs and motion preset, then re-call the corresponding proto_* with replaceExisting=true to apply a modification.',
+      schema: ProtoGetLastHistoryInput,
+      handler: async (input) => {
+        const { count } = input;
+        return { entries: historyStore2.getLast(count) };
+      }
+    }
+  ];
+}
+function registerToolHandlers(mcp, session2, historyStore2) {
+  const TOOLS = makeTools(historyStore2);
+  mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: zodToJsonSchema(t.schema)
+    }))
+  }));
+  mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const tool = TOOLS.find((t) => t.name === req.params.name);
+    if (!tool) {
+      return { isError: true, content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }] };
+    }
+    const parsed = tool.schema.safeParse(req.params.arguments ?? {});
+    if (!parsed.success) {
+      return { isError: true, content: [{ type: "text", text: `Invalid input: ${parsed.error.message}` }] };
+    }
+    try {
+      const result = tool.handler !== void 0 ? await tool.handler(parsed.data, session2) : await session2.sendCommand(tool.command, parsed.data);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { isError: true, content: [{ type: "text", text: err.message }] };
+    }
+  });
+}
+function createMcpServer(session2, historyStore2, version) {
+  const server = new Server(
+    { name: "figma-prototype-mcp", version },
+    { capabilities: { tools: {} } }
+  );
+  registerToolHandlers(server, session2, historyStore2);
+  return server;
+}
+
+// src/server/sse-session.ts
+var SseSession = class {
+  active = null;
+  /**
+   * Adopt `transport` as the active connection; close + discard any prior one.
+   * Returns `true` iff a *different* prior connection was evicted — the caller
+   * logs this so a silent takeover (a second MCP client displacing the first) is
+   * diagnosable. A well-behaved MCP client fast-fails its next call after eviction
+   * (the displaced POST gets HTTP 400 "unknown session"; verified 2026-06-12). A
+   * stdio↔SSE bridge such as supergateway may NOT propagate that failure to its
+   * stdio client, which then hangs to its own timeout — so keep ONE MCP client per
+   * server. Newest-wins is deliberate: it lets a fresh reconnect replace a dead
+   * prior stream (the zombie-SSE case) without manual cleanup.
+   */
+  activate(server, transport) {
+    const evicted = this.active !== null && this.active.transport !== transport;
+    if (evicted) {
+      try {
+        void this.active.transport.close();
+      } catch {
+      }
+    }
+    this.active = { server, transport };
+    return evicted;
+  }
+  /** The active transport iff its id matches `sessionId` (POST routing); else null. */
+  get(sessionId) {
+    return this.active && this.active.transport.sessionId === sessionId ? this.active.transport : null;
+  }
+  /** Clear iff `transport` is still the active one (called on stream close). */
+  clear(transport) {
+    if (this.active && this.active.transport === transport) {
+      this.active = null;
+    }
+  }
+  isActive() {
+    return this.active !== null;
+  }
+};
+
+// src/server/index.ts
+var pkg = JSON.parse(
+  readFileSync(new URL("../../package.json", import.meta.url), "utf8")
+);
+var PORT = Number(process.env.PORT ?? 3e3);
+var session = new PluginSession();
+var historyStore = new HistoryStore();
+var sse = new SseSession();
+var app = express();
+app.get("/sse", async (_req, res) => {
+  const server = createMcpServer(session, historyStore, pkg.version);
+  const transport = new SSEServerTransport("/messages", res);
+  res.on("close", () => sse.clear(transport));
+  await server.connect(transport);
+  const evicted = sse.activate(server, transport);
+  if (evicted) {
+    console.warn(
+      "[server] a second MCP client connected \u2014 evicted the prior SSE connection (newest-wins). The displaced client's next call fails fast with HTTP 400 and it should reconnect; keep a single MCP client per server (a supergateway bridge may hang instead of surfacing the eviction)."
+    );
+  }
+});
+app.post("/messages", express.json(), async (req, res) => {
+  const t = sse.get(String(req.query.sessionId ?? ""));
+  if (!t) {
+    res.status(400).send("unknown session");
+    return;
+  }
+  await t.handlePostMessage(req, res, req.body);
+});
+var httpServer = app.listen(PORT, () => {
+  console.log(`[server] listening on http://localhost:${PORT}`);
+  console.log(`[server]   MCP SSE endpoint: GET /sse`);
+  console.log(`[server]   Plugin WebSocket:  ws://localhost:${PORT}/ws`);
+  console.log(
+    `[server]   Figma plugin manifest: ${fileURLToPath(new URL("../figma-plugin/manifest.json", import.meta.url))}`
+  );
+});
+attachPluginWebSocket(httpServer, session);
+process.on("unhandledRejection", (err) => {
+  console.error("[server] unhandledRejection:", err);
+});
+process.on("uncaughtException", (err) => {
+  console.error("[server] uncaughtException:", err);
+});