@ufira/vibma 0.1.1 → 0.2.2

package/dist/mcp.cjs

@@ -38,19 +38,15 @@ var init_serialize_node = __esm({
   }
 });
 
-// src/tools/helpers.ts
-var init_helpers = __esm({
-  "src/tools/helpers.ts"() {
-    init_serialize_node();
-  }
-});
-
 // src/mcp.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod19 = require("zod");
 var import_ws = __toESM(require("ws"), 1);
 var import_uuid = require("uuid");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_url = require("url");
 
 // src/tools/document.ts
 var import_zod = require("zod");
@@ -204,7 +200,7 @@ function registerMcpTools2(server2, sendCommand) {
   );
   server2.tool(
     "read_my_design",
-    "Get detailed information about the current selection, including all node details. Use depth to control traversal.",
+    "Read the nodes the user has selected in Figma (or set via set_selection). Returns nothing if no selection exists \u2014 ask the user to select something, or use get_node_info with specific node IDs. Use depth to control child traversal.",
     { depth: import_zod3.z.coerce.number().optional().describe("Levels of children to recurse. 0=selection only, -1 or omit for unlimited.") },
     async ({ depth: depth2 }) => {
       try {
@@ -375,8 +371,10 @@ var effectEntry = import_zod5.z.object({
   blendMode: import_zod5.z.string().optional()
 });
 
+// src/tools/helpers.ts
+init_serialize_node();
+
 // src/tools/create-shape.ts
-init_helpers();
 var rectItem = import_zod6.z.object({
   name: import_zod6.z.string().optional().describe("Name (default: 'Rectangle')"),
   x: xPos,
@@ -498,7 +496,6 @@ function registerMcpTools4(server2, sendCommand) {
 
 // src/tools/create-frame.ts
 var import_zod7 = require("zod");
-init_helpers();
 var frameItem = import_zod7.z.object({
   name: import_zod7.z.string().optional().describe("Frame name (default: 'Frame')"),
   x: xPos,
@@ -545,7 +542,7 @@ var autoLayoutItem = import_zod7.z.object({
 function registerMcpTools5(server2, sendCommand) {
   server2.tool(
     "create_frame",
-    "Create frames in Figma. Supports batch. Prefer fillStyleName or fillVariableId over hardcoded fillColor for design token consistency.",
+    "Create frames in Figma. Batch supported. Use fillStyleName/fillVariableId and strokeStyleName/strokeVariableId instead of hardcoded colors \u2014 hardcoded values skip design tokens and will trigger lint warnings.",
     { items: flexJson(import_zod7.z.array(frameItem)).describe("Array of frames to create"), depth },
     async (params) => {
       try {
@@ -571,14 +568,15 @@ function registerMcpTools5(server2, sendCommand) {
 
 // src/tools/create-text.ts
 var import_zod8 = require("zod");
-init_helpers();
 var textItem = import_zod8.z.object({
   text: import_zod8.z.string().describe("Text content"),
   name: import_zod8.z.string().optional().describe("Layer name (default: text content)"),
   x: xPos,
   y: yPos,
+  fontFamily: import_zod8.z.string().optional().describe("Font family (default: Inter). Use get_available_fonts to list installed fonts."),
+  fontStyle: import_zod8.z.string().optional().describe("Font style, e.g. 'Regular', 'Bold', 'Italic' (default: derived from fontWeight). Overrides fontWeight when set."),
   fontSize: import_zod8.z.coerce.number().optional().describe("Font size (default: 14)"),
-  fontWeight: import_zod8.z.coerce.number().optional().describe("Font weight: 100-900 (default: 400)"),
+  fontWeight: import_zod8.z.coerce.number().optional().describe("Font weight: 100-900 (default: 400). Ignored when fontStyle is set."),
   fontColor: flexJson(colorRgba).optional().describe('Font color. Hex "#000000" or {r,g,b,a?} 0-1. Default: black.'),
   fontColorVariableId: import_zod8.z.string().optional().describe("Bind a color variable to the text fill instead of hardcoded fontColor."),
   fontColorStyleName: import_zod8.z.string().optional().describe("Apply a paint style to the text fill by name (case-insensitive). Overrides fontColor."),
@@ -594,7 +592,7 @@ var textItem = import_zod8.z.object({
 function registerMcpTools6(server2, sendCommand) {
   server2.tool(
     "create_text",
-    "Create text nodes in Figma. Uses Inter font. Max 10 items per batch. Use textStyleName for typography and fontColorStyleName for fill color.",
+    "Create text nodes. Max 10 per batch. Prefer textStyleName for typography and fontColorStyleName or fontColorVariableId for color \u2014 hardcoded values skip design tokens. Supports custom fonts via fontFamily.",
     { items: flexJson(import_zod8.z.array(textItem).max(10)).describe("Array of text nodes to create (max 10)"), depth },
     async (params) => {
       try {
@@ -608,7 +606,6 @@ function registerMcpTools6(server2, sendCommand) {
 
 // src/tools/modify-node.ts
 var import_zod9 = require("zod");
-init_helpers();
 var moveItem = import_zod9.z.object({
   nodeId,
   x: import_zod9.z.coerce.number().describe("New X"),
@@ -698,7 +695,6 @@ function registerMcpTools7(server2, sendCommand) {
 
 // src/tools/fill-stroke.ts
 var import_zod10 = require("zod");
-init_helpers();
 var fillItem = import_zod10.z.object({
   nodeId,
   color: flexJson(colorRgba).optional().describe('Fill color. Hex "#FF0000" or {r,g,b,a?} 0-1. Ignored when styleName is set.'),
@@ -722,7 +718,7 @@ var opacityItem = import_zod10.z.object({
 function registerMcpTools8(server2, sendCommand) {
   server2.tool(
     "set_fill_color",
-    "Set fill color on nodes. Use styleName to apply a paint style by name, or provide color directly. Batch: pass multiple items.",
+    "Set fill color on nodes. Prefer styleName (design token) over hardcoded color \u2014 hardcoded values trigger lint warnings. Batch: pass multiple items.",
     { items: flexJson(import_zod10.z.array(fillItem)).describe("Array of {nodeId, color?, styleName?}"), depth },
     async (params) => {
       try {
@@ -734,7 +730,7 @@ function registerMcpTools8(server2, sendCommand) {
   );
   server2.tool(
     "set_stroke_color",
-    "Set stroke color on nodes. Use styleName to apply a paint style by name. Batch: pass multiple items.",
+    "Set stroke color on nodes. Prefer styleName (design token) over hardcoded color \u2014 hardcoded values trigger lint warnings. Batch: pass multiple items.",
     { items: flexJson(import_zod10.z.array(strokeItem)).describe("Array of {nodeId, color?, strokeWeight?, styleName?}"), depth },
     async (params) => {
       try {
@@ -772,7 +768,6 @@ function registerMcpTools8(server2, sendCommand) {
 
 // src/tools/update-frame.ts
 var import_zod11 = require("zod");
-init_helpers();
 var updateFrameItem = import_zod11.z.object({
   nodeId,
   layoutMode: import_zod11.z.enum(["NONE", "HORIZONTAL", "VERTICAL"]).optional().describe("Auto-layout direction"),
@@ -805,7 +800,6 @@ function registerMcpTools9(server2, sendCommand) {
 
 // src/tools/effects.ts
 var import_zod12 = require("zod");
-init_helpers();
 var effectItem = import_zod12.z.object({
   nodeId,
   effects: flexJson(import_zod12.z.array(effectEntry)).optional().describe("Array of effect objects. Ignored when effectStyleName is set."),
@@ -886,7 +880,6 @@ function registerMcpTools10(server2, sendCommand) {
 
 // src/tools/text.ts
 var import_zod13 = require("zod");
-init_helpers();
 var textContentItem = import_zod13.z.object({
   nodeId: import_zod13.z.string().describe("Text node ID"),
   text: import_zod13.z.string().describe("New text content")
@@ -968,7 +961,6 @@ function registerMcpTools12(server2, sendCommand) {
 
 // src/tools/components.ts
 var import_zod15 = require("zod");
-init_helpers();
 var componentItem = import_zod15.z.object({
   name: import_zod15.z.string().describe("Component name"),
   x: xPos,
@@ -1023,7 +1015,7 @@ var instanceItem = import_zod15.z.object({
 function registerMcpTools13(server2, sendCommand) {
   server2.tool(
     "create_component",
-    "Create components in Figma. Same layout params as create_frame. Name with 'Property=Value' pattern (e.g. 'Size=Small') if you plan to combine_as_variants later. Batch: pass multiple items.",
+    "Create components in Figma. Same layout params as create_frame. Name with 'Property=Value' pattern (e.g. 'Size=Small') if you plan to combine_as_variants later. Use fillStyleName/fillVariableId over hardcoded colors. After adding text children, use add_component_property to expose text as editable properties. Batch: pass multiple items.",
     { items: flexJson(import_zod15.z.array(componentItem)).describe("Array of components to create"), depth },
     async (params) => {
       try {
@@ -1125,11 +1117,25 @@ function registerMcpTools13(server2, sendCommand) {
       }
     }
   );
+  server2.tool(
+    "set_instance_properties",
+    "Set component property values on instances (e.g. text, boolean, instance swap). Use get_component_by_id to discover property keys. Batch: pass multiple items.",
+    { items: flexJson(import_zod15.z.array(import_zod15.z.object({
+      nodeId,
+      properties: flexJson(import_zod15.z.record(import_zod15.z.string(), import_zod15.z.union([import_zod15.z.string(), import_zod15.z.boolean()]))).describe('Property key\u2192value map, e.g. {"Label#1:0":"Click Me"}')
+    }))).describe("Array of {nodeId, properties}"), depth },
+    async (params) => {
+      try {
+        return mcpJson(await sendCommand("set_instance_properties", params));
+      } catch (e) {
+        return mcpError("Error setting instance properties", e);
+      }
+    }
+  );
 }
 
 // src/tools/styles.ts
 var import_zod16 = require("zod");
-init_helpers();
 var paintStyleItem = import_zod16.z.object({
   name: import_zod16.z.string().describe("Style name"),
   color: flexJson(colorRgba).describe('Color. Hex "#FF0000" or {r,g,b,a?} 0-1.')
@@ -1154,6 +1160,28 @@ var effectStyleItem = import_zod16.z.object({
   name: import_zod16.z.string().describe("Style name"),
   effects: flexJson(import_zod16.z.array(effectEntry)).describe("Array of effects")
 });
+var updatePaintStyleItem = import_zod16.z.object({
+  id: import_zod16.z.string().describe("Style ID or name (case-insensitive match)"),
+  name: import_zod16.z.string().optional().describe("New name"),
+  color: flexJson(colorRgba).optional().describe('New color. Hex "#FF0000" or {r,g,b,a?} 0-1.')
+});
+var updateTextStyleItem = import_zod16.z.object({
+  id: import_zod16.z.string().describe("Style ID or name (case-insensitive match)"),
+  name: import_zod16.z.string().optional().describe("New name"),
+  fontFamily: import_zod16.z.string().optional().describe("Font family"),
+  fontStyle: import_zod16.z.string().optional().describe("Font style (e.g. Regular, Bold)"),
+  fontSize: import_zod16.z.coerce.number().optional().describe("Font size"),
+  lineHeight: flexNum(import_zod16.z.union([
+    import_zod16.z.number(),
+    import_zod16.z.object({ value: import_zod16.z.coerce.number(), unit: import_zod16.z.enum(["PIXELS", "PERCENT", "AUTO"]) })
+  ])).optional().describe("Line height \u2014 number (px) or {value, unit}. Default: auto."),
+  letterSpacing: flexNum(import_zod16.z.union([
+    import_zod16.z.number(),
+    import_zod16.z.object({ value: import_zod16.z.coerce.number(), unit: import_zod16.z.enum(["PIXELS", "PERCENT"]) })
+  ])).optional().describe("Letter spacing \u2014 number (px) or {value, unit}. Default: 0."),
+  textCase: import_zod16.z.enum(["ORIGINAL", "UPPER", "LOWER", "TITLE"]).optional(),
+  textDecoration: import_zod16.z.enum(["NONE", "UNDERLINE", "STRIKETHROUGH"]).optional()
+});
 var applyStyleItem = import_zod16.z.object({
   nodeId,
   styleId: import_zod16.z.string().optional().describe("Style ID. Provide either styleId or styleName."),
@@ -1245,11 +1273,34 @@ function registerMcpTools14(server2, sendCommand) {
       }
     }
   );
+  server2.tool(
+    "update_paint_style",
+    "Update paint style color/name by ID or name. Changes propagate to all nodes using the style. Batch: pass multiple items.",
+    { items: flexJson(import_zod16.z.array(updatePaintStyleItem)).describe("Array of {id, name?, color?}") },
+    async (params) => {
+      try {
+        return mcpJson(await sendCommand("update_paint_style", params));
+      } catch (e) {
+        return mcpError("Error updating paint style", e);
+      }
+    }
+  );
+  server2.tool(
+    "update_text_style",
+    "Update text style properties by ID or name. Changes propagate to all nodes using the style. Batch: pass multiple items.",
+    { items: flexJson(import_zod16.z.array(updateTextStyleItem)).describe("Array of {id, name?, fontSize?, fontFamily?, ...}") },
+    async (params) => {
+      try {
+        return mcpJson(await sendCommand("update_text_style", params));
+      } catch (e) {
+        return mcpError("Error updating text style", e);
+      }
+    }
+  );
 }
 
 // src/tools/variables.ts
 var import_zod17 = require("zod");
-init_helpers();
 var collectionItem = import_zod17.z.object({
   name: import_zod17.z.string().describe("Collection name")
 });
@@ -1263,10 +1314,9 @@ var setValueItem = import_zod17.z.object({
   modeId: import_zod17.z.string().describe("Mode ID"),
   value: flexJson(import_zod17.z.union([
     import_zod17.z.number(),
-    import_zod17.z.string(),
     import_zod17.z.boolean(),
-    import_zod17.z.object({ r: import_zod17.z.coerce.number(), g: import_zod17.z.coerce.number(), b: import_zod17.z.coerce.number(), a: import_zod17.z.coerce.number().optional() })
-  ])).describe("Value: number, string, boolean, or {r,g,b,a} color")
+    colorRgba
+  ])).describe('Value: number, boolean, or color (hex "#RRGGBB" or {r,g,b,a?} 0-1)')
 });
 var bindingItem = import_zod17.z.object({
   nodeId: import_zod17.z.string().describe("Node ID"),
@@ -1452,11 +1502,23 @@ function registerMcpTools15(server2, sendCommand) {
       }
     }
   );
+  server2.tool(
+    "delete_variable_collection",
+    "Delete a variable collection and all its variables. This is destructive and cannot be undone.",
+    { collectionId: import_zod17.z.string().describe("Collection ID to delete") },
+    async ({ collectionId }) => {
+      try {
+        return mcpJson(await sendCommand("delete_variable_collection", { collectionId }));
+      } catch (e) {
+        return mcpError("Error deleting variable collection", e);
+      }
+    }
+  );
 }
 
 // src/tools/lint.ts
 var import_zod18 = require("zod");
-init_helpers();
+init_color();
 var lintRules = import_zod18.z.enum([
   "no-autolayout",
   // Frames with >1 child and no auto-layout
@@ -1474,8 +1536,25 @@ var lintRules = import_zod18.z.enum([
   // Frames/components with layout but no children
   "stale-text-name",
   // Text nodes where layer name diverges from content
+  "no-text-property",
+  // Text in components not bound to a component property
+  // ── WCAG 2.2 rules ──
+  "wcag-contrast",
+  // 1.4.3 AA text contrast (4.5:1 / 3:1 large)
+  "wcag-contrast-enhanced",
+  // 1.4.6 AAA text contrast (7:1 / 4.5:1 large)
+  "wcag-non-text-contrast",
+  // 1.4.11 AA non-text contrast (3:1)
+  "wcag-target-size",
+  // 2.5.8 AA target size minimum (24x24px)
+  "wcag-text-size",
+  // Best practice: minimum readable text (12px)
+  "wcag-line-height",
+  // 1.4.12 AA text spacing (line height 1.5x)
+  "wcag",
+  // Meta: run all wcag-* rules
   "all"
-  // Run all rules
+  // Run all rules (including WCAG)
 ]);
 function registerMcpTools16(server2, sendCommand) {
   server2.tool(
@@ -1483,7 +1562,7 @@ function registerMcpTools16(server2, sendCommand) {
     "Run design linter on a node tree. Returns issues grouped by category with affected node IDs and fix instructions. Lint child nodes individually for large trees.",
     {
       nodeId: import_zod18.z.string().optional().describe("Node ID to lint. Omit to lint current selection."),
-      rules: flexJson(import_zod18.z.array(lintRules)).optional().describe('Rules to run. Default: ["all"]. Options: no-autolayout, shape-instead-of-frame, hardcoded-color, no-text-style, fixed-in-autolayout, default-name, empty-container, stale-text-name, all'),
+      rules: flexJson(import_zod18.z.array(lintRules)).optional().describe('Rules to run. Default: ["all"]. Options: no-autolayout, shape-instead-of-frame, hardcoded-color, no-text-style, fixed-in-autolayout, default-name, empty-container, stale-text-name, no-text-property, all, wcag-contrast, wcag-contrast-enhanced, wcag-non-text-contrast, wcag-target-size, wcag-text-size, wcag-line-height, wcag'),
       maxDepth: import_zod18.z.coerce.number().optional().describe("Max depth to recurse (default: 10)"),
       maxFindings: import_zod18.z.coerce.number().optional().describe("Stop after N findings (default: 50)")
     },
@@ -1807,6 +1886,23 @@ function registerAllTools(server2, sendCommand) {
 }
 
 // src/mcp.ts
+var import_meta = {};
+var VIBMA_VERSION = "0.0.0";
+try {
+  const start = typeof import_meta?.url !== "undefined" ? (0, import_path.join)((0, import_url.fileURLToPath)(import_meta.url), "..") : typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  for (let dir = start; dir !== "/"; dir = (0, import_path.join)(dir, "..")) {
+    try {
+      const pkg = JSON.parse((0, import_fs.readFileSync)((0, import_path.join)(dir, "package.json"), "utf8"));
+      if (pkg.name === "@ufira/vibma") {
+        VIBMA_VERSION = pkg.version;
+        break;
+      }
+    } catch {
+      continue;
+    }
+  }
+} catch {
+}
 var logger = {
   info: (msg) => process.stderr.write(`[INFO] ${msg}
 `),
@@ -1823,6 +1919,8 @@ var ws = null;
 var pendingRequests = /* @__PURE__ */ new Map();
 var currentChannel = null;
 var activePort = parseInt(process.env.VIBMA_PORT || "3055");
+var rejected = false;
+var versionWarning = null;
 var args = process.argv.slice(2);
 var serverArg = args.find((a) => a.startsWith("--server="));
 var portArg = args.find((a) => a.startsWith("--port="));
@@ -1845,6 +1943,34 @@ function connectToFigma(port = activePort) {
   ws.on("message", (data) => {
     try {
       const json = JSON.parse(data);
+      if (json.type === "join-success") {
+        logger.info(json.message);
+        if (json.id && pendingRequests.has(json.id)) {
+          const req = pendingRequests.get(json.id);
+          clearTimeout(req.timeout);
+          req.resolve({ status: "already_joined", channel: json.channel });
+          pendingRequests.delete(json.id);
+        }
+        return;
+      }
+      if (json.type === "system" && json.code) {
+        if (json.code === "VERSION_MISMATCH") {
+          versionWarning = json.message;
+          logger.warn(`Version mismatch: ${json.message}`);
+        }
+        return;
+      }
+      if (json.type === "error") {
+        logger.error(`Relay error: ${json.message}`);
+        if (json.code === "ROLE_OCCUPIED") rejected = true;
+        if (json.id && pendingRequests.has(json.id)) {
+          const req = pendingRequests.get(json.id);
+          clearTimeout(req.timeout);
+          req.reject(new Error(json.message));
+          pendingRequests.delete(json.id);
+        }
+        return;
+      }
       if (json.type === "progress_update") {
         const progressData = json.message.data;
         const requestId = json.id || "";
@@ -1896,13 +2022,23 @@ function connectToFigma(port = activePort) {
       request.reject(new Error("Connection closed"));
       pendingRequests.delete(id);
     }
-    logger.info("Attempting to reconnect in 2 seconds...");
-    setTimeout(() => connectToFigma(port), 2e3);
+    if (rejected) {
+      logger.info("Not reconnecting \u2014 channel role was rejected. Call join_channel to retry.");
+    } else {
+      logger.info("Attempting to reconnect in 2 seconds...");
+      setTimeout(() => connectToFigma(port), 2e3);
+    }
   });
 }
 async function joinChannel(channelName) {
+  rejected = false;
+  versionWarning = null;
   if (!ws || ws.readyState !== import_ws.default.OPEN) {
-    throw new Error("Not connected to Figma");
+    connectToFigma();
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    if (!ws || ws.readyState !== import_ws.default.OPEN) {
+      throw new Error("Not connected to relay. Check that the relay server is running.");
+    }
   }
   try {
     await sendCommandToFigma("join", { channel: channelName });
@@ -1929,7 +2065,7 @@ function sendCommandToFigma(command, params = {}, timeoutMs = 3e4) {
     const request = {
       id,
       type: command === "join" ? "join" : "message",
-      ...command === "join" ? { channel: params.channel } : { channel: currentChannel },
+      ...command === "join" ? { channel: params.channel, role: "mcp", version: VIBMA_VERSION, name: (0, import_path.basename)(process.cwd()) } : { channel: currentChannel },
       message: {
         id,
         command,
@@ -1965,8 +2101,14 @@ server.tool(
   async ({ channel }) => {
     try {
       await joinChannel(channel);
+      await new Promise((r) => setTimeout(r, 200));
+      let msg = `Joined channel "${channel}" on port ${activePort}. Call \`ping\` now to verify the Figma plugin is connected.`;
+      if (versionWarning) msg += `
+
+\u26A0\uFE0F ${versionWarning}
+See "Version mismatch" in CARRYME.md or DRAGME.md for update steps.`;
       return {
-        content: [{ type: "text", text: `Joined channel "${channel}" on port ${activePort}. Call \`ping\` now to verify the Figma plugin is connected.` }]
+        content: [{ type: "text", text: msg }]
       };
     } catch (error) {
       return {
@@ -1978,7 +2120,92 @@ server.tool(
     }
   }
 );
+server.tool(
+  "channel_info",
+  "Debug: inspect which clients (MCP, plugin) are connected to each relay channel. Useful for diagnosing connection issues. Does not require an active channel.",
+  {},
+  async () => {
+    try {
+      const url = serverUrl === "localhost" ? `http://localhost:${activePort}/channels` : `https://${serverUrl}/channels`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        return { content: [{ type: "text", text: `Relay returned ${response.status}: ${await response.text()}` }] };
+      }
+      const data = await response.json();
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Could not reach relay at port ${activePort}: ${error instanceof Error ? error.message : String(error)}`
+        }]
+      };
+    }
+  }
+);
+server.tool(
+  "reset_tunnel",
+  "DESTRUCTIVE: Factory-reset a channel on the relay via HTTP, disconnecting ALL occupants (MCP + Figma plugin). Only use this when the channel is stuck or occupied by another MCP \u2014 do NOT use it just to reconnect yourself (use `join_channel` instead). After reset, ask the user to reopen the Vibma plugin in Figma, then call `join_channel` and `ping`.",
+  {
+    channel: import_zod19.z.string().describe("Channel to reset. Defaults to 'vibma'.").default("vibma")
+  },
+  async ({ channel }) => {
+    const targetChannel = channel || currentChannel || "vibma";
+    try {
+      const url = serverUrl === "localhost" ? `http://localhost:${activePort}/channels/${encodeURIComponent(targetChannel)}` : `https://${serverUrl}/channels/${encodeURIComponent(targetChannel)}`;
+      const res = await fetch(url, { method: "DELETE" });
+      const body = await res.json();
+      for (const [reqId, request] of pendingRequests.entries()) {
+        clearTimeout(request.timeout);
+        request.reject(new Error("Tunnel reset by user"));
+        pendingRequests.delete(reqId);
+      }
+      if (ws) {
+        const old = ws;
+        ws = null;
+        old.removeAllListeners();
+        old.close(1e3, "Tunnel reset");
+      }
+      currentChannel = null;
+      rejected = false;
+      connectToFigma();
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      const connected = ws && ws.readyState === import_ws.default.OPEN;
+      return {
+        content: [{
+          type: "text",
+          text: connected ? `Tunnel reset: ${body.message}. Reconnected on port ${activePort}.
+
+IMPORTANT: The Figma plugin was also disconnected. Ask the user to reopen the Vibma plugin in Figma (or click "Reset tunnel" in the plugin panel). Then call \`join_channel\` followed by \`ping\`.` : `Tunnel reset: ${body.message}. Reconnection in progress.
+
+IMPORTANT: The Figma plugin was also disconnected. Ask the user to reopen the Vibma plugin in Figma (or click "Reset tunnel" in the plugin panel). Then call \`join_channel\` to retry.`
+        }]
+      };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error resetting tunnel: ${error instanceof Error ? error.message : String(error)}`
+        }]
+      };
+    }
+  }
+);
 registerAllTools(server, sendCommandToFigma);
+function cleanup() {
+  if (ws && ws.readyState === import_ws.default.OPEN) {
+    ws.close(1e3, "MCP server shutting down");
+  }
+}
+process.on("SIGINT", () => {
+  cleanup();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  cleanup();
+  process.exit(0);
+});
+process.on("exit", cleanup);
 async function main() {
   try {
     connectToFigma();