conductor-figma 3.0.0 → 3.0.2

package/figma-plugin/code.js

@@ -62,7 +62,7 @@ function resolveRef(ref) {
 
 async function loadFont(family, style) {
   try { await figma.loadFontAsync({ family: family || 'Inter', style: style || 'Regular' }) }
-  catch { await figma.loadFontAsync({ family: 'Inter', style: 'Regular' }) }
+  catch (e) { await figma.loadFontAsync({ family: 'Inter', style: 'Regular' }) }
 }
 
 function serializeNode(node, depth) {

package/figma-plugin/manifest.json

@@ -8,7 +8,7 @@
   "enableProposedApi": false,
   "editorType": ["figma"],
   "networkAccess": {
-    "allowedDomains": ["none"],
-    "reasoning": "Conductor connects to a local WebSocket server only"
+    "allowedDomains": ["*"],
+    "reasoning": "Connects to local MCP WebSocket server"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conductor-figma",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Design-intelligent MCP server for Figma. 201 design-intelligent tools for Figma. Every tool knows typography, spacing, color, accessibility. Not a shape proxy — a design engine.",
   "author": "0xDragoon",
   "license": "MIT",

package/src/bridge.js

@@ -4,57 +4,73 @@
 
 import { WebSocketServer } from 'ws'
 
-function log(...args) { process.stderr.write('[bridge] ' + args.join(' ') + '\n') }
+function log() { process.stderr.write('[bridge] ' + Array.prototype.join.call(arguments, ' ') + '\n') }
 
 export function createBridge(port) {
   port = port || parseInt(process.env.CONDUCTOR_PORT) || 3055
-  let wss = null
-  let client = null
-  let pending = new Map()
-  let msgId = 0
+  var wss = null
+  var client = null
+  var pending = new Map()
+  var msgId = 0
+  var isOwner = false
 
   function start() {
-    return new Promise((resolve) => {
-      wss = new WebSocketServer({ port })
-      wss.on('listening', () => { log(`WebSocket server on port ${port}`); resolve() })
-      wss.on('connection', (ws) => {
-        client = ws
-        log('Figma plugin connected')
-        ws.on('message', (data) => {
-          try {
-            const msg = JSON.parse(data.toString())
-            if (msg.id && pending.has(msg.id)) {
-              const { resolve, reject, timer } = pending.get(msg.id)
-              clearTimeout(timer)
-              pending.delete(msg.id)
-              if (msg.error) reject(new Error(msg.error))
-              else resolve(msg.result)
-            }
-          } catch (e) { log('Parse error:', e.message) }
+    return new Promise(function(resolve) {
+      try {
+        wss = new WebSocketServer({ port: port })
+        wss.on('listening', function() { isOwner = true; log('WebSocket server on port ' + port); resolve() })
+        wss.on('connection', function(ws) {
+          client = ws
+          log('Figma plugin connected')
+          ws.on('message', function(data) {
+            try {
+              var msg = JSON.parse(data.toString())
+              if (msg.id && pending.has(msg.id)) {
+                var p = pending.get(msg.id)
+                clearTimeout(p.timer)
+                pending.delete(msg.id)
+                if (msg.error) p.reject(new Error(msg.error))
+                else p.resolve(msg.result)
+              }
+            } catch (e) { log('Parse error:', e.message) }
+          })
+          ws.on('close', function() { client = null; log('Figma plugin disconnected') })
+          ws.on('error', function(e) { log('WS error:', e.message) })
         })
-        ws.on('close', () => { client = null; log('Figma plugin disconnected') })
-        ws.on('error', (e) => log('WS error:', e.message))
-      })
-      wss.on('error', (e) => { log('Server error:', e.message); resolve() })
+        wss.on('error', function(e) {
+          if (e.code === 'EADDRINUSE') {
+            log('Port ' + port + ' in use — another Conductor instance is running. This instance will handle MCP only.')
+            wss = null
+            resolve()
+          } else {
+            log('Server error:', e.message)
+            resolve()
+          }
+        })
+      } catch (e) {
+        log('Bridge start error:', e.message)
+        resolve()
+      }
     })
   }
 
-  function stop() { if (wss) { wss.close(); wss = null } }
+  function stop() { if (wss && isOwner) { wss.close(); wss = null } }
 
   function isConnected() { return client !== null && client.readyState === 1 }
 
-  function send(command, data, timeout = 15000) {
-    return new Promise((resolve, reject) => {
-      if (!isConnected()) return reject(new Error('Figma plugin not connected. Open Figma → Plugins → Development → Conductor'))
-      const id = ++msgId
-      const timer = setTimeout(() => {
+  function send(command, data, timeout) {
+    timeout = timeout || 15000
+    return new Promise(function(resolve, reject) {
+      if (!isConnected()) return reject(new Error('Figma plugin not connected. Run the Conductor plugin in Figma, and make sure the WebSocket server is running on port ' + port))
+      var id = ++msgId
+      var timer = setTimeout(function() {
         pending.delete(id)
-        reject(new Error(`Timeout waiting for Figma response (${timeout}ms)`))
+        reject(new Error('Timeout waiting for Figma response (' + timeout + 'ms)'))
       }, timeout)
-      pending.set(id, { resolve, reject, timer })
-      client.send(JSON.stringify({ id, command, data }))
+      pending.set(id, { resolve: resolve, reject: reject, timer: timer })
+      client.send(JSON.stringify({ id: id, command: command, data: data }))
     })
   }
 
-  return { start, stop, isConnected, send, getPort: () => port }
+  return { start: start, stop: stop, isConnected: isConnected, send: send, getPort: function() { return port } }
 }

package/src/server.js

@@ -7,9 +7,11 @@ import { handleTool } from './tools/handlers.js'
 import { createBridge } from './bridge.js'
 
 const VERSION = '3.0.0'
-let bridge = null
+const bridge = createBridge()
+bridge.start()
 
 function log(...args) { process.stderr.write('[conductor] ' + args.join(' ') + '\n') }
+log(`Conductor v${VERSION} starting — WebSocket on port ${bridge.getPort()}`)
 
 // ─── JSON-RPC over stdio ───
 let buffer = ''
@@ -49,10 +51,6 @@ async function handleMessage(msg) {
 
   switch (method) {
     case 'initialize':
-      if (!bridge) {
-        bridge = createBridge()
-        await bridge.start()
-      }
       return respond(id, {
         protocolVersion: '2024-11-05',
         capabilities: { tools: { listChanged: false } },