@deerdesign/deertools 1.2.32 → 1.2.34

package/README.md

@@ -179,12 +179,103 @@ deertools team create "Interior Designers" --slug designers # Create new organiz
 
 # 9. AI Agent MCP Registry & Configuration:
 deertools mcp list                           # List available MCP servers across the ecosystem
-deertools mcp config                         # Generate Remote MCP JSON config for Cursor, Claude, Antigravity
-deertools mcp install                        # Automatically write MCP config to local AI agents
+deertools mcp config                         # Print JSON MCP configuration for manual pasting
+deertools mcp install                        # Automatically write & update MCP config across ALL 7 agent targets
+deertools doctor                             # Verify MCP connectivity, auth tokens and client config files
 ```
 
 ---
 
+## AI Agent MCP Configuration & Tooling (Cursor, Antigravity, Claude)
+
+`@deerdesign/deertools` provides 7 official MCP servers covering the complete Deer Design ecosystem:
+1. `deer-estimate`: Floor plan PDF analysis, kitchen detection, interior cost calculations.
+2. `deer-catalog`: 17k+ finishing materials (Smart/Modern/High Life), technical specs, filtering.
+3. `deer-deliveries`: Site delivery tracking, supplier shipments, warehouse WZ generation.
+4. `deer-supplier`: Supplier orders, purchase discounts, sales markups, commercial terms.
+5. `deer-rendermind`: Interior rendering, pCon CAD visualization, product photorealistic renders.
+6. `deer-baselinker`: Full BaseLinker catalog CRUD, pricing batch updates, Smart Cache.
+7. `deer-skills`: DeerSkills Hub registry, skill search, download, and review pipelines.
+
+### 1. Automatic Zero-Config Setup (Recommended)
+
+You don't need to manually edit JSON files. Simply log in or run:
+
+```bash
+deertools login all    # Automatically logs in and syncs MCP configs across all clients
+# or at any time:
+deertools mcp install  # Re-generates and writes configuration to all 7 targets
+```
+
+`deertools mcp install` automatically discovers and writes to all 7 supported AI environments:
+
+| Target Environment | Configuration Path | Supported Tools |
+| :--- | :--- | :--- |
+| **Workspace Standard** | `<project-root>/.mcp.json` | Claude Code, Claude Desktop Cowork, Windsurf, Zed |
+| **Claude Desktop (macOS)** | `~/Library/Application Support/Claude/claude_desktop_config.json` | Claude Desktop native MCP |
+| **Claude Code CLI** | `~/.claude.json` | Claude Code terminal assistant |
+| **Cursor IDE (Global)** | `~/.cursor/mcp.json` | Cursor Agent & Composer |
+| **Cursor Workspace** | `<project-root>/.cursor/mcp.json` | Cursor project-scoped |
+| **Antigravity Workspace** | `<project-root>/.agents/mcp_config.json` | Google Antigravity / Gemini Agent |
+| **Antigravity Global** | `~/.gemini/config/mcp_config.json` | Google Antigravity global profile |
+
+Verify all clients at any time with:
+```bash
+deertools doctor
+```
+
+---
+
+### 2. Manual Configuration & Claude Integration Details
+
+If configuring manually or adding to existing setups:
+
+#### A. Project-level `.mcp.json` (Recommended for Claude Code & Cowork)
+Create or edit `.mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "deer-rendermind": {
+      "command": "/Users/<your-user>/.local/bin/deertools",
+      "args": ["rendermind", "mcp"],
+      "env": {
+        "PATH": "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Users/<your-user>/.local/bin"
+      }
+    },
+    "deer-baselinker": {
+      "command": "/Users/<your-user>/.local/bin/deertools",
+      "args": ["baselinker", "mcp"],
+      "env": {
+        "PATH": "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Users/<your-user>/.local/bin"
+      }
+    },
+    "deer-catalog": {
+      "url": "https://ftzaobeixglnssemugjf.supabase.co/functions/v1/catalog-mcp",
+      "headers": {
+        "x-api-key": "<your-catalog-key>",
+        "Authorization": "Bearer <your-catalog-key>"
+      }
+    },
+    "deer-estimate": {
+      "url": "https://vlemuxlubrowuuxpgllk.supabase.co/functions/v1/estimate-mcp",
+      "headers": {
+        "x-api-key": "<your-estimate-key>",
+        "Authorization": "Bearer <your-estimate-key>"
+      }
+    }
+  }
+}
+```
+
+> [!IMPORTANT]
+> **Key Rules for Claude Desktop & Claude Code:**
+> 1. **PATH Inheritance on macOS**: Desktop GUI applications (like Claude Desktop) do NOT inherit your terminal's shell `$PATH` (`~/.local/bin`, `/usr/local/bin`). Always specify the absolute binary path (e.g. `~/.local/bin/deertools`) and include the `env.PATH` block as shown above so `node` and child processes can be spawned without errors.
+> 2. **Project Trust Dialog**: When opening a workspace with a project-level `.mcp.json`, Claude displays a security consent prompt (*"Allow MCP servers from .mcp.json?"*). You must click **Allow / Always Allow** to activate the tools.
+> 3. **Session Restart Required**: MCP server tools are registered strictly when a conversation session is initialized. If you configure MCP while a session is already active, start a **New Chat (`Cmd + N`)** or restart the Claude application (`Cmd + Q`). MCP tools cannot be hot-reloaded into an ongoing conversation.
+
+---
+
 ## BaseLinker MCP Proxy & Catalog Management
 
 `@deerdesign/deertools` includes a built-in, local **BaseLinker MCP Proxy & Hub** providing deep catalog management:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deerdesign/deertools",
-  "version": "1.2.32",
+  "version": "1.2.34",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/src/baselinker/cache.js

@@ -0,0 +1,306 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getClient } = require('./client');
+
+const CACHE_DIR = path.join(os.homedir(), '.deertools', 'cache');
+const TTL_HOURS = 24;
+
+// Zdefiniowane stałe katalogu Kosztorys Deer Design
+const DEER_KOSZTORYS_CATALOG_ID = 81186;
+const ROOT_CAT_USLUGI = 5578342;
+const ROOT_CAT_PRODUKTY = 8769388;
+const DEFAULT_PRICE_GROUP_ID = '49162'; // Domyślna grupa cenowa (PLN brutto)
+
+function ensureCacheDir() {
+  if (!fs.existsSync(CACHE_DIR)) {
+    fs.mkdirSync(CACHE_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+function getCachePath(inventoryId) {
+  ensureCacheDir();
+  return path.join(CACHE_DIR, `inventory_${inventoryId}.json`);
+}
+
+function getMetadataPath(inventoryId) {
+  ensureCacheDir();
+  return path.join(CACHE_DIR, `inventory_${inventoryId}.meta.json`);
+}
+
+let inMemoryCache = {};
+
+/**
+ * Wczytuje cache dla danego katalogu (z pamięci podręcznej lub z dysku).
+ */
+function loadCache(inventoryId = DEER_KOSZTORYS_CATALOG_ID) {
+  const invId = Number(inventoryId) || DEER_KOSZTORYS_CATALOG_ID;
+  if (inMemoryCache[invId]) {
+    return inMemoryCache[invId];
+  }
+
+  const filePath = getCachePath(invId);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const data = JSON.parse(raw);
+    inMemoryCache[invId] = data;
+    return data;
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Zapisuje cache na dysk i do pamięci.
+ */
+function saveCache(inventoryId, cacheData) {
+  const invId = Number(inventoryId);
+  ensureCacheDir();
+  const filePath = getCachePath(invId);
+  fs.writeFileSync(filePath, JSON.stringify(cacheData), { encoding: 'utf8', mode: 0o600 });
+  inMemoryCache[invId] = cacheData;
+}
+
+/**
+ * Buduje mapę kategorii z przynależnością do gałęzi (Usługi vs Produkty).
+ */
+function buildCategoryHierarchy(categories = []) {
+  const catMap = {};
+  for (const c of categories) {
+    catMap[c.category_id] = { ...c, branch: 'Inne' };
+  }
+
+  function getRootBranch(catId) {
+    let curr = catMap[catId];
+    let depth = 0;
+    while (curr && depth < 10) {
+      if (curr.category_id === ROOT_CAT_USLUGI || curr.parent_id === ROOT_CAT_USLUGI) {
+        return 'Usługi';
+      }
+      if (curr.category_id === ROOT_CAT_PRODUKTY || curr.parent_id === ROOT_CAT_PRODUKTY) {
+        return 'Produkty';
+      }
+      if (curr.parent_id === 0) {
+        if (curr.name?.toLowerCase().includes('usług') || curr.name?.toLowerCase().includes('uslug')) return 'Usługi';
+        if (curr.name?.toLowerCase().includes('produkt')) return 'Produkty';
+        return curr.name;
+      }
+      curr = catMap[curr.parent_id];
+      depth++;
+    }
+    return 'Inne';
+  }
+
+  for (const c of categories) {
+    catMap[c.category_id].branch = getRootBranch(c.category_id);
+  }
+
+  return catMap;
+}
+
+/**
+ * Pełna lub przyrostowa synchronizacja produktów z BaseLinker do lokalnego cache.
+ */
+async function syncCatalogCache(inventoryId = DEER_KOSZTORYS_CATALOG_ID, force = false, client = null) {
+  const invId = Number(inventoryId) || DEER_KOSZTORYS_CATALOG_ID;
+  const existing = loadCache(invId);
+  const now = Date.now();
+
+  if (!force && existing && existing.synced_at) {
+    const ageHours = (now - existing.synced_at) / (1000 * 3600);
+    if (ageHours < TTL_HOURS) {
+      return {
+        cached: true,
+        age_hours: Math.round(ageHours * 10) / 10,
+        total_products: Object.keys(existing.products || {}).length,
+        synced_at: new Date(existing.synced_at).toISOString(),
+        message: `Cache dla katalogu ${invId} jest aktualny (${Math.round(ageHours)}h temu). Użyj force=true aby wymusić odświeżenie.`
+      };
+    }
+  }
+
+  const bl = client || getClient();
+
+  // 1. Pobierz kategorie
+  const catRes = await bl.call('getInventoryCategories', { inventory_id: invId });
+  const rawCategories = catRes.categories || [];
+  const categories = buildCategoryHierarchy(rawCategories);
+
+  // 2. Pobierz produkty strona po stronie
+  const products = {};
+  let page = 1;
+  let hasMore = true;
+
+  while (hasMore) {
+    const listRes = await bl.call('getInventoryProductsList', {
+      inventory_id: invId,
+      page
+    });
+
+    const pageProducts = listRes.products || {};
+    const count = Object.keys(pageProducts).length;
+    if (count === 0) {
+      hasMore = false;
+      break;
+    }
+
+    for (const [id, p] of Object.entries(pageProducts)) {
+      const catId = p.category_id || 0;
+      const catObj = categories[catId];
+      const branch = catObj?.branch || (p.sku?.startsWith('DdUsl') ? 'Usługi' : 'Produkty');
+      const priceBrutto = p.prices?.[DEFAULT_PRICE_GROUP_ID] ?? Object.values(p.prices || {})[0] ?? 0;
+
+      products[id] = {
+        id: Number(id),
+        sku: p.sku || '',
+        ean: p.ean || '',
+        name: p.name || '',
+        category_id: catId,
+        category_name: catObj?.name || '',
+        branch,
+        price_brutto: Number(priceBrutto) || 0,
+        stock: p.stock || {}
+      };
+    }
+
+    if (count < 1000) {
+      hasMore = false;
+    } else {
+      page++;
+    }
+  }
+
+  const cachePayload = {
+    inventory_id: invId,
+    synced_at: now,
+    total_products: Object.keys(products).length,
+    total_categories: rawCategories.length,
+    categories,
+    products
+  };
+
+  saveCache(invId, cachePayload);
+
+  return {
+    cached: false,
+    total_products: Object.keys(products).length,
+    total_categories: rawCategories.length,
+    synced_at: new Date(now).toISOString(),
+    message: `Pomyślnie zsynchronizowano katalog ${invId}: ${Object.keys(products).length} pozycji.`
+  };
+}
+
+/**
+ * Błyskawiczne przeszukiwanie lokalnego cache produktów (2-5ms).
+ */
+function searchCatalogCache(inventoryId = DEER_KOSZTORYS_CATALOG_ID, opts = {}) {
+  const invId = Number(inventoryId) || DEER_KOSZTORYS_CATALOG_ID;
+  const cache = loadCache(invId);
+  if (!cache || !cache.products) {
+    return null; // Brak cache, fallback do live API
+  }
+
+  const {
+    query = '',
+    filter_name = '',
+    filter_sku = '',
+    filter_ean = '',
+    filter_category_id = null,
+    branch = 'wszystko', // 'wszystko' | 'uslugi' | 'produkty'
+    page = 1,
+    limit = 50
+  } = opts;
+
+  const searchTokens = (query || filter_name || '')
+    .toLowerCase()
+    .trim()
+    .split(/\s+/)
+    .filter(t => t.length > 0);
+
+  const skuQuery = (filter_sku || '').toLowerCase().trim();
+  const eanQuery = (filter_ean || '').trim();
+  const targetCatId = filter_category_id ? Number(filter_category_id) : null;
+  const targetBranch = branch ? branch.toLowerCase() : 'wszystko';
+
+  const results = [];
+
+  for (const p of Object.values(cache.products)) {
+    // Filtrowanie gałęzi
+    if (targetBranch === 'uslugi' || targetBranch === 'usługi') {
+      if (p.branch !== 'Usługi' && !p.sku?.startsWith('DdUsl')) continue;
+    } else if (targetBranch === 'produkty') {
+      if (p.branch === 'Usługi' || p.sku?.startsWith('DdUsl')) continue;
+    }
+
+    // Filtrowanie kategorii
+    if (targetCatId && p.category_id !== targetCatId) {
+      continue;
+    }
+
+    // Filtrowanie SKU
+    if (skuQuery && !p.sku.toLowerCase().includes(skuQuery)) {
+      continue;
+    }
+
+    // Filtrowanie EAN
+    if (eanQuery && !p.ean.includes(eanQuery)) {
+      continue;
+    }
+
+    // Filtrowanie po tokenach słownych (każde słowo musi pasować w nazwie lub SKU)
+    if (searchTokens.length > 0) {
+      const haystack = `${p.name} ${p.sku} ${p.category_name}`.toLowerCase();
+      const allMatch = searchTokens.every(token => haystack.includes(token));
+      if (!allMatch) continue;
+    }
+
+    results.push(p);
+  }
+
+  // Paginacja
+  const startIndex = (page - 1) * limit;
+  const paginated = results.slice(startIndex, startIndex + limit);
+
+  return {
+    from_cache: true,
+    cache_synced_at: new Date(cache.synced_at).toISOString(),
+    total_found: results.length,
+    page,
+    limit,
+    total_pages: Math.ceil(results.length / limit) || 1,
+    products: paginated
+  };
+}
+
+/**
+ * Aktualizacja ceny w lokalnym cache po udanej operacji write-through w BaseLinker.
+ */
+function updateProductPriceInCache(inventoryId = DEER_KOSZTORYS_CATALOG_ID, productId, priceGroupId, newPrice) {
+  const invId = Number(inventoryId) || DEER_KOSZTORYS_CATALOG_ID;
+  const cache = loadCache(invId);
+  if (!cache || !cache.products) return;
+
+  const p = cache.products[productId];
+  if (p) {
+    if (String(priceGroupId) === DEFAULT_PRICE_GROUP_ID || !priceGroupId) {
+      p.price_brutto = Number(newPrice);
+    }
+    saveCache(invId, cache);
+  }
+}
+
+module.exports = {
+  DEER_KOSZTORYS_CATALOG_ID,
+  ROOT_CAT_USLUGI,
+  ROOT_CAT_PRODUKTY,
+  loadCache,
+  saveCache,
+  syncCatalogCache,
+  searchCatalogCache,
+  updateProductPriceInCache
+};

package/src/baselinker/catalog-tools.js

@@ -1,6 +1,12 @@
 'use strict';
 const { getClient } = require('./client');
 const { searchMethods, getMethodSchema } = require('./crawler');
+const {
+  DEER_KOSZTORYS_CATALOG_ID,
+  syncCatalogCache,
+  searchCatalogCache,
+  updateProductPriceInCache
+} = require('./cache');
 
 /**
  * Definicje narzędzi MCP dla zaawansowanego zarządzania katalogiem BaseLinker.
@@ -20,21 +26,39 @@ const CATALOG_MCP_TOOLS = [
       required: ['inventory_id', 'product_id']
     }
   },
+  {
+    name: 'bl_catalog_sync_cache',
+    description: 'Pobiera i odświeża lokalny szybki cache produktów i kategorii wybranego katalogu BaseLinker (np. 81186 Kosztorys) do błyskawicznego przeszukiwania lokalnego (2-5ms) bez zużywania limitów API (100 req/min).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        inventory_id: { type: 'integer', default: 81186, description: 'ID katalogu BaseLinker (domyślnie 81186 Kosztorys).' },
+        force: { type: 'boolean', default: false, description: 'Czy wymusić pełne pobranie nawet jeśli cache jest świeży (< 24h).' }
+      }
+    }
+  },
   {
     name: 'bl_catalog_search_products',
-    description: 'Wyszukuje i listuje produkty z katalogu BaseLinker wg nazwy, SKU, EAN, kategorii lub producenta.',
+    description: 'Błyskawiczne wyszukiwanie i filtrowanie produktów/usług z katalogu BaseLinker (lokalny cache 2ms lub live API). Obsługuje wyszukiwanie frazowe, podział na gałąź Usługi (DdUsl) vs Produkty oraz filtry SKU/kategorii.',
     inputSchema: {
       type: 'object',
       properties: {
-        inventory_id: { type: 'integer', description: 'ID katalogu BaseLinker.' },
-        filter_category_id: { type: 'integer', description: 'Opcjonalne filtrowanie po ID kategorii.' },
+        inventory_id: { type: 'integer', default: 81186, description: 'ID katalogu BaseLinker (domyślnie 81186 Kosztorys).' },
+        query: { type: 'string', description: 'Dowolna fraza wyszukiwania (szuka po słowach w nazwie, SKU i kategorii).' },
+        branch: {
+          type: 'string',
+          enum: ['wszystko', 'uslugi', 'produkty'],
+          default: 'wszystko',
+          description: 'Filtruj gałąź katalogu: "uslugi" (gałąź Usługi ID 5578342 / SKU DdUsl), "produkty" (gałąź Produkty ID 8769388 / armatura, płytki, podłogi), "wszystko".'
+        },
+        filter_category_id: { type: 'integer', description: 'Opcjonalne filtrowanie po dokładnym ID kategorii.' },
         filter_manufacturer_id: { type: 'integer', description: 'Opcjonalne filtrowanie po ID producenta.' },
-        filter_sku: { type: 'string', description: 'Opcjonalne wyszukiwanie po SKU produktu.' },
+        filter_sku: { type: 'string', description: 'Opcjonalne wyszukiwanie po SKU produktu (np. DdUsl247, A5D186ENB0).' },
         filter_ean: { type: 'string', description: 'Opcjonalne wyszukiwanie po kodzie EAN.' },
         filter_name: { type: 'string', description: 'Opcjonalne wyszukiwanie po fragmencie nazwy.' },
-        page: { type: 'integer', default: 1, description: 'Numer strony wyników (po 1000 produktów).' }
-      },
-      required: ['inventory_id']
+        use_cache: { type: 'boolean', default: true, description: 'Domyślnie true (błyskawiczne przeszukiwanie lokalnego cache 2ms). Ustaw false, aby wymusić zapytanie live do API.' },
+        page: { type: 'integer', default: 1, description: 'Numer strony wyników.' }
+      }
     }
   },
   {
@@ -56,7 +80,9 @@ const CATALOG_MCP_TOOLS = [
         height: { type: 'number', description: 'Wysokość w cm.' },
         width: { type: 'number', description: 'Szerokość w cm.' },
         length: { type: 'number', description: 'Długość w cm.' },
-        prices: { type: 'object', description: 'Ceny brutto wg grup cenowych, np. {"105": 149.99}.' },
+        prices: { type: 'object', description: 'Ceny brutto wg grup cenowych, np. {"49162": 149.99}.' },
+        average_cost: { type: 'number', description: 'Koszt własny / stawka robocizny wykonawcy netto.' },
+        average_landed_cost: { type: 'number', description: 'Średni koszt dodatkowy / koszt materiału budowlanego dodatkowego netto z zapasem.' },
         stock: { type: 'object', description: 'Stany magazynowe wg magazynów, np. {"bl_123": 25}.' },
         tags: { type: 'array', items: { type: 'string' }, description: 'Lista tagów przypisanych do produktu.' }
       },
@@ -278,14 +304,49 @@ async function handleCatalogToolCall(toolName, args, client = null) {
       return product;
     }
 
+    case 'bl_catalog_sync_cache': {
+      const { inventory_id = DEER_KOSZTORYS_CATALOG_ID, force = false } = args;
+      return await syncCatalogCache(inventory_id, force, bl);
+    }
+
     case 'bl_catalog_search_products': {
-      const { inventory_id, filter_category_id, filter_manufacturer_id, filter_sku, filter_ean, filter_name, page = 1 } = args;
+      const {
+        inventory_id = DEER_KOSZTORYS_CATALOG_ID,
+        query,
+        branch = 'wszystko',
+        filter_category_id,
+        filter_manufacturer_id,
+        filter_sku,
+        filter_ean,
+        filter_name,
+        use_cache = true,
+        page = 1
+      } = args;
+
+      // 1. Spróbuj lokalnego błyskawicznego przeszukania cache (2ms)
+      if (use_cache !== false) {
+        const cachedRes = searchCatalogCache(inventory_id, {
+          query: query || filter_name,
+          filter_name,
+          filter_sku,
+          filter_ean,
+          filter_category_id,
+          branch,
+          page,
+          limit: 50
+        });
+        if (cachedRes) {
+          return cachedRes;
+        }
+      }
+
+      // 2. Fallback do live API BaseLinkera
       const params = { inventory_id, page };
       if (filter_category_id) params.filter_category_id = filter_category_id;
       if (filter_manufacturer_id) params.filter_manufacturer_id = filter_manufacturer_id;
       if (filter_sku) params.filter_sku = filter_sku;
       if (filter_ean) params.filter_ean = filter_ean;
-      if (filter_name) params.filter_name = filter_name;
+      if (filter_name || query) params.filter_name = filter_name || query;
       return await bl.call('getInventoryProductsList', params);
     }
 
@@ -407,11 +468,20 @@ async function handleCatalogToolCall(toolName, args, client = null) {
     }
 
     case 'bl_catalog_update_prices_batch': {
-      const { inventory_id, products } = args;
-      return await bl.call('updateInventoryProductsPrices', {
+      const { inventory_id = DEER_KOSZTORYS_CATALOG_ID, products } = args;
+      const res = await bl.call('updateInventoryProductsPrices', {
         inventory_id,
         products
       });
+      // Write-through cache update
+      try {
+        for (const [prodId, groupPrices] of Object.entries(products || {})) {
+          for (const [groupId, priceVal] of Object.entries(groupPrices || {})) {
+            updateProductPriceInCache(inventory_id, prodId, groupId, priceVal);
+          }
+        }
+      } catch (_) {}
+      return res;
     }
 
     case 'bl_catalog_update_stock_batch': {

package/src/commands.js

@@ -52,7 +52,8 @@ async function cmdLogin(pos, flags) {
         log: out
       });
       out(`✓ Zalogowano do BaseLinker. Token zapisany w credentials.json.`);
-      out(`  Serwer MCP: deertools mcp install   |   Test połączenia: deertools baselinker test`);
+      installMcpServers(null, true);
+      out(`  Serwery MCP: automatycznie zaktualizowano konfigurację dla Cursor, Antigravity i Claude.`);
       return;
     } catch (e) {
       err(`✗ BaseLinker: ${e.message}`);
@@ -67,6 +68,7 @@ async function cmdLogin(pos, flags) {
       const token = pos[1] || flags.token;
       await loginSkillsDirect(token);
       out(`✓ Zalogowano do DeerSkills Hub. Klucz zapisany w credentials.json.`);
+      installMcpServers(null, true);
       out(`  Przegląd umiejętności: deertools skill list   |   Synchronizacja: deertools skill sync`);
       return;
     } catch (e) {
@@ -105,23 +107,26 @@ async function cmdLogin(pos, flags) {
         : scope;
       const entry = await login(product, { scope: productScope, port: flags.port ? Number(flags.port) : 0, clientName: flags.name, openBrowser: flags['no-open'] ? null : undefined, log: out });
       out(`✓ Zalogowano${entry.email ? ` jako ${entry.email}` : ''}. Zakres: ${entry.scope}${entry.expires_at ? `, ważny do ${entry.expires_at.slice(0, 10)}` : ''}.`);
-      out(`  Konfiguracja MCP: deertools mcp install   |   Synchronizacja skilli: deertools skill sync`);
     } catch (e) {
       failures += 1;
       err(`✗ ${product.name}: ${e.message}`);
     }
   }
   if (failures) fail(`Nie udało się zalogować do ${failures} z ${products.length} produktów.`, 1);
+  out(`\n[Auto-Sync] Automatycznie zaktualizowano konfigurację serwerów MCP dla Cursor, Antigravity, Claude i .mcp.json.`);
+  installMcpServers(null, true);
 }
 
 async function cmdLogout(pos) {
   if (pos[0] === 'baselinker' || pos[0] === 'bl') {
     out(credentials.removeProduct('baselinker') ? `✓ Wylogowano z BaseLinker (token usunięty lokalnie).` : `– BaseLinker: nie byłeś zalogowany.`);
+    installMcpServers(null, true);
     return;
   }
   for (const product of resolveProducts(pos[0])) {
     out(credentials.removeProduct(product.id) ? `✓ Wylogowano z ${product.name} (klucz usunięty lokalnie).` : `– ${product.name}: nie byłeś zalogowany.`);
   }
+  installMcpServers(null, true);
   if (pos[0] === 'all') {
     if (credentials.removeProduct('baselinker')) {
       out('✓ Wylogowano z BaseLinker (token usunięty lokalnie).');
@@ -384,77 +389,158 @@ async function cmdMcp(pos, flags) {
     return;
   }
 
-  if (sub === 'install') {
-    const servers = buildMcpServersConfig(products, true);
-    let touched = 0;
-    // 1. Cursor global (~/.cursor/mcp.json)
-    const cursorGlobal = path.join(os.homedir(), '.cursor', 'mcp.json');
+function installMcpServers(customProducts = null, silent = false) {
+  const prods = customProducts || resolveProducts('all');
+  const servers = buildMcpServersConfig(prods, true);
+  let touched = 0;
+
+  // 1. Cursor global (~/.cursor/mcp.json)
+  const cursorGlobal = path.join(os.homedir(), '.cursor', 'mcp.json');
+  try {
+    let cur = { mcpServers: {} };
+    if (fs.existsSync(cursorGlobal)) {
+      try { cur = JSON.parse(fs.readFileSync(cursorGlobal, 'utf8')); } catch (_) {}
+    }
+    cur.mcpServers = Object.assign({}, cur.mcpServers, servers);
+    fs.mkdirSync(path.dirname(cursorGlobal), { recursive: true });
+    fs.writeFileSync(cursorGlobal, JSON.stringify(cur, null, 2));
+    if (!silent) out(`✓ Cursor IDE: ${cursorGlobal}`);
+    touched++;
+  } catch (e) {
+    if (!silent) err(`✗ Cursor IDE (${cursorGlobal}): ${e.message}`);
+  }
+
+  // 2. Cursor workspace (.cursor/mcp.json)
+  const workspaceCursor = path.join(process.cwd(), '.cursor', 'mcp.json');
+  if (fs.existsSync(path.join(process.cwd(), '.cursor')) || fs.existsSync(path.join(process.cwd(), '.git'))) {
     try {
       let cur = { mcpServers: {} };
-      if (fs.existsSync(cursorGlobal)) {
-        try { cur = JSON.parse(fs.readFileSync(cursorGlobal, 'utf8')); } catch (_) {}
+      if (fs.existsSync(workspaceCursor)) {
+        try { cur = JSON.parse(fs.readFileSync(workspaceCursor, 'utf8')); } catch (_) {}
       }
       cur.mcpServers = Object.assign({}, cur.mcpServers, servers);
-      fs.mkdirSync(path.dirname(cursorGlobal), { recursive: true });
-      fs.writeFileSync(cursorGlobal, JSON.stringify(cur, null, 2));
-      out(`✓ Cursor IDE: ${cursorGlobal}`);
+      fs.mkdirSync(path.dirname(workspaceCursor), { recursive: true });
+      fs.writeFileSync(workspaceCursor, JSON.stringify(cur, null, 2));
+      if (!silent) out(`✓ Cursor Workspace: ${workspaceCursor}`);
       touched++;
     } catch (e) {
-      err(`✗ Cursor IDE (${cursorGlobal}): ${e.message}`);
+      if (!silent) err(`✗ Cursor Workspace (${workspaceCursor}): ${e.message}`);
     }
+  }
 
-    // 2. Cursor workspace (.cursor/mcp.json)
-    const workspaceCursor = path.join(process.cwd(), '.cursor', 'mcp.json');
-    if (fs.existsSync(path.join(process.cwd(), '.cursor')) || fs.existsSync(path.join(process.cwd(), '.git'))) {
-      try {
-        let cur = { mcpServers: {} };
-        if (fs.existsSync(workspaceCursor)) {
-          try { cur = JSON.parse(fs.readFileSync(workspaceCursor, 'utf8')); } catch (_) {}
-        }
-        cur.mcpServers = Object.assign({}, cur.mcpServers, servers);
-        fs.mkdirSync(path.dirname(workspaceCursor), { recursive: true });
-        fs.writeFileSync(workspaceCursor, JSON.stringify(cur, null, 2));
-        out(`✓ Cursor Workspace: ${workspaceCursor}`);
-        touched++;
-      } catch (e) {
-        err(`✗ Cursor Workspace (${workspaceCursor}): ${e.message}`);
+  // 3. Antigravity / Gemini Workspace (.agents/mcp_config.json)
+  const agentsConfig = path.join(process.cwd(), '.agents', 'mcp_config.json');
+  if (fs.existsSync(path.dirname(agentsConfig))) {
+    try {
+      let cur = { mcpServers: {} };
+      if (fs.existsSync(agentsConfig)) {
+        try { cur = JSON.parse(fs.readFileSync(agentsConfig, 'utf8')); } catch (_) {}
       }
+      cur.mcpServers = Object.assign({}, cur.mcpServers, servers);
+      fs.writeFileSync(agentsConfig, JSON.stringify(cur, null, 2));
+      if (!silent) out(`✓ Antigravity / Agent Workspace: ${agentsConfig}`);
+      touched++;
+    } catch (e) {
+      if (!silent) err(`✗ Antigravity (${agentsConfig}): ${e.message}`);
     }
+  }
 
-    // 3. Antigravity / Gemini Workspace (.agents/mcp_config.json)
-    const agentsConfig = path.join(process.cwd(), '.agents', 'mcp_config.json');
-    if (fs.existsSync(path.dirname(agentsConfig))) {
-      try {
-        let cur = { mcpServers: {} };
-        if (fs.existsSync(agentsConfig)) {
-          try { cur = JSON.parse(fs.readFileSync(agentsConfig, 'utf8')); } catch (_) {}
+  // 4. Antigravity Global (~/.gemini/config/mcp_config.json)
+  const geminiGlobal = path.join(os.homedir(), '.gemini', 'config', 'mcp_config.json');
+  if (fs.existsSync(path.dirname(geminiGlobal))) {
+    try {
+      let cur = { mcpServers: {} };
+      if (fs.existsSync(geminiGlobal)) {
+        try { cur = JSON.parse(fs.readFileSync(geminiGlobal, 'utf8')); } catch (_) {}
+      }
+      cur.mcpServers = Object.assign({}, cur.mcpServers, servers);
+      fs.writeFileSync(geminiGlobal, JSON.stringify(cur, null, 2));
+      if (!silent) out(`✓ Antigravity Global: ${geminiGlobal}`);
+      touched++;
+    } catch (e) {
+      if (!silent) err(`✗ Antigravity Global (${geminiGlobal}): ${e.message}`);
+    }
+  }
+
+  // 5. Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json)
+  const claudeDesktop = path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  if (fs.existsSync(path.dirname(claudeDesktop))) {
+    try {
+      let cur = {};
+      if (fs.existsSync(claudeDesktop)) {
+        try { cur = JSON.parse(fs.readFileSync(claudeDesktop, 'utf8')); } catch (_) {}
+      }
+      const claudeServers = {};
+      for (const [k, v] of Object.entries(servers)) {
+        claudeServers[k] = { ...v };
+        if (v.command) {
+          claudeServers[k].env = {
+            PATH: '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:' + path.join(os.homedir(), '.local', 'bin')
+          };
         }
-        cur.mcpServers = Object.assign({}, cur.mcpServers, servers);
-        fs.writeFileSync(agentsConfig, JSON.stringify(cur, null, 2));
-        out(`✓ Antigravity / Agent Workspace: ${agentsConfig}`);
-        touched++;
-      } catch (e) {
-        err(`✗ Antigravity (${agentsConfig}): ${e.message}`);
       }
+      cur.mcpServers = Object.assign({}, cur.mcpServers || {}, claudeServers);
+      fs.writeFileSync(claudeDesktop, JSON.stringify(cur, null, 2));
+      if (!silent) out(`✓ Claude Desktop: ${claudeDesktop}`);
+      touched++;
+    } catch (e) {
+      if (!silent) err(`✗ Claude Desktop (${claudeDesktop}): ${e.message}`);
     }
+  }
 
-    // 4. Antigravity Global (~/.gemini/config/mcp_config.json)
-    const geminiGlobal = path.join(os.homedir(), '.gemini', 'config', 'mcp_config.json');
-    if (fs.existsSync(path.dirname(geminiGlobal))) {
-      try {
-        let cur = { mcpServers: {} };
-        if (fs.existsSync(geminiGlobal)) {
-          try { cur = JSON.parse(fs.readFileSync(geminiGlobal, 'utf8')); } catch (_) {}
+  // 6. Claude Code CLI (~/.claude.json)
+  const claudeCli = path.join(os.homedir(), '.claude.json');
+  if (fs.existsSync(claudeCli)) {
+    try {
+      let cur = {};
+      try { cur = JSON.parse(fs.readFileSync(claudeCli, 'utf8')); } catch (_) {}
+      const claudeServers = {};
+      for (const [k, v] of Object.entries(servers)) {
+        claudeServers[k] = { ...v };
+        if (v.command) {
+          claudeServers[k].env = {
+            PATH: '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:' + path.join(os.homedir(), '.local', 'bin')
+          };
         }
-        cur.mcpServers = Object.assign({}, cur.mcpServers, servers);
-        fs.writeFileSync(geminiGlobal, JSON.stringify(cur, null, 2));
-        out(`✓ Antigravity Global: ${geminiGlobal}`);
-        touched++;
-      } catch (e) {
-        err(`✗ Antigravity Global (${geminiGlobal}): ${e.message}`);
+      }
+      cur.mcpServers = Object.assign({}, cur.mcpServers || {}, claudeServers);
+      fs.writeFileSync(claudeCli, JSON.stringify(cur, null, 2));
+      if (!silent) out(`✓ Claude Code CLI: ${claudeCli}`);
+      touched++;
+    } catch (e) {
+      if (!silent) err(`✗ Claude Code CLI (${claudeCli}): ${e.message}`);
+    }
+  }
+
+  // 7. Workspace .mcp.json (Claude Code / Cowork / Standard MCP workspace)
+  const workspaceMcp = path.join(process.cwd(), '.mcp.json');
+  try {
+    let cur = {};
+    if (fs.existsSync(workspaceMcp)) {
+      try { cur = JSON.parse(fs.readFileSync(workspaceMcp, 'utf8')); } catch (_) {}
+    }
+    const claudeServers = {};
+    for (const [k, v] of Object.entries(servers)) {
+      claudeServers[k] = { ...v };
+      if (v.command) {
+        claudeServers[k].env = {
+          PATH: '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:' + path.join(os.homedir(), '.local', 'bin')
+        };
       }
     }
+    cur.mcpServers = Object.assign({}, cur.mcpServers || {}, claudeServers);
+    fs.writeFileSync(workspaceMcp, JSON.stringify(cur, null, 2));
+    if (!silent) out(`✓ Workspace MCP (.mcp.json): ${workspaceMcp}`);
+    touched++;
+  } catch (e) {
+    if (!silent) err(`✗ Workspace MCP (${workspaceMcp}): ${e.message}`);
+  }
+
+  return touched;
+}
 
+  if (sub === 'install') {
+    const touched = installMcpServers(products, false);
     if (!touched) fail('Nie znaleziono środowiska agenta do instalacji MCP.', 4);
     out(`\nPomyślnie skonfigurowano wszystkie 7 serwerów MCP dla produktów DeerTools!`);
     return;

package/src/doctor.js

@@ -254,7 +254,11 @@ async function cmdDoctor(pos, flags) {
   const mcpLocations = [
     { name: 'Cursor IDE (global)', path: path.join(os.homedir(), '.cursor', 'mcp.json') },
     { name: 'Cursor Workspace', path: path.join(process.cwd(), '.cursor', 'mcp.json') },
-    { name: 'Antigravity / Gemini Workspace', path: path.join(process.cwd(), '.agents', 'mcp_config.json') },
+    { name: 'Antigravity Workspace', path: path.join(process.cwd(), '.agents', 'mcp_config.json') },
+    { name: 'Antigravity Global', path: path.join(os.homedir(), '.gemini', 'config', 'mcp_config.json') },
+    { name: 'Claude Desktop', path: path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json') },
+    { name: 'Claude Code CLI', path: path.join(os.homedir(), '.claude.json') },
+    { name: 'Workspace MCP (.mcp.json)', path: path.join(process.cwd(), '.mcp.json') },
   ];
   for (const loc of mcpLocations) {
     if (fs.existsSync(loc.path)) {