conductor-figma 3.0.1 → 3.0.3

package/README.md

@@ -80,22 +80,6 @@ Every tool queries the intelligence engine:
 - **Font Weights**: Auto-resolves "bold" → "Bold", "600" → "Semi Bold"
 - **Layout Intelligence**: 13 layout presets (row, column, center, spread, grid, sidebar, form)
 
-## vs Competition
-
-|---------|-----------|--------|-----------|---------------|
-| Tools | 201 | 45 | 5 | 12 |
-| Categories | 17 | ~8 | 1 | ~4 |
-| Design intelligence | Yes | No | No | No |
-| Smart components | 18 types | No | No | No |
-| Accessibility | 12 tools | No | No | No |
-| Code export | 5 frameworks | No | No | Partial |
-| Batch operations | 17 tools | No | No | No |
-| Design system | 10 tools (free) | $9 add-on | No | Partial |
-| Responsive | 5 tools | No | No | No |
-| Typography | 10 tools | No | No | No |
-| Prototype | 10 tools | No | No | No |
-| Annotation | 10 tools | No | No | No |
-
 ## License
 
 MIT. Built by [0xDragoon](https://github.com/dragoon0x).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conductor-figma",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "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

@@ -6,96 +6,110 @@ import { TOOL_LIST, TOOL_COUNT, getTool, CATEGORIES } from './tools/registry.js'
 import { handleTool } from './tools/handlers.js'
 import { createBridge } from './bridge.js'
 
-const VERSION = '3.0.0'
-const bridge = createBridge()
-bridge.start()
+var VERSION = '3.0.2'
+var bridge = null
+var bridgeStarted = false
 
-function log(...args) { process.stderr.write('[conductor] ' + args.join(' ') + '\n') }
-log(`Conductor v${VERSION} starting — WebSocket on port ${bridge.getPort()}`)
+function log() { process.stderr.write('[conductor] ' + Array.prototype.join.call(arguments, ' ') + '\n') }
+
+function ensureBridge() {
+  if (!bridgeStarted) {
+    bridgeStarted = true
+    bridge = createBridge()
+    bridge.start()
+  }
+  return bridge
+}
 
 // ─── JSON-RPC over stdio ───
-let buffer = ''
+var buffer = ''
 
 process.stdin.setEncoding('utf8')
-process.stdin.on('data', chunk => {
+process.stdin.on('data', function(chunk) {
   buffer += chunk
   while (true) {
-    const headerEnd = buffer.indexOf('\r\n\r\n')
+    var headerEnd = buffer.indexOf('\r\n\r\n')
     if (headerEnd === -1) break
-    const header = buffer.slice(0, headerEnd)
-    const match = header.match(/Content-Length:\s*(\d+)/i)
+    var header = buffer.slice(0, headerEnd)
+    var match = header.match(/Content-Length:\s*(\d+)/i)
     if (!match) { buffer = buffer.slice(headerEnd + 4); continue }
-    const len = parseInt(match[1])
-    const bodyStart = headerEnd + 4
+    var len = parseInt(match[1])
+    var bodyStart = headerEnd + 4
     if (buffer.length < bodyStart + len) break
-    const body = buffer.slice(bodyStart, bodyStart + len)
+    var body = buffer.slice(bodyStart, bodyStart + len)
     buffer = buffer.slice(bodyStart + len)
     try {
-      const msg = JSON.parse(body)
+      var msg = JSON.parse(body)
       handleMessage(msg)
     } catch (e) { log('Parse error:', e.message) }
   }
 })
 
 function send(msg) {
-  const json = JSON.stringify(msg)
-  const out = `Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`
+  var json = JSON.stringify(msg)
+  var out = 'Content-Length: ' + Buffer.byteLength(json) + '\r\n\r\n' + json
   process.stdout.write(out)
 }
 
-function respond(id, result) { send({ jsonrpc: '2.0', id, result }) }
-function respondError(id, code, message) { send({ jsonrpc: '2.0', id, error: { code, message } }) }
+function respond(id, result) { send({ jsonrpc: '2.0', id: id, result: result }) }
+function respondError(id, code, message) { send({ jsonrpc: '2.0', id: id, error: { code: code, message: message } }) }
 
-async function handleMessage(msg) {
-  const { id, method, params } = msg
+function handleMessage(msg) {
+  var id = msg.id
+  var method = msg.method
+  var params = msg.params
 
   switch (method) {
     case 'initialize':
-      return respond(id, {
+      // Start bridge in background, respond immediately
+      ensureBridge()
+      log('Conductor v' + VERSION + ' ready — ' + TOOL_COUNT + ' tools')
+      respond(id, {
         protocolVersion: '2024-11-05',
         capabilities: { tools: { listChanged: false } },
         serverInfo: { name: 'conductor-figma', version: VERSION },
       })
+      return
 
     case 'notifications/initialized':
-      log(`Conductor v${VERSION} ready — ${TOOL_COUNT} tools across ${Object.keys(CATEGORIES).length} categories`)
       return
 
     case 'tools/list':
-      return respond(id, {
-        tools: TOOL_LIST.map(t => ({
-          name: t.name,
-          description: t.description,
-          inputSchema: t.inputSchema,
-        }))
+      respond(id, {
+        tools: TOOL_LIST.map(function(t) {
+          return { name: t.name, description: t.description, inputSchema: t.inputSchema }
+        })
       })
+      return
 
-    case 'tools/call': {
-      const { name, arguments: args } = params
-      const tool = getTool(name)
-      if (!tool) return respondError(id, -32601, `Unknown tool: ${name}`)
+    case 'tools/call':
+      var name = params.name
+      var args = params.arguments || {}
+      var tool = getTool(name)
+      if (!tool) { respondError(id, -32601, 'Unknown tool: ' + name); return }
 
-      try {
-        const result = await handleTool(name, args || {}, bridge)
-        return respond(id, {
+      var b = ensureBridge()
+      handleTool(name, args, b).then(function(result) {
+        respond(id, {
           content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result, null, 2) }]
         })
-      } catch (e) {
-        log(`Tool error [${name}]:`, e.message)
-        return respond(id, {
-          content: [{ type: 'text', text: `Error: ${e.message}` }],
+      }).catch(function(e) {
+        log('Tool error [' + name + ']:', e.message)
+        respond(id, {
+          content: [{ type: 'text', text: 'Error: ' + e.message }],
           isError: true,
         })
-      }
-    }
+      })
+      return
 
     case 'ping':
-      return respond(id, {})
+      respond(id, {})
+      return
 
     default:
-      if (id) respondError(id, -32601, `Unknown method: ${method}`)
+      if (id) respondError(id, -32601, 'Unknown method: ' + method)
   }
 }
 
-process.on('SIGINT', () => { if (bridge) bridge.stop(); process.exit(0) })
-process.on('SIGTERM', () => { if (bridge) bridge.stop(); process.exit(0) })
+process.on('SIGINT', function() { if (bridge) bridge.stop(); process.exit(0) })
+process.on('SIGTERM', function() { if (bridge) bridge.stop(); process.exit(0) })