@seed-design/mcp 0.0.15 → 0.0.17

package/bin/{main.mjs → index.mjs}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { cac } from 'cac';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import require$$0 from 'stream';
@@ -11363,7 +11364,7 @@ function requireWebsocket () {
 }
 
 var websocketExports = requireWebsocket();
-var WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
+var WebSocket$1 = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
 
 var subprotocol;
 var hasRequiredSubprotocol;
@@ -11858,13 +11859,13 @@ function createFigmaWebSocketClient(serverUrl) {
     // Update the connectToFigma function
     function connectToFigma(port = 3055) {
         // If already connected, do nothing
-        if (ws && ws.readyState === WebSocket.OPEN) {
+        if (ws && ws.readyState === WebSocket$1.OPEN) {
             logger.info("Already connected to Figma");
             return;
         }
         const wsUrl = serverUrl === "localhost" ? `${WS_URL}:${port}` : WS_URL;
         logger.info(`Connecting to Figma socket server at ${wsUrl}...`);
-        ws = new WebSocket(wsUrl);
+        ws = new WebSocket$1(wsUrl);
         ws.on("open", ()=>{
             logger.info("Connected to Figma socket server");
             // Reset channel on new connection
@@ -11948,7 +11949,7 @@ function createFigmaWebSocketClient(serverUrl) {
     }
     // Function to join a channel
     async function joinChannel(channelName) {
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
+        if (!ws || ws.readyState !== WebSocket$1.OPEN) {
             throw new Error("Not connected to Figma");
         }
         try {
@@ -11966,7 +11967,7 @@ function createFigmaWebSocketClient(serverUrl) {
     function sendCommandToFigma(command, params = {}, timeoutMs = 30000) {
         return new Promise((resolve, reject)=>{
             // If not connected, try to connect first
-            if (!ws || ws.readyState !== WebSocket.OPEN) {
+            if (!ws || ws.readyState !== WebSocket$1.OPEN) {
                 connectToFigma();
                 reject(new Error("Not connected to Figma. Attempting to connect..."));
                 return;
@@ -16680,24 +16681,6 @@ function registerTools(server, figmaClient) {
             return formatErrorResponse("get_node_react_code", error);
         }
     });
-    // Clone Node Tool
-    server.tool("clone_node", "Clone an existing node in Figma", {
-        nodeId: z.string().describe("The ID of the node to clone"),
-        x: z.number().optional().describe("New X position for the clone"),
-        y: z.number().optional().describe("New Y position for the clone")
-    }, async ({ nodeId, x, y })=>{
-        try {
-            const result = await sendCommandToFigma("clone_node", {
-                nodeId,
-                x,
-                y
-            });
-            const typedResult = result;
-            return formatTextResponse(`Cloned node "${typedResult.name}" with new ID: ${typedResult.id}${x !== undefined && y !== undefined ? ` at position (${x}, ${y})` : ""}`);
-        } catch (error) {
-            return formatErrorResponse("clone_node", error);
-        }
-    });
     // Export Node as Image Tool
     server.tool("export_node_as_image", "Export a node as an image from Figma", {
         nodeId: z.string().describe("The ID of the node to export"),
@@ -16737,6 +16720,27 @@ function registerTools(server, figmaClient) {
             return formatErrorResponse("retrieve_color_variable_names", error);
         }
     });
+}
+function registerEditingTools(server, figmaClient) {
+    const { sendCommandToFigma } = figmaClient;
+    // Clone Node Tool
+    server.tool("clone_node", "Clone an existing node in Figma", {
+        nodeId: z.string().describe("The ID of the node to clone"),
+        x: z.number().optional().describe("New X position for the clone"),
+        y: z.number().optional().describe("New Y position for the clone")
+    }, async ({ nodeId, x, y })=>{
+        try {
+            const result = await sendCommandToFigma("clone_node", {
+                nodeId,
+                x,
+                y
+            });
+            const typedResult = result;
+            return formatTextResponse(`Cloned node "${typedResult.name}" with new ID: ${typedResult.id}${x !== undefined && y !== undefined ? ` at position (${x}, ${y})` : ""}`);
+        } catch (error) {
+            return formatErrorResponse("clone_node", error);
+        }
+    });
     server.tool("set_fill_color", "Set the fill color of a node", {
         nodeId: z.string().describe("The ID of the node to set the fill color of"),
         colorToken: z.string().describe("The color token to set the fill color to. Format: `{category}/{name}`. Example: `bg/brand`")
@@ -16844,6 +16848,29 @@ function registerTools(server, figmaClient) {
 }
 
 function registerPrompts(server) {
+    server.prompt("react_implementation_strategy", "Best practices for implementing React components", (_extra)=>{
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: `When implementing React components, follow these best practices:
+  
+  1. Start with selection:
+     - First use get_selection() to understand the current selection
+     - If no selection ask user to select single node
+  
+  2. Get React code of the selected nodes:
+     - Use get_node_react_code() to get the React code of the selected node
+     - If no selection ask user to select single node
+  `
+                    }
+                }
+            ],
+            description: "Best practices for reading Figma designs"
+        };
+    });
     server.prompt("read_design_strategy", "Best practices for reading Figma designs", (_extra)=>{
         return {
             messages: [
@@ -16869,36 +16896,196 @@ function registerPrompts(server) {
     });
 }
 
-// Add command line argument parsing
-const args = process.argv.slice(2);
-const serverArg = args.find((arg)=>arg.startsWith("--server="));
-const serverUrl = serverArg ? serverArg.split("=")[1] : "localhost";
-// Create Figma WebSocket client
-const figmaClient = createFigmaWebSocketClient(serverUrl);
-// Create MCP server
-const server = new McpServer({
-    name: "SEED Design MCP",
-    version: "1.0.0"
-});
-// Register tools and prompts
-registerTools(server, figmaClient);
-registerPrompts(server);
-// Start the server
-async function main() {
+var version = "0.0.17";
+
+// Initialize CLI
+const cli = cac("@seed-design/mcp");
+// Store WebSocket clients by channel
+const channels = new Map();
+function handleWebSocketConnection(ws) {
+    console.log("New client connected");
+    ws.send(JSON.stringify({
+        type: "system",
+        message: "Please join a channel to start chatting"
+    }));
+    ws.close = ()=>{
+        console.log("Client disconnected");
+        channels.forEach((clients, channelName)=>{
+            if (clients.has(ws)) {
+                clients.delete(ws);
+                clients.forEach((client)=>{
+                    if (client.readyState === WebSocket.OPEN) {
+                        client.send(JSON.stringify({
+                            type: "system",
+                            message: "A user has left the channel",
+                            channel: channelName
+                        }));
+                    }
+                });
+            }
+        });
+    };
+}
+async function startWebSocketServer(port) {
+    const server = Bun.serve({
+        port,
+        // uncomment this to allow connections in windows wsl
+        // hostname: "0.0.0.0",
+        fetch (req, server) {
+            // Handle CORS preflight
+            if (req.method === "OPTIONS") {
+                return new Response(null, {
+                    headers: {
+                        "Access-Control-Allow-Origin": "*",
+                        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+                        "Access-Control-Allow-Headers": "Content-Type, Authorization"
+                    }
+                });
+            }
+            // Handle WebSocket upgrade
+            const success = server.upgrade(req, {
+                headers: {
+                    "Access-Control-Allow-Origin": "*"
+                }
+            });
+            if (success) return;
+            // Return response for non-WebSocket requests
+            return new Response("WebSocket server running", {
+                headers: {
+                    "Access-Control-Allow-Origin": "*"
+                }
+            });
+        },
+        websocket: {
+            open: handleWebSocketConnection,
+            message (ws, message) {
+                try {
+                    console.log("Received message from client:", message);
+                    const data = JSON.parse(message);
+                    if (data.type === "join") {
+                        const channelName = data.channel;
+                        if (!channelName || typeof channelName !== "string") {
+                            ws.send(JSON.stringify({
+                                type: "error",
+                                message: "Channel name is required"
+                            }));
+                            return;
+                        }
+                        // Create channel if it doesn't exist
+                        if (!channels.has(channelName)) {
+                            channels.set(channelName, new Set());
+                        }
+                        // Add client to channel
+                        const channelClients = channels.get(channelName);
+                        channelClients.add(ws);
+                        // Notify client they joined successfully
+                        ws.send(JSON.stringify({
+                            type: "system",
+                            message: `Joined channel: ${channelName}`,
+                            channel: channelName
+                        }));
+                        console.log("Sending message to client:", data.id);
+                        ws.send(JSON.stringify({
+                            type: "system",
+                            message: {
+                                id: data.id,
+                                result: "Connected to channel: " + channelName
+                            },
+                            channel: channelName
+                        }));
+                        // Notify other clients in channel
+                        channelClients.forEach((client)=>{
+                            if (client !== ws && client.readyState === WebSocket.OPEN) {
+                                client.send(JSON.stringify({
+                                    type: "system",
+                                    message: "A new user has joined the channel",
+                                    channel: channelName
+                                }));
+                            }
+                        });
+                        return;
+                    }
+                    // Handle regular messages
+                    if (data.type === "message") {
+                        const channelName = data.channel;
+                        if (!channelName || typeof channelName !== "string") {
+                            ws.send(JSON.stringify({
+                                type: "error",
+                                message: "Channel name is required"
+                            }));
+                            return;
+                        }
+                        const channelClients = channels.get(channelName);
+                        if (!channelClients || !channelClients.has(ws)) {
+                            ws.send(JSON.stringify({
+                                type: "error",
+                                message: "You must join the channel first"
+                            }));
+                            return;
+                        }
+                        // Broadcast to all clients in the channel
+                        channelClients.forEach((client)=>{
+                            if (client.readyState === WebSocket.OPEN) {
+                                console.log("Broadcasting message to client:", data.message);
+                                client.send(JSON.stringify({
+                                    type: "broadcast",
+                                    message: data.message,
+                                    sender: client === ws ? "You" : "User",
+                                    channel: channelName
+                                }));
+                            }
+                        });
+                    }
+                } catch (err) {
+                    console.error("Error handling message:", err);
+                }
+            },
+            close (ws) {
+                // Remove client from their channel
+                channels.forEach((clients)=>{
+                    clients.delete(ws);
+                });
+            }
+        }
+    });
+    console.log(`WebSocket server running on port ${server.port}`);
+    return server;
+}
+async function startMcpServer(serverUrl, experimental) {
+    const figmaClient = createFigmaWebSocketClient(serverUrl);
+    const server = new McpServer({
+        name: "SEED Design MCP",
+        version
+    });
+    registerTools(server, figmaClient);
+    if (experimental) {
+        registerEditingTools(server, figmaClient);
+    }
+    registerPrompts(server);
     try {
-        // Try to connect to Figma socket server
         figmaClient.connectToFigma();
     } catch (error) {
         logger.warn(`Could not connect to Figma initially: ${error instanceof Error ? error.message : String(error)}`);
         logger.warn("Will try to connect when the first command is sent");
     }
-    // Start the MCP server with stdio transport
     const transport = new StdioServerTransport();
     await server.connect(transport);
     logger.info("FigmaMCP server running on stdio");
 }
-// Run the server
-main().catch((error)=>{
-    logger.error(`Error starting FigmaMCP server: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
+// Define CLI commands
+cli.command("", "Start the MCP server").option("--server <server>", "Server URL", {
+    default: "localhost"
+}).option("--experimental", "Enable experimental features", {
+    default: false
+}).action(async (options)=>{
+    await startMcpServer(options.server, options.experimental);
+});
+cli.command("socket", "Start the WebSocket server").option("--port <port>", "Port number", {
+    default: 3055
+}).action(async (options)=>{
+    await startWebSocketServer(options.port);
 });
+cli.help();
+cli.version(version);
+// Parse CLI args
+cli.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seed-design/mcp",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/daangn/seed-design.git",
@@ -12,21 +12,19 @@
   "sideEffects": false,
   "files": [
     "bin",
-    "src"
+    "src",
+    "package.json"
   ],
-  "bin": {
-    "main": "./bin/main.mjs",
-    "socket": "./bin/socket.mjs"
-  },
+  "bin": "./bin/index.mjs",
   "scripts": {
     "clean": "rm -rf lib",
-    "dev": "bun run --watch ./src/bin/socket.ts",
     "build": "bunchee",
     "lint:publish": "bun publint"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.7.0",
-    "@seed-design/figma": "0.0.15",
+    "@seed-design/figma": "0.0.17",
+    "cac": "^6.7.14",
     "express": "^4.21.2",
     "yargs": "^17.7.2"
   },

package/src/bin/index.ts

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+import { cac } from "cac";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { logger } from "../logger";
+import { createFigmaWebSocketClient } from "../websocket";
+import { registerEditingTools, registerTools } from "../tools";
+import { registerPrompts } from "../prompts";
+import { version } from "../../package.json" assert { type: "json" };
+import type { Server, ServerWebSocket } from "bun";
+
+// Initialize CLI
+const cli = cac("@seed-design/mcp");
+
+// Store WebSocket clients by channel
+const channels = new Map<string, Set<ServerWebSocket<any>>>();
+
+function handleWebSocketConnection(ws: ServerWebSocket<any>) {
+  console.log("New client connected");
+
+  ws.send(
+    JSON.stringify({
+      type: "system",
+      message: "Please join a channel to start chatting",
+    }),
+  );
+
+  ws.close = () => {
+    console.log("Client disconnected");
+    channels.forEach((clients, channelName) => {
+      if (clients.has(ws)) {
+        clients.delete(ws);
+        clients.forEach((client) => {
+          if (client.readyState === WebSocket.OPEN) {
+            client.send(
+              JSON.stringify({
+                type: "system",
+                message: "A user has left the channel",
+                channel: channelName,
+              }),
+            );
+          }
+        });
+      }
+    });
+  };
+}
+
+async function startWebSocketServer(port: number) {
+  const server = Bun.serve({
+    port,
+    // uncomment this to allow connections in windows wsl
+    // hostname: "0.0.0.0",
+    fetch(req: Request, server: Server) {
+      // Handle CORS preflight
+      if (req.method === "OPTIONS") {
+        return new Response(null, {
+          headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+          },
+        });
+      }
+
+      // Handle WebSocket upgrade
+      const success = server.upgrade(req, {
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+        },
+      });
+
+      if (success) return;
+
+      // Return response for non-WebSocket requests
+      return new Response("WebSocket server running", {
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+        },
+      });
+    },
+    websocket: {
+      open: handleWebSocketConnection,
+      message(ws: ServerWebSocket<any>, message: string | Buffer) {
+        try {
+          console.log("Received message from client:", message);
+          const data = JSON.parse(message as string);
+
+          if (data.type === "join") {
+            const channelName = data.channel;
+            if (!channelName || typeof channelName !== "string") {
+              ws.send(JSON.stringify({ type: "error", message: "Channel name is required" }));
+              return;
+            }
+
+            // Create channel if it doesn't exist
+            if (!channels.has(channelName)) {
+              channels.set(channelName, new Set());
+            }
+
+            // Add client to channel
+            const channelClients = channels.get(channelName)!;
+            channelClients.add(ws);
+
+            // Notify client they joined successfully
+            ws.send(
+              JSON.stringify({
+                type: "system",
+                message: `Joined channel: ${channelName}`,
+                channel: channelName,
+              }),
+            );
+
+            console.log("Sending message to client:", data.id);
+
+            ws.send(
+              JSON.stringify({
+                type: "system",
+                message: {
+                  id: data.id,
+                  result: "Connected to channel: " + channelName,
+                },
+                channel: channelName,
+              }),
+            );
+
+            // Notify other clients in channel
+            channelClients.forEach((client) => {
+              if (client !== ws && client.readyState === WebSocket.OPEN) {
+                client.send(
+                  JSON.stringify({
+                    type: "system",
+                    message: "A new user has joined the channel",
+                    channel: channelName,
+                  }),
+                );
+              }
+            });
+            return;
+          }
+
+          // Handle regular messages
+          if (data.type === "message") {
+            const channelName = data.channel;
+            if (!channelName || typeof channelName !== "string") {
+              ws.send(JSON.stringify({ type: "error", message: "Channel name is required" }));
+              return;
+            }
+
+            const channelClients = channels.get(channelName);
+            if (!channelClients || !channelClients.has(ws)) {
+              ws.send(
+                JSON.stringify({ type: "error", message: "You must join the channel first" }),
+              );
+              return;
+            }
+
+            // Broadcast to all clients in the channel
+            channelClients.forEach((client) => {
+              if (client.readyState === WebSocket.OPEN) {
+                console.log("Broadcasting message to client:", data.message);
+                client.send(
+                  JSON.stringify({
+                    type: "broadcast",
+                    message: data.message,
+                    sender: client === ws ? "You" : "User",
+                    channel: channelName,
+                  }),
+                );
+              }
+            });
+          }
+        } catch (err) {
+          console.error("Error handling message:", err);
+        }
+      },
+      close(ws: ServerWebSocket<any>) {
+        // Remove client from their channel
+        channels.forEach((clients) => {
+          clients.delete(ws);
+        });
+      },
+    },
+  });
+
+  console.log(`WebSocket server running on port ${server.port}`);
+  return server;
+}
+
+async function startMcpServer(serverUrl: string, experimental: boolean) {
+  const figmaClient = createFigmaWebSocketClient(serverUrl);
+  const server = new McpServer({
+    name: "SEED Design MCP",
+    version,
+  });
+
+  registerTools(server, figmaClient);
+  if (experimental) {
+    registerEditingTools(server, figmaClient);
+  }
+  registerPrompts(server);
+
+  try {
+    figmaClient.connectToFigma();
+  } catch (error) {
+    logger.warn(
+      `Could not connect to Figma initially: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    logger.warn("Will try to connect when the first command is sent");
+  }
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("FigmaMCP server running on stdio");
+}
+
+// Define CLI commands
+cli
+  .command("", "Start the MCP server")
+  .option("--server <server>", "Server URL", { default: "localhost" })
+  .option("--experimental", "Enable experimental features", { default: false })
+  .action(async (options) => {
+    await startMcpServer(options.server, options.experimental);
+  });
+
+cli
+  .command("socket", "Start the WebSocket server")
+  .option("--port <port>", "Port number", { default: 3055 })
+  .action(async (options) => {
+    await startWebSocketServer(options.port);
+  });
+
+cli.help();
+cli.version(version);
+
+// Parse CLI args
+cli.parse();

package/src/prompts.ts

@@ -1,6 +1,34 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 export function registerPrompts(server: McpServer): void {
+  server.prompt(
+    "react_implementation_strategy",
+    "Best practices for implementing React components",
+    (_extra) => {
+      return {
+        messages: [
+          {
+            role: "assistant",
+            content: {
+              type: "text",
+              text: `When implementing React components, follow these best practices:
+  
+  1. Start with selection:
+     - First use get_selection() to understand the current selection
+     - If no selection ask user to select single node
+  
+  2. Get React code of the selected nodes:
+     - Use get_node_react_code() to get the React code of the selected node
+     - If no selection ask user to select single node
+  `,
+            },
+          },
+        ],
+        description: "Best practices for reading Figma designs",
+      };
+    },
+  );
+
   server.prompt("read_design_strategy", "Best practices for reading Figma designs", (_extra) => {
     return {
       messages: [

package/src/tools.ts

@@ -230,28 +230,6 @@ export function registerTools(server: McpServer, figmaClient: FigmaWebSocketClie
     },
   );
 
-  // Clone Node Tool
-  server.tool(
-    "clone_node",
-    "Clone an existing node in Figma",
-    {
-      nodeId: z.string().describe("The ID of the node to clone"),
-      x: z.number().optional().describe("New X position for the clone"),
-      y: z.number().optional().describe("New Y position for the clone"),
-    },
-    async ({ nodeId, x, y }) => {
-      try {
-        const result = await sendCommandToFigma("clone_node", { nodeId, x, y });
-        const typedResult = result as { name: string; id: string };
-        return formatTextResponse(
-          `Cloned node "${typedResult.name}" with new ID: ${typedResult.id}${x !== undefined && y !== undefined ? ` at position (${x}, ${y})` : ""}`,
-        );
-      } catch (error) {
-        return formatErrorResponse("clone_node", error);
-      }
-    },
-  );
-
   // Export Node as Image Tool
   server.tool(
     "export_node_as_image",
@@ -295,6 +273,32 @@ export function registerTools(server: McpServer, figmaClient: FigmaWebSocketClie
       }
     },
   );
+}
+
+export function registerEditingTools(server: McpServer, figmaClient: FigmaWebSocketClient): void {
+  const { sendCommandToFigma } = figmaClient;
+
+  // Clone Node Tool
+  server.tool(
+    "clone_node",
+    "Clone an existing node in Figma",
+    {
+      nodeId: z.string().describe("The ID of the node to clone"),
+      x: z.number().optional().describe("New X position for the clone"),
+      y: z.number().optional().describe("New Y position for the clone"),
+    },
+    async ({ nodeId, x, y }) => {
+      try {
+        const result = await sendCommandToFigma("clone_node", { nodeId, x, y });
+        const typedResult = result as { name: string; id: string };
+        return formatTextResponse(
+          `Cloned node "${typedResult.name}" with new ID: ${typedResult.id}${x !== undefined && y !== undefined ? ` at position (${x}, ${y})` : ""}`,
+        );
+      } catch (error) {
+        return formatErrorResponse("clone_node", error);
+      }
+    },
+  );
 
   server.tool(
     "set_fill_color",

package/bin/socket.mjs

@@ -1,155 +0,0 @@
-#!/usr/bin/env node
-// Store clients by channel
-const channels = new Map();
-function handleConnection(ws) {
-    // Don't add to clients immediately - wait for channel join
-    console.log("New client connected");
-    // Send welcome message to the new client
-    ws.send(JSON.stringify({
-        type: "system",
-        message: "Please join a channel to start chatting"
-    }));
-    ws.close = ()=>{
-        console.log("Client disconnected");
-        // Remove client from their channel
-        channels.forEach((clients, channelName)=>{
-            if (clients.has(ws)) {
-                clients.delete(ws);
-                // Notify other clients in same channel
-                clients.forEach((client)=>{
-                    if (client.readyState === WebSocket.OPEN) {
-                        client.send(JSON.stringify({
-                            type: "system",
-                            message: "A user has left the channel",
-                            channel: channelName
-                        }));
-                    }
-                });
-            }
-        });
-    };
-}
-const server = Bun.serve({
-    port: 3055,
-    // uncomment this to allow connections in windows wsl
-    // hostname: "0.0.0.0",
-    fetch (req, server) {
-        // Handle CORS preflight
-        if (req.method === "OPTIONS") {
-            return new Response(null, {
-                headers: {
-                    "Access-Control-Allow-Origin": "*",
-                    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-                    "Access-Control-Allow-Headers": "Content-Type, Authorization"
-                }
-            });
-        }
-        // Handle WebSocket upgrade
-        const success = server.upgrade(req, {
-            headers: {
-                "Access-Control-Allow-Origin": "*"
-            }
-        });
-        if (success) {
-            return; // Upgraded to WebSocket
-        }
-        // Return response for non-WebSocket requests
-        return new Response("WebSocket server running", {
-            headers: {
-                "Access-Control-Allow-Origin": "*"
-            }
-        });
-    },
-    websocket: {
-        open: handleConnection,
-        message (ws, message) {
-            try {
-                console.log("Received message from client:", message);
-                const data = JSON.parse(message);
-                if (data.type === "join") {
-                    const channelName = data.channel;
-                    if (!channelName || typeof channelName !== "string") {
-                        ws.send(JSON.stringify({
-                            type: "error",
-                            message: "Channel name is required"
-                        }));
-                        return;
-                    }
-                    // Create channel if it doesn't exist
-                    if (!channels.has(channelName)) {
-                        channels.set(channelName, new Set());
-                    }
-                    // Add client to channel
-                    const channelClients = channels.get(channelName);
-                    channelClients.add(ws);
-                    // Notify client they joined successfully
-                    ws.send(JSON.stringify({
-                        type: "system",
-                        message: `Joined channel: ${channelName}`,
-                        channel: channelName
-                    }));
-                    console.log("Sending message to client:", data.id);
-                    ws.send(JSON.stringify({
-                        type: "system",
-                        message: {
-                            id: data.id,
-                            result: "Connected to channel: " + channelName
-                        },
-                        channel: channelName
-                    }));
-                    // Notify other clients in channel
-                    channelClients.forEach((client)=>{
-                        if (client !== ws && client.readyState === WebSocket.OPEN) {
-                            client.send(JSON.stringify({
-                                type: "system",
-                                message: "A new user has joined the channel",
-                                channel: channelName
-                            }));
-                        }
-                    });
-                    return;
-                }
-                // Handle regular messages
-                if (data.type === "message") {
-                    const channelName = data.channel;
-                    if (!channelName || typeof channelName !== "string") {
-                        ws.send(JSON.stringify({
-                            type: "error",
-                            message: "Channel name is required"
-                        }));
-                        return;
-                    }
-                    const channelClients = channels.get(channelName);
-                    if (!channelClients || !channelClients.has(ws)) {
-                        ws.send(JSON.stringify({
-                            type: "error",
-                            message: "You must join the channel first"
-                        }));
-                        return;
-                    }
-                    // Broadcast to all clients in the channel
-                    channelClients.forEach((client)=>{
-                        if (client.readyState === WebSocket.OPEN) {
-                            console.log("Broadcasting message to client:", data.message);
-                            client.send(JSON.stringify({
-                                type: "broadcast",
-                                message: data.message,
-                                sender: client === ws ? "You" : "User",
-                                channel: channelName
-                            }));
-                        }
-                    });
-                }
-            } catch (err) {
-                console.error("Error handling message:", err);
-            }
-        },
-        close (ws) {
-            // Remove client from their channel
-            channels.forEach((clients)=>{
-                clients.delete(ws);
-            });
-        }
-    }
-});
-console.log(`WebSocket server running on port ${server.port}`);

package/src/bin/main.ts

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { logger } from "../logger";
-import { createFigmaWebSocketClient } from "../websocket";
-import { registerTools } from "../tools";
-import { registerPrompts } from "../prompts";
-
-// Add command line argument parsing
-const args = process.argv.slice(2);
-const serverArg = args.find((arg) => arg.startsWith("--server="));
-const serverUrl = serverArg ? serverArg.split("=")[1] : "localhost";
-
-// Create Figma WebSocket client
-const figmaClient = createFigmaWebSocketClient(serverUrl);
-
-// Create MCP server
-const server = new McpServer({
-  name: "SEED Design MCP",
-  version: "1.0.0",
-});
-
-// Register tools and prompts
-registerTools(server, figmaClient);
-registerPrompts(server);
-
-// Start the server
-async function main() {
-  try {
-    // Try to connect to Figma socket server
-    figmaClient.connectToFigma();
-  } catch (error) {
-    logger.warn(
-      `Could not connect to Figma initially: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    logger.warn("Will try to connect when the first command is sent");
-  }
-
-  // Start the MCP server with stdio transport
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  logger.info("FigmaMCP server running on stdio");
-}
-
-// Run the server
-main().catch((error) => {
-  logger.error(
-    `Error starting FigmaMCP server: ${error instanceof Error ? error.message : String(error)}`,
-  );
-  process.exit(1);
-});

package/src/bin/socket.ts

@@ -1,194 +0,0 @@
-import type { Server, ServerWebSocket } from "bun";
-
-// Store clients by channel
-const channels = new Map<string, Set<ServerWebSocket<any>>>();
-
-function handleConnection(ws: ServerWebSocket<any>) {
-  // Don't add to clients immediately - wait for channel join
-  console.log("New client connected");
-
-  // Send welcome message to the new client
-  ws.send(
-    JSON.stringify({
-      type: "system",
-      message: "Please join a channel to start chatting",
-    }),
-  );
-
-  ws.close = () => {
-    console.log("Client disconnected");
-
-    // Remove client from their channel
-    channels.forEach((clients, channelName) => {
-      if (clients.has(ws)) {
-        clients.delete(ws);
-
-        // Notify other clients in same channel
-        clients.forEach((client) => {
-          if (client.readyState === WebSocket.OPEN) {
-            client.send(
-              JSON.stringify({
-                type: "system",
-                message: "A user has left the channel",
-                channel: channelName,
-              }),
-            );
-          }
-        });
-      }
-    });
-  };
-}
-
-const server = Bun.serve({
-  port: 3055,
-  // uncomment this to allow connections in windows wsl
-  // hostname: "0.0.0.0",
-  fetch(req: Request, server: Server) {
-    // Handle CORS preflight
-    if (req.method === "OPTIONS") {
-      return new Response(null, {
-        headers: {
-          "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-          "Access-Control-Allow-Headers": "Content-Type, Authorization",
-        },
-      });
-    }
-
-    // Handle WebSocket upgrade
-    const success = server.upgrade(req, {
-      headers: {
-        "Access-Control-Allow-Origin": "*",
-      },
-    });
-
-    if (success) {
-      return; // Upgraded to WebSocket
-    }
-
-    // Return response for non-WebSocket requests
-    return new Response("WebSocket server running", {
-      headers: {
-        "Access-Control-Allow-Origin": "*",
-      },
-    });
-  },
-  websocket: {
-    open: handleConnection,
-    message(ws: ServerWebSocket<any>, message: string | Buffer) {
-      try {
-        console.log("Received message from client:", message);
-        const data = JSON.parse(message as string);
-
-        if (data.type === "join") {
-          const channelName = data.channel;
-          if (!channelName || typeof channelName !== "string") {
-            ws.send(
-              JSON.stringify({
-                type: "error",
-                message: "Channel name is required",
-              }),
-            );
-            return;
-          }
-
-          // Create channel if it doesn't exist
-          if (!channels.has(channelName)) {
-            channels.set(channelName, new Set());
-          }
-
-          // Add client to channel
-          const channelClients = channels.get(channelName)!;
-          channelClients.add(ws);
-
-          // Notify client they joined successfully
-          ws.send(
-            JSON.stringify({
-              type: "system",
-              message: `Joined channel: ${channelName}`,
-              channel: channelName,
-            }),
-          );
-
-          console.log("Sending message to client:", data.id);
-
-          ws.send(
-            JSON.stringify({
-              type: "system",
-              message: {
-                id: data.id,
-                result: "Connected to channel: " + channelName,
-              },
-              channel: channelName,
-            }),
-          );
-
-          // Notify other clients in channel
-          channelClients.forEach((client) => {
-            if (client !== ws && client.readyState === WebSocket.OPEN) {
-              client.send(
-                JSON.stringify({
-                  type: "system",
-                  message: "A new user has joined the channel",
-                  channel: channelName,
-                }),
-              );
-            }
-          });
-          return;
-        }
-
-        // Handle regular messages
-        if (data.type === "message") {
-          const channelName = data.channel;
-          if (!channelName || typeof channelName !== "string") {
-            ws.send(
-              JSON.stringify({
-                type: "error",
-                message: "Channel name is required",
-              }),
-            );
-            return;
-          }
-
-          const channelClients = channels.get(channelName);
-          if (!channelClients || !channelClients.has(ws)) {
-            ws.send(
-              JSON.stringify({
-                type: "error",
-                message: "You must join the channel first",
-              }),
-            );
-            return;
-          }
-
-          // Broadcast to all clients in the channel
-          channelClients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-              console.log("Broadcasting message to client:", data.message);
-              client.send(
-                JSON.stringify({
-                  type: "broadcast",
-                  message: data.message,
-                  sender: client === ws ? "You" : "User",
-                  channel: channelName,
-                }),
-              );
-            }
-          });
-        }
-      } catch (err) {
-        console.error("Error handling message:", err);
-      }
-    },
-    close(ws: ServerWebSocket<any>) {
-      // Remove client from their channel
-      channels.forEach((clients) => {
-        clients.delete(ws);
-      });
-    },
-  },
-});
-
-console.log(`WebSocket server running on port ${server.port}`);