continente-mcp 3.1.0 → 4.1.0

package/.env.example

@@ -1,19 +1,29 @@
 # 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: use a different private env file. This one cannot go in the file
+# itself; set it in your MCP client's server "env" instead.
+# 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. These cookies give access
+# to your account: only use a private folder you control.
 # 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,64 @@
-# 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.
+Let your AI assistant search Continente.pt and fill your basket with the products you usually buy.
 
-Lets your AI assistant search products, manage your shopping cart, and browse order history using your real Continente account.
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-> **⚠️ 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).
+## Features
 
----
+- **Search that knows your habits** — catalogue results put your saved favourites first.
+- **Hands-free basket** — add, change and remove items; every change is checked against the basket afterwards.
+- **Order history** — read recent orders and see your most-bought products.
+- **Automatic login** — expired sessions sign in again on their own from a private credentials file.
+- **You stay in control** — checkout and payment always happen on Continente.pt.
 
-## What it can do
+## Install
 
-| 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)
-
----
-
-## Setup
-
-### 1. Clone and install
-
-The setup requires the repository — the Python cookie scripts live here and are needed before the server can authenticate.
-
-```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
-```
-
-To specify a browser explicitly:
-
-```bash
-python3 continente-cookie-reader.py --browser firefox
-python3 continente-cookie-reader.py --list-browsers   # see all supported browsers
-```
-
-Cookies are saved to `~/.continente/cookies.json` (`%USERPROFILE%\.continente\cookies.json` on Windows) with owner-only read permissions.
-
-### 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:**
-
-```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):**
+Requires Node.js 20.18.1 or later. Install the browser the server uses (on Linux, add `--with-deps`):
 
 ```bash
-crontab -e
-# Add:
-*/20 * * * * python3 /path/to/continente-keepalive.py >> ~/.continente/keepalive.log 2>&1
+npx -y -p continente-mcp playwright install chromium
 ```
 
-**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.
+For favourites, basket and order history, create `~/.continente/credentials.env` with your Continente login and make it private to your user (`chmod 600` on macOS/Linux). Search works without it.
 
----
-
-## 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
+CONTINENTE_EMAIL=you@example.com
+CONTINENTE_PASSWORD=your-password
 ```
 
-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):
+Then add the server to your MCP client and restart it:
 
 ```json
 {
   "mcpServers": {
-    "continente": {
-      "command": "npx",
-      "args": ["continente-mcp"],
-      "env": {
-        "CONTINENTE_ALERT_WEBHOOK": "https://hooks.slack.com/services/..."
-      }
-    }
+    "continente": { "command": "npx", "args": ["-y", "continente-mcp"] }
   }
 }
 ```
 
----
-
-## 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 | ✓ | — | — |
-
-Powered by [browser-cookie3](https://github.com/borisbabic/browser_cookie3).
-
----
-
-## Environment variables
-
-See [`.env.example`](./.env.example) for all options. The main ones:
+To run from source instead, clone the repository, run `npm install && npm run setup`, and use `node /absolute/path/to/continente-mcp/src/index.js` as the command.
 
-| 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) |
+## Use
 
-> **Windows:** Replace `~` with `%USERPROFILE%` (cmd) or `$env:USERPROFILE` (PowerShell). Node.js accepts both `/` and `\` as path separators.
-
----
-
-## Skills
-
-The [`skills/`](./skills/) directory contains ready-made agent skills for clients that support them (e.g. Claude Code).
-
-### groceries
-
-Adds items to the basket by name. Matches against your favourites and order history to pick the right product variant automatically.
-
-Install it in Claude Code:
-
-```bash
-# From the repo root
-claude skill install skills/groceries
-```
-
-Then use it:
-
-```
-/groceries queijo flamengo, leite mimosa, ovos
-```
+Ask your assistant things like "add milk, eggs and bread to my Continente basket". Run `refresh_favorites` once so searches know what you buy.
 
-Or naturally: *"add some manteiga and pão de forma to my Continente cart"*
+| Tool | Purpose |
+| --- | --- |
+| `search_products` | Search the catalogue, favourites first |
+| `get_favorites` / `refresh_favorites` | Read cached favourites / refresh them from your account |
+| `get_cart` | Read the basket |
+| `add_to_cart` / `update_cart_item` | Add a product / set its quantity (zero removes it) |
+| `get_order_history` / `get_most_bought` | Read recent orders / your most-bought products |
+| `close_session` | Close the browser session |
 
-See [`skills/groceries/SKILL.md`](./skills/groceries/SKILL.md) for full details.
+## More
 
----
+- **Agents:** the [groceries skill](skills/groceries/SKILL.md) teaches assistants to pick the products you usually buy.
+- **Settings:** custom credential, state and cookie paths are listed in [`.env.example`](.env.example).
+- **Troubleshooting:** [docs/troubleshooting.md](docs/troubleshooting.md).
+- **Developers:** [docs/development.md](docs/development.md) and [docs/releases.md](docs/releases.md).
 
 ## License
 
-[MIT](./LICENSE)
+[MIT](LICENSE)

package/continente-auto-login.js

@@ -0,0 +1,233 @@
+#!/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}`);
+}
+
+export function writeCookies(path, cookies) {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  // Create owner-only; chmod also tightens files created by older versions.
+  writeFileSync(path, JSON.stringify(cookies, null, 2), { mode: 0o600 });
+  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.1.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,16 +40,13 @@
   "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"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.32.1",
     "cheerio": "^1.2.0",
     "playwright": "^1.59.1"
   }