continente-mcp 3.1.0

package/continente-cookie-reader.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+continente-cookie-reader — export Continente.pt cookies from your browser.
+
+Reads browser cookies for continente.pt and writes them to ~/.continente/cookies.json
+so the MCP server can use them. Auto-detects your browser or let you specify one.
+
+Usage:
+  python3 continente-cookie-reader.py                    # auto-detect
+  python3 continente-cookie-reader.py --browser chrome
+  python3 continente-cookie-reader.py --browser firefox
+  python3 continente-cookie-reader.py --output /path/to/cookies.json
+  python3 continente-cookie-reader.py --list-browsers
+
+Requirements:
+  pip install browser-cookie3
+
+Environment variables:
+  CONTINENTE_COOKIES_PATH      Override the default output path (~/.continente/cookies.json)
+  CONTINENTE_VAULT_COOKIE_PATH If set, also write cookies to this path (useful for syncing
+                               to a second machine via a shared folder, e.g. Obsidian vault)
+"""
+import argparse
+import json
+import os
+import stat
+import sys
+from pathlib import Path
+
+DOMAIN = "continente.pt"
+DEFAULT_OUTPUT = Path(
+    os.environ.get("CONTINENTE_COOKIES_PATH", str(Path.home() / ".continente" / "cookies.json"))
+)
+
+# If set, cookies are also written here (e.g. for syncing to a remote machine)
+VAULT_PATH = Path(os.environ["CONTINENTE_VAULT_COOKIE_PATH"]) if "CONTINENTE_VAULT_COOKIE_PATH" in os.environ else None
+
+# Tried in this order when auto-detecting
+BROWSERS = ["arc", "chrome", "edge", "brave", "firefox", "chromium", "vivaldi", "opera", "safari"]
+
+
+def get_browser_cookies(browser_name: str) -> list[dict]:
+    """Read continente.pt cookies from the given browser."""
+    import browser_cookie3
+
+    getter = getattr(browser_cookie3, browser_name, None)
+    if getter is None:
+        raise ValueError(f"Browser '{browser_name}' not supported by browser-cookie3.")
+
+    jar = getter(domain_name=DOMAIN)
+    cookies = []
+    for c in jar:
+        cookies.append({
+            "domain": c.domain,
+            "name": c.name,
+            "value": c.value,
+            "path": getattr(c, "path", "/"),
+            "secure": bool(getattr(c, "secure", False)),
+            "httpOnly": c.has_nonstandard_attr("HttpOnly") if hasattr(c, "has_nonstandard_attr") else False,
+            "sameSite": "Lax",
+            "expires": getattr(c, "expires", None),
+        })
+    return cookies
+
+
+def find_cookies(browser: str | None) -> tuple[list[dict], str]:
+    """Return (cookies, browser_name). Tries specified browser or auto-detects."""
+    if browser:
+        try:
+            cookies = get_browser_cookies(browser)
+        except Exception as e:
+            print(f"Error reading {browser}: {e}", file=sys.stderr)
+            sys.exit(1)
+        if not cookies:
+            print(f"No Continente cookies found in {browser}. Are you logged in?", file=sys.stderr)
+            sys.exit(1)
+        return cookies, browser
+
+    print("Auto-detecting browser with Continente cookies...", file=sys.stderr)
+    for name in BROWSERS:
+        try:
+            cookies = get_browser_cookies(name)
+            if cookies:
+                return cookies, name
+        except Exception as e:
+            print(f"  {name}: {e}", file=sys.stderr)
+            continue
+
+    print(
+        "\nNo Continente cookies found in any supported browser.\n"
+        "Make sure you are logged into continente.pt, then try again.\n"
+        f"Supported browsers: {', '.join(BROWSERS)}",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+
+def write_cookie_file(cookies: list[dict], path: Path) -> None:
+    """Write cookies JSON and set owner-only permissions."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(cookies, indent=2, ensure_ascii=False))
+    os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)  # 600 — cookies = full account access
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Export Continente.pt browser cookies for use with continente-mcp.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--browser", "-b",
+        choices=BROWSERS,
+        metavar="BROWSER",
+        help=f"Browser to read from (default: auto-detect). One of: {', '.join(BROWSERS)}",
+    )
+    parser.add_argument(
+        "--output", "-o",
+        type=Path,
+        default=DEFAULT_OUTPUT,
+        help=f"Output path (default: {DEFAULT_OUTPUT})",
+    )
+    parser.add_argument(
+        "--list-browsers",
+        action="store_true",
+        help="List supported browsers and exit",
+    )
+    args = parser.parse_args()
+
+    if args.list_browsers:
+        print("Supported browsers: " + ", ".join(BROWSERS))
+        sys.exit(0)
+
+    try:
+        import browser_cookie3  # noqa: F401
+    except ImportError:
+        print(
+            "browser-cookie3 is not installed.\n"
+            "Run: pip install browser-cookie3",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    cookies, browser_name = find_cookies(args.browser)
+
+    write_cookie_file(cookies, args.output)
+    print(f"Saved {len(cookies)} cookies → {args.output}  (browser: {browser_name})")
+
+    # Optional: also write to a secondary path (e.g. for syncing to a remote machine)
+    if VAULT_PATH:
+        existing = []
+        if VAULT_PATH.exists():
+            try:
+                existing = json.loads(VAULT_PATH.read_text())
+            except Exception:
+                pass
+        if cookies != existing:
+            write_cookie_file(cookies, VAULT_PATH)
+            print(f"Saved {len(cookies)} cookies → {VAULT_PATH}  (vault sync)")
+        else:
+            print(f"Vault unchanged — skipping write to {VAULT_PATH}")
+
+
+if __name__ == "__main__":
+    main()

package/continente-keepalive.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+Continente Session Keepalive
+
+Pings continente.pt to reset the idle session timeout.
+If the session has expired, re-reads cookies from your browser automatically.
+
+Run every 20 minutes via cron or launchd:
+  */20 * * * * python3 /path/to/continente-keepalive.py >> ~/.continente/keepalive.log 2>&1
+"""
+import json
+import os
+import stat
+import subprocess
+import sys
+from pathlib import Path
+
+import requests
+
+LOCAL_COOKIE = Path(
+    os.environ.get("CONTINENTE_COOKIES_PATH", str(Path.home() / ".continente" / "cookies.json"))
+)
+PING_URL = "https://www.continente.pt/on/demandware.store/Sites-continente-Site/default/Account-Show"
+CHECK_URL = "https://www.continente.pt/conta/encomendas/"
+LOG_PREFIX = "[continente-keepalive]"
+
+USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+)
+
+
+def log(msg: str) -> None:
+    print(f"{LOG_PREFIX} {msg}", flush=True)
+
+
+def load_cookies(path: Path) -> list[dict] | None:
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+        return data if isinstance(data, list) else data.get("cookies")
+    except Exception as e:
+        log(f"Failed to read {path}: {e}")
+        return None
+
+
+def save_cookies(cookies: list[dict]) -> None:
+    LOCAL_COOKIE.parent.mkdir(parents=True, exist_ok=True)
+    LOCAL_COOKIE.write_text(json.dumps(cookies, indent=2, ensure_ascii=False))
+    os.chmod(LOCAL_COOKIE, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def is_logged_in(session: requests.Session) -> bool:
+    try:
+        r = session.get(CHECK_URL, timeout=10, allow_redirects=True)
+        return "login" not in r.url and r.status_code == 200
+    except Exception:
+        return False
+
+
+def refresh_from_browser() -> list[dict] | None:
+    """Re-run continente-cookie-reader.py to pull fresh cookies from the browser."""
+    script = Path(__file__).parent / "continente-cookie-reader.py"
+    if not script.exists():
+        log("continente-cookie-reader.py not found next to this script.")
+        return None
+    try:
+        result = subprocess.run(
+            [sys.executable, str(script)],
+            capture_output=True, text=True, timeout=30
+        )
+        output = (result.stdout + result.stderr).strip()
+        if output:
+            log(f"Cookie reader: {output}")
+        return load_cookies(LOCAL_COOKIE)
+    except Exception as e:
+        log(f"Cookie reader failed: {e}")
+        return None
+
+
+def ping(cookies: list[dict]) -> bool:
+    session = requests.Session()
+    session.headers.update({
+        "User-Agent": USER_AGENT,
+        "Accept-Language": "pt-PT,pt;q=0.9",
+    })
+    for c in cookies:
+        if c.get("name") and c["name"] != "undefined":
+            session.cookies.set(c["name"], c["value"], domain=c.get("domain", ".continente.pt"))
+
+    logged_in = is_logged_in(session)
+    if logged_in:
+        try:
+            session.get(PING_URL, timeout=10)
+        except Exception:
+            pass
+    return logged_in
+
+
+def main() -> None:
+    cookies = load_cookies(LOCAL_COOKIE)
+
+    if not cookies:
+        log("No cookies found — trying to refresh from browser...")
+        cookies = refresh_from_browser()
+        if not cookies:
+            log("ERROR: No cookies found. Run continente-cookie-reader.py first.")
+            sys.exit(1)
+
+    if ping(cookies):
+        log("Session alive.")
+        save_cookies(cookies)
+        return
+
+    log("Session expired — refreshing from browser...")
+    cookies = refresh_from_browser()
+    if not cookies:
+        log("ERROR: Could not refresh cookies. Run continente-cookie-reader.py manually.")
+        sys.exit(1)
+
+    if ping(cookies):
+        save_cookies(cookies)
+        log("Session restored.")
+        return
+
+    log(
+        "ERROR: Still not logged in after refresh. "
+        "Log into Continente in your browser and re-run continente-cookie-reader.py."
+    )
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "continente-mcp",
+  "version": "3.1.0",
+  "description": "MCP server for Continente.pt — search products, manage your cart, and browse order history from your AI assistant.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "continente-mcp": "src/index.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "setup": "playwright install chromium --with-deps",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "continente",
+    "supermarket",
+    "portugal",
+    "claude",
+    "ai-assistant",
+    "shopping",
+    "cart"
+  ],
+  "author": "David Marques",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davidmarqu3s/continente-mcp.git"
+  },
+  "homepage": "https://github.com/davidmarqu3s/continente-mcp",
+  "bugs": {
+    "url": "https://github.com/davidmarqu3s/continente-mcp/issues"
+  },
+  "files": [
+    "src/",
+    "skills/",
+    "continente-cookie-reader.py",
+    "continente-keepalive.py",
+    "continente-backup.js",
+    "check-change.js",
+    ".env.example",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "cheerio": "^1.2.0",
+    "playwright": "^1.59.1"
+  }
+}

package/skills/groceries/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: groceries
+description: Adds items to the Continente online shopping basket. Use this skill whenever the user says /groceries, wants to add something to their Continente cart, mentions shopping for groceries, or asks to "add X to the basket/cart". Also trigger for multi-item lists like "add milk, cheese and eggs to Continente". Works by matching item names against the user's favourites and order history before searching, so the right product variant gets added.
+---
+
+# Groceries Skill
+
+Add one or more items to the Continente shopping basket using the `continente-mcp` tools. Match against the user's purchase history to pick the right product variant.
+
+## Input parsing
+
+Items may come in various formats:
+- Single item: `add queijo flamengo to the cart`
+- Comma-separated: `/groceries leite, ovos, pão de forma`
+- Natural language: `I need some iogurte and manteiga from Continente`
+
+Parse all items before starting. If the input is ambiguous, ask to clarify.
+
+## Matching strategy (per item)
+
+The goal is to pick the product the user actually buys, not just any product with that name.
+
+**1. Search with favourites context**
+
+Call `search_products` with the item name. Results are automatically ranked by the favourites list — the top result is usually correct. Note the top 3.
+
+**2. Cross-check favourites**
+
+Call `get_favorites` once (reuse for all items in this request). If any favourite matches the item name, prefer it — even if not the top search result. A favourite is a stronger signal than search rank.
+
+**3. Fallback: order history**
+
+Only call `get_order_history` if the result is genuinely uncertain (e.g. several near-identical variants with different sizes/brands and no favourites match). Scan recent orders to break the tie.
+
+**4. Pick**
+
+If confidence is high (clear favourite or obvious top result), add silently and report afterwards. If genuinely ambiguous between two equally plausible products, show the top 2 and ask the user to pick.
+
+## Adding to cart
+
+Call `add_to_cart` with `product_id`. Default quantity is 1 unless specified (e.g. "2 pacotes de leite").
+
+## Output format
+
+After all items are processed, print a compact summary:
+
+```
+✓ Queijo Flamengo Mil Vacas 400g — added (from favourites)
+✓ Leite Mimosa Meio-Gordo 1L — added
+✗ Pão de Forma — unclear match, please check manually
+```
+
+## Error handling
+
+- No search results → report as not found, skip, continue with others
+- `add_to_cart` fails → report the error, move on
+- Never stop the whole run because one item failed
+
+## Performance
+
+`get_favorites` is slow. Call it once and reuse across all items. Only call `get_order_history` when favourites give no clear signal.

package/src/auth.js

@@ -0,0 +1,180 @@
+import { chromium } from 'playwright';
+
+const CONTINENTE_LOGIN_URL = 'https://login.continente.pt/u/login?clientId=NLR6WHyO8Iba4eRS&lang=pt-PT';
+const CONTINENTE_MAIN = 'https://www.continente.pt';
+const SESSION_DIR = `${process.env.HOME}/.continente`;
+
+export class Authenticator {
+  constructor() {
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+    this.cookies = [];
+  }
+
+  async ensureBrowser() {
+    if (!this.browser) {
+      this.browser = await chromium.launch({ headless: true });
+    }
+    if (!this.context) {
+      this.context = await this.browser.newContext({
+        userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
+        locale: 'pt-PT'
+      });
+      // Load existing cookies if available
+      await this.loadCookies();
+    }
+    if (!this.page) {
+      this.page = await this.context.newPage();
+    }
+    return this.page;
+  }
+
+  getCookiesPath() {
+    return `${SESSION_DIR}/session.json`;
+  }
+
+  async saveCookies() {
+    const fs = await import('fs');
+    try {
+      fs.mkdirSync(SESSION_DIR, { recursive: true });
+    } catch (e) {}
+    const cookies = await this.context.cookies();
+    fs.writeFileSync(this.getCookiesPath(), JSON.stringify(cookies, null, 2));
+  }
+
+  async loadCookies() {
+    const fs = await import('fs');
+    try {
+      const data = fs.readFileSync(this.getCookiesPath(), 'utf8');
+      const cookies = JSON.parse(data);
+      if (cookies.length > 0) {
+        await this.context.addCookies(cookies);
+        this.cookies = cookies;
+      }
+    } catch (e) {
+      // No cookies yet
+    }
+  }
+
+  async isLoggedIn() {
+    try {
+      const page = await this.ensureBrowser();
+      await page.goto(CONTINENTE_MAIN, { waitUntil: 'domcontentloaded', timeout: 15000 });
+      // Look for the account/logged-in state
+      const loginLink = await page.$('a[href*="logout"], a[href*="sair"], [class*="user"], [class*="account"]');
+      const pageContent = await page.content();
+      // If we see a logged-in indicator (e.g., user name in header)
+      const isLogged = pageContent.includes('data-testid="user"') || 
+                       pageContent.includes('class="logged-in') ||
+                       pageContent.includes('bjzIjUWquR'); // some session marker
+      return false; // Conservative - always try to re-auth for now
+    } catch (e) {
+      return false;
+    }
+  }
+
+  async login(email, password) {
+    const fs = await import('fs');
+    try { fs.mkdirSync(SESSION_DIR, { recursive: true }); } catch (e) {}
+    
+    const page = await this.ensureBrowser();
+    
+    console.error(`[Auth] Starting login flow for ${email}`);
+    
+    // Go to login page
+    await page.goto(CONTINENTE_LOGIN_URL, { waitUntil: 'networkidle', timeout: 30000 });
+    await page.waitForTimeout(2000);
+    
+    // Step 1: Enter email
+    console.error('[Auth] Step 1: Entering email...');
+    const emailInput = await page.waitForSelector('input[type="email"], input[type="text"]', { timeout: 10000 }).catch(() => null);
+    if (!emailInput) {
+      throw new Error('Could not find email input field');
+    }
+    
+    await emailInput.fill(email);
+    await page.waitForTimeout(500);
+    
+    // Click continue/next
+    const continueBtn = await page.waitForSelector('button[type="submit"], button:has-text("Avançar"), button:has-text("Continuar")', { timeout: 5000 }).catch(() => null);
+    if (continueBtn) {
+      await continueBtn.click();
+    } else {
+      await page.keyboard.press('Enter');
+    }
+    
+    await page.waitForTimeout(2000);
+    
+    // Step 2: Enter password
+    console.error('[Auth] Step 2: Entering password...');
+    const passwordInput = await page.waitForSelector('input[type="password"]', { timeout: 10000 }).catch(() => null);
+    if (!passwordInput) {
+      // Maybe already logged in or different flow
+      const currentUrl = page.url();
+      console.error(`[Auth] No password field found. Current URL: ${currentUrl}`);
+      throw new Error('Password field not found - login flow may have changed');
+    }
+    
+    await passwordInput.fill(password);
+    await page.waitForTimeout(500);
+    
+    // Submit
+    const submitBtn = await page.waitForSelector('button[type="submit"], button:has-text("Entrar"), button:has-text("Login")', { timeout: 5000 }).catch(() => null);
+    if (submitBtn) {
+      await submitBtn.click();
+    } else {
+      await page.keyboard.press('Enter');
+    }
+    
+    // Wait for redirect to main site
+    await page.waitForTimeout(3000);
+    await page.waitForURL(/continente\.pt/, { timeout: 15000 }).catch(() => {});
+    
+    const finalUrl = page.url();
+    console.error(`[Auth] Final URL after login: ${finalUrl}`);
+    
+    // Save session cookies
+    await this.saveCookies();
+    this.cookies = await this.context.cookies();
+    
+    console.error(`[Auth] Login successful, ${this.cookies.length} cookies saved`);
+    
+    return { success: true, url: finalUrl, cookies: this.cookies.length };
+  }
+
+  async logout() {
+    const fs = await import('fs');
+    if (this.page) {
+      try {
+        await this.page.goto(`${CONTINENTE_MAIN}/logout`, { timeout: 5000 }).catch(() => {});
+      } catch (e) {}
+      await this.page.close();
+      this.page = null;
+    }
+    if (this.context) {
+      await this.context.close();
+      this.context = null;
+    }
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+    // Remove saved cookies
+    try { fs.unlinkSync(this.getCookiesPath()); } catch (e) {}
+    console.error('[Auth] Logged out, session cleared');
+  }
+
+  async getSessionCookies() {
+    if (!this.context && !this.browser) {
+      await this.ensureBrowser();
+    }
+    return this.context ? await this.context.cookies() : [];
+  }
+
+  async close() {
+    if (this.page) { try { await this.page.close(); } catch (e) {} this.page = null; }
+    if (this.context) { try { await this.context.close(); } catch (e) {} this.context = null; }
+    if (this.browser) { try { await this.browser.close(); } catch (e) {} this.browser = null; }
+  }
+}