continente-mcp 3.1.0 → 4.1.0

package/src/index.js

@@ -4,11 +4,16 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { chromium } from 'playwright';
 import * as cheerio from 'cheerio';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { pathToFileURL } from 'node:url';
+import { chmodSync, existsSync, readFileSync, writeFileSync, mkdirSync, statSync, realpathSync } from 'fs';
 import { normalizeCookies } from './utils.js';
+import { normalizeCartProductId, parseOrderQuantity, quantityForCartUpdate, summarizeCartState, tallyMostBought } from './cart-utils.js';
+import { refreshAuthCookies, resolveStatePaths } from './auth-session.js';
+import { createQueue, normalizeFavoriteId, retryAuthentication, validateToolInput } from './reliability.js';
 
 const CONTINENTE_BASE = 'https://www.continente.pt';
-const STATE_DIR = process.env.CONTINENTE_STATE_DIR || `${process.env.HOME}/.continente`;
+const { stateDir: STATE_DIR, cookieFile: COOKIE_FILE } = resolveStatePaths();
+const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 
 function getPlatformUserAgent() {
   if (process.platform === 'win32') {
@@ -24,49 +29,90 @@ function getPlatformUserAgent() {
 let browser = null;
 let context = null;
 let page = null;
+let loadedCookieMtimeMs = null;
 
-async function ensureBrowser() {
-  if (browser) return browser;
-  
-  browser = await chromium.launch({ headless: true });
-  context = await browser.newContext({
-    userAgent: getPlatformUserAgent(),
-    locale: 'pt-PT'
+async function refreshAuthSession() {
+  const refreshed = await refreshAuthCookies({
+    stateDir: STATE_DIR,
+    closeBrowser,
+    log: (message) => console.error(message),
   });
+  return refreshed;
+}
 
-  // Load cookies from file
-  const cookieFile = `${STATE_DIR}/cookies.json`;
-  if (existsSync(cookieFile)) {
-    try {
-      const cookies = JSON.parse(readFileSync(cookieFile, 'utf8'));
-      const normalized = normalizeCookies(cookies);
-      await context.addCookies(normalized);
-    } catch (e) {
-      console.error('Failed to load cookies:', e.message);
+const NOT_LOGGED_IN = 'Not logged in. Add CONTINENTE_EMAIL and CONTINENTE_PASSWORD to ~/.continente/credentials.env (or the server environment), then try again.';
+
+async function ensureBrowser() {
+  const cookieFile = COOKIE_FILE;
+  if (!existsSync(cookieFile)) {
+    await refreshAuthSession();
+  }
+  const nextCookieMtimeMs = existsSync(cookieFile) ? statSync(cookieFile).mtimeMs : null;
+
+  if (context && loadedCookieMtimeMs !== nextCookieMtimeMs) {
+    if (page) { try { await page.close(); } catch (e) {} page = null; }
+    if (context) { try { await context.close(); } catch (e) {} context = null; }
+  }
+
+  if (!browser) {
+    const launched = await chromium.launch({ headless: true });
+    // After a crash, start a fresh browser on the next call instead of failing until close_session.
+    launched.on('disconnected', () => {
+      if (browser === launched) { browser = context = page = null; loadedCookieMtimeMs = null; }
+    });
+    browser = launched;
+  }
+
+  if (!context) {
+    context = await browser.newContext({
+      userAgent: getPlatformUserAgent(),
+      locale: 'pt-PT'
+    });
+
+    // Load cookies from file
+    if (existsSync(cookieFile)) {
+      try {
+        const cookies = JSON.parse(readFileSync(cookieFile, 'utf8'));
+        const normalized = normalizeCookies(cookies);
+        await context.addCookies(normalized);
+      } catch (e) {
+        console.error('Could not read the cookie cache; refresh login or replace the cache.');
+      }
+      // Record the attempt even when it fails, so an unreadable cache does not reset the session on every call.
+      loadedCookieMtimeMs = nextCookieMtimeMs;
     }
   }
 
-  page = await context.newPage();
+  if (!page || page.isClosed()) {
+    page = await context.newPage();
+  }
   return browser;
 }
 
 async function goto(url, wait = 'networkidle') {
   await ensureBrowser();
-  await page.goto(url, { waitUntil: wait, timeout: 20000 });
+  const response = await page.goto(url, { waitUntil: wait, timeout: 20000 });
+  if (!response?.ok()) throw new Error(`Continente page returned HTTP ${response?.status() ?? 'unknown'}`);
   await page.waitForTimeout(1500);
   return page;
 }
 
+async function retryAfterAutoLogin(operation, mutation = false) {
+  return retryAuthentication(operation, refreshAuthSession, mutation);
+}
+
 async function closeBrowser() {
   if (page) { try { await page.close(); } catch(e) {} page = null; }
   if (context) { try { await context.close(); } catch(e) {} context = null; }
   if (browser) { try { await browser.close(); } catch(e) {} browser = null; }
+  loadedCookieMtimeMs = null;
 }
 
 // ─── Favorites / Preferences ───────────────────────────────────────────────────
 
 async function fetchFavorites() {
   await goto(`${CONTINENTE_BASE}/conta/lista-produtos/?list=favorites`);
+  if (page.url().includes('/login')) return { error: 'not_authenticated', writeAttempted: false };
   const html = await page.content();
   const $ = cheerio.load(html);
   const products = [];
@@ -77,7 +123,7 @@ async function fetchFavorites() {
     const href = $el.attr('href') || '';
     if (text.length > 5 && href) {
       const idMatch = href.match(/\/produto\/([^\/\?]+)/);
-      const productId = idMatch ? idMatch[1] : null;
+      const productId = idMatch ? normalizeFavoriteId(idMatch[1]) : null;
       const priceMatch = text.match(/(\d+[,.]\d+€)/);
       const name = text.replace(/\d+[,.]\d+€/g, '').trim().substring(0, 120);
       if (name && name.length > 3 && productId) {
@@ -97,10 +143,30 @@ async function fetchFavorites() {
 
 // ─── Product Search ────────────────────────────────────────────────────────────
 
-async function searchProducts(query, limit = 10) {
+async function searchProducts(query, extraPages = 0) {
   await goto(`${CONTINENTE_BASE}/pesquisa/?q=${encodeURIComponent(query)}`);
   const html = await page.content();
-  return parseProducts(html, limit);
+  const products = parseProducts(html, Infinity);
+
+  // The search page holds one page of results (35); the grid endpoint serves the next ones.
+  const moreUrl = extraPages > 0 ? cheerio.load(html)('[data-url*="Search-UpdateGrid"]').attr('data-url') : null;
+  if (moreUrl) {
+    const url = new URL(moreUrl, CONTINENTE_BASE);
+    const start = Number(url.searchParams.get('start')) || products.length;
+    const size = Number(url.searchParams.get('sz')) || products.length;
+    if (url.origin === CONTINENTE_BASE && size > 0) {
+      const pages = await Promise.all(Array.from({ length: extraPages }, (_, i) => {
+        url.searchParams.set('start', String(start + i * size));
+        return context.request.get(url.href, { timeout: 10000 })
+          .then(res => res.ok() ? res.text() : '')
+          .catch(() => '');
+      }));
+      for (const pageHtml of pages) products.push(...parseProducts(pageHtml, Infinity));
+    }
+  }
+
+  const seen = new Set();
+  return products.filter(p => !seen.has(p.product_id) && seen.add(p.product_id));
 }
 
 function parseProducts(html, limit = 30) {
@@ -119,12 +185,16 @@ function parseProducts(html, limit = 30) {
     const productId = idMatch ? idMatch[1] : null;
     if (!productId) return;
 
-    const cardText = $el.text().replace(/\s+/g, ' ').trim();
-    const priceMatch = cardText.match(/(\d+[,.]\d+)€/);
+    const primaryText = $el.find('.pwc-tile--price-primary').first().text().replace(/\s+/g, ' ').trim();
+    const priceMatch = primaryText.match(/(\d+[,.]\d+)€/);
     if (!priceMatch) return;
 
     const price = parseFloat(priceMatch[1].replace(',', '.'));
-    const unitMatch = cardText.match(/(\d+[,.]\d+€)\/([a-zA-Z]+)/);
+    const secondaryText = $el.find('.pwc-tile--price-secondary').first().text().replace(/\s+/g, ' ').trim();
+    const unitMatch = secondaryText.match(/(\d+[,.]\d+€)\/([a-zA-Z]+)/);
+
+    // e.g. "Quant. Mínima = 600 gr (3 un)" on products sold by weight
+    const minimumMatch = $el.find('.pwc-tile--quantity').first().text().replace(/\s+/g, ' ').match(/M[ií]nima\s*=\s*(.+?)\s*$/i);
 
     const nameLink = $el.find('a[href*="/produto/"]').filter((_, a) => $(a).text().trim().length > 0).first();
     let name = nameLink.text().replace(/\s+/g, ' ').trim().substring(0, 100);
@@ -136,7 +206,8 @@ function parseProducts(html, limit = 30) {
       currency: '€',
       product_id: productId,
       url: href.startsWith('http') ? href : CONTINENTE_BASE + href,
-      unit: unitMatch ? `${unitMatch[1]}/${unitMatch[2]}` : null
+      unit: unitMatch ? `${unitMatch[1]}/${unitMatch[2]}` : null,
+      minimum: minimumMatch ? minimumMatch[1] : null
     });
   });
 
@@ -151,40 +222,148 @@ function parseProducts(html, limit = 30) {
 // ─── Cart ─────────────────────────────────────────────────────────────────────
 
 async function getCart() {
+  await ensureBrowser();
+
+  try {
+    const res = await context.request.get(
+      `${CONTINENTE_BASE}/on/demandware.store/Sites-continente-Site/default/Cart-MiniCartShow`,
+      {
+        headers: { 'X-Requested-With': 'XMLHttpRequest' },
+        timeout: 10000
+      }
+    );
+
+    if (!res.ok()) return { error: `http_${res.status()}` };
+
+    const payload = await res.json();
+    const cart = summarizeCartState(payload);
+    if (!cart.customerAuthenticated) return { error: 'not_authenticated' };
+    return cart;
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+async function updateCartItem(productId, quantity) {
+  const before = await getCart();
+  if (before.error) return { success: false, error: before.error, writeAttempted: false };
   await goto(`${CONTINENTE_BASE}/checkout/carrinho/`);
 
-  if (page.url().includes('/login')) return { error: 'not_authenticated' };
+  if (page.url().includes('/login')) return { error: 'not_authenticated', writeAttempted: false };
 
-  return page.evaluate(() => {
-    const cartList = document.querySelector('.js-cart-product-list');
-    if (!cartList) return [];
+  const cartPid = normalizeCartProductId(productId);
+  const updateData = await page.evaluate(({ cartPid }) => {
+    const item = Array.from(document.querySelectorAll('[data-pid][data-product-name]'))
+      .find(el => el.dataset.pid === cartPid || el.querySelector(`input.add-to-cart-quantity[data-pid="${cartPid}-master"]`));
 
-    const seen = new Set();
-    const items = [];
+    if (!item) return { error: 'not_found' };
 
-    cartList.querySelectorAll('[data-pid][data-product-name]').forEach(el => {
-      const pid = el.dataset.pid;
-      const name = el.dataset.productName;
-      if (!name || seen.has(pid)) return;
-      seen.add(pid);
+    const removeEl = item.querySelector('button.remove-product');
+    const updateEl = item.querySelector('.ct-tile-quantity-update');
+    const qtyInput = item.querySelector('input.add-to-cart-quantity');
+    if ((!updateEl || !qtyInput) && !removeEl) return { error: 'missing_quantity_controls' };
 
-      const priceEl = el.querySelector('.pwc-tile--price-primary');
-      const priceText = priceEl?.textContent?.trim().replace(/[^\d,]/g, '').replace(',', '.');
-      const price = priceText ? parseFloat(priceText) : null;
+    let measureOptions = {};
+    try {
+      measureOptions = updateEl?.dataset.measureOptions ? JSON.parse(updateEl.dataset.measureOptions) : {};
+    } catch {
+      measureOptions = {};
+    }
 
-      const qtyInput = el.querySelector('input.add-to-cart-quantity');
-      const qty = qtyInput ? parseInt(qtyInput.value) || 1 : 1;
+    const updateUrl = updateEl?.dataset.action;
+    const uuid = updateEl?.dataset.uuid || item.dataset.uuid;
 
-      items.push({ name, price, qty });
-    });
+    return {
+      updateUrl,
+      uuid,
+      measureOptions,
+      gtmIndex: item.dataset.idx || '1',
+      removeUrl: removeEl?.dataset.action,
+      removeUuid: removeEl?.dataset.uuid || item.dataset.uuid
+    };
+  }, { cartPid });
+
+  if (updateData.error) return { success: false, error: updateData.error };
+
+  if (quantity === 0) {
+    if (!updateData.removeUrl || !updateData.removeUuid) {
+      return { success: false, error: 'missing_remove_data' };
+    }
+
+    const params = new URLSearchParams({ pid: cartPid, uuid: updateData.removeUuid });
+    const result = await requestCartChange(updateData.removeUrl, params);
+    if (result.error) return { success: false, error: result.error, writeAttempted: true };
+    return verifyCartQuantity(cartPid, 0);
+  }
+
+  if (!updateData.updateUrl || !updateData.uuid) return { success: false, error: 'missing_update_data' };
+
+  const formattedQuantity = quantityForCartUpdate(quantity, updateData.measureOptions);
+  const conversion = Number(updateData.measureOptions.primaryToSecondary || updateData.measureOptions.unitConversionRate);
+  const step = Number(updateData.measureOptions.stepQuantity || conversion || 1).toString();
+  const dimension = updateData.measureOptions.secondaryunit || updateData.measureOptions.primaryunit || 'un';
+
+  const params = new URLSearchParams({
+    pid: cartPid,
+    quantity: formattedQuantity,
+    step,
+    uuid: updateData.uuid,
+    dimension,
+    isCart: 'true',
+    gtmList: 'Checkout',
+    gtmIndex: updateData.gtmIndex,
+    promotionData: 'null',
+    taggstarPromotionData: ''
+  });
+
+  const result = await requestCartChange(updateData.updateUrl, params);
+  if (result.error) return { success: false, error: result.error, writeAttempted: true };
+  return verifyCartQuantity(cartPid, quantity);
+}
 
-    return items;
+async function requestCartChange(action, params) {
+  const url = new URL(action, CONTINENTE_BASE);
+  if (url.origin !== CONTINENTE_BASE) return { error: 'invalid_cart_action' };
+  for (const [key, value] of params) url.searchParams.set(key, value);
+  const res = await context.request.get(url.href, {
+    headers: { 'X-Requested-With': 'XMLHttpRequest' }, timeout: 10000
   });
+  if (!res.ok()) return { error: `http_${res.status()}` };
+  const payload = await res.json();
+  if (payload?.error || payload?.success === false) return { error: 'cart_update_rejected' };
+  return { success: true };
+}
+
+async function verifyCartQuantity(productId, expectedQuantity) {
+  const cart = await getCart();
+  const actual = cart.items?.find(item => item.id === productId)?.qty ?? 0;
+  if (cart.error || Math.abs(actual - expectedQuantity) > 0.0005) {
+    // A write may have happened. Never automatically repeat it after this point.
+    return { success: false, error: 'cart_quantity_not_confirmed', writeAttempted: true };
+  }
+  return { success: true, product_id: productId, cart_quantity: actual };
 }
 
 async function addToCart(productId, quantity = 1) {
+  const before = await getCart();
+  if (before.error) return { success: false, error: before.error, writeAttempted: false };
   const slug = productId.endsWith('.html') ? productId : `${productId}.html`;
-  await goto(`${CONTINENTE_BASE}/produto/${slug}`);
+  await goto(`${CONTINENTE_BASE}/produto/${slug}`, 'domcontentloaded');
+  await page.waitForSelector('input.add-to-cart-url', { state: 'attached', timeout: 10000 });
+
+  const measureOptions = await page.evaluate(() => {
+    const options = document.querySelector('.ct-tile-quantity-update[data-measure-options]')?.dataset.measureOptions;
+    try { return options ? JSON.parse(options) : {}; } catch { return null; }
+  });
+  if (!measureOptions) return { success: false, error: 'quantity_semantics_unknown', writeAttempted: false };
+  const numericPid = normalizeCartProductId(productId);
+  const previousQuantity = before.items.find(item => item.id === numericPid)?.qty ?? 0;
+  // Rejects unclear units and basket totals below the product minimum.
+  quantityForCartUpdate(previousQuantity + quantity, measureOptions);
+  // Like the website, weighted products are added at their minimum (-1), then set to the exact quantity.
+  const weighted = Boolean(measureOptions.hasAlternativeSaleUnit || measureOptions.hasConversionRate);
+  if (weighted && previousQuantity > 0) return updateCartItem(numericPid, previousQuantity + quantity);
+  const cartQuantity = weighted ? -1 : quantity;
 
   // Extract numeric PID and Cart-AddProduct URL from page
   const result = await page.evaluate(async (qty) => {
@@ -197,6 +376,8 @@ async function addToCart(productId, quantity = 1) {
     const pid = pidInput.value;
     const cartUrl = urlInput.value;
     const csrf = csrfInput ? csrfInput.value : '';
+    // Only send the session and CSRF token to Continente itself.
+    if (new URL(cartUrl, location.href).origin !== location.origin) return { success: false, message: 'invalid_cart_action' };
 
     const body = new URLSearchParams({ pid, quantity: String(qty), options: '[]' });
     if (csrf) body.append('csrf_token', csrf);
@@ -210,22 +391,27 @@ async function addToCart(productId, quantity = 1) {
         signal: AbortSignal.timeout(10000)
       });
       const json = await res.json();
-      return { success: res.ok, status: res.status, cartCount: json?.quantityTotal, error: json?.message };
+      return { success: res.ok, status: res.status, payload: json, error: json?.message };
     } catch (e) {
       return { success: false, message: e.message };
     }
-  }, quantity);
+  }, cartQuantity);
 
-  return result;
+  if (!result.success || result.payload?.error || result.payload?.resources?.customerAuthenticated === false) {
+    return { success: false, error: 'cart_add_not_confirmed', writeAttempted: true };
+  }
+  if (!weighted) return verifyCartQuantity(numericPid, previousQuantity + quantity);
+  // The add already wrote to the basket, so any failure from here must not be retried.
+  const updated = await updateCartItem(numericPid, previousQuantity + quantity);
+  return updated.success ? updated : { ...updated, writeAttempted: true };
 }
 
 // ─── Order History ────────────────────────────────────────────────────────────
 
 async function getOrderHistory(limit = 5) {
   await goto(`${CONTINENTE_BASE}/conta/encomendas/`);
-  await page.waitForTimeout(3000);
 
-  if (page.url().includes('/login')) return { error: 'not_authenticated' };
+  if (page.url().includes('/login')) return { error: 'not_authenticated', writeAttempted: false };
 
   const text = await page.evaluate(() => document.body.innerText);
   const rawLines = text.split('\n').map(l => l.trim()).filter(Boolean);
@@ -246,17 +432,22 @@ async function getOrderHistory(limit = 5) {
     const seen = new Set();
     return Array.from(document.querySelectorAll('a[href*="detalhe-encomenda"]'))
       .map(a => a.href)
+      .filter(h => h.startsWith(`${location.origin}/`))
       .filter(h => { if (seen.has(h)) return false; seen.add(h); return true; });
   });
 
-  // Fetch product lines for each order up to limit
-  const detailLinks = orderLinks.slice(0, limit);
-  for (let idx = 0; idx < detailLinks.length; idx++) {
+  // Links carry an internal ID, not the order number, so they are paired by position.
+  // If the counts disagree, show orders without items rather than attach the wrong ones.
+  if (orderLinks.length !== orders.length) {
+    orders.forEach(order => { order.linesUnavailable = true; });
+    return orders;
+  }
+  for (let idx = 0; idx < Math.min(limit, orders.length); idx++) {
     try {
-      const products = await getOrderProducts(detailLinks[idx]);
-      if (orders[idx]) orders[idx].lines = products.map(p => `${p.qty}x ${p.name}`);
+      const products = await getOrderProducts(orderLinks[idx]);
+      orders[idx].lines = products.map(p => `${p.unit === 'un' ? `${p.qty}x` : `${p.qty} ${p.unit}`} ${p.name}`);
     } catch (e) {
-      // skip failed pages
+      orders[idx].linesUnavailable = true;
     }
   }
 
@@ -264,10 +455,10 @@ async function getOrderHistory(limit = 5) {
 }
 
 async function getOrderProducts(orderDetailUrl) {
-  await page.goto(orderDetailUrl, { waitUntil: 'networkidle', timeout: 20000 });
-  await page.waitForTimeout(2000);
+  const response = await page.goto(orderDetailUrl, { waitUntil: 'networkidle', timeout: 20000 });
+  if (!response?.ok() || page.url().includes('/login')) throw new Error('order_detail_unavailable');
 
-  return page.evaluate(() => {
+  const products = await page.evaluate(() => {
     const products = [];
     document.querySelectorAll('[class*="product-line"]').forEach(el => {
       const qtyEl = el.querySelector('[class*="qty"], [class*="quantity"], [class*="amount"]');
@@ -278,18 +469,15 @@ async function getOrderProducts(orderDetailUrl) {
       // Take only first line — rest is brand/subcopy
       const name = rawName.split('\n')[0].trim();
 
-      const qtyMatch = qtyEl.textContent.trim().match(/^(\d+)/);
-      const qty = qtyMatch ? parseInt(qtyMatch[1], 10) : 1;
-
-      if (name && name.length > 3) products.push({ name, qty });
+      if (name && name.length > 3) products.push({ name, qtyText: qtyEl.textContent.trim() });
     });
     return products;
   });
+  return products.map(({ name, qtyText }) => ({ name, ...parseOrderQuantity(qtyText) }));
 }
 
-async function getMostBought() {
+async function getMostBought(limit = 10) {
   await goto(`${CONTINENTE_BASE}/conta/encomendas/`);
-  await page.waitForTimeout(3000);
 
   if (page.url().includes('/login')) return { error: 'not_authenticated' };
 
@@ -303,29 +491,21 @@ async function getMostBought() {
 
   if (orderLinks.length === 0) return { error: 'no_orders' };
 
-  // Tally products across all orders
-  const tally = new Map(); // name -> { qty, orders }
+  const orderProducts = [];
 
-  for (const link of orderLinks) {
+  const scanned = orderLinks.slice(0, limit);
+  let failed = 0;
+  for (const link of scanned) {
     try {
       const products = await getOrderProducts(link);
-      for (const { name, qty } of products) {
-        const existing = tally.get(name);
-        if (existing) {
-          existing.qty += qty;
-          existing.orders += 1;
-        } else {
-          tally.set(name, { qty, orders: 1 });
-        }
-      }
+      orderProducts.push(products);
     } catch (e) {
-      // skip failed order pages
+      failed++;
     }
   }
+  if (failed === scanned.length) return { error: 'order_details_unavailable' };
 
-  return Array.from(tally.entries())
-    .map(([name, { qty, orders }]) => ({ name, qty, orders }))
-    .sort((a, b) => b.qty - a.qty);
+  return { products: tallyMostBought(orderProducts), scanned: scanned.length, failed };
 }
 
 // ─── Preferences ───────────────────────────────────────────────────────────────
@@ -341,13 +521,15 @@ async function getPreferences() {
 }
 
 async function savePreferences(prefs) {
-  try { mkdirSync(STATE_DIR, { recursive: true }); } catch (e) {}
+  try { mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 }); } catch (e) {}
   const prefsFile = `${STATE_DIR}/preferences.json`;
-  writeFileSync(prefsFile, JSON.stringify(prefs, null, 2));
+  writeFileSync(prefsFile, JSON.stringify(prefs, null, 2), { mode: 0o600 });
+  chmodSync(prefsFile, 0o600);
 }
 
 async function updatePreferencesFromFavorites() {
-  const favorites = await fetchFavorites();
+  const favorites = await retryAfterAutoLogin(() => fetchFavorites());
+  if (favorites?.error) throw new Error(favorites.error);
   const prefs = {
     favorites,
     lastUpdated: new Date().toISOString()
@@ -356,17 +538,17 @@ async function updatePreferencesFromFavorites() {
   return prefs;
 }
 
-function rankByPreference(products, preferences) {
+export function rankByPreference(products, preferences) {
   if (!preferences || !preferences.favorites) return products;
 
-  const favIds = new Set(preferences.favorites.map(f => f.productId));
+  const favIds = new Set(preferences.favorites.map(f => normalizeCartProductId(f.productId)));
   const favNames = new Map(preferences.favorites.map(f => [f.name.toLowerCase(), f]));
 
   return products.map(p => {
     let score = 0;
-    if (favIds.has(p.product_id)) score += 100;
+    if (favIds.has(normalizeCartProductId(p.product_id))) score += 100;
     const nameLower = p.name.toLowerCase();
-    for (const [favName, fav] of favNames) {
+    for (const favName of favNames.keys()) {
       if (nameLower.includes(favName) || favName.includes(nameLower)) score += 50;
     }
     return { ...p, score };
@@ -375,12 +557,14 @@ function rankByPreference(products, preferences) {
 
 // ─── MCP Server ───────────────────────────────────────────────────────────────
 
-class ContinenteServer {
+export class ContinenteServer {
   constructor() {
     this.server = new Server(
-      { name: 'continente-mcp', version: '3.1.0' },
+      { name: 'continente-mcp', version: VERSION },
       { capabilities: { tools: {} } }
     );
+    this.server.onclose = () => { void closeBrowser(); };
+    this.pending = createQueue();
     this.setupTools();
   }
 
@@ -394,7 +578,7 @@ class ContinenteServer {
             type: 'object',
             properties: {
               query: { type: 'string', description: 'Search term (e.g., "leite", "pao")' },
-              limit: { type: 'number', description: 'Max results (default: 10)' }
+              limit: { type: 'integer', minimum: 1, maximum: 50, description: 'Max results (default: 10)' }
             },
             required: ['query']
           }
@@ -421,25 +605,42 @@ class ContinenteServer {
             type: 'object',
             properties: {
               product_id: { type: 'string', description: 'Product ID from search results' },
-              quantity: { type: 'number', description: 'Quantity (default: 1)' }
+              quantity: { type: 'number', exclusiveMinimum: 0, description: 'Quantity (default: 1)' }
             },
             required: ['product_id']
           }
         },
+        {
+          name: 'update_cart_item',
+          description: 'Set the quantity for a product already in the cart by product ID. Use quantity 0 to remove the line if the site supports it.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              product_id: { type: 'string', description: 'Product ID from search results or cart item' },
+              quantity: { type: 'number', minimum: 0, description: 'Desired cart quantity' }
+            },
+            required: ['product_id', 'quantity']
+          }
+        },
         {
           name: 'get_order_history',
           description: 'Get your recent order history from your account.',
           inputSchema: {
             type: 'object',
             properties: {
-              limit: { type: 'number', description: 'Number of orders (default: 5)' }
+              limit: { type: 'integer', minimum: 1, maximum: 50, description: 'Number of orders (default: 5)' }
             }
           }
         },
         {
           name: 'get_most_bought',
-          description: 'Get the products you buy most often, tallied across all orders. Scans every order page sequentially — slow on accounts with many orders.',
-          inputSchema: { type: 'object', properties: {} }
+          description: 'Get the products you buy most often, tallied across recent orders.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              limit: { type: 'integer', minimum: 1, maximum: 50, description: 'Number of recent orders to scan (default: 10)' }
+            }
+          }
         },
         {
           name: 'close_session',
@@ -449,9 +650,18 @@ class ContinenteServer {
       ]
     }));
 
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
+    this.server.setRequestHandler(CallToolRequestSchema, request =>
+      this.callTool(request.params.name, request.params.arguments ?? {}));
+  }
+
+  callTool(name, args = {}) {
+    // All tools share one browser page, including close_session.
+    return this.pending(() => this.executeTool(name, args));
+  }
+
+  async executeTool(name, args) {
       try {
+        args = validateToolInput(name, args);
         switch (name) {
           case 'search_products':
             return await this.handle_search(args.query, args.limit || 10);
@@ -462,11 +672,13 @@ class ContinenteServer {
           case 'get_cart':
             return await this.handle_get_cart();
           case 'add_to_cart':
-            return await this.handle_add_to_cart(args.product_id, args.quantity || 1);
+            return await this.handle_add_to_cart(args.product_id, args.quantity ?? 1);
+          case 'update_cart_item':
+            return await this.handle_update_cart_item(args.product_id, args.quantity);
           case 'get_order_history':
             return await this.handle_order_history(args.limit || 5);
           case 'get_most_bought':
-            return await this.handle_most_bought();
+            return await this.handle_most_bought(args.limit || 10);
           case 'close_session':
             await closeBrowser();
             return { content: [{ type: 'text', text: 'Session closed.' }] };
@@ -476,26 +688,28 @@ class ContinenteServer {
       } catch (error) {
         return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
       }
-    });
   }
 
   formatProducts(products, preferences = null) {
     return products.map((p, i) => {
-      const fav = preferences?.favorites?.find(f => f.productId === p.product_id);
+      const fav = preferences?.favorites?.find(f => normalizeCartProductId(f.productId) === normalizeCartProductId(p.product_id));
       const favBadge = fav ? ' ⭐ (favorite)' : '';
       const unitStr = p.unit ? ` (${p.unit})` : '';
-      return `${i + 1}. ${p.name}${favBadge}\n   💰 ${p.price?.toFixed(2) || '?'}€${unitStr}\n   🆔 ${p.product_id}`;
+      const minimumStr = p.minimum ? `\n   ⚖️ Minimum ${p.minimum}` : '';
+      return `${i + 1}. ${p.name}${favBadge}\n   💰 ${p.price?.toFixed(2) || '?'}€${unitStr}${minimumStr}\n   🆔 ${p.product_id}`;
     }).join('\n\n');
   }
 
   async handle_search(query, limit) {
     const prefs = await getPreferences();
-    const products = await searchProducts(query, limit * 2);
+    // Look further down the results when there are favourites to rank first.
+    const products = await searchProducts(query, prefs?.favorites?.length ? 2 : 0);
     const ranked = rankByPreference(products, prefs);
     const top = ranked.slice(0, limit);
 
     const favCount = prefs?.favorites?.length || 0;
     return {
+      structuredContent: { products: top },
       content: [{
         type: 'text',
         text: `Found ${products.length} products for "${query}" (${favCount} favorites loaded)${top.some(p => p.score > 0) ? ' — ⭐ = in your favorites' : ''}:\n\n${this.formatProducts(top, prefs)}\n\nUse add_to_cart with the product_id.`
@@ -504,9 +718,9 @@ class ContinenteServer {
   }
 
   async handle_favorites() {
-    const prefs = await getPreferences();
+    let prefs = await getPreferences();
     if (!prefs?.favorites?.length) {
-      return { content: [{ type: 'text', text: 'No favorites loaded. Run refresh_favorites first.' }] };
+      prefs = await updatePreferencesFromFavorites();
     }
 
     const list = prefs.favorites.map((f, i) =>
@@ -532,37 +746,56 @@ class ContinenteServer {
   }
 
   async handle_get_cart() {
-    const items = await getCart();
-    if (items?.error === 'not_authenticated') {
-      return { content: [{ type: 'text', text: 'Not logged in — cookies may have expired. Re-run the cookie sync script.' }] };
+    const cart = await retryAfterAutoLogin(() => getCart());
+    if (cart?.error === 'not_authenticated') {
+      return { content: [{ type: 'text', text: NOT_LOGGED_IN }], isError: true };
     }
-    if (!Array.isArray(items) || items.length === 0) {
-      return { content: [{ type: 'text', text: '🛒 Cart is empty.' }] };
+    if (cart?.error) {
+      return { content: [{ type: 'text', text: `Could not load cart. (${cart.error})` }], isError: true };
     }
-    const total = items.reduce((s, i) => s + (i.price || 0) * i.qty, 0);
-    const list = items.map((item, i) =>
-      `${i + 1}. ${item.name}\n   Qtd: ${item.qty} × ${item.price?.toFixed(2) || '?'}€`
+    if (!Array.isArray(cart.items) || cart.items.length === 0) {
+      return { structuredContent: cart, content: [{ type: 'text', text: '🛒 Cart is empty.' }] };
+    }
+    const total = cart.total;
+    const totalText = total === null ? 'Unavailable' : `${total.toFixed(2)}€`;
+    const list = cart.items.map((item, i) =>
+      `${i + 1}. ${item.name}\n   Qtd: ${item.qty} × ${item.price?.toFixed(2) || '?'}€\n   🆔 ${item.id}`
     ).join('\n');
     return {
+      structuredContent: cart,
       content: [{
         type: 'text',
-        text: `🛒 Cart (${items.length} items):\n\n${list}\n\n💶 Total: ${total.toFixed(2)}€\n\nGo to https://www.continente.pt/checkout/carrinho/ to checkout.`
+        text: `🛒 Cart (${cart.items.length} items):\n\n${list}\n\n💶 Total: ${totalText}\n\nGo to https://www.continente.pt/checkout/carrinho/ to checkout.`
       }]
     };
   }
 
   async handle_add_to_cart(productId, quantity) {
-    const result = await addToCart(productId, quantity);
+    const result = await retryAfterAutoLogin(() => addToCart(productId, quantity), true);
     if (result.success) {
-      return { content: [{ type: 'text', text: `✅ Added to cart! (${quantity}x)\n\nUse get_cart to review.` }] };
+      return { structuredContent: result, content: [{ type: 'text', text: `✅ Added to cart! (${quantity}x)\n\nUse get_cart to review.` }] };
     }
-    return { content: [{ type: 'text', text: `⚠️ ${result.message || 'Could not add to cart.'}` }], isError: true };
+    return { content: [{ type: 'text', text: `⚠️ ${result.error || result.message || 'Could not add to cart.'}` }], isError: true };
+  }
+
+  async handle_update_cart_item(productId, quantity) {
+    const result = await retryAfterAutoLogin(() => updateCartItem(productId, quantity), true);
+    if (result?.error === 'not_authenticated') {
+      return { content: [{ type: 'text', text: NOT_LOGGED_IN }], isError: true };
+    }
+    if (result?.error === 'not_found') {
+      return { content: [{ type: 'text', text: `Product ${productId} is not in the cart.` }], isError: true };
+    }
+    if (result.success) {
+      return { structuredContent: result, content: [{ type: 'text', text: `✅ Updated cart item ${productId} to ${quantity}.\n\nUse get_cart to review.` }] };
+    }
+    return { content: [{ type: 'text', text: `⚠️ ${result.error || 'Could not update cart item.'}` }], isError: true };
   }
 
   async handle_order_history(limit) {
-    const orders = await getOrderHistory(limit);
+    const orders = await retryAfterAutoLogin(() => getOrderHistory(limit));
     if (orders?.error === 'not_authenticated') {
-      return { content: [{ type: 'text', text: 'Not logged in — cookies may have expired. Re-sync your cookies.' }] };
+      return { content: [{ type: 'text', text: NOT_LOGGED_IN }], isError: true };
     }
     if (!Array.isArray(orders) || orders.length === 0) {
       return { content: [{ type: 'text', text: 'Could not load order history. Check https://www.continente.pt/conta/encomendas/' }] };
@@ -571,7 +804,7 @@ class ContinenteServer {
       if (o.raw) return `${i + 1}. ${o.raw}`;
       const date = o.date ? `📅 ${o.date}` : '';
       const total = o.total ? ` — ${o.total}` : '';
-      const lines = o.lines ? o.lines.join(' · ') : '';
+      const lines = o.lines ? o.lines.join(' · ') : o.linesUnavailable ? '(items could not be read)' : '';
       return `${i + 1}. ${date}${total}\n   ${lines}`;
     }).join('\n\n');
     return {
@@ -582,22 +815,23 @@ class ContinenteServer {
     };
   }
 
-  async handle_most_bought() {
-    const result = await getMostBought();
+  async handle_most_bought(limit) {
+    const result = await retryAfterAutoLogin(() => getMostBought(limit));
     if (result.error) {
-      return { content: [{ type: 'text', text: result.error === 'not_authenticated' ? 'Not logged in — cookies may have expired.' : `Error: ${result.error}` }] };
+      return { content: [{ type: 'text', text: result.error === 'not_authenticated' ? NOT_LOGGED_IN : `Error: ${result.error}` }], isError: true };
     }
-    if (!Array.isArray(result) || result.length === 0) {
+    if (!Array.isArray(result.products) || result.products.length === 0) {
       return { content: [{ type: 'text', text: 'Could not calculate most bought items from order history.' }] };
     }
-    const top = result.slice(0, 25);
+    const top = result.products.slice(0, 25);
     const list = top.map((item, i) =>
-      `${i + 1}. ${item.name} — ${item.qty} units across ${item.orders} order${item.orders > 1 ? 's' : ''}`
+      `${i + 1}. ${item.name} — ${Object.entries(item.quantities).map(([unit, qty]) => `${qty} ${unit}`).join(' + ')} across ${item.orders} order${item.orders > 1 ? 's' : ''}`
     ).join('\n');
     return {
       content: [{
         type: 'text',
-        text: `Most bought products (calculated from your order history):\n\n${list}`
+        text: `Most bought products (calculated from your order history):\n\n${list}` +
+          (result.failed ? `\n\n⚠️ ${result.failed} of ${result.scanned} orders could not be read and are not counted.` : '')
       }]
     };
   }
@@ -605,9 +839,12 @@ class ContinenteServer {
   async start() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
-    console.error('Continente MCP v3.1.0 started');
+    console.error(`Continente MCP v${VERSION} started`);
   }
 }
 
-const server = new ContinenteServer();
-server.start().catch(console.error);
+// npm bins run through symlinks, so compare the resolved path.
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+  const server = new ContinenteServer();
+  server.start().catch(error => { console.error(error.message); process.exitCode = 1; });
+}