good-eggs-mcp-server 0.1.0 → 0.1.2

package/build/index.js

@@ -70,7 +70,7 @@ async function main() {
     // Step 1: Validate environment variables
     validateEnvironment();
     // Step 2: Create server using factory
-    const { server, registerHandlers, cleanup } = createMCPServer();
+    const { server, registerHandlers, cleanup, startBackgroundLogin } = createMCPServer();
     // Step 3: Register all handlers (tools)
     await registerHandlers(server);
     // Step 4: Set up graceful shutdown
@@ -85,6 +85,23 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     logServerStart('Good Eggs');
+    // Step 6: Start background login process
+    // This kicks off Playwright and performs login without blocking the stdio connection.
+    // If login fails, the server will close with an error.
+    logWarning('login', 'Starting background login to Good Eggs...');
+    startBackgroundLogin((error) => {
+        // Login failed - log error and exit
+        logError('login', `Background login failed: ${error.message}`);
+        logError('login', 'Server shutting down due to authentication failure.');
+        // Clean up and exit with error
+        cleanup()
+            .catch((cleanupError) => {
+            logError('cleanup', `Error during cleanup: ${cleanupError}`);
+        })
+            .finally(() => {
+            process.exit(1);
+        });
+    });
 }
 // Run the server
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "good-eggs-mcp-server",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "MCP server for Good Eggs grocery shopping with Playwright automation",
   "main": "build/index.js",
   "type": "module",

package/shared/server.d.ts

@@ -90,6 +90,11 @@ export declare class GoodEggsClient implements IGoodEggsClient {
     getConfig(): GoodEggsConfig;
 }
 export type ClientFactory = () => IGoodEggsClient;
+/**
+ * Callback invoked when background login fails
+ * @param error The error that caused login to fail
+ */
+export type LoginFailedCallback = (error: Error) => void;
 export declare function createMCPServer(): {
     server: Server<{
         method: string;
@@ -116,5 +121,6 @@ export declare function createMCPServer(): {
     }>;
     registerHandlers: (server: Server, clientFactory?: ClientFactory) => Promise<void>;
     cleanup: () => Promise<void>;
+    startBackgroundLogin: (onFailed?: LoginFailedCallback) => void;
 };
 //# sourceMappingURL=server.d.ts.map

package/shared/server.js

@@ -41,7 +41,9 @@ export class GoodEggsClient {
         });
         this.page = await this.context.newPage();
         // Navigate to login page
-        await this.page.goto(`${BASE_URL}/signin`, { waitUntil: 'networkidle' });
+        // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections that prevent networkidle
+        await this.page.goto(`${BASE_URL}/signin`, { waitUntil: 'domcontentloaded' });
+        await this.page.waitForTimeout(2000);
         // Fill in login credentials
         await this.page.fill('input[name="email"], input[type="email"]', this.config.username);
         await this.page.fill('input[name="password"], input[type="password"]', this.config.password);
@@ -61,22 +63,40 @@ export class GoodEggsClient {
     async searchGroceries(query) {
         const page = await this.ensureBrowser();
         // Navigate to search page
+        // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
         await page.goto(`${BASE_URL}/search?q=${encodeURIComponent(query)}`, {
-            waitUntil: 'networkidle',
+            waitUntil: 'domcontentloaded',
         });
-        // Wait for products to load
-        await page.waitForTimeout(1000);
+        // Wait for React to render the product list
+        await page.waitForTimeout(3000);
         // Extract product information from the page
         const items = await page.evaluate(() => {
             const products = [];
-            // Find all product cards/links by looking for product name elements
-            const productElements = document.querySelectorAll('a[href*="/product/"], a[href*="goodeggs"]');
             const seen = new Set();
+            // Good Eggs uses 'js-product-link' class for product links
+            // URL format: /producer-slug/product-slug/product-id (e.g., /cloversfbay/organic-whole-milk/53fe295358ed090200000f2d)
+            const productElements = document.querySelectorAll('a.js-product-link');
             productElements.forEach((el) => {
                 const link = el;
                 const href = link.href;
-                // Skip if not a product link or already seen
-                if (!href || seen.has(href) || href.includes('/search') || href.includes('/signin')) {
+                // Skip if already seen or not a valid product URL
+                if (!href || seen.has(href)) {
+                    return;
+                }
+                // Validate URL structure: should have at least 3 path segments after domain
+                const urlPath = new URL(href).pathname;
+                const segments = urlPath.split('/').filter((s) => s.length > 0);
+                if (segments.length < 3) {
+                    return;
+                }
+                // Skip navigation pages
+                if (href.includes('/search') ||
+                    href.includes('/signin') ||
+                    href.includes('/home') ||
+                    href.includes('/basket') ||
+                    href.includes('/account') ||
+                    href.includes('/favorites') ||
+                    href.includes('/reorder')) {
                     return;
                 }
                 // Try to find product info within or near this element
@@ -87,7 +107,11 @@ export class GoodEggsClient {
                 const priceEl = container.querySelector('[class*="price"]');
                 const discountEl = container.querySelector('[class*="off"], [class*="discount"]');
                 const imgEl = container.querySelector('img');
-                const name = nameEl?.textContent?.trim();
+                // Get name from element or from the link text itself
+                let name = nameEl?.textContent?.trim();
+                if (!name || name.length < 3) {
+                    name = link.textContent?.trim();
+                }
                 if (!name || name.length < 3)
                     return;
                 seen.add(href);
@@ -107,9 +131,10 @@ export class GoodEggsClient {
     async getFavorites() {
         const page = await this.ensureBrowser();
         // Navigate to favorites page
-        await page.goto(`${BASE_URL}/favorites`, { waitUntil: 'networkidle' });
-        // Wait for page to load
-        await page.waitForTimeout(1000);
+        // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
+        await page.goto(`${BASE_URL}/favorites`, { waitUntil: 'domcontentloaded' });
+        // Wait for React to render
+        await page.waitForTimeout(3000);
         // Check if we're redirected to signin
         if (page.url().includes('/signin')) {
             throw new Error('Not logged in. Cannot access favorites.');
@@ -118,19 +143,29 @@ export class GoodEggsClient {
         const items = await page.evaluate(() => {
             const products = [];
             const seen = new Set();
-            const productElements = document.querySelectorAll('a[href*="/product/"], a[href*="goodeggs"]');
+            // Good Eggs uses 'js-product-link' class for product links
+            const productElements = document.querySelectorAll('a.js-product-link');
             productElements.forEach((el) => {
                 const link = el;
                 const href = link.href;
                 if (!href || seen.has(href) || href.includes('/favorites') || href.includes('/signin')) {
                     return;
                 }
+                // Validate URL structure
+                const urlPath = new URL(href).pathname;
+                const segments = urlPath.split('/').filter((s) => s.length > 0);
+                if (segments.length < 3) {
+                    return;
+                }
                 const container = link.closest('div[class*="product"], article, [class*="card"]') || link;
                 const nameEl = container.querySelector('h2, h3, [class*="title"], [class*="name"]');
                 const brandEl = container.querySelector('[class*="brand"], [class*="producer"]');
                 const priceEl = container.querySelector('[class*="price"]');
                 const imgEl = container.querySelector('img');
-                const name = nameEl?.textContent?.trim();
+                let name = nameEl?.textContent?.trim();
+                if (!name || name.length < 3) {
+                    name = link.textContent?.trim();
+                }
                 if (!name || name.length < 3)
                     return;
                 seen.add(href);
@@ -152,11 +187,12 @@ export class GoodEggsClient {
         const currentUrl = page.url();
         if (!currentUrl.includes(groceryUrl) && !groceryUrl.includes(currentUrl)) {
             // Navigate to the product page
+            // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
             const fullUrl = groceryUrl.startsWith('http') ? groceryUrl : `${BASE_URL}${groceryUrl}`;
-            await page.goto(fullUrl, { waitUntil: 'networkidle' });
+            await page.goto(fullUrl, { waitUntil: 'domcontentloaded' });
         }
-        // Wait for page content to load
-        await page.waitForTimeout(1000);
+        // Wait for React to render
+        await page.waitForTimeout(3000);
         // Extract product details
         const details = await page.evaluate((url) => {
             // Find the main product info
@@ -199,8 +235,10 @@ export class GoodEggsClient {
         const normalizedCurrentUrl = currentUrl.replace(BASE_URL, '');
         if (!normalizedCurrentUrl.includes(normalizedGroceryUrl.split('/').pop() || '')) {
             // Navigate to the product page
+            // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
             const fullUrl = groceryUrl.startsWith('http') ? groceryUrl : `${BASE_URL}${groceryUrl}`;
-            await page.goto(fullUrl, { waitUntil: 'networkidle' });
+            await page.goto(fullUrl, { waitUntil: 'domcontentloaded' });
+            await page.waitForTimeout(3000);
         }
         // Get the product name for the result
         const itemName = await page.evaluate(() => {
@@ -265,8 +303,8 @@ export class GoodEggsClient {
             return await page.evaluate(() => {
                 const products = [];
                 const seenUrls = new Set();
-                // Find all product links
-                const productElements = document.querySelectorAll('a[href*="/product/"], a[href*="goodeggs"]');
+                // Good Eggs uses 'js-product-link' class for product links
+                const productElements = document.querySelectorAll('a.js-product-link');
                 productElements.forEach((el) => {
                     const link = el;
                     const href = link.href;
@@ -276,6 +314,12 @@ export class GoodEggsClient {
                         href.includes('/signin')) {
                         return;
                     }
+                    // Validate URL structure
+                    const urlPath = new URL(href).pathname;
+                    const segments = urlPath.split('/').filter((s) => s.length > 0);
+                    if (segments.length < 3) {
+                        return;
+                    }
                     const container = link.closest('div[class*="product"], article, [class*="card"]') || link;
                     // Look for price element and check if it's $0.00
                     const priceEl = container.querySelector('[class*="price"]');
@@ -289,7 +333,10 @@ export class GoodEggsClient {
                     const nameEl = container.querySelector('h2, h3, [class*="title"], [class*="name"]');
                     const brandEl = container.querySelector('[class*="brand"], [class*="producer"]');
                     const imgEl = container.querySelector('img');
-                    const name = nameEl?.textContent?.trim();
+                    let name = nameEl?.textContent?.trim();
+                    if (!name || name.length < 3) {
+                        name = link.textContent?.trim();
+                    }
                     if (!name || name.length < 3)
                         return;
                     seenUrls.add(href);
@@ -306,8 +353,9 @@ export class GoodEggsClient {
             });
         };
         // Check homepage for free items
-        await page.goto(BASE_URL, { waitUntil: 'networkidle' });
-        await page.waitForTimeout(1000);
+        // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
+        await page.goto(BASE_URL, { waitUntil: 'domcontentloaded' });
+        await page.waitForTimeout(3000);
         const homePageItems = await extractFreeItems();
         for (const item of homePageItems) {
             if (!seen.has(item.url)) {
@@ -316,8 +364,8 @@ export class GoodEggsClient {
             }
         }
         // Check /fresh-picks page for free items
-        await page.goto(`${BASE_URL}/fresh-picks`, { waitUntil: 'networkidle' });
-        await page.waitForTimeout(1000);
+        await page.goto(`${BASE_URL}/fresh-picks`, { waitUntil: 'domcontentloaded' });
+        await page.waitForTimeout(3000);
         const freshPicksItems = await extractFreeItems();
         for (const item of freshPicksItems) {
             if (!seen.has(item.url)) {
@@ -330,9 +378,10 @@ export class GoodEggsClient {
     async getPastOrderDates() {
         const page = await this.ensureBrowser();
         // Navigate to reorder/past orders page
-        await page.goto(`${BASE_URL}/reorder`, { waitUntil: 'networkidle' });
-        // Wait for page to load
-        await page.waitForTimeout(1000);
+        // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
+        await page.goto(`${BASE_URL}/reorder`, { waitUntil: 'domcontentloaded' });
+        // Wait for React to render
+        await page.waitForTimeout(3000);
         // Check if we're redirected to signin
         if (page.url().includes('/signin')) {
             throw new Error('Not logged in. Cannot access past orders.');
@@ -363,8 +412,9 @@ export class GoodEggsClient {
         const page = await this.ensureBrowser();
         // First, go to reorder page
         if (!page.url().includes('/reorder')) {
-            await page.goto(`${BASE_URL}/reorder`, { waitUntil: 'networkidle' });
-            await page.waitForTimeout(1000);
+            // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
+            await page.goto(`${BASE_URL}/reorder`, { waitUntil: 'domcontentloaded' });
+            await page.waitForTimeout(3000);
         }
         // Check if we're redirected to signin
         if (page.url().includes('/signin')) {
@@ -374,25 +424,35 @@ export class GoodEggsClient {
         const orderLink = await page.$(`text=${orderDate}`);
         if (orderLink) {
             await orderLink.click();
-            await page.waitForTimeout(1000);
+            await page.waitForTimeout(2000);
         }
         // Extract items from the order
         const items = await page.evaluate(() => {
             const products = [];
             const seen = new Set();
-            const productElements = document.querySelectorAll('a[href*="/product/"], a[href*="goodeggs"]');
+            // Good Eggs uses 'js-product-link' class for product links
+            const productElements = document.querySelectorAll('a.js-product-link');
             productElements.forEach((el) => {
                 const link = el;
                 const href = link.href;
                 if (!href || seen.has(href) || href.includes('/reorder') || href.includes('/signin')) {
                     return;
                 }
+                // Validate URL structure
+                const urlPath = new URL(href).pathname;
+                const segments = urlPath.split('/').filter((s) => s.length > 0);
+                if (segments.length < 3) {
+                    return;
+                }
                 const container = link.closest('div[class*="product"], article, [class*="card"]') || link;
                 const nameEl = container.querySelector('h2, h3, [class*="title"], [class*="name"]');
                 const brandEl = container.querySelector('[class*="brand"], [class*="producer"]');
                 const priceEl = container.querySelector('[class*="price"]');
                 const imgEl = container.querySelector('img');
-                const name = nameEl?.textContent?.trim();
+                let name = nameEl?.textContent?.trim();
+                if (!name || name.length < 3) {
+                    name = link.textContent?.trim();
+                }
                 if (!name || name.length < 3)
                     return;
                 seen.add(href);
@@ -415,8 +475,10 @@ export class GoodEggsClient {
         const normalizedGroceryUrl = groceryUrl.replace(BASE_URL, '');
         const normalizedCurrentUrl = currentUrl.replace(BASE_URL, '');
         if (!normalizedCurrentUrl.includes(normalizedGroceryUrl.split('/').pop() || '')) {
+            // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
             const fullUrl = groceryUrl.startsWith('http') ? groceryUrl : `${BASE_URL}${groceryUrl}`;
-            await page.goto(fullUrl, { waitUntil: 'networkidle' });
+            await page.goto(fullUrl, { waitUntil: 'domcontentloaded' });
+            await page.waitForTimeout(3000);
         }
         // Get the product name for the result
         const itemName = await page.evaluate(() => {
@@ -463,8 +525,10 @@ export class GoodEggsClient {
         const normalizedGroceryUrl = groceryUrl.replace(BASE_URL, '');
         const normalizedCurrentUrl = currentUrl.replace(BASE_URL, '');
         if (!normalizedCurrentUrl.includes(normalizedGroceryUrl.split('/').pop() || '')) {
+            // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
             const fullUrl = groceryUrl.startsWith('http') ? groceryUrl : `${BASE_URL}${groceryUrl}`;
-            await page.goto(fullUrl, { waitUntil: 'networkidle' });
+            await page.goto(fullUrl, { waitUntil: 'domcontentloaded' });
+            await page.waitForTimeout(3000);
         }
         // Get the product name for the result
         const itemName = await page.evaluate(() => {
@@ -507,8 +571,9 @@ export class GoodEggsClient {
     async removeFromCart(groceryUrl) {
         const page = await this.ensureBrowser();
         // Navigate to cart page
-        await page.goto(`${BASE_URL}/basket`, { waitUntil: 'networkidle' });
-        await page.waitForTimeout(1000);
+        // Use domcontentloaded instead of networkidle - Good Eggs has persistent connections
+        await page.goto(`${BASE_URL}/basket`, { waitUntil: 'domcontentloaded' });
+        await page.waitForTimeout(3000);
         // Try to find the item in the cart by its URL or name
         // First, let's get the product name from the URL if possible
         const productSlug = groceryUrl.split('/').pop() || '';
@@ -588,26 +653,86 @@ export function createMCPServer() {
     });
     // Track active client for cleanup
     let activeClient = null;
+    // Track background login state
+    let loginPromise = null;
+    let loginFailed = false;
+    let loginError = null;
+    let onLoginFailed = null;
+    /**
+     * Create the client instance (but don't initialize/login yet)
+     */
+    const createClient = () => {
+        const username = process.env.GOOD_EGGS_USERNAME;
+        const password = process.env.GOOD_EGGS_PASSWORD;
+        const headless = process.env.HEADLESS !== 'false';
+        const timeout = parseInt(process.env.TIMEOUT || '30000', 10);
+        if (!username || !password) {
+            throw new Error('GOOD_EGGS_USERNAME and GOOD_EGGS_PASSWORD environment variables must be configured');
+        }
+        activeClient = new GoodEggsClient({
+            username,
+            password,
+            headless,
+            timeout,
+        });
+        return activeClient;
+    };
+    /**
+     * Start background login process
+     * This should be called after the server is connected to start authentication
+     * without blocking the stdio connection.
+     *
+     * @param onFailed Callback invoked if login fails - use this to close the server
+     */
+    const startBackgroundLogin = (onFailed) => {
+        if (loginPromise) {
+            // Already started
+            return;
+        }
+        onLoginFailed = onFailed || null;
+        // Create client if not already created
+        if (!activeClient) {
+            createClient();
+        }
+        // Start login in background
+        loginPromise = activeClient.initialize().catch((error) => {
+            loginFailed = true;
+            loginError = error instanceof Error ? error : new Error(String(error));
+            // Invoke callback to notify about login failure
+            if (onLoginFailed) {
+                onLoginFailed(loginError);
+            }
+            // Re-throw to make the promise rejected
+            throw loginError;
+        });
+    };
+    /**
+     * Get a client that is ready to use (login completed)
+     * If background login was started, this waits for it to complete.
+     * If not started, this will initialize synchronously (blocking).
+     */
+    const getReadyClient = async () => {
+        // If login already failed, throw immediately
+        if (loginFailed && loginError) {
+            throw new Error(`Login failed: ${loginError.message}`);
+        }
+        // If background login is in progress, wait for it
+        if (loginPromise) {
+            await loginPromise;
+            return activeClient;
+        }
+        // No background login started - create and initialize client now (legacy behavior)
+        if (!activeClient) {
+            createClient();
+        }
+        await activeClient.initialize();
+        return activeClient;
+    };
     const registerHandlers = async (server, clientFactory) => {
-        // Use provided factory or create default client
-        const factory = clientFactory ||
-            (() => {
-                const username = process.env.GOOD_EGGS_USERNAME;
-                const password = process.env.GOOD_EGGS_PASSWORD;
-                const headless = process.env.HEADLESS !== 'false';
-                const timeout = parseInt(process.env.TIMEOUT || '30000', 10);
-                if (!username || !password) {
-                    throw new Error('GOOD_EGGS_USERNAME and GOOD_EGGS_PASSWORD environment variables must be configured');
-                }
-                activeClient = new GoodEggsClient({
-                    username,
-                    password,
-                    headless,
-                    timeout,
-                });
-                return activeClient;
-            });
-        const registerTools = createRegisterTools(factory);
+        // Use provided factory or create our managed client getter
+        const factory = clientFactory || (() => activeClient || createClient());
+        // Create tools with a special async getter that waits for background login
+        const registerTools = createRegisterTools(factory, getReadyClient);
         registerTools(server);
     };
     const cleanup = async () => {
@@ -615,6 +740,10 @@ export function createMCPServer() {
             await activeClient.close();
             activeClient = null;
         }
+        // Reset login state
+        loginPromise = null;
+        loginFailed = false;
+        loginError = null;
     };
-    return { server, registerHandlers, cleanup };
+    return { server, registerHandlers, cleanup, startBackgroundLogin };
 }

package/shared/tools.d.ts

@@ -1,4 +1,8 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { ClientFactory } from './server.js';
-export declare function createRegisterTools(clientFactory: ClientFactory): (server: Server) => void;
+import { ClientFactory, IGoodEggsClient } from './server.js';
+/**
+ * Async getter that returns a ready-to-use client (login completed)
+ */
+export type GetReadyClientFn = () => Promise<IGoodEggsClient>;
+export declare function createRegisterTools(clientFactory: ClientFactory, getReadyClient?: GetReadyClientFn): (server: Server) => void;
 //# sourceMappingURL=tools.d.ts.map

package/shared/tools.js

@@ -86,11 +86,18 @@ Provide the Good Eggs URL of the item to remove from your cart.
 Navigates to the cart and removes the specified item.
 
 Returns confirmation of the removal or an error if the item is not in the cart.`;
-export function createRegisterTools(clientFactory) {
+export function createRegisterTools(clientFactory, getReadyClient) {
     // Create a single client instance that persists across calls
     let client = null;
     let isInitialized = false;
+    // If getReadyClient is provided (background login mode), use it
+    // Otherwise fall back to lazy initialization (legacy behavior)
     const getClient = async () => {
+        if (getReadyClient) {
+            // Use the provided getter that handles background login
+            return getReadyClient();
+        }
+        // Legacy behavior: lazy initialization
         if (!client) {
             client = clientFactory();
         }