@deerdesign/deertools 1.2.27 → 1.2.32

package/src/rendermind/client.js

@@ -0,0 +1,393 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const credentials = require('../credentials');
+const { getProduct } = require('../registry');
+
+const RENDERMIND_API_BASE = 'https://lkljsuptgyktkwojnwbu.supabase.co/functions/v1/rendermind-api';
+const CATALOG_API_BASE = 'https://ftzaobeixglnssemugjf.supabase.co/functions/v1/api-gateway';
+const CATALOG_MCP_URL = 'https://ftzaobeixglnssemugjf.supabase.co/functions/v1/catalog-mcp';
+const RENDERMIND_STORAGE_PREFIX = 'https://lkljsuptgyktkwojnwbu.supabase.co/storage/v1/object/public/ai-visualizations/';
+
+function getRenderMindKey() {
+  const p = getProduct('rendermind');
+  const cred = credentials.getKey(p);
+  if (cred && cred.key) return cred.key;
+  if (process.env.RENDERMIND_API_KEY) return process.env.RENDERMIND_API_KEY;
+  if (process.env.DEERTOOLS_RENDERMIND_KEY) return process.env.DEERTOOLS_RENDERMIND_KEY;
+  return null;
+}
+
+function getCatalogKey() {
+  const p = getProduct('catalog');
+  const cred = credentials.getKey(p);
+  if (cred && cred.key) return cred.key;
+  if (process.env.DEERTOOLS_CATALOG_KEY) return process.env.DEERTOOLS_CATALOG_KEY;
+  return null;
+}
+
+function ensureRenderMindAuth() {
+  const key = getRenderMindKey();
+  if (!key) {
+    throw new Error('Brak klucza API do RenderMind. Zaloguj się poleceniem: deertools login rendermind --rw');
+  }
+  return key;
+}
+
+async function callCatalogMcp(toolName, args) {
+  const catKey = getCatalogKey();
+  if (!catKey) return null;
+  try {
+    const res = await fetch(CATALOG_MCP_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': catKey,
+        'Authorization': `Bearer ${catKey}`,
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: { name: toolName, arguments: args },
+      }),
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    const text = json?.result?.content?.[0]?.text;
+    if (!text) return null;
+    return JSON.parse(text);
+  } catch (_) {
+    return null;
+  }
+}
+
+async function lookupProductBySku(skuOrUrl) {
+  if (!skuOrUrl) return null;
+  const raw = String(skuOrUrl).trim();
+  const catKey = getCatalogKey();
+  const headers = { 'Accept': 'application/json' };
+  if (catKey) headers['x-api-key'] = catKey;
+
+  // 1. Sprawdź czy to URL produktu lub slug z Katalogu Connect
+  const isUrl = /^https?:\/\//i.test(raw) || raw.includes('/katalog/product/');
+  if (isUrl) {
+    const slugMatch = raw.match(/\/product\/([^/?#]+)/i);
+    const slug = slugMatch ? slugMatch[1] : raw;
+    const extMatch = slug.match(/-(\d{5,})$/);
+    const extId = extMatch ? extMatch[1] : null;
+    const words = slug
+      .replace(/-\d{5,}$/, '')
+      .split('-')
+      .filter((w) => w.length >= 3)
+      .slice(0, 4)
+      .join(' ');
+
+    try {
+      const searchQ = words || extId || slug;
+      const res = await fetch(`${CATALOG_API_BASE}/products?search=${encodeURIComponent(searchQ)}&active=all&limit=25`, { headers });
+      if (res.ok) {
+        const data = await res.json();
+        const list = data?.data || data?.items || [];
+        const matched = list.find((p) => p.slug === slug || (extId && String(p.external_id) === extId)) || list[0];
+        if (matched && matched.id) {
+          const full = await callCatalogMcp('catalog_get_product', { id: matched.id });
+          return full || matched;
+        }
+      }
+    } catch (_) {}
+  }
+
+  // 2. Spróbuj bezpośrednio przez catalog_get_product po SKU
+  const direct = await callCatalogMcp('catalog_get_product', { sku: raw });
+  if (direct && (direct.id || direct.sku)) return direct;
+
+  if (raw.includes('|')) {
+    const firstPart = raw.split('|')[0].trim();
+    const partDirect = await callCatalogMcp('catalog_get_product', { sku: firstPart });
+    if (partDirect && (partDirect.id || partDirect.sku)) return partDirect;
+  }
+
+  // 3. Fallback: wyszukiwanie przez search=...&active=all
+  try {
+    const q = raw.includes('|') ? raw.split('|')[0].trim() : raw;
+    const res = await fetch(`${CATALOG_API_BASE}/products?search=${encodeURIComponent(q)}&active=all&limit=10`, { headers });
+    if (res.ok) {
+      const data = await res.json();
+      const list = data?.data || data?.items || [];
+      const exact = list.find((p) => p.sku === raw || p.sku === q || String(p.external_id) === q) || list[0];
+      if (exact) return exact;
+    }
+  } catch (_) {}
+
+  return null;
+}
+
+async function uploadImage({ filePath, buffer, fileName, contentType }) {
+  const apiKey = ensureRenderMindAuth();
+  let bytes;
+  let finalFileName = fileName;
+  let finalContentType = contentType;
+
+  if (filePath) {
+    if (!fs.existsSync(filePath)) throw new Error(`Plik nie istnieje: ${filePath}`);
+    bytes = fs.readFileSync(filePath);
+    if (!finalFileName) finalFileName = path.basename(filePath);
+    if (!finalContentType) {
+      const ext = path.extname(filePath).toLowerCase();
+      if (ext === '.jpg' || ext === '.jpeg') finalContentType = 'image/jpeg';
+      else if (ext === '.png') finalContentType = 'image/png';
+      else if (ext === '.webp') finalContentType = 'image/webp';
+      else finalContentType = 'image/png';
+    }
+  } else if (buffer) {
+    bytes = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+    if (!finalFileName) finalFileName = 'upload.png';
+    if (!finalContentType) finalContentType = 'image/png';
+  } else {
+    throw new Error('Wymagany parametr: filePath lub buffer');
+  }
+
+  // 1. Zgłoszenie żądania podpisanego URL-a uploadu
+  const uploadRes = await fetch(`${RENDERMIND_API_BASE}/uploads`, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      file_name: finalFileName,
+      content_type: finalContentType,
+      size_bytes: bytes.length
+    })
+  });
+
+  const uploadData = await uploadRes.json();
+  if (!uploadRes.ok) {
+    throw new Error(`Błąd pobierania upload URL (${uploadRes.status}): ${uploadData.error || JSON.stringify(uploadData)}`);
+  }
+
+  // 2. Wgranie bajtów pod podpisany adres Supabase Storage
+  const putRes = await fetch(uploadData.upload_url, {
+    method: 'PUT',
+    headers: { 'Content-Type': finalContentType },
+    body: bytes
+  });
+
+  if (!putRes.ok) {
+    throw new Error(`Błąd zapisu pliku do storage (${putRes.status}): ${putRes.statusText}`);
+  }
+
+  return {
+    public_url: uploadData.public_url,
+    path: uploadData.path,
+    size_bytes: bytes.length,
+    file_name: finalFileName
+  };
+}
+
+async function ensureOwnedRenderMindUrl(url) {
+  if (!url) return null;
+  if (url.startsWith(RENDERMIND_STORAGE_PREFIX)) return url;
+
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Nie udało się pobrać obrazu źródłowego z URL (${res.status}): ${url}`);
+  }
+  const contentTypeHeader = (res.headers.get('content-type') || '').split(';')[0].trim().toLowerCase();
+  let contentType = 'image/jpeg';
+  let ext = '.jpg';
+  if (contentTypeHeader === 'image/png' || url.toLowerCase().endsWith('.png')) {
+    contentType = 'image/png';
+    ext = '.png';
+  } else if (contentTypeHeader === 'image/webp' || url.toLowerCase().endsWith('.webp')) {
+    contentType = 'image/webp';
+    ext = '.webp';
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  const uploaded = await uploadImage({
+    buffer: buf,
+    fileName: `product_ref${ext}`,
+    contentType,
+  });
+  return uploaded.public_url;
+}
+
+async function createVisualization({ prompt, imageUrls = [], imagePath = null, sku = null, productUrl = null, kind = 'photo' }) {
+  const apiKey = ensureRenderMindAuth();
+  let rawUrls = [...(imageUrls || [])];
+
+  if (imagePath && rawUrls.length === 0) {
+    const uploadRes = await uploadImage({ filePath: imagePath });
+    rawUrls.push(uploadRes.public_url);
+  }
+
+  let enrichedPrompt = prompt || '';
+  let productInfo = null;
+  const lookupQuery = sku || productUrl;
+
+  if (lookupQuery) {
+    productInfo = await lookupProductBySku(lookupQuery);
+    if (productInfo) {
+      const details = [];
+      if (productInfo.name) details.push(`Produkt: ${productInfo.name}`);
+      if (productInfo.features && Object.keys(productInfo.features).length) {
+        details.push(`Cechy: ${JSON.stringify(productInfo.features)}`);
+      }
+      if (productInfo.tags && Array.isArray(productInfo.tags)) {
+        const pkg = productInfo.tags.find((t) => ['SMART', 'MODERN', 'HIGH'].includes(String(t).toUpperCase()));
+        if (pkg) details.push(`Pakiet: ${pkg}`);
+      } else if (productInfo.finish_package) {
+        details.push(`Pakiet: ${productInfo.finish_package}`);
+      }
+      const resolvedSku = productInfo.sku || sku || '';
+      enrichedPrompt = `${enrichedPrompt ? enrichedPrompt + '. ' : ''}Użyj i wiernie odwzoruj produkt w aranżacji wnętrza [SKU: ${resolvedSku}]: ${details.join(', ')}. Zachowaj geometrię, proporcje, wykończenie i detale materiałowe.`;
+
+      // Jeśli nie podano żadnego obrazu, automatycznie użyj zdjęcia referencyjnego produktu z Katalogu Connect
+      if (rawUrls.length === 0 && Array.isArray(productInfo.images) && productInfo.images.length > 0) {
+        const preferredImg = productInfo.images.find((u) => u.includes('/mirror/')) || productInfo.images[0];
+        rawUrls.push(preferredImg);
+      }
+    }
+  }
+
+  if (rawUrls.length === 0) {
+    throw new Error('RenderMind wymaga co najmniej jednego obrazu bazowego (parametr image_path, image_url lub sku/product_url produktu ze zdjęciem w Katalogu Connect).');
+  }
+
+  // Upewnij się, że każdy obraz znajduje się w autoryzowanym buckecie RenderMind
+  const finalUrls = [];
+  for (const u of rawUrls.slice(0, 1)) {
+    const ownedUrl = await ensureOwnedRenderMindUrl(u);
+    if (ownedUrl) finalUrls.push(ownedUrl);
+  }
+
+  const res = await fetch(`${RENDERMIND_API_BASE}/visualizations`, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      image_urls: finalUrls,
+      prompt: enrichedPrompt,
+      kind: kind || 'photo'
+    })
+  });
+
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`Błąd tworzenia wizualizacji (${res.status}): ${data.error || JSON.stringify(data)}`);
+  }
+
+  return {
+    job_id: data.job_id,
+    conversation_id: data.conversation_id,
+    prompt: enrichedPrompt,
+    input_image_urls: finalUrls,
+    product: productInfo ? {
+      id: productInfo.id,
+      sku: productInfo.sku || sku,
+      name: productInfo.name,
+      url: productInfo.url,
+      images: productInfo.images
+    } : null
+  };
+}
+
+async function getVisualization(jobId) {
+  const apiKey = ensureRenderMindAuth();
+  const res = await fetch(`${RENDERMIND_API_BASE}/visualizations/${jobId}`, {
+    headers: { 'x-api-key': apiKey }
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`Błąd pobierania statusu wizualizacji (${res.status}): ${data.error || JSON.stringify(data)}`);
+  }
+  return data;
+}
+
+async function getMe() {
+  const apiKey = ensureRenderMindAuth();
+  const res = await fetch(`${RENDERMIND_API_BASE}/me`, {
+    headers: { 'x-api-key': apiKey }
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`Błąd sprawdzania uprawnień RenderMind (${res.status}): ${data.error || JSON.stringify(data)}`);
+  }
+  return data;
+}
+
+async function pollVisualization(jobId, { timeoutMs = 180000, intervalMs = 2500, onProgress = null } = {}) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    const data = await getVisualization(jobId);
+    if (onProgress) onProgress(data);
+    if (data.status === 'done' || data.status === 'completed') {
+      return {
+        success: true,
+        job_id: data.job_id,
+        conversation_id: data.conversation_id,
+        status: 'completed',
+        image_urls: data.output_image_urls || [],
+        error: null
+      };
+    }
+    if (data.status === 'failed' || data.error) {
+      return {
+        success: false,
+        job_id: data.job_id,
+        status: 'failed',
+        error: data.error || 'Nieznany błąd silnika generowania wizualizacji'
+      };
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  throw new Error(`Upłynął limit czasu (${Math.round(timeoutMs / 1000)}s) na ukończenie wizualizacji.`);
+}
+
+async function estimateFloorPlan({ fileUrl, filePath, rooms, kitchenOpenAreaM2 = 6 }) {
+  const apiKey = ensureRenderMindAuth();
+  let finalFileUrl = fileUrl;
+
+  if (filePath && !finalFileUrl) {
+    const uploadRes = await uploadImage({ filePath });
+    finalFileUrl = uploadRes.public_url;
+  }
+
+  const payload = {
+    kitchen_open_area_m2: kitchenOpenAreaM2
+  };
+  if (finalFileUrl) payload.file_url = finalFileUrl;
+  if (rooms && Array.isArray(rooms)) payload.rooms = rooms;
+
+  const res = await fetch(`${RENDERMIND_API_BASE}/floor-plan-estimates`, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(payload)
+  });
+
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`Błąd szacowania rzutu (${res.status}): ${data.error || JSON.stringify(data)}`);
+  }
+  return data;
+}
+
+module.exports = {
+  getRenderMindKey,
+  getCatalogKey,
+  ensureRenderMindAuth,
+  lookupProductBySku,
+  uploadImage,
+  ensureOwnedRenderMindUrl,
+  createVisualization,
+  getVisualization,
+  getMe,
+  pollVisualization,
+  estimateFloorPlan
+};

package/src/rendermind/mcp-server.js

@@ -0,0 +1,305 @@
+'use strict';
+const readline = require('readline');
+const client = require('./client');
+
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER_INFO = { name: 'deer-rendermind-mcp', version: '1.1.0' };
+
+const RENDERMIND_TOOLS = [
+  {
+    name: 'rendermind_create_visualization',
+    description: 'Generuje fotorealistyczną wizualizację wnętrza w RenderMind Deer Design. Przyjmuje kod SKU lub link do produktu z Katalogu Connect, opcjonalną ścieżkę lokalną do szkicu/rzutu lub adres URL oraz prompt stylistyczny. Automatycznie dociąga specyfikację i zdjęcie produktu z Katalogu Connect, wgrywa obraz do bucketu RenderMind i oczekuje na ukończenie renderu.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        prompt: {
+          type: 'string',
+          description: 'Opis stylu wnętrza, oświetlenia, kolorystyki, np. "Elegancka łazienka w pakiecie High Life, płytki wielkoformatowe trawertyn, armatura złoty szczotkowany, ciepłe światło 3000K".'
+        },
+        sku: {
+          type: 'string',
+          description: 'Kod SKU produktu z bazy Katalog Connect (np. A5D186ENB0, NAC_09LP, BQA_R40M|NQA_R51K) lub URL produktu. Narzędzie automatycznie pobierze specyfikację i zdjęcie produktu z Katalogu Connect.'
+        },
+        product_url: {
+          type: 'string',
+          description: 'Opcjonalny pełny adres URL karty produktu z Katalogu Connect (np. https://connect.deerdesign.pl/katalog/product/...).'
+        },
+        image_path: {
+          type: 'string',
+          description: 'Opcjonalna lokalna ścieżka do pliku rzutu, szkicu pCon lub zdjęcia referencyjnego (jeśli brak, zostanie użyte zdjęcie produktu z Katalogu Connect dla podanego SKU).'
+        },
+        image_url: {
+          type: 'string',
+          description: 'Opcjonalny adres URL do obrazu bazowego (jeśli pochodzi spoza RenderMind, zostanie automatycznie pobrany i wgrany do bucketu RenderMind).'
+        },
+        kind: {
+          type: 'string',
+          enum: ['pcon', 'photo'],
+          default: 'photo',
+          description: 'Typ wejścia: "pcon" dla szkicu technicznego CAD/pCon, "photo" dla zdjęcia lub rzutu.'
+        },
+        wait: {
+          type: 'boolean',
+          default: true,
+          description: 'Czy czekać na wygenerowanie gotowego renderu (domyślnie true).'
+        }
+      },
+      required: ['prompt']
+    }
+  },
+  {
+    name: 'rendermind_get_visualization',
+    description: 'Pobiera aktualny status zadania wizualizacji w RenderMind po identyfikatorze job_id.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        job_id: {
+          type: 'string',
+          description: 'Identyfikator zadania wizualizacji (UUID).'
+        }
+      },
+      required: ['job_id']
+    }
+  },
+  {
+    name: 'rendermind_upload_image',
+    description: 'Wgrywa lokalny plik graficzny (PNG, JPG, WEBP) do dedykowanego magazynu RenderMind i zwraca publiczny URL do użycia w wizualizacjach i wycenach.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_path: {
+          type: 'string',
+          description: 'Bezwzględna lub względna ścieżka do lokalnego pliku obrazu.'
+        }
+      },
+      required: ['file_path']
+    }
+  },
+  {
+    name: 'rendermind_floor_plan_estimate',
+    description: 'Szacuje zestawienie powierzchni i koszty wykończenia mieszkania z rzutu architektonicznego lub listy pomieszczeń w RenderMind.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        image_path: {
+          type: 'string',
+          description: 'Ścieżka do pliku rzutu architektonicznego na dysku.'
+        },
+        file_url: {
+          type: 'string',
+          description: 'Publiczny URL do pliku rzutu.'
+        },
+        kitchen_open_area_m2: {
+          type: 'number',
+          default: 6,
+          description: 'Szacowany metraż otwartego aneksu kuchennego w m2 (domyślnie 6 m2).'
+        },
+        rooms: {
+          type: 'array',
+          description: 'Opcjonalna lista pomieszczeń z metrażami.',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              area_m2: { type: 'number' },
+              perimeter_m: { type: 'number' }
+            },
+            required: ['name', 'area_m2']
+          }
+        }
+      }
+    }
+  }
+];
+
+async function handleMcpMessage(msg) {
+  if (!msg || typeof msg !== 'object') return null;
+  const { id, method, params } = msg;
+
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO
+      }
+    };
+  }
+
+  if (method === 'notifications/initialized' || method === 'initialized') {
+    return null;
+  }
+
+  if (method === 'ping') {
+    return { jsonrpc: '2.0', id, result: {} };
+  }
+
+  if (method === 'tools/list') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        tools: RENDERMIND_TOOLS
+      }
+    };
+  }
+
+  if (method === 'tools/call') {
+    const toolName = params?.name;
+    const args = params?.arguments || {};
+
+    try {
+      if (toolName === 'rendermind_create_visualization') {
+        const imageUrls = [];
+        if (args.image_url) imageUrls.push(args.image_url);
+
+        const initRes = await client.createVisualization({
+          prompt: args.prompt,
+          imageUrls,
+          imagePath: args.image_path,
+          sku: args.sku,
+          productUrl: args.product_url,
+          kind: args.kind || 'photo'
+        });
+
+        if (args.wait === false) {
+          return {
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  status: 'running',
+                  job_id: initRes.job_id,
+                  conversation_id: initRes.conversation_id,
+                  prompt: initRes.prompt,
+                  product: initRes.product
+                }, null, 2)
+              }]
+            }
+          };
+        }
+
+        const pollRes = await client.pollVisualization(initRes.job_id, {
+          timeoutMs: 180000,
+          intervalMs: 2500
+        });
+
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                status: pollRes.status,
+                job_id: pollRes.job_id,
+                conversation_id: pollRes.conversation_id,
+                image_urls: pollRes.image_urls,
+                prompt: initRes.prompt,
+                product: initRes.product
+              }, null, 2)
+            }]
+          }
+        };
+      }
+
+      if (toolName === 'rendermind_get_visualization') {
+        const data = await client.getVisualization(args.job_id);
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }]
+          }
+        };
+      }
+
+      if (toolName === 'rendermind_upload_image') {
+        const data = await client.uploadImage({ filePath: args.file_path });
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }]
+          }
+        };
+      }
+
+      if (toolName === 'rendermind_floor_plan_estimate') {
+        const data = await client.estimateFloorPlan({
+          filePath: args.image_path,
+          fileUrl: args.file_url,
+          rooms: args.rooms,
+          kitchenOpenAreaM2: args.kitchen_open_area_m2
+        });
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }]
+          }
+        };
+      }
+
+      return {
+        jsonrpc: '2.0',
+        id,
+        error: { code: -32601, message: `Nieznane narzędzie: ${toolName}` }
+      };
+    } catch (e) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        error: { code: -32000, message: e.message }
+      };
+    }
+  }
+
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: { code: -32601, message: `Nieobsługiwana metoda: ${method}` }
+  };
+}
+
+function runRenderMindMcpServer() {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+
+    rl.on('line', async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const msg = JSON.parse(trimmed);
+        const resp = await handleMcpMessage(msg);
+        if (resp) {
+          process.stdout.write(JSON.stringify(resp) + '\n');
+        }
+      } catch (e) {
+        process.stdout.write(JSON.stringify({
+          jsonrpc: '2.0',
+          id: null,
+          error: { code: -32700, message: `Parse error: ${e.message}` }
+        }) + '\n');
+      }
+    });
+
+    rl.on('close', () => resolve());
+    process.on('SIGINT', () => { rl.close(); resolve(); });
+    process.on('SIGTERM', () => { rl.close(); resolve(); });
+  });
+}
+
+module.exports = {
+  RENDERMIND_TOOLS,
+  handleMcpMessage,
+  runRenderMindMcpServer
+};