continentept-mcp 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -6,6 +6,45 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-10-16
+
+### Fixed
+
+- `get_product` reported some products as available that could not be bought: the page's structured data said in stock while its add button was disabled. Availability now follows the page's own add button, with the structured data as a fallback.
+- A product page the website redirects to its home page was reported as "no longer sold". It may only be hidden from this session: the same product can open signed in and redirect signed out, or not be sold in your area. The `not_found` message now says so.
+
+- Some products sold by the piece but priced per kg, such as onions, were shown in the cart with the wrong number of pieces: 4 onions read as 1, so setting them to 4 always ended with an unknown outcome. For these products the cart's JSON does not count pieces; the quantity is now read from the kilograms on the cart page, and stays unknown when that is not a whole number of pieces.
+
+### Changed
+
+- **Breaking:** `search_products` keeps the website's relevance order. Saved favorites are still marked `favorite: true`, but only move to the top with the new `favoritesFirst: true`, and then only within the returned products.
+
+### Added
+
+- `search_products` filters by `category`, `excludeCategory` and `brand`, and sorts by `unit_price`. Results have `brand` and `category` (the website's category path), filtered searches read further pages to fill `limit`, and `unknownToFilter` counts products left out only because the results page gave no category or brand for them.
+- `search_products` and `get_product` return `drainedPrice`, the price per kg of drained weight, for packs whose label states a drained weight.
+- `get_product_labels`: ingredients, allergens and nutrition for up to 20 products, as the website's copy of each label declares them. It returns the ingredients verbatim, the words they print in capitals, the allergen and "may contain traces" statements, and nutrients per 100 g or ml. Nothing is inferred.
+- Cart and `preview_basket` lines have `storefrontQuantity` for products sold by the piece but priced by weight: the kilograms in the cart, which are also the estimated weight. `get_cart` text shows it, as in "4 un (about 1.16 kg)".
+- `search_products`, `get_product` and `preview_basket` return `catalogView`: whether the result is the signed-in or the signed-out catalogue, which can differ in availability and in which products open.
+- Search results have `availability`, from the results page: `available` or `unavailable` when its "Indisponível" badge and add button agree, `unknown` otherwise. Unavailable results are marked in the text.
+- `preview_basket`: for a list of products and desired totals, what the cart holds now, what `set_cart_item_quantity` would do, what would be refused and why, availability, pack details and the estimated cost. It changes nothing.
+- `search_products` accepts `cursor`: pass `nextCursor` back with the same query to continue right after the last product returned. Following cursors never skips or repeats a result. Before, products read beyond `limit` were dropped and `nextCursor` could not be used.
+- `search_products`, `get_product` and `get_cart` return `observedAt`, when the website was read.
+- Cart lines and totals have `estimated`: products sold by the piece but priced by weight are charged by the weight picked, so their line total, and then the cart totals, are estimates. `get_cart` text says "about" for them.
+
+- `search_products` and `get_product` return `package`, the pack label read into numbers: `count`, `each`, `net` (including any free extra), `drained` and `approximate`. For example, `6 x 1 lt` is 6 items of 1 l, 6 l in total. A label with an unknown part gives `null`.
+- `get_product` returns `packageText` and `minimumText`, like `search_products`, and shows the pack size in its text.
+- A `not_authenticated` error before any cart write carries `signIn`: whether credentials are configured, what to do next, the settings and command involved, and which tools work without signing in.
+
+## [0.6.1] - 2026-10-15
+
+### Fixed
+
+- The first request after the browser started could fail with "The order history page was not recognised", or a search error, while the website was still setting up its session. A page that does not show what it should is now loaded once more.
+- Order dates with abbreviated months, as the website now shows them ("01 Set 26"), are read. They were all `null`.
+- `get_product` reports a product the website no longer sells as `not_found`, instead of `invalid_data`.
+- After an upgrade, the update check no longer reports an older version as the latest one.
+
 ## [0.6.0] - 2026-10-15
 
 ### Changed
@@ -88,7 +127,9 @@ All notable changes to this project are documented here. The format follows
 - Automatic sign-in from environment variables or a private credentials file, and a `login` command.
 - The `basket-planner` skill for planning a shopping list and updating the basket.
 
-[Unreleased]: https://github.com/andredelgado/continente-mcp/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/andredelgado/continente-mcp/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/andredelgado/continente-mcp/compare/v0.6.1...v0.7.0
+[0.6.1]: https://github.com/andredelgado/continente-mcp/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/andredelgado/continente-mcp/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/andredelgado/continente-mcp/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/andredelgado/continente-mcp/compare/v0.3.1...v0.4.0

package/README.md

@@ -116,10 +116,12 @@ Continente cart"* or *"What do I usually buy? Build me a list for this week."*
 
 | Tool | What it does |
 | --- | --- |
-| `search_products` | Search the catalogue; favorites rank first |
-| `get_product` | Price, availability and sale rules for one product |
+| `search_products` | Search the catalogue in relevance order, with favorites marked and a cursor for more |
+| `get_product` | Price, pack size, availability and sale rules for one product |
+| `get_product_labels` | Ingredients, allergens and nutrition as the label declares them |
 | `list_favorites` | Your saved favorites (`refresh: true` fetches the latest) |
 | `get_cart` | Cart lines, quantities, bags and totals |
+| `preview_basket` | What a list of changes would do and cost, without changing the cart |
 | `add_cart_item` | Add an amount on top of what is in the cart |
 | `set_cart_item_quantity` | Make the cart hold exactly a quantity; zero removes |
 | `remove_cart_item` | Remove a line from the cart |

package/dist/clients/storefront.d.ts

@@ -1,5 +1,5 @@
-import type { CatalogGateway, FavoritesGateway, CartGateway, OrdersGateway, PreparedCartMutation, RetrievedPages } from '../ports.js';
-import type { Result, ToolError } from '../domain/index.js';
+import type { CatalogGateway, FavoritesGateway, CartGateway, OrdersGateway, PreparedCartMutation, RetrievedPages, SearchResume } from '../ports.js';
+import type { Product, Result, ToolError } from '../domain/index.js';
 import type { BrowserLease, StorefrontSession } from '../session/browser.js';
 export declare const CART_SUMMARY_URL = "https://www.continente.pt/on/demandware.store/Sites-continente-Site/default/Cart-MiniCartShow";
 export declare class StorefrontClient {
@@ -7,6 +7,16 @@ export declare class StorefrontClient {
     constructor(session: StorefrontSession);
     io<T>(lease: BrowserLease, operation: () => Promise<T>): Promise<T>;
     navigateToStorefrontPage(path: string): Promise<Result<BrowserLease, ToolError>>;
+    /**
+     * Load a page and wait for a marker only the expected page has. A fresh browser's first visit can
+     * land on an interim page while the website sets up its session, so a page without the marker is
+     * loaded once more; `ready` says whether the marker appeared. `landed` rejects a final URL early.
+     */
+    readPage(path: string, marker: string, landed?: (url: URL) => ToolError | null): Promise<Result<{
+        html: string;
+        url: string;
+        ready: boolean;
+    }, ToolError>>;
     html(path: string, marker?: string): Promise<Result<string, ToolError>>;
 }
 export declare class CatalogClient implements CatalogGateway {
@@ -16,8 +26,17 @@ export declare class CatalogClient implements CatalogGateway {
         html: string;
         url: string;
     }, ToolError>>;
-    searchProducts(query: string, limit: number): Promise<Result<RetrievedPages, ToolError>>;
+    fetchProductLabel(url: string): Promise<Result<string, ToolError>>;
+    /**
+     * Read result pages until `limit` products are collected, at most five pages. `resume` continues
+     * at a position of the full list: from the results grid when its URL is known, otherwise from
+     * the first page, whose earlier results the caller drops.
+     */
+    searchProducts(query: string, limit: number, resume?: SearchResume, accept?: (product: Product) => boolean): Promise<Result<RetrievedPages, ToolError>>;
 }
+/** The results grid URL without its position, so a search can continue anywhere in the list. */
+export declare function searchGridBase(url: string): string;
+export declare function searchGridUrl(base: string, start: number): string;
 export declare class FavoritesClient implements FavoritesGateway {
     private readonly site;
     constructor(site: StorefrontClient);

package/dist/clients/storefront.js

@@ -40,20 +40,36 @@ export class StorefrontClient {
             return browserFailure(error);
         }
     }
-    async html(path, marker = 'main, [role="main"], .product-line, a[href*="/produto/"]') {
-        const response = await this.navigateToStorefrontPage(path);
-        if (!response.ok)
-            return response;
-        try {
-            await this.io(response.value, () => response.value.page.waitForSelector(marker, { state: 'attached', timeout: requestTimeout(10000) }));
-            return success(await this.io(response.value, () => response.value.page.content()));
-        }
-        catch (error) {
-            if (error instanceof RequestStopped)
-                throw error;
-            return failure('upstream_unavailable', 'Page readiness marker was not found');
+    /**
+     * Load a page and wait for a marker only the expected page has. A fresh browser's first visit can
+     * land on an interim page while the website sets up its session, so a page without the marker is
+     * loaded once more; `ready` says whether the marker appeared. `landed` rejects a final URL early.
+     */
+    async readPage(path, marker, landed) {
+        for (let attempt = 1;; attempt++) {
+            const response = await this.navigateToStorefrontPage(path);
+            if (!response.ok)
+                return response;
+            const lease = response.value;
+            const rejected = landed?.(new URL(lease.page.url()));
+            if (rejected)
+                return { ok: false, error: rejected };
+            try {
+                const ready = await this.io(lease, () => lease.page.waitForSelector(marker, { state: 'attached', timeout: requestTimeout(10000) }).then(() => true, () => false));
+                if (ready || attempt === 2)
+                    return success({ html: await this.io(lease, () => lease.page.content()), url: lease.page.url(), ready });
+            }
+            catch (error) {
+                return browserFailure(error);
+            }
         }
     }
+    async html(path, marker = 'main, [role="main"], .product-line, a[href*="/produto/"]') {
+        const page = await this.readPage(path, marker);
+        if (!page.ok)
+            return page;
+        return page.value.ready ? success(page.value.html) : failure('upstream_unavailable', 'Page readiness marker was not found');
+    }
 }
 export class CatalogClient {
     site;
@@ -61,40 +77,57 @@ export class CatalogClient {
         this.site = site;
     }
     async fetchProductDetails(reference) {
-        const result = await this.site.navigateToStorefrontPage(productPath(reference));
-        if (!result.ok)
-            return result;
-        try {
-            await this.site.io(result.value, () => result.value.page.waitForSelector('h1.product-name, main', { state: 'attached', timeout: requestTimeout(10000) }));
-            return success({ html: await this.site.io(result.value, () => result.value.page.content()), url: result.value.page.url() });
-        }
-        catch (error) {
-            if (error instanceof RequestStopped)
-                throw error;
-            return failure('invalid_data', 'Product detail content is unavailable');
-        }
+        // The website redirects a product page it does not show to this session to its home page. It may be
+        // sold elsewhere: the same product can open signed in and redirect signed out.
+        const page = await this.site.readPage(productPath(reference), 'h1.product-name, .ct-pdp--prices', url => url.pathname.startsWith('/produto/') ? null : failure('not_found', 'The website does not show this product to this session: it may not be sold in your area, or no longer be sold').error);
+        if (!page.ok)
+            return page;
+        return page.value.ready ? success({ html: page.value.html, url: page.value.url }) : failure('invalid_data', 'Product detail content is unavailable');
+    }
+    async fetchProductLabel(url) {
+        const href = storefrontUrl(url);
+        if (!href || !new URL(href).pathname.endsWith('/Product-ProductNutritionalInfoTab'))
+            return failure('invalid_input', 'Invalid product label URL');
+        return readContinuation(this.site, href);
     }
-    async searchProducts(query, limit) {
-        const first = await this.site.html(`/pesquisa/?q=${encodeURIComponent(query)}`, '.ct-inner-tile-wrap, .search-noresults-wrapper, .search-no-results, [data-search-empty]');
+    /**
+     * Read result pages until `limit` products are collected, at most five pages. `resume` continues
+     * at a position of the full list: from the results grid when its URL is known, otherwise from
+     * the first page, whose earlier results the caller drops.
+     */
+    async searchProducts(query, limit, resume, accept = () => true) {
+        const from = resume?.start ?? 0;
+        const resumeUrl = resume?.grid ? searchGridUrl(resume.grid, from) : null;
+        const first = resumeUrl ? await readContinuation(this.site, resumeUrl)
+            : await this.site.html(`/pesquisa/?q=${encodeURIComponent(query)}`, '.ct-inner-tile-wrap, .search-noresults-wrapper, .search-no-results, [data-search-empty]');
         if (!first.ok)
             return first;
         const pages = [];
+        const starts = [];
         const failures = [];
         const ids = new Set();
+        const seen = new Set();
         const visited = new Set();
         let html = first.value;
+        let start = resumeUrl ? from : 0;
+        let grid = resume?.grid ?? null;
         let nextCursor = null;
         for (let index = 0; index < 5; index++) {
-            const parsed = parseProductSearchPage(html);
+            const parsed = parseProductSearchPage(html, start);
             if (!parsed.ok) {
                 if (!pages.length)
                     return parsed;
                 failures.push(parsed.error);
                 break;
             }
-            const previousCount = ids.size;
-            parsed.value.products.forEach(product => ids.add(product.productId));
+            const previousCount = seen.size;
+            parsed.value.products.forEach((product, position) => {
+                seen.add(product.productId);
+                if ((parsed.value.positions[position] ?? 0) >= from && accept(product))
+                    ids.add(product.productId);
+            });
             pages.push(html);
+            starts.push(start);
             reportProgress(pages.length, 5, 'Reading catalogue pages');
             const continuation = parseSearchPagination(html);
             if (!continuation.ok) {
@@ -103,25 +136,41 @@ export class CatalogClient {
                 break;
             }
             nextCursor = continuation.value?.url ?? null;
-            if (!nextCursor || ids.size >= limit)
+            if (continuation.value)
+                grid ??= searchGridBase(continuation.value.url);
+            if (!continuation.value || ids.size >= limit)
                 break;
-            if (visited.has(nextCursor) || (index > 0 && ids.size === previousCount)) {
+            if (visited.has(continuation.value.url) || (index > 0 && seen.size === previousCount)) {
                 failures.push(failure('invalid_data', 'Search pagination did not advance').error);
                 break;
             }
             if (index === 4)
                 break;
-            visited.add(nextCursor);
-            const response = await readContinuation(this.site, nextCursor);
+            visited.add(continuation.value.url);
+            const response = await readContinuation(this.site, continuation.value.url);
             if (!response.ok) {
                 failures.push(response.error);
                 break;
             }
             html = response.value;
+            start = continuation.value.start;
         }
-        return success({ pages, failures, nextCursor, completeness: failures.length ? 'partial' : nextCursor ? 'unknown' : 'complete' });
+        return success({ pages, starts, grid, failures, nextCursor, completeness: failures.length ? 'partial' : nextCursor ? 'unknown' : 'complete' });
     }
 }
+/** The results grid URL without its position, so a search can continue anywhere in the list. */
+export function searchGridBase(url) {
+    const base = new URL(url);
+    base.searchParams.delete('start');
+    base.searchParams.delete('sz');
+    return base.href;
+}
+export function searchGridUrl(base, start) {
+    const url = new URL(base);
+    url.searchParams.set('start', String(start));
+    url.searchParams.set('sz', '35');
+    return url.href;
+}
 async function readContinuation(site, url) {
     try {
         const lease = await site.session.ensureReady();
@@ -280,17 +329,9 @@ export class OrdersClient {
         const path = cursor === undefined ? '/conta/encomendas/' : orderHistoryUrl(cursor);
         if (!path)
             return failure('invalid_input', 'Invalid order history cursor');
-        const response = await this.site.navigateToStorefrontPage(path);
-        if (!response.ok)
-            return response;
-        const { page } = response.value;
-        try {
-            await this.site.io(response.value, () => page.waitForSelector('main, [role="main"], a[href*="detalhe-encomenda"]', { state: 'attached', timeout: requestTimeout(10000) }));
-            return success(await this.site.io(response.value, () => page.content()));
-        }
-        catch (error) {
-            return browserFailure(error);
-        }
+        // Without the marker the page is still handed to the parser, which says what it does not recognise.
+        const page = await this.site.readPage(path, '.ct-order-history--landing-container, .ct-order-history--order-preview-item');
+        return page.ok ? success(page.value.html) : page;
     }
     async fetchOrderLines(url) {
         const href = storefrontUrl(url);