continente-mcp 3.1.0 → 4.0.0

package/.env.example

@@ -1,19 +1,27 @@
 # continente-mcp environment variables
-# Copy this to .env or set in your shell / launchd / systemd unit.
+# Copy this to a private env file, for example:
+#   ~/.continente/credentials.env
+#
+# Keep the real file outside your repo, chmod 600, and never commit it.
+
+# Required for automatic login.
+# CONTINENTE_EMAIL=you@example.com
+# CONTINENTE_PASSWORD=your-password
+
+# Optional: point the tools at a different private env file.
+# CONTINENTE_ENV_PATH=/absolute/path/to/credentials.env
+
+# Set to false only for local debugging, so you can watch the login browser.
+# CONTINENTE_LOGIN_HEADLESS=true
 
 # Path where cookies are stored (default: ~/.continente/cookies.json)
-# CONTINENTE_COOKIES_PATH=~/.continente/cookies.json
+# Cookies are an internal session cache; you usually do not need to edit this.
+# CONTINENTE_COOKIES_PATH=/absolute/path/to/cookies.json
 
 # If you run the MCP server on a second machine and sync cookies via a shared
 # folder (e.g. Obsidian vault, Syncthing, Dropbox), set this to the shared path
-# on the machine that runs the cookie reader. The reader will write cookies to
-# both the default path and this one whenever it runs.
+# for automatic login to also write cookies there.
 # CONTINENTE_VAULT_COOKIE_PATH=/path/to/shared/folder/cookies.json
 
-# Override the state directory (preferences, fingerprint, backups)
-# CONTINENTE_STATE_DIR=~/.continente
-
-# Webhook URL to notify when the website structure changes (check-change.js).
-# Supports anything that accepts a POST with { "text": "..." } — Slack, Discord,
-# n8n, Make, etc. If not set, changes are logged to stdout only.
-# CONTINENTE_ALERT_WEBHOOK=https://hooks.slack.com/services/...
+# Override the state directory (preferences and default cookies)
+# CONTINENTE_STATE_DIR=/absolute/path/to/state

package/README.md

@@ -1,325 +1,102 @@
-# continente-mcp
+# Continente MCP
 
-An [MCP (Model Context Protocol)](https://modelcontextprotocol.io) server for [Continente.pt](https://www.continente.pt) — Portugal's largest supermarket chain.
-
-Lets your AI assistant search products, manage your shopping cart, and browse order history using your real Continente account.
-
-> **⚠️ Stability note:** This server works by automating a real browser session against Continente's website using CSS selectors. If Continente updates their site structure, some tools may break. See [Detecting changes](#detecting-changes).
-
----
-
-## What it can do
-
-| Tool | Description |
-|------|-------------|
-| `search_products` | Search the catalogue — results ranked by your favourites |
-| `get_favorites` | List your saved favourite products |
-| `refresh_favorites` | Re-sync favourites from the website |
-| `get_cart` | View your current basket |
-| `add_to_cart` | Add a product by ID |
-| `get_order_history` | Recent orders with product lines |
-| `get_most_bought` | Products you order most often (scans all orders — slow) |
-| `close_session` | Close the browser and free memory |
-
----
-
-## Requirements
-
-- [Node.js](https://nodejs.org/) 18 or later
-- [Python](https://www.python.org/) 3.10+ (for the cookie export script)
-- A Continente.pt account, logged in on one of the [supported browsers](#supported-browsers)
-
----
+A local MCP server for Continente.pt: search products, rank favourites, manage your basket, and read order history. Checkout and payment stay on Continente.pt.
 
 ## Setup
 
-### 1. Clone and install
-
-The setup requires the repository — the Python cookie scripts live here and are needed before the server can authenticate.
+Requires **Node.js 20.18.1 or later** and a Continente account for favourites, basket and order history. Public product search works without login.
 
 ```bash
 git clone https://github.com/davidmarqu3s/continente-mcp
 cd continente-mcp
 npm install
-```
-
-Install the Chromium browser that Playwright uses internally:
-
-```bash
 npm run setup
-# or: npx playwright install chromium --with-deps
-```
-
-> **Linux note:** `--with-deps` installs OS-level dependencies via apt. On macOS and Windows this flag is a no-op — `npx playwright install chromium` is sufficient.
-
-Once set up, you can run the server either via the local clone or via `npx continente-mcp` — both work in your MCP client config (see [step 3](#3-configure-your-mcp-client)).
-
-### 2. Export your cookies
-
-The server authenticates using cookies from your existing browser session — no password handling, no OAuth flow. You need to be **logged into Continente.pt** in your browser first.
-
-Install the cookie reader dependencies:
-
-```bash
-python3 -m pip install browser-cookie3 requests   # macOS / Linux
-python  -m pip install browser-cookie3 requests   # Windows
-```
-
-Export your cookies:
-
-```bash
-python3 continente-cookie-reader.py   # macOS / Linux
-python  continente-cookie-reader.py   # Windows
-# Auto-detecting browser with Continente cookies...
-# Found 20 cookies in chrome.
-# Saved 20 cookies → ~/.continente/cookies.json  (browser: chrome)
-# On Windows: %USERPROFILE%\.continente\cookies.json
+mkdir -p ~/.continente
+cp .env.example ~/.continente/credentials.env
+chmod 600 ~/.continente/credentials.env
 ```
 
-To specify a browser explicitly:
+Edit the private credentials file and set `CONTINENTE_EMAIL` and `CONTINENTE_PASSWORD`, then verify login:
 
 ```bash
-python3 continente-cookie-reader.py --browser firefox
-python3 continente-cookie-reader.py --list-browsers   # see all supported browsers
+node continente-auto-login.js
 ```
 
-Cookies are saved to `~/.continente/cookies.json` (`%USERPROFILE%\.continente\cookies.json` on Windows) with owner-only read permissions.
+Login uses Playwright Chromium and saves a private session cache in `~/.continente/cookies.json`. Protected tool calls automatically log in again when the session expires. Python and scheduled keepalive jobs are not required to use the MCP server.
 
-### 3. Configure your MCP client
-
-This server works with any [MCP-compatible client](https://modelcontextprotocol.io/clients). The config format is the same across most of them — add an entry under `mcpServers` pointing to the server command.
-
-**Via npx (no local install needed):**
-
-```json
-{
-  "mcpServers": {
-    "continente": {
-      "command": "npx",
-      "args": ["continente-mcp"]
-    }
-  }
-}
-```
-
-**Via local clone:**
+Add the server to your MCP client using its local-server configuration. Clients using JSON `mcpServers` configuration can use:
 
 ```json
 {
   "mcpServers": {
     "continente": {
       "command": "node",
-      "args": ["/path/to/continente-mcp/src/index.js"]
-    }
-  }
-}
-```
-
-Where to put this config:
-
-| Client | Config file |
-|--------|-------------|
-| Claude Desktop (Mac) | `~/Library/Application Support/Claude/claude_desktop_config.json` |
-| Claude Desktop (Windows) | `%APPDATA%\Claude\claude_desktop_config.json` |
-| Cursor (Mac/Linux) | `.cursor/mcp.json` in your project, or `~/.cursor/mcp.json` globally |
-| Cursor (Windows) | `.cursor\mcp.json` in your project, or `%USERPROFILE%\.cursor\mcp.json` globally |
-| Windsurf (Mac/Linux) | `~/.codeium/windsurf/mcp_config.json` |
-| Windsurf (Windows) | `%USERPROFILE%\.codeium\windsurf\mcp_config.json` |
-| Other clients | See your client's MCP documentation |
-
----
-
-## Keeping the session alive
-
-Continente sessions expire after a period of inactivity. Run the keepalive script on a schedule to prevent this:
-
-**macOS (launchd), every 20 minutes:**
-
-Create `~/Library/LaunchAgents/com.continente.keepalive.plist`:
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>com.continente.keepalive</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>/usr/bin/python3</string>
-    <string>/path/to/continente-keepalive.py</string>
-  </array>
-  <key>StartInterval</key>
-  <integer>1200</integer>
-  <key>StandardOutPath</key>
-  <string>/tmp/continente-keepalive.log</string>
-  <key>StandardErrorPath</key>
-  <string>/tmp/continente-keepalive.log</string>
-</dict>
-</plist>
-```
-
-```bash
-launchctl load ~/Library/LaunchAgents/com.continente.keepalive.plist
-```
-
-**Linux / WSL (cron):**
-
-```bash
-crontab -e
-# Add:
-*/20 * * * * python3 /path/to/continente-keepalive.py >> ~/.continente/keepalive.log 2>&1
-```
-
-**Windows (Task Scheduler):**
-
-```powershell
-schtasks /create /tn "ContinenteKeepalive" /tr "python C:\path\to\continente-keepalive.py" /sc minute /mo 20 /f
-```
-
-Or open Task Scheduler and create a task that runs `python C:\path\to\continente-keepalive.py` every 20 minutes.
-
-If the session expires, the keepalive script will automatically re-read cookies from your browser.
-
----
-
-## Security
-
-- **Cookies give full account access** — they can view your address, manage your cart, and see your order history. Treat them like a password.
-- **macOS / Linux:** Cookies are stored at `~/.continente/cookies.json` with owner-only read permissions (`chmod 600`).
-- **Windows:** Cookies are stored at `%USERPROFILE%\.continente\cookies.json`. To restrict access: `icacls "%USERPROFILE%\.continente\cookies.json" /inheritance:r /grant:r "%USERNAME%:R"`
-- This path is excluded from git via `.gitignore`. Never commit it.
-- Cookies expire roughly every 30 days. Re-run `continente-cookie-reader.py` to refresh them.
-
----
-
-## Detecting changes
-
-Run `check-change.js` on a schedule to get notified if Continente updates their site structure in a way that might break scraping:
-
-```bash
-# First run saves a structural fingerprint
-node check-change.js
-```
-
-**Linux / WSL (cron):**
-```bash
-# Daily at 9am
-0 9 * * * node /path/to/check-change.js >> ~/.continente/change-detector.log 2>&1
-```
-
-**macOS (launchd):** Add a plist similar to the keepalive one above, with `StartInterval` set to `86400`.
-
-**Windows (Task Scheduler):**
-```powershell
-schtasks /create /tn "ContinenteChangeDetector" /tr "node C:\path\to\check-change.js" /sc daily /st 09:00 /f
-```
-
-To receive a webhook notification (Slack, Discord, n8n, etc.) on change, set `CONTINENTE_ALERT_WEBHOOK` in your environment or MCP client config:
-
-```bash
-# macOS / Linux
-export CONTINENTE_ALERT_WEBHOOK=https://hooks.slack.com/services/...
-
-# Windows cmd
-set CONTINENTE_ALERT_WEBHOOK=https://hooks.slack.com/services/...
-
-# Windows PowerShell
-$env:CONTINENTE_ALERT_WEBHOOK = "https://hooks.slack.com/services/..."
-```
-
-Or add it to your MCP client config under `env` (platform-neutral):
-
-```json
-{
-  "mcpServers": {
-    "continente": {
-      "command": "npx",
-      "args": ["continente-mcp"],
-      "env": {
-        "CONTINENTE_ALERT_WEBHOOK": "https://hooks.slack.com/services/..."
-      }
+      "args": ["/absolute/path/to/continente-mcp/src/index.js"]
     }
   }
 }
 ```
 
----
-
-## Utilities
-
-**Back up order history** (incremental — only fetches new orders):
-
-```bash
-node continente-backup.js
-# → ~/.continente/orders-backup.json
-# → %USERPROFILE%\.continente\orders-backup.json  (Windows)
-```
-
----
-
-## Supported browsers
-
-`continente-cookie-reader.py` can read cookies from:
-
-| Browser | macOS | Windows | Linux |
-|---------|-------|---------|-------|
-| Chrome | ✓ | ✓ | ✓ |
-| Edge | ✓ | ✓ | ✓ |
-| Brave | ✓ | ✓ | ✓ |
-| Firefox | ✓ | ✓ | ✓ |
-| Arc | ✓ | — | — |
-| Chromium | ✓ | ✓ | ✓ |
-| Vivaldi | ✓ | ✓ | ✓ |
-| Opera | ✓ | ✓ | ✓ |
-| Safari | ✓ | — | — |
+Restart the client after configuration or server changes. The published package can also run with `npx continente-mcp`; the local clone configuration above runs the code you just installed and tested. This is a local stdio server, not a hosted MCP endpoint.
 
-Powered by [browser-cookie3](https://github.com/borisbabic/browser_cookie3).
+For Windows, use your user profile directory instead of `~` and restrict the credentials/state directory through Windows filesystem permissions. On Linux, `npm run setup` may need administrator permission to install Chromium system dependencies; if already installed, `npx playwright install chromium` installs only the browser.
 
----
+## Tools
 
-## Environment variables
+| Tool | Purpose |
+| --- | --- |
+| `search_products` | Search the catalogue, with saved favourites ranked first |
+| `get_favorites` | Read cached favourites |
+| `refresh_favorites` | Refresh favourites from your account |
+| `get_cart` | Read the account basket |
+| `add_to_cart` | Add a product by ID |
+| `update_cart_item` | Set a basket quantity; zero removes the item |
+| `get_order_history` | Read recent orders |
+| `get_most_bought` | Aggregate products from order history |
+| `close_session` | Close the browser session |
 
-See [`.env.example`](./.env.example) for all options. The main ones:
+Run `refresh_favorites` once to personalise searches. Read the basket before changing it and verify quantities afterwards. An unrecognised basket page is an error, never proof that the basket is empty. Order aggregation can be slow because it visits order detail pages.
 
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `CONTINENTE_COOKIES_PATH` | `~/.continente/cookies.json` | Where cookies are read/written |
-| `CONTINENTE_STATE_DIR` | `~/.continente` | Directory for preferences, fingerprint, backups |
-| `CONTINENTE_ALERT_WEBHOOK` | — | Webhook URL for change detection alerts |
-| `CONTINENTE_VAULT_COOKIE_PATH` | — | Optional secondary path to also write cookies to (for multi-machine sync) |
+The bundled [groceries skill](skills/groceries/SKILL.md) guides agents through matching names to favourites and previous purchases. Add that skill directory through your client's supported skill installation mechanism.
 
-> **Windows:** Replace `~` with `%USERPROFILE%` (cmd) or `$env:USERPROFILE` (PowerShell). Node.js accepts both `/` and `\` as path separators.
+## Configuration and security
 
----
+Keep real credentials and cookie values out of the repository, client configuration, logs and screenshots. Both credentials and session cookies grant access to private account data. On macOS/Linux, use owner-only permissions (`chmod 600`) for secret files.
 
-## Skills
+See [`.env.example`](.env.example). Process environment settings override the private credentials file.
 
-The [`skills/`](./skills/) directory contains ready-made agent skills for clients that support them (e.g. Claude Code).
+| Variable | Purpose |
+| --- | --- |
+| `CONTINENTE_ENV_PATH` | Private credentials file; defaults to `~/.continente/credentials.env` |
+| `CONTINENTE_EMAIL`, `CONTINENTE_PASSWORD` | Account credentials for automatic login |
+| `CONTINENTE_STATE_DIR` | Local state directory; defaults to `~/.continente` |
+| `CONTINENTE_COOKIES_PATH` | Custom cookie cache path |
+| `CONTINENTE_LOGIN_HEADLESS` | Set `false` to inspect login in a visible browser |
+| `CONTINENTE_VAULT_COOKIE_PATH` | Optional secondary cookie file for private multi-machine sync |
 
-### groceries
+Prefer absolute paths for custom settings.
 
-Adds items to the basket by name. Matches against your favourites and order history to pick the right product variant automatically.
+## Troubleshooting and development
 
-Install it in Claude Code:
+- **Login required:** check the private credentials file and run `node continente-auto-login.js`.
+- **Browser missing:** run `npm run setup`.
+- **No favourites:** run `refresh_favorites`; catalogue search still works without them.
+- **Unexpected cart or product page:** report the tool and error, excluding account details and secrets.
 
 ```bash
-# From the repo root
-claude skill install skills/groceries
+npm test
+npm audit --omit=dev
+npm pack --dry-run
 ```
 
-Then use it:
-
-```
-/groceries queijo flamengo, leite mimosa, ovos
-```
+Unit tests do not establish that Continente's live website still matches every selector. Verify the affected tool against the live site after parser changes; do not place orders during testing.
 
-Or naturally: *"add some manteiga and pão de forma to my Continente cart"*
+Personal backup, keepalive, browser-cookie export and monitoring scripts are maintained separately in the private operations repository. They are not part of the npm package or the normal login workflow. Existing operators must migrate scheduled script paths before switching to this checkout.
 
-See [`skills/groceries/SKILL.md`](./skills/groceries/SKILL.md) for full details.
+## License
 
----
+[MIT](LICENSE)
 
-## License
+## Releases
 
-[MIT](./LICENSE)
+See the [changelog](CHANGELOG.md) and [release instructions](docs/releases.md). Version tags run the platform checks and publish matching npm/GitHub releases. Release candidates use npm's `next` channel; `latest` stays on the last stable release.

package/continente-auto-login.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+import { pathToFileURL } from 'node:url';
+import { chromium } from 'playwright';
+
+const CONTINENTE_LOGIN_URL = 'https://www.continente.pt/login/';
+const CONTINENTE_CHECK_URL = 'https://www.continente.pt/conta/encomendas/';
+const DEFAULT_ENV = process.env;
+
+function log(message) {
+  console.error(`[continente-auto-login] ${message}`);
+}
+
+function writeCookies(path, cookies) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(cookies, null, 2));
+  chmodSync(path, 0o600);
+}
+
+function unquoteEnvValue(value) {
+  const trimmed = value.trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function parseEnvFile(contents) {
+  const parsed = {};
+  for (const line of contents.split(/\r?\n/)) {
+    let raw = line.trim();
+    if (!raw || raw.startsWith('#')) continue;
+    if (raw.startsWith('export ')) raw = raw.slice('export '.length).trim();
+    const index = raw.indexOf('=');
+    if (index === -1) continue;
+    const key = raw.slice(0, index).trim();
+    const value = raw.slice(index + 1);
+    if (/^[A-Z_][A-Z0-9_]*$/.test(key)) {
+      parsed[key] = unquoteEnvValue(value);
+    }
+  }
+  return parsed;
+}
+
+export function credentialEnvPath(env = DEFAULT_ENV) {
+  const home = env.HOME || env.USERPROFILE || (env === DEFAULT_ENV ? homedir() : null);
+  const stateDir = env.CONTINENTE_STATE_DIR || (home ? join(home, '.continente') : null);
+  return env.CONTINENTE_ENV_PATH || (stateDir ? join(stateDir, 'credentials.env') : null);
+}
+
+export function loadCredentialEnv(env = DEFAULT_ENV) {
+  const file = credentialEnvPath(env);
+  if (!file || !existsSync(file)) {
+    return { ...env };
+  }
+  return { ...parseEnvFile(readFileSync(file, 'utf8')), ...env, CONTINENTE_ENV_PATH: file };
+}
+
+export function resolveStatePaths(env = DEFAULT_ENV) {
+  const settings = loadCredentialEnv(env);
+  const stateDir = settings.CONTINENTE_STATE_DIR || join(settings.HOME || settings.USERPROFILE || homedir(), '.continente');
+  return { stateDir, cookieFile: settings.CONTINENTE_COOKIES_PATH || join(stateDir, 'cookies.json') };
+}
+
+function syncVault(cookies, vaultCookiePath, logger) {
+  if (!vaultCookiePath) return;
+  const next = JSON.stringify(cookies, null, 2);
+  if (existsSync(vaultCookiePath) && readFileSync(vaultCookiePath, 'utf8') === next) {
+    logger('Vault unchanged.');
+    return;
+  }
+  writeCookies(vaultCookiePath, cookies);
+  logger('Vault cookies updated.');
+}
+
+export function getCredentialStatus(env = DEFAULT_ENV) {
+  const mergedEnv = loadCredentialEnv(env);
+  return {
+    hasEmail: Boolean(mergedEnv.CONTINENTE_EMAIL),
+    hasPassword: Boolean(mergedEnv.CONTINENTE_PASSWORD),
+    ready: Boolean(mergedEnv.CONTINENTE_EMAIL && mergedEnv.CONTINENTE_PASSWORD),
+  };
+}
+
+export async function isLoggedIn(page) {
+  const response = await page.goto(CONTINENTE_CHECK_URL, { waitUntil: 'domcontentloaded', timeout: 20000 });
+  if (!response?.ok() || page.url().includes('/login')) return false;
+  const session = await page.context().request.get(
+    'https://www.continente.pt/on/demandware.store/Sites-continente-Site/default/Cart-MiniCartShow',
+    { headers: { 'X-Requested-With': 'XMLHttpRequest' }, timeout: 10000 }
+  );
+  if (!session.ok()) return false;
+  const payload = await session.json().catch(() => null);
+  return payload?.resources?.customerAuthenticated === true;
+}
+
+async function fillFirst(page, selectors, value, label) {
+  for (const selector of selectors) {
+    const input = await page.waitForSelector(selector, { timeout: 3000 }).catch(() => null);
+    if (input) {
+      await input.fill(value);
+      return;
+    }
+  }
+  throw new Error(`Could not find ${label} input`);
+}
+
+async function clickFirst(page, selectors) {
+  for (const selector of selectors) {
+    const button = await page.$(selector);
+    if (button) {
+      await button.click();
+      return true;
+    }
+  }
+  await page.keyboard.press('Enter');
+  return false;
+}
+
+async function acceptCookies(page) {
+  await page.getByRole('button', { name: /PERMITIR TODOS|Permitir todos/i })
+    .click({ timeout: 5000 })
+    .catch(() => {});
+}
+
+async function findLoginFrame(page) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    const frame = page.frames().find((candidate) =>
+      candidate.url().includes('login.continente.pt/user-register')
+    );
+    if (frame) {
+      return frame;
+    }
+    await page.waitForTimeout(500);
+  }
+  throw new Error('Could not find Continente login frame');
+}
+
+export async function autoLogin({
+  env = DEFAULT_ENV,
+  log: logger = log,
+} = {}) {
+  const mergedEnv = loadCredentialEnv(env);
+  const email = mergedEnv.CONTINENTE_EMAIL;
+  const password = mergedEnv.CONTINENTE_PASSWORD;
+
+  if (!getCredentialStatus(mergedEnv).ready) {
+    logger('Missing CONTINENTE_EMAIL or CONTINENTE_PASSWORD.');
+    return { success: false, error: 'missing_credentials' };
+  }
+
+  const browser = await chromium.launch({
+    headless: mergedEnv.CONTINENTE_LOGIN_HEADLESS !== 'false',
+  });
+
+  try {
+    const context = await 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',
+    });
+    const page = await context.newPage();
+
+    logger('Opening login page.');
+    await page.goto(CONTINENTE_LOGIN_URL, { waitUntil: 'domcontentloaded', timeout: 30000 });
+    await acceptCookies(page);
+    const loginFrame = await findLoginFrame(page);
+
+    logger('Entering email.');
+    await fillFirst(loginFrame, [
+      '#userNameCC',
+      'input[name="userNameCC"]',
+      'input[type="email"]',
+      'input[name="email"]',
+      'input[name="username"]',
+      'input[type="text"]',
+    ], email, 'email');
+
+    await clickFirst(loginFrame, [
+      'button[type="submit"]',
+      'button:has-text("Avançar")',
+      'button:has-text("Continuar")',
+    ]);
+
+    logger('Entering password.');
+    await page.waitForTimeout(1500);
+    await fillFirst(loginFrame, [
+      '#password_input',
+      'input[name="password_input"]',
+      'input[type="password"]',
+      'input[name="password"]',
+    ], password, 'password');
+
+    await clickFirst(loginFrame, [
+      'button[type="submit"]',
+      'button:has-text("Avançar")',
+      'button:has-text("Entrar")',
+      'button:has-text("Login")',
+    ]);
+
+    await page.waitForTimeout(4000);
+    await page.waitForLoadState('domcontentloaded', { timeout: 15000 }).catch(() => {});
+
+    if (!(await isLoggedIn(page))) {
+      throw new Error('Login did not reach an authenticated Continente page');
+    }
+
+    const cookies = await context.cookies();
+    writeCookies(resolveStatePaths(mergedEnv).cookieFile, cookies);
+    syncVault(cookies, mergedEnv.CONTINENTE_VAULT_COOKIE_PATH, logger);
+    logger(`Saved ${cookies.length} cookies.`);
+    return { success: true, cookies: cookies.length };
+  } finally {
+    await browser.close();
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  autoLogin().then((result) => {
+    if (!result.success) {
+      process.exit(1);
+    }
+  }).catch((error) => {
+    log(error.message);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,19 +1,20 @@
 {
   "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.",
+  "version": "4.0.0",
+  "description": "MCP server for Continente.pt — search products, manage your cart, and browse order history.",
   "type": "module",
   "main": "src/index.js",
   "bin": {
     "continente-mcp": "src/index.js"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.18.1"
   },
   "scripts": {
     "start": "node src/index.js",
     "setup": "playwright install chromium --with-deps",
-    "test": "echo \"No tests yet\" && exit 0"
+    "test": "node --test",
+    "check:release": "node scripts/check-release.js"
   },
   "keywords": [
     "mcp",
@@ -39,10 +40,7 @@
   "files": [
     "src/",
     "skills/",
-    "continente-cookie-reader.py",
-    "continente-keepalive.py",
-    "continente-backup.js",
-    "check-change.js",
+    "continente-auto-login.js",
     ".env.example",
     "LICENSE",
     "README.md"