@deerdesign/deertools 1.0.3 → 1.2.0

package/src/baselinker/crawler.js

@@ -0,0 +1,157 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { homeDir } = require('../credentials');
+
+const CACHE_FILE = path.join(__dirname, 'schema-cache.json');
+const USER_CACHE_FILE = path.join(homeDir(), 'baselinker-schema.json');
+const INDEX_FILE = path.join(__dirname, 'methods-index.json');
+
+function loadSchemas() {
+  if (fs.existsSync(USER_CACHE_FILE)) {
+    try {
+      return JSON.parse(fs.readFileSync(USER_CACHE_FILE, 'utf8'));
+    } catch (_) {}
+  }
+  if (fs.existsSync(CACHE_FILE)) {
+    try {
+      return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+    } catch (_) {}
+  }
+  if (fs.existsSync(INDEX_FILE)) {
+    try {
+      return JSON.parse(fs.readFileSync(INDEX_FILE, 'utf8'));
+    } catch (_) {}
+  }
+  return {};
+}
+
+function parseType(rawType) {
+  const t = (rawType || '').toLowerCase();
+  if (t.includes('int')) return 'integer';
+  if (t.includes('bool')) return 'boolean';
+  if (t.includes('float') || t.includes('decimal')) return 'number';
+  if (t.includes('array')) return 'array';
+  return 'string';
+}
+
+async function fetchMethodDetails(methodName) {
+  try {
+    const res = await fetch(`https://api.baselinker.com/index.php?method=${methodName}`);
+    if (!res.ok) return null;
+    const html = await res.text();
+    const tableMatch = html.match(/<div class=[\'\"]header[\'\"]>\s*Input parameters\s*<\/div>\s*<table class=[\'\"]table[\'\"]>(.*?)<\/table>/s);
+    if (!tableMatch) return { properties: {}, required: [] };
+
+    const rows = [...tableMatch[1].matchAll(/<tr><td[^>]*><B>(.*?)<\/B><\/td><td>(.*?)<\/td><td>(.*?)<\/td><\/tr>/gs)];
+    const properties = {};
+    const required = [];
+
+    for (const r of rows) {
+      const name = r[1].replace(/<[^>]+>/g, '').trim();
+      const rawType = r[2].replace(/<[^>]+>/g, '').trim();
+      const desc = r[3].replace(/<[^>]+>/g, '').trim();
+      const isOptional = desc.toLowerCase().includes('optional');
+
+      properties[name] = {
+        type: parseType(rawType),
+        description: desc
+      };
+      if (!isOptional && !name.includes('|')) {
+        required.push(name);
+      }
+    }
+    return { properties, required };
+  } catch (err) {
+    return null;
+  }
+}
+
+async function syncSchema(onProgress = null) {
+  const res = await fetch('https://api.baselinker.com/');
+  const html = await res.text();
+
+  const sections = html.split(/<div class=[\'\"]header[\'\"]>/i);
+  const catalog = {};
+
+  for (let i = 1; i < sections.length; i++) {
+    const sec = sections[i];
+    const titleEnd = sec.indexOf('</div>');
+    if (titleEnd === -1) continue;
+    const categoryName = sec.substring(0, titleEnd).trim();
+    const re = /method=([a-zA-Z0-9_]+)[\'\"]>([a-zA-Z0-9_]+)<\/B><\/a><\/td><td>(.*?)<\/td>/g;
+    let m;
+    while ((m = re.exec(sec)) !== null) {
+      const methodName = m[1];
+      const desc = m[3].replace(/<[^>]+>/g, '').trim();
+      catalog[methodName] = {
+        name: methodName,
+        category: categoryName,
+        description: desc,
+        parameters: {}
+      };
+    }
+  }
+
+  const methodNames = Object.keys(catalog);
+  let done = 0;
+  const concurrency = 6;
+  const queue = [...methodNames];
+
+  async function worker() {
+    while (queue.length > 0) {
+      const m = queue.shift();
+      const schema = await fetchMethodDetails(m);
+      if (schema) {
+        catalog[m].parameters = schema.properties;
+        catalog[m].required = schema.required;
+      }
+      done++;
+      if (onProgress) onProgress(done, methodNames.length, m);
+    }
+  }
+
+  const workers = Array.from({ length: concurrency }, () => worker());
+  await Promise.all(workers);
+
+  const dir = homeDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(USER_CACHE_FILE, JSON.stringify(catalog, null, 2));
+
+  return catalog;
+}
+
+function searchMethods(query, category = null) {
+  const schemas = loadSchemas();
+  const q = (query || '').toLowerCase().trim();
+  const cat = (category || '').toLowerCase().trim();
+
+  return Object.values(schemas).filter(item => {
+    if (cat && !item.category.toLowerCase().includes(cat)) return false;
+    const hasParam = item.parameters && Object.keys(item.parameters).some(p => p.toLowerCase().includes(q));
+    return (
+      item.name.toLowerCase().includes(q) ||
+      (item.description && item.description.toLowerCase().includes(q)) ||
+      (item.category && item.category.toLowerCase().includes(q)) ||
+      hasParam
+    );
+  });
+}
+
+function getMethodSchema(methodName) {
+  const schemas = loadSchemas();
+  return schemas[methodName] || null;
+}
+
+function getAllCatalogMethods() {
+  const schemas = loadSchemas();
+  return Object.values(schemas).filter(s => s.category === 'Product catalog');
+}
+
+module.exports = {
+  loadSchemas,
+  syncSchema,
+  searchMethods,
+  getMethodSchema,
+  getAllCatalogMethods
+};

package/src/baselinker/index.js

@@ -0,0 +1,24 @@
+'use strict';
+const { BaseLinkerClient, getClient } = require('./client');
+const { CATALOG_MCP_TOOLS, handleCatalogToolCall } = require('./catalog-tools');
+const { buildToolsList, handleMcpMessage, runBaseLinkerMcpServer } = require('./mcp-server');
+const { startBaseLinkerServer } = require('./ui');
+const { loadSchemas, syncSchema, searchMethods, getMethodSchema, getAllCatalogMethods } = require('./crawler');
+const { loginBaseLinkerBrowser } = require('./browser-login');
+
+module.exports = {
+  BaseLinkerClient,
+  getClient,
+  CATALOG_MCP_TOOLS,
+  handleCatalogToolCall,
+  buildToolsList,
+  handleMcpMessage,
+  runBaseLinkerMcpServer,
+  startBaseLinkerServer,
+  loadSchemas,
+  syncSchema,
+  searchMethods,
+  getMethodSchema,
+  getAllCatalogMethods,
+  loginBaseLinkerBrowser
+};

package/src/baselinker/mcp-server.js

@@ -0,0 +1,153 @@
+'use strict';
+const readline = require('readline');
+const { CATALOG_MCP_TOOLS, handleCatalogToolCall } = require('./catalog-tools');
+const { getClient } = require('./client');
+const { getAllCatalogMethods, getMethodSchema, loadSchemas } = require('./crawler');
+
+function buildToolsList(mode = 'catalog') {
+  if (mode === 'all') {
+    const all = loadSchemas();
+    const tools = [...CATALOG_MCP_TOOLS];
+    for (const [name, def] of Object.entries(all)) {
+      if (tools.some(t => t.name === `bl_${name}` || t.name === name)) continue;
+      tools.push({
+        name: `bl_${name}`,
+        description: def.description || `Metoda BaseLinker ${name} (${def.category})`,
+        inputSchema: {
+          type: 'object',
+          properties: def.parameters || {},
+          required: def.required || []
+        }
+      });
+    }
+    return tools;
+  }
+  return CATALOG_MCP_TOOLS;
+}
+
+async function handleMcpMessage(msg, client = null, mode = 'catalog') {
+  if (!msg || typeof msg !== 'object') return null;
+  const { id, method, params } = msg;
+
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: {
+          name: 'deer-baselinker-mcp',
+          version: '1.0.0'
+        }
+      }
+    };
+  }
+
+  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: buildToolsList(mode)
+      }
+    };
+  }
+
+  if (method === 'tools/call') {
+    const { name, arguments: args } = params || {};
+    try {
+      let resultData;
+      if (name.startsWith('bl_catalog_') || name === 'bl_search_methods' || name === 'bl_call_api') {
+        resultData = await handleCatalogToolCall(name, args || {}, client);
+      } else if (name.startsWith('bl_') || loadSchemas()[name]) {
+        const rawMethod = name.startsWith('bl_') ? name.slice(3) : name;
+        const bl = client || getClient();
+        resultData = await bl.call(rawMethod, args || {});
+      } else {
+        throw new Error(`Nieznane narzędzie: ${name}`);
+      }
+
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(resultData, null, 2)
+            }
+          ]
+        }
+      };
+    } catch (err) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        isError: true,
+        result: {
+          content: [
+            {
+              type: 'text',
+              text: `Błąd wykonania ${name}: ${err.message}`
+            }
+          ]
+        }
+      };
+    }
+  }
+
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: {
+      code: -32601,
+      message: `Nieznana metoda: ${method}`
+    }
+  };
+}
+
+function runBaseLinkerMcpServer(options = {}) {
+  const { mode = 'catalog' } = options;
+  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 res = await handleMcpMessage(msg, null, mode);
+      if (res) {
+        process.stdout.write(JSON.stringify(res) + '\n');
+      }
+    } catch (err) {
+      const errRes = {
+        jsonrpc: '2.0',
+        id: null,
+        error: { code: -32700, message: 'Parse error: ' + err.message }
+      };
+      process.stdout.write(JSON.stringify(errRes) + '\n');
+    }
+  });
+
+  process.on('SIGINT', () => process.exit(0));
+  process.on('SIGTERM', () => process.exit(0));
+}
+
+module.exports = {
+  buildToolsList,
+  handleMcpMessage,
+  runBaseLinkerMcpServer
+};