ingresseflow-bridge 1.0.1 → 1.1.0

package/dist/index.js

@@ -14,10 +14,40 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { WebSocketServer, WebSocket } from 'ws';
 import { createServer } from 'http';
 import { z } from 'zod';
-// ── WebSocket bridge ──────────────────────────────────────────────────────────
+const HTTP_PORT = 9242;
+function log(msg) {
+    process.stderr.write(`[IngresseFlow] ${msg}\n`);
+}
+// ── Bridge state ──────────────────────────────────────────────────────────────
+// Two boot modes:
+//   - 'server': this process owns the WebSocket bridge and HTTP command server.
+//   - 'client': another bridge already owns :9242 (typically the LaunchAgent).
+//               This process is just an MCP front-end and forwards calls via HTTP.
+// The client mode prevents EADDRINUSE crashes when Claude Code spawns a stdio
+// MCP child while the persistent bridge is already running.
+let mode = 'server';
 let pluginSocket = null;
 const pending = new Map();
+async function detectExistingBridge() {
+    // If :9242 is occupied, another bridge owns it — go into client mode.
+    // tryPort returns false when listen fails (EADDRINUSE), which is exactly
+    // the signal we need; works even against older bridges without /health.
+    return !(await tryPort(HTTP_PORT));
+}
+async function forwardViaHttp(type, payload) {
+    const r = await fetch(`http://localhost:${HTTP_PORT}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type, payload }),
+    });
+    const json = await r.json();
+    if (!json.success)
+        throw new Error(json.error ?? 'Erro desconhecido');
+    return json.data;
+}
 function sendToPlugin(type, payload) {
+    if (mode === 'client')
+        return forwardViaHttp(type, payload);
     return new Promise((resolve, reject) => {
         if (!pluginSocket || pluginSocket.readyState !== WebSocket.OPEN) {
             return reject(new Error('Plugin não conectado. Abra o IngresseFlow no Figma Desktop (FigJam).'));
@@ -35,14 +65,14 @@ function sendToPlugin(type, payload) {
         pluginSocket.send(JSON.stringify({ id, type, payload }));
     });
 }
-async function tryPort(port) {
+async function tryPort(port, host = '127.0.0.1') {
     return new Promise(resolve => {
         const srv = createServer();
         srv.once('error', () => resolve(false));
-        srv.listen(port, () => srv.close(() => resolve(true)));
+        srv.listen(port, host, () => srv.close(() => resolve(true)));
     });
 }
-async function startBridge() {
+async function startWebSocketBridge() {
     const BASE_PORT = 9243;
     const MAX_PORT = 9250;
     let port = BASE_PORT;
@@ -54,6 +84,9 @@ async function startBridge() {
     if (port > MAX_PORT)
         throw new Error('Nenhuma porta livre em 9243–9250');
     const wss = new WebSocketServer({ port, host: '127.0.0.1' });
+    wss.on('error', (err) => {
+        log(`Erro no WebSocketServer: ${err.message}`);
+    });
     wss.on('connection', (ws) => {
         pluginSocket = ws;
         log(`Plugin conectado`);
@@ -82,6 +115,44 @@ async function startBridge() {
     log(`Abra o plugin IngresseFlow no Figma Desktop para conectar`);
     return port;
 }
+// ── HTTP command server ──────────────────────────────────────────────────────
+// Exposes:
+//   GET  /health   — used by other bridge instances to detect us and switch
+//                    to client mode instead of crashing on EADDRINUSE.
+//   POST /command  — { type, payload } forwarded to the plugin via WebSocket.
+function startCommandServer() {
+    const http = createServer(async (req, res) => {
+        if (req.method === 'GET' && req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', plugin: !!pluginSocket }));
+            return;
+        }
+        if (req.method !== 'POST' || req.url !== '/command') {
+            res.writeHead(404).end();
+            return;
+        }
+        let body = '';
+        req.on('data', (c) => { body += c; });
+        req.on('end', async () => {
+            try {
+                const { type, payload } = JSON.parse(body);
+                const result = await sendToPlugin(type, payload);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: true, data: result }));
+            }
+            catch (err) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: err.message }));
+            }
+        });
+    });
+    http.on('error', (err) => {
+        log(`Erro no HTTP server: ${err.message}`);
+    });
+    http.listen(HTTP_PORT, '127.0.0.1', () => {
+        log(`Comando HTTP em http://localhost:${HTTP_PORT}/command`);
+    });
+}
 // ── MCP tools ─────────────────────────────────────────────────────────────────
 const ColorEnum = z.enum([
     'YELLOW', 'BLUE', 'GREEN', 'PINK', 'ORANGE',
@@ -126,37 +197,123 @@ server.tool('figjam_create_section', 'Cria uma seção nomeada no FigJam para ag
     const result = await sendToPlugin('CREATE_SECTION', { name, x, y, width, height });
     return { content: [{ type: 'text', text: JSON.stringify(result) }] };
 });
-// ── HTTP command server (port 9242) ───────────────────────────────────────────
-// Accepts POST /command { type, payload } — lets any local client send operations
-// without needing an MCP session. Used by scripts and tests.
-function startCommandServer() {
-    const http = createServer(async (req, res) => {
-        if (req.method !== 'POST' || req.url !== '/command') {
-            res.writeHead(404).end();
-            return;
-        }
-        let body = '';
-        req.on('data', (c) => { body += c; });
-        req.on('end', async () => {
-            try {
-                const { type, payload } = JSON.parse(body);
-                const result = await sendToPlugin(type, payload);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ success: true, data: result }));
-            }
-            catch (err) {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ success: false, error: err.message }));
-            }
-        });
-    });
-    http.listen(9242, '127.0.0.1', () => log('Comando HTTP em http://localhost:9242/command'));
-}
+// ── Shapes & connectors (BPMN-friendly) ───────────────────────────────────────
+const ShapeTypeEnum = z.enum([
+    'SQUARE', 'ELLIPSE', 'ROUNDED_RECTANGLE', 'DIAMOND',
+    'TRIANGLE_UP', 'TRIANGLE_DOWN',
+    'PARALLELOGRAM_RIGHT', 'PARALLELOGRAM_LEFT',
+    'ENG_DATABASE', 'ENG_QUEUE', 'ENG_FILE', 'ENG_FOLDER',
+    'TRAPEZOID', 'PREDEFINED_PROCESS', 'SHIELD',
+    'DOCUMENT_SINGLE', 'DOCUMENT_MULTIPLE', 'MANUAL_INPUT',
+    'HEXAGON', 'CHEVRON_RIGHT_ARROW', 'CHEVRON_RIGHT_PENTAGON',
+]).describe('Tipo de shape (BPMN: ELLIPSE=evento, ROUNDED_RECTANGLE=tarefa, DIAMOND=gateway)');
+const MagnetEnum = z.enum(['AUTO', 'TOP', 'LEFT', 'BOTTOM', 'RIGHT', 'CENTER'])
+    .describe('Ponto de ancoragem do conector no nó');
+const StrokeCapEnum = z.enum([
+    'NONE', 'ARROW_LINES', 'ARROW_EQUILATERAL',
+    'TRIANGLE_FILLED', 'DIAMOND_FILLED', 'CIRCLE_FILLED',
+]).describe('Estilo da ponta do conector');
+const LineTypeEnum = z.enum(['STRAIGHT', 'ELBOWED'])
+    .describe('Reta direta ou com cotovelos (90°)');
+const ShapeItem = z.object({
+    shape: ShapeTypeEnum.default('ROUNDED_RECTANGLE'),
+    text: z.string().optional().describe('Texto interno do shape'),
+    color: ColorEnum.default('BLUE'),
+    x: z.number().optional(),
+    y: z.number().optional(),
+    width: z.number().optional(),
+    height: z.number().optional(),
+});
+const ConnectorItem = z.object({
+    startNodeId: z.string().describe('ID do nó de origem'),
+    endNodeId: z.string().describe('ID do nó de destino'),
+    startMagnet: MagnetEnum.default('AUTO'),
+    endMagnet: MagnetEnum.default('AUTO'),
+    label: z.string().optional().describe('Texto sobre o conector (ex.: Sim/Não)'),
+    lineType: LineTypeEnum.optional(),
+    startCap: StrokeCapEnum.optional(),
+    endCap: StrokeCapEnum.optional(),
+    strokeWeight: z.number().optional(),
+    color: ColorEnum.optional(),
+});
+server.tool('figjam_create_shape', 'Cria uma forma com texto no FigJam (BPMN: ELLIPSE=evento, ROUNDED_RECTANGLE=tarefa, DIAMOND=gateway). Retorna nodeId para conectar.', ShapeItem.shape, async (params) => {
+    const result = await sendToPlugin('CREATE_SHAPE', params);
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
+server.tool('figjam_create_shapes', 'Cria múltiplas formas com texto de uma vez. Máximo 50 por chamada. Use com figjam_create_connectors para montar fluxos BPMN.', {
+    shapes: z.array(ShapeItem).max(50).describe('Lista de formas para criar'),
+}, async ({ shapes }) => {
+    const result = await sendToPlugin('CREATE_SHAPES', { shapes });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
+server.tool('figjam_create_connector', 'Conecta dois nós existentes com uma seta (BPMN sequence flow). Aceita nodeId de stickies, shapes ou qualquer SceneNode.', ConnectorItem.shape, async (params) => {
+    const result = await sendToPlugin('CREATE_CONNECTOR', params);
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
+server.tool('figjam_create_connectors', 'Cria múltiplos conectores de uma vez. Máximo 100 por chamada. Use após figjam_create_shapes para montar fluxos completos.', {
+    connectors: z.array(ConnectorItem).max(100).describe('Lista de conectores'),
+}, async ({ connectors }) => {
+    const result = await sendToPlugin('CREATE_CONNECTORS', { connectors });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
+server.tool('figjam_create_flow', 'Atalho: cria um fluxo linear (shapes em sequência horizontal já conectados). Para fluxos com ramificações use figjam_create_shapes + figjam_create_connectors.', {
+    steps: z.array(z.object({
+        label: z.string(),
+        shape: ShapeTypeEnum.optional(),
+        color: ColorEnum.optional(),
+    })).describe('Etapas do fluxo, da esquerda para a direita'),
+    x: z.number().optional().describe('X inicial do primeiro shape'),
+    y: z.number().optional().describe('Y comum a todos os shapes'),
+    gap: z.number().default(220).describe('Distância horizontal entre shapes'),
+}, async ({ steps, x, y, gap }) => {
+    const result = await sendToPlugin('CREATE_FLOW', { steps, x, y, gap });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
+server.tool('figjam_set_connector_labels', 'Define ou atualiza rótulos em conectores existentes (ex.: Sim/Não em gateways BPMN).', {
+    labels: z.array(z.object({
+        nodeId: z.string(),
+        label: z.string(),
+    })).describe('Pares { nodeId, label } para conectores existentes'),
+}, async ({ labels }) => {
+    const result = await sendToPlugin('SET_CONNECTOR_LABELS', { labels });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
+server.tool('figjam_move_nodes', 'Reposiciona nós existentes pelo ID.', {
+    moves: z.array(z.object({
+        nodeId: z.string(),
+        x: z.number(),
+        y: z.number(),
+    })),
+}, async ({ moves }) => {
+    const result = await sendToPlugin('MOVE_NODES', { moves });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
+server.tool('figjam_delete_nodes', 'Remove nós do canvas pelo ID.', {
+    nodeIds: z.array(z.string()),
+}, async ({ nodeIds }) => {
+    const result = await sendToPlugin('DELETE_NODES', { nodeIds });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
+// Generic forwarder — lets new plugin operations be invoked without bridge updates.
+// Useful for evolving the plugin independently: any new op type added in code.ts
+// becomes immediately accessible via this tool.
+server.tool('figjam_execute', 'Encaminha uma operação arbitrária para o plugin (escape hatch para ops novas que ainda não têm tool dedicada). Tipos válidos atuais: PING, CREATE_STICKY, CREATE_STICKIES, CREATE_SECTION, CREATE_SHAPE, CREATE_SHAPES, CREATE_CONNECTOR, CREATE_CONNECTORS, CREATE_FLOW, SET_CONNECTOR_LABELS, MOVE_NODES, DELETE_NODES, READ_BOARD, GET_SELECTION.', {
+    type: z.string().describe('Nome da operação no plugin (ex.: CREATE_SHAPE)'),
+    payload: z.record(z.unknown()).optional().describe('Payload da operação'),
+}, async ({ type, payload }) => {
+    const result = await sendToPlugin(type, payload ?? {});
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+});
 // ── Boot ──────────────────────────────────────────────────────────────────────
-function log(msg) {
-    process.stderr.write(`[IngresseFlow] ${msg}\n`);
+const existing = await detectExistingBridge();
+if (existing) {
+    mode = 'client';
+    log(`Bridge persistente detectada em :${HTTP_PORT} — operando em modo cliente.`);
+}
+else {
+    mode = 'server';
+    await startWebSocketBridge();
+    startCommandServer();
 }
-await startBridge();
-startCommandServer();
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ingresseflow-bridge",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Bridge MCP server for IngresseFlow — connects Claude Code to FigJam via Figma Desktop plugin",
   "type": "module",
   "bin": {

package/src/index.ts

@@ -11,8 +11,21 @@ import { WebSocketServer, WebSocket } from 'ws';
 import { createServer } from 'http';
 import { z } from 'zod';
 
-// ── WebSocket bridge ──────────────────────────────────────────────────────────
+const HTTP_PORT = 9242;
 
+function log(msg: string) {
+  process.stderr.write(`[IngresseFlow] ${msg}\n`);
+}
+
+// ── Bridge state ──────────────────────────────────────────────────────────────
+// Two boot modes:
+//   - 'server': this process owns the WebSocket bridge and HTTP command server.
+//   - 'client': another bridge already owns :9242 (typically the LaunchAgent).
+//               This process is just an MCP front-end and forwards calls via HTTP.
+// The client mode prevents EADDRINUSE crashes when Claude Code spawns a stdio
+// MCP child while the persistent bridge is already running.
+
+let mode: 'server' | 'client' = 'server';
 let pluginSocket: WebSocket | null = null;
 
 const pending = new Map<string, {
@@ -21,7 +34,27 @@ const pending = new Map<string, {
   timer: ReturnType<typeof setTimeout>;
 }>();
 
+async function detectExistingBridge(): Promise<boolean> {
+  // If :9242 is occupied, another bridge owns it — go into client mode.
+  // tryPort returns false when listen fails (EADDRINUSE), which is exactly
+  // the signal we need; works even against older bridges without /health.
+  return !(await tryPort(HTTP_PORT));
+}
+
+async function forwardViaHttp<T>(type: string, payload: unknown): Promise<T> {
+  const r = await fetch(`http://localhost:${HTTP_PORT}/command`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ type, payload }),
+  });
+  const json = await r.json() as { success: boolean; data?: T; error?: string };
+  if (!json.success) throw new Error(json.error ?? 'Erro desconhecido');
+  return json.data as T;
+}
+
 function sendToPlugin<T>(type: string, payload: unknown): Promise<T> {
+  if (mode === 'client') return forwardViaHttp<T>(type, payload);
+
   return new Promise((resolve, reject) => {
     if (!pluginSocket || pluginSocket.readyState !== WebSocket.OPEN) {
       return reject(new Error(
@@ -44,15 +77,15 @@ function sendToPlugin<T>(type: string, payload: unknown): Promise<T> {
   });
 }
 
-async function tryPort(port: number): Promise<boolean> {
+async function tryPort(port: number, host = '127.0.0.1'): Promise<boolean> {
   return new Promise(resolve => {
     const srv = createServer();
     srv.once('error', () => resolve(false));
-    srv.listen(port, () => srv.close(() => resolve(true)));
+    srv.listen(port, host, () => srv.close(() => resolve(true)));
   });
 }
 
-async function startBridge(): Promise<number> {
+async function startWebSocketBridge(): Promise<number> {
   const BASE_PORT = 9243;
   const MAX_PORT  = 9250;
   let port = BASE_PORT;
@@ -65,6 +98,10 @@ async function startBridge(): Promise<number> {
 
   const wss = new WebSocketServer({ port, host: '127.0.0.1' });
 
+  wss.on('error', (err) => {
+    log(`Erro no WebSocketServer: ${(err as Error).message}`);
+  });
+
   wss.on('connection', (ws) => {
     pluginSocket = ws;
     log(`Plugin conectado`);
@@ -95,6 +132,47 @@ async function startBridge(): Promise<number> {
   return port;
 }
 
+// ── HTTP command server ──────────────────────────────────────────────────────
+// Exposes:
+//   GET  /health   — used by other bridge instances to detect us and switch
+//                    to client mode instead of crashing on EADDRINUSE.
+//   POST /command  — { type, payload } forwarded to the plugin via WebSocket.
+
+function startCommandServer() {
+  const http = createServer(async (req, res) => {
+    if (req.method === 'GET' && req.url === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'ok', plugin: !!pluginSocket }));
+      return;
+    }
+    if (req.method !== 'POST' || req.url !== '/command') {
+      res.writeHead(404).end();
+      return;
+    }
+    let body = '';
+    req.on('data', (c: Buffer) => { body += c; });
+    req.on('end', async () => {
+      try {
+        const { type, payload } = JSON.parse(body) as { type: string; payload: unknown };
+        const result = await sendToPlugin(type, payload);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, data: result }));
+      } catch (err) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: (err as Error).message }));
+      }
+    });
+  });
+
+  http.on('error', (err) => {
+    log(`Erro no HTTP server: ${(err as Error).message}`);
+  });
+
+  http.listen(HTTP_PORT, '127.0.0.1', () => {
+    log(`Comando HTTP em http://localhost:${HTTP_PORT}/command`);
+  });
+}
+
 // ── MCP tools ─────────────────────────────────────────────────────────────────
 
 const ColorEnum = z.enum([
@@ -172,41 +250,185 @@ server.tool(
   }
 );
 
-// ── HTTP command server (port 9242) ───────────────────────────────────────────
-// Accepts POST /command { type, payload } — lets any local client send operations
-// without needing an MCP session. Used by scripts and tests.
+// ── Shapes & connectors (BPMN-friendly) ───────────────────────────────────────
 
-function startCommandServer() {
-  const http = createServer(async (req, res) => {
-    if (req.method !== 'POST' || req.url !== '/command') {
-      res.writeHead(404).end();
-      return;
-    }
-    let body = '';
-    req.on('data', (c: Buffer) => { body += c; });
-    req.on('end', async () => {
-      try {
-        const { type, payload } = JSON.parse(body) as { type: string; payload: unknown };
-        const result = await sendToPlugin(type, payload);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: true, data: result }));
-      } catch (err) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: (err as Error).message }));
-      }
-    });
-  });
-  http.listen(9242, '127.0.0.1', () => log('Comando HTTP em http://localhost:9242/command'));
-}
+const ShapeTypeEnum = z.enum([
+  'SQUARE', 'ELLIPSE', 'ROUNDED_RECTANGLE', 'DIAMOND',
+  'TRIANGLE_UP', 'TRIANGLE_DOWN',
+  'PARALLELOGRAM_RIGHT', 'PARALLELOGRAM_LEFT',
+  'ENG_DATABASE', 'ENG_QUEUE', 'ENG_FILE', 'ENG_FOLDER',
+  'TRAPEZOID', 'PREDEFINED_PROCESS', 'SHIELD',
+  'DOCUMENT_SINGLE', 'DOCUMENT_MULTIPLE', 'MANUAL_INPUT',
+  'HEXAGON', 'CHEVRON_RIGHT_ARROW', 'CHEVRON_RIGHT_PENTAGON',
+]).describe('Tipo de shape (BPMN: ELLIPSE=evento, ROUNDED_RECTANGLE=tarefa, DIAMOND=gateway)');
+
+const MagnetEnum = z.enum(['AUTO', 'TOP', 'LEFT', 'BOTTOM', 'RIGHT', 'CENTER'])
+  .describe('Ponto de ancoragem do conector no nó');
+
+const StrokeCapEnum = z.enum([
+  'NONE', 'ARROW_LINES', 'ARROW_EQUILATERAL',
+  'TRIANGLE_FILLED', 'DIAMOND_FILLED', 'CIRCLE_FILLED',
+]).describe('Estilo da ponta do conector');
+
+const LineTypeEnum = z.enum(['STRAIGHT', 'ELBOWED'])
+  .describe('Reta direta ou com cotovelos (90°)');
+
+const ShapeItem = z.object({
+  shape:  ShapeTypeEnum.default('ROUNDED_RECTANGLE'),
+  text:   z.string().optional().describe('Texto interno do shape'),
+  color:  ColorEnum.default('BLUE'),
+  x:      z.number().optional(),
+  y:      z.number().optional(),
+  width:  z.number().optional(),
+  height: z.number().optional(),
+});
+
+const ConnectorItem = z.object({
+  startNodeId:  z.string().describe('ID do nó de origem'),
+  endNodeId:    z.string().describe('ID do nó de destino'),
+  startMagnet:  MagnetEnum.default('AUTO'),
+  endMagnet:    MagnetEnum.default('AUTO'),
+  label:        z.string().optional().describe('Texto sobre o conector (ex.: Sim/Não)'),
+  lineType:     LineTypeEnum.optional(),
+  startCap:     StrokeCapEnum.optional(),
+  endCap:       StrokeCapEnum.optional(),
+  strokeWeight: z.number().optional(),
+  color:        ColorEnum.optional(),
+});
+
+server.tool(
+  'figjam_create_shape',
+  'Cria uma forma com texto no FigJam (BPMN: ELLIPSE=evento, ROUNDED_RECTANGLE=tarefa, DIAMOND=gateway). Retorna nodeId para conectar.',
+  ShapeItem.shape,
+  async (params) => {
+    const result = await sendToPlugin('CREATE_SHAPE', params);
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
+
+server.tool(
+  'figjam_create_shapes',
+  'Cria múltiplas formas com texto de uma vez. Máximo 50 por chamada. Use com figjam_create_connectors para montar fluxos BPMN.',
+  {
+    shapes: z.array(ShapeItem).max(50).describe('Lista de formas para criar'),
+  },
+  async ({ shapes }) => {
+    const result = await sendToPlugin('CREATE_SHAPES', { shapes });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
+
+server.tool(
+  'figjam_create_connector',
+  'Conecta dois nós existentes com uma seta (BPMN sequence flow). Aceita nodeId de stickies, shapes ou qualquer SceneNode.',
+  ConnectorItem.shape,
+  async (params) => {
+    const result = await sendToPlugin('CREATE_CONNECTOR', params);
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
+
+server.tool(
+  'figjam_create_connectors',
+  'Cria múltiplos conectores de uma vez. Máximo 100 por chamada. Use após figjam_create_shapes para montar fluxos completos.',
+  {
+    connectors: z.array(ConnectorItem).max(100).describe('Lista de conectores'),
+  },
+  async ({ connectors }) => {
+    const result = await sendToPlugin('CREATE_CONNECTORS', { connectors });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
+
+server.tool(
+  'figjam_create_flow',
+  'Atalho: cria um fluxo linear (shapes em sequência horizontal já conectados). Para fluxos com ramificações use figjam_create_shapes + figjam_create_connectors.',
+  {
+    steps: z.array(z.object({
+      label: z.string(),
+      shape: ShapeTypeEnum.optional(),
+      color: ColorEnum.optional(),
+    })).describe('Etapas do fluxo, da esquerda para a direita'),
+    x:   z.number().optional().describe('X inicial do primeiro shape'),
+    y:   z.number().optional().describe('Y comum a todos os shapes'),
+    gap: z.number().default(220).describe('Distância horizontal entre shapes'),
+  },
+  async ({ steps, x, y, gap }) => {
+    const result = await sendToPlugin('CREATE_FLOW', { steps, x, y, gap });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
+
+server.tool(
+  'figjam_set_connector_labels',
+  'Define ou atualiza rótulos em conectores existentes (ex.: Sim/Não em gateways BPMN).',
+  {
+    labels: z.array(z.object({
+      nodeId: z.string(),
+      label:  z.string(),
+    })).describe('Pares { nodeId, label } para conectores existentes'),
+  },
+  async ({ labels }) => {
+    const result = await sendToPlugin('SET_CONNECTOR_LABELS', { labels });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
+
+server.tool(
+  'figjam_move_nodes',
+  'Reposiciona nós existentes pelo ID.',
+  {
+    moves: z.array(z.object({
+      nodeId: z.string(),
+      x:      z.number(),
+      y:      z.number(),
+    })),
+  },
+  async ({ moves }) => {
+    const result = await sendToPlugin('MOVE_NODES', { moves });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
+
+server.tool(
+  'figjam_delete_nodes',
+  'Remove nós do canvas pelo ID.',
+  {
+    nodeIds: z.array(z.string()),
+  },
+  async ({ nodeIds }) => {
+    const result = await sendToPlugin('DELETE_NODES', { nodeIds });
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
+
+// Generic forwarder — lets new plugin operations be invoked without bridge updates.
+// Useful for evolving the plugin independently: any new op type added in code.ts
+// becomes immediately accessible via this tool.
+server.tool(
+  'figjam_execute',
+  'Encaminha uma operação arbitrária para o plugin (escape hatch para ops novas que ainda não têm tool dedicada). Tipos válidos atuais: PING, CREATE_STICKY, CREATE_STICKIES, CREATE_SECTION, CREATE_SHAPE, CREATE_SHAPES, CREATE_CONNECTOR, CREATE_CONNECTORS, CREATE_FLOW, SET_CONNECTOR_LABELS, MOVE_NODES, DELETE_NODES, READ_BOARD, GET_SELECTION.',
+  {
+    type:    z.string().describe('Nome da operação no plugin (ex.: CREATE_SHAPE)'),
+    payload: z.record(z.unknown()).optional().describe('Payload da operação'),
+  },
+  async ({ type, payload }) => {
+    const result = await sendToPlugin(type, payload ?? {});
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+  }
+);
 
 // ── Boot ──────────────────────────────────────────────────────────────────────
 
-function log(msg: string) {
-  process.stderr.write(`[IngresseFlow] ${msg}\n`);
+const existing = await detectExistingBridge();
+if (existing) {
+  mode = 'client';
+  log(`Bridge persistente detectada em :${HTTP_PORT} — operando em modo cliente.`);
+} else {
+  mode = 'server';
+  await startWebSocketBridge();
+  startCommandServer();
 }
 
-await startBridge();
-startCommandServer();
-
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/src/index.js

@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { WebSocketServer, WebSocket } from 'ws';
-import { createServer } from 'http';
-import { z } from 'zod';
-// ── WebSocket bridge ──────────────────────────────────────────────────────────
-let pluginSocket = null;
-const pending = new Map();
-function sendToPlugin(type, payload) {
-    return new Promise((resolve, reject) => {
-        if (!pluginSocket || pluginSocket.readyState !== WebSocket.OPEN) {
-            return reject(new Error('Plugin não conectado. Abra o IngresseFlow no Figma Desktop (FigJam).'));
-        }
-        const id = crypto.randomUUID();
-        const timer = setTimeout(() => {
-            pending.delete(id);
-            reject(new Error(`Timeout aguardando resposta para ${type}`));
-        }, 15000);
-        pending.set(id, {
-            resolve: (v) => { clearTimeout(timer); resolve(v); },
-            reject: (e) => { clearTimeout(timer); reject(e); },
-            timer,
-        });
-        pluginSocket.send(JSON.stringify({ id, type, payload }));
-    });
-}
-async function tryPort(port) {
-    return new Promise(resolve => {
-        const srv = createServer();
-        srv.once('error', () => resolve(false));
-        srv.listen(port, () => srv.close(() => resolve(true)));
-    });
-}
-async function startBridge() {
-    const BASE_PORT = 9243;
-    const MAX_PORT = 9250;
-    let port = BASE_PORT;
-    while (port <= MAX_PORT) {
-        if (await tryPort(port))
-            break;
-        port++;
-    }
-    if (port > MAX_PORT)
-        throw new Error('Nenhuma porta livre em 9243–9250');
-    const wss = new WebSocketServer({ port });
-    wss.on('connection', (ws) => {
-        pluginSocket = ws;
-        log(`Plugin conectado`);
-        ws.on('message', (raw) => {
-            try {
-                const msg = JSON.parse(raw.toString());
-                const p = pending.get(msg.id);
-                if (!p)
-                    return;
-                pending.delete(msg.id);
-                if (msg.success)
-                    p.resolve(msg.data);
-                else
-                    p.reject(new Error(msg.error ?? 'Erro desconhecido'));
-            }
-            catch (e) {
-                log(`Erro ao parsear mensagem: ${e}`);
-            }
-        });
-        ws.on('close', () => {
-            pluginSocket = null;
-            log(`Plugin desconectado`);
-        });
-    });
-    log(`Bridge escutando em ws://localhost:${port}`);
-    log(`Abra o plugin IngresseFlow no Figma Desktop para conectar`);
-    return port;
-}
-// ── MCP tools ─────────────────────────────────────────────────────────────────
-const ColorEnum = z.enum([
-    'YELLOW', 'BLUE', 'GREEN', 'PINK', 'ORANGE',
-    'PURPLE', 'RED', 'GRAY', 'LIGHT_GRAY',
-]);
-const server = new McpServer({ name: 'ingresseflow', version: '1.0.0' });
-server.tool('figjam_create_sticky', 'Cria um post-it no FigJam. Requer o plugin IngresseFlow aberto no Figma Desktop.', {
-    text: z.string().describe('Texto do post-it'),
-    color: ColorEnum.default('YELLOW').describe('Cor de fundo'),
-    x: z.number().optional().describe('Posição X no canvas'),
-    y: z.number().optional().describe('Posição Y no canvas'),
-}, async ({ text, color, x, y }) => {
-    const result = await sendToPlugin('CREATE_STICKY', { text, color, x, y });
-    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-});
-server.tool('figjam_create_stickies', 'Cria múltiplos post-its de uma vez no FigJam. Máximo 50 por chamada. Use para documentar análises completas.', {
-    stickies: z.array(z.object({
-        text: z.string(),
-        color: ColorEnum.default('YELLOW'),
-        x: z.number().optional(),
-        y: z.number().optional(),
-    })).max(50).describe('Lista de post-its para criar'),
-}, async ({ stickies }) => {
-    const result = await sendToPlugin('CREATE_STICKIES', { stickies });
-    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-});
-server.tool('figjam_read_board', 'Lê todo o conteúdo do FigJam atual. Retorna nós com texto, posição e tipo.', {}, async () => {
-    const result = await sendToPlugin('READ_BOARD', {});
-    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-});
-server.tool('figjam_get_selection', 'Retorna os nós atualmente selecionados no Figma.', {}, async () => {
-    const result = await sendToPlugin('GET_SELECTION', {});
-    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-});
-server.tool('figjam_create_section', 'Cria uma seção nomeada no FigJam para agrupar conteúdo.', {
-    name: z.string().describe('Nome da seção'),
-    x: z.number().optional().describe('Posição X'),
-    y: z.number().optional().describe('Posição Y'),
-    width: z.number().default(900).describe('Largura em px'),
-    height: z.number().default(700).describe('Altura em px'),
-}, async ({ name, x, y, width, height }) => {
-    const result = await sendToPlugin('CREATE_SECTION', { name, x, y, width, height });
-    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-});
-// ── Boot ──────────────────────────────────────────────────────────────────────
-function log(msg) {
-    process.stderr.write(`[IngresseFlow] ${msg}\n`);
-}
-await startBridge();
-const transport = new StdioServerTransport();
-await server.connect(transport);