continente-mcp 3.1.0 → 4.0.0

package/src/index.js

@@ -4,11 +4,15 @@ 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 { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'fs';
 import { normalizeCookies } from './utils.js';
+import { normalizeCartProductId, quantityForCartUpdate, summarizeCartState } from './cart-utils.js';
+import { refreshAuthCookies, resolveStatePaths } from './auth-session.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 +28,91 @@ 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);
+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) {
+    browser = await chromium.launch({ headless: true });
+  }
+
+  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);
+        loadedCookieMtimeMs = nextCookieMtimeMs;
+      } catch (e) {
+        console.error('Could not read the cookie cache; refresh login or replace the cache.');
+      }
     }
   }
 
-  page = await context.newPage();
+  if (!page) {
+    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) {
+  const first = await operation();
+  if (first?.error !== 'not_authenticated') {
+    return first;
+  }
+
+  if (!(await refreshAuthSession())) {
+    return first;
+  }
+
+  return operation();
+}
+
 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' };
   const html = await page.content();
   const $ = cheerio.load(html);
   const products = [];
@@ -119,12 +165,13 @@ 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]+)/);
 
     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);
@@ -151,40 +198,134 @@ 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 };
   await goto(`${CONTINENTE_BASE}/checkout/carrinho/`);
 
   if (page.url().includes('/login')) return { error: 'not_authenticated' };
 
-  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 });
 
-    return items;
+  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 };
+    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 };
+  return verifyCartQuantity(cartPid, quantity);
+}
+
+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' };
+  }
+  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 };
   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 });
 
   // Extract numeric PID and Cart-AddProduct URL from page
   const result = await page.evaluate(async (qty) => {
@@ -210,20 +351,24 @@ 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);
 
-  return result;
+  if (!result.success || result.payload?.error || result.payload?.resources?.customerAuthenticated === false) {
+    return { success: false, error: 'cart_add_not_confirmed' };
+  }
+  const numericPid = normalizeCartProductId(productId);
+  const previousQuantity = before.items.find(item => item.id === numericPid)?.qty ?? 0;
+  return verifyCartQuantity(numericPid, previousQuantity + quantity);
 }
 
 // ─── 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' };
 
@@ -265,7 +410,6 @@ async function getOrderHistory(limit = 5) {
 
 async function getOrderProducts(orderDetailUrl) {
   await page.goto(orderDetailUrl, { waitUntil: 'networkidle', timeout: 20000 });
-  await page.waitForTimeout(2000);
 
   return page.evaluate(() => {
     const products = [];
@@ -287,9 +431,8 @@ async function getOrderProducts(orderDetailUrl) {
   });
 }
 
-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,10 +446,10 @@ async function getMostBought() {
 
   if (orderLinks.length === 0) return { error: 'no_orders' };
 
-  // Tally products across all orders
+  // Tally products across recent orders
   const tally = new Map(); // name -> { qty, orders }
 
-  for (const link of orderLinks) {
+  for (const link of orderLinks.slice(0, limit)) {
     try {
       const products = await getOrderProducts(link);
       for (const { name, qty } of products) {
@@ -347,7 +490,8 @@ async function savePreferences(prefs) {
 }
 
 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 +500,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 +519,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 = Promise.resolve();
     this.setupTools();
   }
 
@@ -394,7 +540,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 +567,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 +612,28 @@ 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.
+    const result = this.pending.then(() => this.executeTool(name, args));
+    this.pending = result.catch(() => {});
+    return result;
+  }
+
+  async executeTool(name, args) {
       try {
+        if (!args || typeof args !== 'object' || Array.isArray(args)) throw new Error('Arguments must be an object');
+        if (['search_products', 'get_order_history', 'get_most_bought'].includes(name) && args.limit !== undefined &&
+          (!Number.isInteger(args.limit) || args.limit < 1 || args.limit > 50)) throw new Error('limit must be an integer from 1 to 50');
+        if (name === 'search_products' && (typeof args.query !== 'string' || !args.query.trim())) throw new Error('query must be a non-empty string');
+        if (['add_to_cart', 'update_cart_item'].includes(name)) {
+          if (typeof args.product_id !== 'string' || !/^[a-zA-Z0-9_-]+(?:\.html)?$/.test(args.product_id)) throw new Error('Invalid product_id');
+          const quantity = args.quantity ?? (name === 'add_to_cart' ? 1 : undefined);
+          if (typeof quantity !== 'number' || !Number.isFinite(quantity) || quantity < 0 || (name === 'add_to_cart' && quantity === 0)) throw new Error('Invalid quantity');
+        }
         switch (name) {
           case 'search_products':
             return await this.handle_search(args.query, args.limit || 10);
@@ -462,11 +644,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,12 +660,11 @@ 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}`;
@@ -504,9 +687,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 +715,55 @@ 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. Set CONTINENTE_EMAIL and CONTINENTE_PASSWORD in the MCP server environment, or refresh cookies manually.' }], isError: true };
+    }
+    if (cart?.error) {
+      return { content: [{ type: 'text', text: `Could not load cart. (${cart.error})` }], isError: true };
     }
-    if (!Array.isArray(items) || items.length === 0) {
+    if (!Array.isArray(cart.items) || cart.items.length === 0) {
       return { content: [{ type: 'text', text: '🛒 Cart is empty.' }] };
     }
-    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) || '?'}€`
+    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 {
       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));
     if (result.success) {
       return { 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));
+    if (result?.error === 'not_authenticated') {
+      return { content: [{ type: 'text', text: 'Not logged in. Set CONTINENTE_EMAIL and CONTINENTE_PASSWORD in the MCP server environment, or refresh cookies manually.' }], 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 { 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. Set CONTINENTE_EMAIL and CONTINENTE_PASSWORD in the MCP server environment, or refresh cookies manually.' }], 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/' }] };
@@ -582,10 +783,10 @@ 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. Set CONTINENTE_EMAIL and CONTINENTE_PASSWORD in the MCP server environment, or refresh cookies manually.' : `Error: ${result.error}` }], isError: true };
     }
     if (!Array.isArray(result) || result.length === 0) {
       return { content: [{ type: 'text', text: 'Could not calculate most bought items from order history.' }] };
@@ -605,9 +806,11 @@ 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);
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const server = new ContinenteServer();
+  server.start().catch(error => { console.error(error.message); process.exitCode = 1; });
+}