conductor-figma 3.0.2 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conductor-figma",
-  "version": "3.0.2",
+  "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/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) })