amazon-personal-shopping-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,2671 @@
+#!/usr/bin/env node
+
+// src/env.ts
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { config } from "dotenv";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+config({ path: resolve(__dirname, "..", ".env") });
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/search.ts
+import { z } from "zod";
+
+// src/errors.ts
+var BrowserError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BrowserError";
+  }
+};
+var BrowserNotInstalledError = class extends BrowserError {
+  constructor(message = "Chromium is not installed. Run: npx playwright install chromium") {
+    super(message);
+    this.name = "BrowserNotInstalledError";
+  }
+};
+var BrowserLaunchError = class extends BrowserError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BrowserLaunchError";
+  }
+};
+var SessionExpiredError = class extends BrowserError {
+  constructor(message = "Session expired. Please call amazon-login to re-authenticate.") {
+    super(message);
+    this.name = "SessionExpiredError";
+  }
+};
+var AuthRequiredError = class extends BrowserError {
+  constructor(message = "Not logged in. Please call amazon-login to authenticate.") {
+    super(message);
+    this.name = "AuthRequiredError";
+  }
+};
+var ContextInUseError = class extends BrowserError {
+  constructor(message = "Browser context is already in use by another process. Close other instances first.") {
+    super(message);
+    this.name = "ContextInUseError";
+  }
+};
+var ScrapingError = class extends BrowserError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ScrapingError";
+  }
+};
+var CaptchaRequiredError = class extends BrowserError {
+  constructor(message = "CAPTCHA required - please solve in browser window", options) {
+    super(message, options);
+    this.name = "CaptchaRequiredError";
+  }
+};
+
+// src/tools/search.ts
+function registerSearchTools(server2, provider2) {
+  server2.tool(
+    "search-products",
+    "Search for products on Amazon. Returns structured product data including ASIN, title, price, rating, brand, and Prime eligibility. Requires an active Amazon session (call amazon-login first).",
+    {
+      query: z.string().describe("Search query for Amazon products"),
+      category: z.string().optional().describe("Product category to filter by (e.g., 'electronics')"),
+      maxResults: z.number().int().min(1).max(50).optional().describe("Maximum number of results to return (default: 20)")
+    },
+    async ({ query, category, maxResults }) => {
+      try {
+        const products = await provider2.searchProducts(query, category, maxResults);
+        return {
+          content: [{ type: "text", text: JSON.stringify(products, null, 2) }],
+          isError: false
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Search failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/product.ts
+import { z as z2 } from "zod";
+function registerProductTools(server2, provider2) {
+  server2.tool(
+    "get-product-details",
+    "Get detailed product information for an Amazon product by ASIN. Returns title, description, features, price, rating, availability, images, and more. Requires an active Amazon session (call amazon-login first).",
+    {
+      asin: z2.string().describe("Amazon Standard Identification Number (ASIN) of the product")
+    },
+    async ({ asin }) => {
+      try {
+        const { details, primaryImageBase64 } = await provider2.getProductDetails(asin);
+        const content = [{ type: "text", text: JSON.stringify(details, null, 2) }];
+        if (primaryImageBase64) {
+          content.push({
+            type: "image",
+            data: primaryImageBase64,
+            mimeType: "image/jpeg"
+          });
+        }
+        return { content, isError: false };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get product details: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/reviews.ts
+import { z as z3 } from "zod";
+function registerReviewTools(server2, provider2) {
+  server2.tool(
+    "get-reviews",
+    "Get customer reviews for an Amazon product by ASIN. Returns individual reviews with author, rating, title, body, date, and verified purchase status, plus summary statistics with average rating and star distribution. Supports sorting by relevance or recency, and filtering by star rating. Requires an active Amazon session (call amazon-login first).",
+    {
+      asin: z3.string().describe("ASIN of the product to get reviews for"),
+      maxReviews: z3.number().int().min(1).max(50).optional().describe("Maximum number of reviews to return (default: all from first page)"),
+      sortBy: z3.enum(["relevant", "recent"]).optional().describe("Sort reviews by relevance or most recent"),
+      filterByStars: z3.number().int().min(1).max(5).optional().describe("Filter reviews by star rating (1-5)")
+    },
+    async ({ asin, maxReviews, sortBy, filterByStars }) => {
+      try {
+        const result = await provider2.getReviews(asin, maxReviews, sortBy, filterByStars);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          isError: false
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get reviews: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/cart.ts
+import { z as z4 } from "zod";
+function registerCartTools(server2, provider2) {
+  server2.tool(
+    "add-to-cart",
+    "Add a product to your Amazon cart. Before using this tool, confirm with the user which product and quantity they want to add. Requires an active Amazon session (call amazon-login first).",
+    {
+      asin: z4.string().describe("ASIN of the product to add to cart"),
+      quantity: z4.number().int().positive().optional().describe("Quantity to add (default: 1)")
+    },
+    async ({ asin, quantity }) => {
+      try {
+        const result = await provider2.addToCart(asin, quantity);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ],
+          isError: !result.success
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to add to cart: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "view-cart",
+    "View the contents of your Amazon cart including items, quantities, prices, and subtotal. Requires an active Amazon session (call amazon-login first).",
+    {},
+    async () => {
+      try {
+        const cart = await provider2.getCart();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(cart, null, 2)
+            }
+          ],
+          isError: false
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to view cart: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "remove-from-cart",
+    "Remove a specific item from your Amazon cart. Before using this tool, confirm with the user which item they want to remove. Requires an active Amazon session (call amazon-login first).",
+    {
+      asin: z4.string().describe("ASIN of the product to remove from cart")
+    },
+    async ({ asin }) => {
+      try {
+        const result = await provider2.removeFromCart(asin);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ],
+          isError: !result.success
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to remove from cart: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "clear-cart",
+    "Remove all items from your Amazon cart. Before using this tool, confirm with the user that they want to clear their entire cart. This action cannot be undone. Requires an active Amazon session (call amazon-login first).",
+    {},
+    async () => {
+      try {
+        await provider2.clearCart();
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Cart cleared successfully"
+            }
+          ],
+          isError: false
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to clear cart: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/orders.ts
+import { z as z5 } from "zod";
+function registerOrderTools(server2, provider2) {
+  server2.tool(
+    "get-order-history",
+    "View your Amazon order history. Returns a list of past orders with order ID, date, total, status, and item count. Supports pagination and optional date filtering. Requires an active Amazon session (call amazon-login first).",
+    {
+      limit: z5.number().int().min(1).max(50).optional().describe("Maximum number of orders to return (1-50, default: 10)"),
+      page: z5.number().int().min(1).optional().describe("Page number for pagination (default: 1)"),
+      startDate: z5.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional().describe("Filter orders from this date (YYYY-MM-DD format)"),
+      endDate: z5.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional().describe("Filter orders until this date (YYYY-MM-DD format)")
+    },
+    async ({ limit, page, startDate, endDate }) => {
+      try {
+        const result = await provider2.getOrderHistory({
+          limit,
+          page,
+          startDate,
+          endDate
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ],
+          isError: false
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get order history: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get-order-details",
+    "View detailed information about a specific Amazon order including all items, prices, quantities, and delivery status. Requires an active Amazon session (call amazon-login first).",
+    {
+      orderId: z5.string().describe("The Amazon order ID (e.g., 112-3456789-0123456)")
+    },
+    async ({ orderId }) => {
+      try {
+        const order = await provider2.getOrderDetails(orderId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(order, null, 2)
+            }
+          ],
+          isError: false
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get order details: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/purchase.ts
+import { z as z6 } from "zod";
+function registerPurchaseTools(server2, provider2) {
+  server2.tool(
+    "perform-purchase",
+    `Complete the checkout process and place an order for all items currently in your Amazon cart.
+
+**IMPORTANT - AI SAFETY REQUIREMENT**: Before calling this tool, you MUST:
+1. Call view-cart to show the user exactly what items are in their cart
+2. Display the items, quantities, and total price to the user
+3. Ask the user to explicitly confirm they want to purchase these items
+4. Only call this tool after receiving clear confirmation (e.g., "yes", "confirm", "proceed")
+
+This tool will:
+- Navigate to Amazon checkout
+- Use the default shipping address and payment method
+- Log all items and totals before placing the order
+- Complete the purchase and return the order ID
+
+Requires an active Amazon session with a valid payment method on file (call amazon-login first).`,
+    {
+      confirmationToken: z6.string().min(1).describe(
+        "A non-empty string confirming the user has approved this purchase. Can be any confirmation like 'yes', 'confirmed', or the user's explicit approval text."
+      )
+    },
+    async ({ confirmationToken }) => {
+      try {
+        const result = await provider2.purchase(confirmationToken);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ],
+          isError: !result.success
+        };
+      } catch (error) {
+        if (error instanceof SessionExpiredError || error instanceof AuthRequiredError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Not logged in or session expired. Please call amazon-login first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to complete purchase: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/auth.ts
+import { z as z7 } from "zod";
+
+// src/providers/playwright/browser.ts
+import { chromium } from "playwright";
+
+// src/utils/paths.ts
+import { homedir, platform } from "os";
+import { join } from "path";
+import { mkdirSync, accessSync, constants } from "fs";
+var APP_NAME = "amazon-shopping-mcp";
+function getDataDir() {
+  const envOverride = process.env.AMAZON_MCP_DATA_DIR;
+  if (envOverride) {
+    return join(envOverride, APP_NAME);
+  }
+  const os = platform();
+  const home = homedir();
+  if (os === "darwin") {
+    return join(home, "Library", "Application Support", APP_NAME);
+  }
+  if (os === "linux") {
+    const xdgDataHome = process.env.XDG_DATA_HOME;
+    if (xdgDataHome) {
+      return join(xdgDataHome, APP_NAME);
+    }
+    return join(home, ".local", "share", APP_NAME);
+  }
+  throw new Error(`Unsupported platform: ${os}. Only macOS and Linux are supported.`);
+}
+function ensureDataDir() {
+  const dir = getDataDir();
+  mkdirSync(dir, { recursive: true });
+  validateDirWritable(dir);
+  return dir;
+}
+function validateDirWritable(dir) {
+  try {
+    accessSync(dir, constants.W_OK);
+  } catch {
+    throw new Error(`Data directory is not writable: ${dir}. Check file permissions.`);
+  }
+}
+
+// src/providers/playwright/stealth.ts
+var STEALTH_ARGS = [
+  "--disable-blink-features=AutomationControlled",
+  "--disable-features=AutomationControlled",
+  "--disable-dev-shm-usage",
+  "--disable-infobars",
+  "--disable-background-networking",
+  "--disable-default-apps",
+  "--disable-extensions",
+  "--disable-sync",
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--disable-component-update",
+  "--disable-hang-monitor"
+];
+var REALISTIC_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+var VIEWPORT_PRESETS = [
+  { width: 1920, height: 1080 },
+  { width: 1536, height: 864 },
+  { width: 1440, height: 900 },
+  { width: 1366, height: 768 },
+  { width: 1280, height: 800 }
+];
+function randomViewport() {
+  const preset = VIEWPORT_PRESETS[Math.floor(Math.random() * VIEWPORT_PRESETS.length)];
+  return { width: preset.width, height: preset.height };
+}
+var STEALTH_INIT_SCRIPT = `
+  // Hide navigator.webdriver
+  Object.defineProperty(navigator, 'webdriver', {
+    get: () => false,
+    configurable: true,
+  });
+
+  // Mock window.chrome.runtime (missing in headless automation)
+  if (!window.chrome) {
+    window.chrome = {};
+  }
+  if (!window.chrome.runtime) {
+    window.chrome.runtime = {
+      connect: function() {},
+      sendMessage: function() {},
+    };
+  }
+
+  // Realistic navigator.plugins (Chrome PDF plugins)
+  Object.defineProperty(navigator, 'plugins', {
+    get: () => {
+      const plugins = [
+        { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+        { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' },
+        { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' },
+      ];
+      plugins.length = 3;
+      return plugins;
+    },
+    configurable: true,
+  });
+
+  // Set realistic languages
+  Object.defineProperty(navigator, 'languages', {
+    get: () => ['en-US', 'en'],
+    configurable: true,
+  });
+
+  // Mask automation artifacts in permissions API
+  const originalQuery = navigator.permissions.query.bind(navigator.permissions);
+  navigator.permissions.query = async (params) => {
+    if (params.name === 'notifications') {
+      return { state: 'prompt', onchange: null };
+    }
+    return originalQuery(params);
+  };
+`;
+async function applyStealthToContext(context) {
+  await context.addInitScript(STEALTH_INIT_SCRIPT);
+}
+function randomDelay(min, max) {
+  const ms = Math.floor(Math.random() * (max - min + 1)) + min;
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function simulateMouseMovement(page) {
+  const viewport = page.viewportSize();
+  if (!viewport) return;
+  const steps = 8 + Math.floor(Math.random() * 8);
+  let x = Math.random() * viewport.width * 0.8;
+  let y = Math.random() * viewport.height * 0.8;
+  for (let i = 0; i < steps; i++) {
+    x += (Math.random() - 0.5) * 120;
+    y += (Math.random() - 0.5) * 80;
+    x = Math.max(10, Math.min(viewport.width - 10, x));
+    y = Math.max(10, Math.min(viewport.height - 10, y));
+    await page.mouse.move(x, y, { steps: 3 });
+    await randomDelay(10, 50);
+  }
+}
+async function simulateScroll(page) {
+  const scrollCount = 2 + Math.floor(Math.random() * 3);
+  for (let i = 0; i < scrollCount; i++) {
+    const deltaY = 100 + Math.floor(Math.random() * 200);
+    await page.mouse.wheel(0, deltaY);
+    await randomDelay(200, 600);
+  }
+}
+var lastNavigationTime = 0;
+async function throttleNavigation() {
+  const now = Date.now();
+  const elapsed = now - lastNavigationTime;
+  const minGap = 2e3 + Math.floor(Math.random() * 3e3);
+  if (lastNavigationTime > 0 && elapsed < minGap) {
+    await new Promise((resolve2) => setTimeout(resolve2, minGap - elapsed));
+  }
+  lastNavigationTime = Date.now();
+}
+
+// src/utils/logger.ts
+var LOG_LEVEL_NAMES = {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR"
+};
+var globalLogLevel = 1 /* INFO */;
+if (process.env.AMAZON_MCP_DEBUG === "true" || process.env.AMAZON_MCP_DEBUG === "1") {
+  globalLogLevel = 0 /* DEBUG */;
+}
+function formatLogMessage(level, module, message, data) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const levelName = LOG_LEVEL_NAMES[level];
+  let logLine = `${timestamp} [${levelName}] [${module}] ${message}`;
+  if (data && Object.keys(data).length > 0) {
+    logLine += ` ${JSON.stringify(data)}`;
+  }
+  return logLine;
+}
+function log(level, module, message, data) {
+  if (level < globalLogLevel) {
+    return;
+  }
+  const formattedMessage = formatLogMessage(level, module, message, data);
+  console.error(formattedMessage);
+}
+function createLogger(module) {
+  return {
+    debug(message, data) {
+      log(0 /* DEBUG */, module, message, data);
+    },
+    info(message, data) {
+      log(1 /* INFO */, module, message, data);
+    },
+    warn(message, data) {
+      log(2 /* WARN */, module, message, data);
+    },
+    error(message, data) {
+      log(3 /* ERROR */, module, message, data);
+    }
+  };
+}
+
+// src/providers/playwright/browser.ts
+var AMAZON_BASE_URL = "https://www.amazon.com";
+var browserContext = null;
+var activePage = null;
+var logger = createLogger("browser");
+function log2(message) {
+  logger.info(message);
+}
+function getHeadlessMode() {
+  const env = process.env.AMAZON_MCP_HEADLESS;
+  if (env === void 0 || env === "") {
+    return true;
+  }
+  if (env === "true") {
+    return true;
+  }
+  if (env === "false") {
+    return false;
+  }
+  log2(`Warning: Invalid AMAZON_MCP_HEADLESS value "${env}", defaulting to true`);
+  return true;
+}
+async function installBrowserIfNeeded() {
+  try {
+    const browsers = chromium.executablePath();
+    if (browsers) {
+      return;
+    }
+  } catch {
+  }
+  log2("Chromium not found. Installing...");
+  try {
+    const { execSync } = await import("child_process");
+    execSync("npx playwright install chromium", {
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 3e5
+    });
+    log2("Chromium installed successfully");
+  } catch {
+    throw new BrowserNotInstalledError(
+      "Failed to auto-install Chromium. Run manually: npx playwright install chromium"
+    );
+  }
+}
+async function ensureBrowser() {
+  if (browserContext) {
+    return;
+  }
+  await installBrowserIfNeeded();
+  log2("Browser ready");
+}
+async function getBrowserContext(options) {
+  if (browserContext) {
+    return browserContext;
+  }
+  await installBrowserIfNeeded();
+  const dataDir = ensureDataDir();
+  const headless = options?.headless ?? getHeadlessMode();
+  log2(`Launching browser (headless: ${headless}, data: ${dataDir})`);
+  try {
+    browserContext = await chromium.launchPersistentContext(dataDir, {
+      headless,
+      args: [...STEALTH_ARGS],
+      userAgent: REALISTIC_USER_AGENT,
+      viewport: randomViewport(),
+      locale: "en-US",
+      timezoneId: "America/New_York"
+    });
+    await applyStealthToContext(browserContext);
+    browserContext.on("close", () => {
+      log2("Browser context closed");
+      browserContext = null;
+      activePage = null;
+    });
+    log2("Browser context launched");
+    return browserContext;
+  } catch (error) {
+    browserContext = null;
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("lock") || message.includes("already")) {
+      throw new ContextInUseError();
+    }
+    throw new BrowserLaunchError(`Failed to launch browser: ${message}`, {
+      cause: error
+    });
+  }
+}
+async function getPage(options) {
+  if (activePage && !activePage.isClosed()) {
+    return activePage;
+  }
+  const context = await getBrowserContext(options);
+  const pages = context.pages();
+  activePage = pages.length > 0 ? pages[0] : await context.newPage();
+  return activePage;
+}
+async function closeBrowser() {
+  if (browserContext) {
+    log2("Closing browser context...");
+    try {
+      await browserContext.close();
+    } catch {
+      log2("Browser context already closed");
+    }
+    browserContext = null;
+    activePage = null;
+    log2("Browser closed");
+  }
+}
+
+// src/providers/playwright/auth.ts
+var LOGIN_URL = `${AMAZON_BASE_URL}/ap/signin`;
+var ACCOUNT_URL = `${AMAZON_BASE_URL}/gp/css/homepage.html`;
+var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+var LOGIN_POLL_INTERVAL_MS = 1e3;
+var logger2 = createLogger("auth");
+function log3(message) {
+  logger2.info(message);
+}
+function isLoginPage(page) {
+  const url = page.url();
+  return url.includes("/ap/signin") || url.includes("/ap/mfa") || url.includes("/ap/forgotpassword");
+}
+async function assertSessionValid(page) {
+  if (isLoginPage(page)) {
+    throw new SessionExpiredError();
+  }
+}
+async function login(force) {
+  if (!force) {
+    const status = await checkSession();
+    if (status.loggedIn) {
+      return {
+        success: true,
+        message: "Already logged in. Use force: true to re-login."
+      };
+    }
+  }
+  log3("Opening headed browser for Amazon login...");
+  await closeBrowser();
+  const context = await getBrowserContext({ headless: false });
+  const pages = context.pages();
+  const page = pages.length > 0 ? pages[0] : await context.newPage();
+  try {
+    await page.goto(LOGIN_URL, { waitUntil: "domcontentloaded" });
+    log3("Navigated to Amazon sign-in page. Waiting for user to complete login...");
+    const startTime = Date.now();
+    while (Date.now() - startTime < LOGIN_TIMEOUT_MS) {
+      await new Promise((resolve2) => setTimeout(resolve2, LOGIN_POLL_INTERVAL_MS));
+      if (page.isClosed()) {
+        return {
+          success: false,
+          message: "Browser was closed before login was completed."
+        };
+      }
+      if (!isLoginPage(page)) {
+        log3("Login detected \u2014 user navigated away from sign-in page");
+        return {
+          success: true,
+          message: "Successfully logged in to Amazon."
+        };
+      }
+    }
+    return {
+      success: false,
+      message: "Login timed out after 5 minutes. Please try again."
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log3(`Login error: ${message}`);
+    return {
+      success: false,
+      message: `Login failed: ${message}`
+    };
+  }
+}
+async function checkSession() {
+  try {
+    const page = await getPage();
+    await page.goto(ACCOUNT_URL, { waitUntil: "domcontentloaded", timeout: 15e3 });
+    if (isLoginPage(page)) {
+      return {
+        loggedIn: false,
+        message: "Not logged in. Please call amazon-login to authenticate."
+      };
+    }
+    return {
+      loggedIn: true,
+      message: "Logged in to Amazon."
+    };
+  } catch {
+    return {
+      loggedIn: false,
+      message: "Unable to verify session. Please call amazon-login to authenticate."
+    };
+  }
+}
+
+// src/tools/auth.ts
+function registerAuthTools(server2) {
+  server2.tool(
+    "amazon-login",
+    "Log in to Amazon. Opens a headed browser window for you to enter your credentials. Supports 2FA. Call this before using any other Amazon tools.",
+    {
+      force: z7.boolean().optional().describe("Force re-login even if a session already exists")
+    },
+    async ({ force }) => {
+      const result = await login(force);
+      return {
+        content: [{ type: "text", text: result.message }],
+        isError: !result.success
+      };
+    }
+  );
+  server2.tool(
+    "amazon-session-status",
+    "Check if you are currently logged in to Amazon and whether the session is valid.",
+    {},
+    async () => {
+      const status = await checkSession();
+      return {
+        content: [
+          {
+            type: "text",
+            text: status.message
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/server.ts
+function createServer(provider2) {
+  const server2 = new McpServer({
+    name: "amazon-shopping-mcp",
+    version: "0.1.0"
+  });
+  registerAuthTools(server2);
+  registerSearchTools(server2, provider2);
+  registerProductTools(server2, provider2);
+  registerReviewTools(server2, provider2);
+  registerCartTools(server2, provider2);
+  registerOrderTools(server2, provider2);
+  registerPurchaseTools(server2, provider2);
+  return server2;
+}
+
+// src/providers/playwright/scraper.ts
+import * as cheerio from "cheerio";
+
+// src/providers/types.ts
+import { z as z8 } from "zod";
+var ProductSchema = z8.object({
+  asin: z8.string().min(1),
+  title: z8.string().min(1),
+  price: z8.number().positive().nullable(),
+  currency: z8.string().min(1),
+  rating: z8.number().min(0).max(5).nullable(),
+  reviewCount: z8.number().int().nonnegative(),
+  brand: z8.string().nullable(),
+  isPrime: z8.boolean(),
+  imageUrl: z8.string().url().nullable(),
+  url: z8.string().url()
+});
+var ProductDetailsSchema = z8.object({
+  asin: z8.string().min(1),
+  title: z8.string().min(1),
+  price: z8.number().positive().nullable(),
+  currency: z8.string().min(1),
+  rating: z8.number().min(0).max(5).nullable(),
+  reviewCount: z8.number().int().nonnegative(),
+  brand: z8.string().nullable(),
+  isPrime: z8.boolean(),
+  description: z8.string(),
+  features: z8.array(z8.string()),
+  imageUrls: z8.array(z8.string().url()),
+  availability: z8.string(),
+  url: z8.string().url()
+});
+var ReviewSchema = z8.object({
+  id: z8.string().min(1),
+  author: z8.string().min(1),
+  rating: z8.number().int().min(1).max(5),
+  title: z8.string(),
+  body: z8.string(),
+  date: z8.string().min(1),
+  verified: z8.boolean()
+});
+var ReviewSummarySchema = z8.object({
+  averageRating: z8.number().min(0).max(5),
+  totalCount: z8.number().int().nonnegative(),
+  starDistribution: z8.object({
+    1: z8.number().int().nonnegative(),
+    2: z8.number().int().nonnegative(),
+    3: z8.number().int().nonnegative(),
+    4: z8.number().int().nonnegative(),
+    5: z8.number().int().nonnegative()
+  })
+});
+var CartItemSchema = z8.object({
+  asin: z8.string().min(1),
+  title: z8.string().min(1),
+  price: z8.number().positive().nullable(),
+  quantity: z8.number().int().positive()
+});
+var CartSchema = z8.object({
+  items: z8.array(CartItemSchema),
+  subtotal: z8.number().nonnegative().nullable(),
+  currency: z8.string().min(1)
+});
+var OrderItemSchema = z8.object({
+  asin: z8.string().min(1),
+  title: z8.string().min(1),
+  price: z8.number().positive().nullable(),
+  quantity: z8.number().int().positive(),
+  deliveryStatus: z8.string().optional()
+});
+var OrderSchema = z8.object({
+  orderId: z8.string().min(1),
+  date: z8.string().min(1),
+  total: z8.number().nonnegative(),
+  currency: z8.string().min(1),
+  status: z8.string().min(1),
+  itemCount: z8.number().int().nonnegative().optional(),
+  items: z8.array(OrderItemSchema)
+});
+var OrderHistoryParamsSchema = z8.object({
+  limit: z8.number().int().min(1).max(50).optional().default(10),
+  page: z8.number().int().min(1).optional().default(1),
+  startDate: z8.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional(),
+  endDate: z8.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional()
+});
+var OrderHistoryResponseSchema = z8.object({
+  orders: z8.array(OrderSchema),
+  hasMore: z8.boolean(),
+  nextPage: z8.number().int().positive().nullable()
+});
+var PurchaseResultSchema = z8.object({
+  success: z8.boolean(),
+  orderId: z8.string().min(1).nullable(),
+  message: z8.string(),
+  orderTotal: z8.string().nullable()
+});
+
+// src/providers/playwright/scraper.ts
+var logger3 = createLogger("scraper");
+function log4(message) {
+  logger3.info(message);
+}
+function parsePrice(priceText) {
+  const cleaned = priceText.replace(/[^0-9.]/g, "");
+  const value = parseFloat(cleaned);
+  return Number.isNaN(value) ? null : value;
+}
+function parseRating(ratingText) {
+  const match = ratingText.match(/([\d.]+)\s*out of\s*5/);
+  if (!match) return null;
+  const value = parseFloat(match[1]);
+  return Number.isNaN(value) ? null : value;
+}
+function parseReviewCount(countText) {
+  const cleaned = countText.replace(/[^0-9]/g, "");
+  const value = parseInt(cleaned, 10);
+  return Number.isNaN(value) ? 0 : value;
+}
+function parseSearchResults(html) {
+  const $ = cheerio.load(html);
+  const products = [];
+  const resultCards = $('[data-component-type="s-search-result"]');
+  if (resultCards.length === 0) {
+    log4("No search result cards found in HTML");
+    return [];
+  }
+  resultCards.each((_index, element) => {
+    try {
+      const card = $(element);
+      const asin = card.attr("data-asin");
+      if (!asin || asin.trim() === "") return;
+      const title = card.find("h2 a span").text().trim() || card.find("h2 span").text().trim();
+      if (!title) return;
+      const href = card.find("h2 a").attr("href") ?? card.find('[data-cy="title-recipe"] a').attr("href") ?? card.find("h2").closest("a").attr("href") ?? "";
+      const url = href.startsWith("http") ? href : `https://www.amazon.com${href}`;
+      const priceText = card.find(".a-price .a-offscreen").first().text().trim();
+      const price = priceText ? parsePrice(priceText) : null;
+      const currency = "USD";
+      const ratingText = card.find("i.a-icon-star-small span.a-icon-alt").first().text().trim() || card.find("i.a-icon-star-mini span").first().text().trim() || card.find('[data-cy="reviews-ratings-slot"]').text().trim();
+      const rating = ratingText ? parseRating(ratingText) : null;
+      let reviewCountText = card.find('[data-cy="reviews-ratings-count"]').text().trim() || card.find("a.s-underline-link-text span.s-underline-text").text().trim();
+      if (!reviewCountText) {
+        card.find('[data-cy="reviews-block"] span').each((_i, el) => {
+          const t = $(el).text().trim();
+          if (t.match(/^\([\d.,]+[KkMm]?\)$/)) {
+            reviewCountText = t;
+            return false;
+          }
+        });
+      }
+      const reviewCount = reviewCountText ? parseReviewCount(reviewCountText) : 0;
+      const brandText = card.find(".a-row .a-size-base-plus").first().text().trim() || card.find(".a-row .a-size-base.s-underline-text").first().text().trim();
+      const brand = brandText || null;
+      const isPrime = card.find("i.a-icon-prime").length > 0 || card.find('[data-cy="delivery-recipe"]').text().includes("FREE delivery");
+      const imageUrl = card.find("img.s-image").attr("src") ?? null;
+      const rawProduct = {
+        asin,
+        title,
+        price,
+        currency,
+        rating,
+        reviewCount,
+        brand,
+        isPrime,
+        imageUrl,
+        url
+      };
+      const parsed = ProductSchema.safeParse(rawProduct);
+      if (parsed.success) {
+        products.push(parsed.data);
+      } else {
+        log4(`Skipping product ${asin}: validation failed \u2014 ${parsed.error.message}`);
+      }
+    } catch {
+    }
+  });
+  log4(`Parsed ${products.length} products from ${resultCards.length} cards`);
+  return products;
+}
+function extractBrand($) {
+  const bylineText = $("#bylineInfo").text().trim();
+  if (bylineText) {
+    const visitMatch = bylineText.match(/Visit the (.+?) Store/);
+    if (visitMatch) return visitMatch[1];
+    const brandMatch = bylineText.match(/Brand:\s*(.+)/);
+    if (brandMatch) return brandMatch[1].trim();
+    return bylineText;
+  }
+  const brandLink = $("a#brand").text().trim();
+  return brandLink || null;
+}
+function parseProductDetails(html) {
+  const $ = cheerio.load(html);
+  const asin = $('input[name="ASIN"]').val()?.toString() ?? $('link[rel="canonical"]').attr("href")?.match(/\/dp\/([A-Z0-9]+)/)?.[1] ?? "";
+  if (!asin) {
+    log4("No ASIN found in product page HTML");
+    return null;
+  }
+  const title = $("#productTitle").text().trim();
+  if (!title) {
+    log4("No product title found in HTML");
+    return null;
+  }
+  const priceText = $(".a-price .a-offscreen").first().text().trim();
+  const price = priceText ? parsePrice(priceText) : null;
+  const currency = "USD";
+  const ratingText = $("#acrPopover span.a-icon-alt").first().text().trim();
+  const rating = ratingText ? parseRating(ratingText) : null;
+  const reviewCountText = $("#acrCustomerReviewText").text().trim();
+  const reviewCount = reviewCountText ? parseReviewCount(reviewCountText) : 0;
+  const brand = extractBrand($);
+  const isPrime = $("i.a-icon-prime").length > 0 || $("#mir-layout-DELIVERY_BLOCK, #deliveryBlockMessage").text().includes("FREE delivery");
+  const description = $("#productDescription p").text().trim() || "";
+  const features = [];
+  $("#feature-bullets ul li span.a-list-item").each((_i, el) => {
+    const text = $(el).text().trim();
+    if (text) features.push(text);
+  });
+  const imageUrls = [];
+  const primaryImage = $("#landingImage").attr("src") ?? $("#imgTagWrapperId img").attr("src");
+  if (primaryImage) imageUrls.push(primaryImage);
+  $("#altImages ul li img").each((_i, el) => {
+    const src = $(el).attr("src");
+    if (src && !imageUrls.includes(src) && src.includes("/images/I/")) {
+      imageUrls.push(src);
+    }
+  });
+  const availability = $("#availability span").first().text().trim() || "Unknown";
+  const url = $('link[rel="canonical"]').attr("href") ?? `https://www.amazon.com/dp/${asin}`;
+  const raw = {
+    asin,
+    title,
+    price,
+    currency,
+    rating,
+    reviewCount,
+    brand,
+    isPrime,
+    description,
+    features,
+    imageUrls,
+    availability,
+    url
+  };
+  const parsed = ProductDetailsSchema.safeParse(raw);
+  if (!parsed.success) {
+    log4(`Product details validation failed: ${parsed.error.message}`);
+    return null;
+  }
+  log4(`Parsed product details for ${asin}`);
+  return parsed.data;
+}
+function parseReviews(html) {
+  const $ = cheerio.load(html);
+  const ratingOutOfText = $('span[data-hook="rating-out-of-text"]').text().trim();
+  const averageRating = ratingOutOfText ? parseRating(ratingOutOfText) ?? 0 : 0;
+  const totalCountText = $('div[data-hook="total-review-count"] span').text().trim();
+  const totalCount = totalCountText ? parseReviewCount(totalCountText) : 0;
+  const starDistribution = {
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0
+  };
+  $("#histogramTable a[aria-label]").each((_i, el) => {
+    const label = $(el).attr("aria-label") ?? "";
+    const match = label.match(/(\d)\s*stars?\s*represent\s*(\d+)%/);
+    if (match) {
+      const star = parseInt(match[1], 10);
+      if (star >= 1 && star <= 5) {
+        starDistribution[star] = parseInt(match[2], 10);
+      }
+    }
+  });
+  if (starDistribution[1] === 0 && starDistribution[5] === 0) {
+    $("#histogramTable tbody tr").each((_i, el) => {
+      const row = $(el);
+      const starText = row.find("td.a-text-right a").text().trim();
+      const percentText = row.find("td.a-text-right span.a-size-base").text().trim();
+      const starMatch = starText.match(/(\d)\s*star/);
+      const percentMatch = percentText.match(/(\d+)%/);
+      if (starMatch && percentMatch) {
+        const star = parseInt(starMatch[1], 10);
+        if (star >= 1 && star <= 5) {
+          starDistribution[star] = parseInt(percentMatch[1], 10);
+        }
+      }
+    });
+  }
+  const summary = { averageRating, totalCount, starDistribution };
+  const reviews = [];
+  $('[data-hook="review"]').each((_i, el) => {
+    try {
+      const reviewEl = $(el);
+      const id = reviewEl.attr("id") ?? "";
+      if (!id) return;
+      const author = reviewEl.find("span.a-profile-name").first().text().trim();
+      const ratingAlt = reviewEl.find('i[data-hook="review-star-rating"] span.a-icon-alt').text().trim();
+      const rating = ratingAlt ? parseRating(ratingAlt) ?? 0 : 0;
+      const titleAnchor = reviewEl.find('a[data-hook="review-title"]');
+      let title = titleAnchor.find("> span:not(.a-letter-space)").text().trim();
+      if (!title) {
+        title = titleAnchor.find("span").first().text().trim();
+      }
+      const body = reviewEl.find('span[data-hook="review-body"] span').text().trim();
+      const date = reviewEl.find('span[data-hook="review-date"]').text().trim();
+      const verified = reviewEl.find('span[data-hook="avp-badge"]').length > 0;
+      const raw = { id, author, rating, title, body, date, verified };
+      const parsed = ReviewSchema.safeParse(raw);
+      if (parsed.success) {
+        reviews.push(parsed.data);
+      } else {
+        log4(`Skipping review ${id}: validation failed \u2014 ${parsed.error.message}`);
+      }
+    } catch {
+    }
+  });
+  log4(`Parsed ${reviews.length} reviews, summary: ${averageRating}/5 (${totalCount} total)`);
+  return { reviews, summary };
+}
+function parseCart(html) {
+  const $ = cheerio.load(html);
+  const items = [];
+  $(".sc-list-item[data-asin]").each((_index, element) => {
+    try {
+      const item = $(element);
+      const asin = item.attr("data-asin");
+      if (!asin || asin.trim() === "") return;
+      const title = item.find(".sc-product-title").text().trim() || item.find(".sc-product-link").text().trim();
+      if (!title) {
+        log4(`Skipping cart item ${asin}: no title found`);
+        return;
+      }
+      const priceText = item.find(".sc-product-price .a-offscreen").first().text().trim();
+      const price = priceText ? parsePrice(priceText) : null;
+      let quantity = 1;
+      const selectedOption = item.find('select[name="quantity"] option[selected]');
+      if (selectedOption.length > 0) {
+        quantity = parseInt(selectedOption.attr("value") ?? selectedOption.text().trim(), 10);
+      } else {
+        const quantityInput = item.find('input[name="quantity"]');
+        if (quantityInput.length > 0) {
+          quantity = parseInt(quantityInput.attr("value") ?? "1", 10);
+        }
+      }
+      if (Number.isNaN(quantity) || quantity < 1) quantity = 1;
+      const rawItem = { asin, title, price, quantity };
+      const parsed2 = CartItemSchema.safeParse(rawItem);
+      if (parsed2.success) {
+        items.push(parsed2.data);
+      } else {
+        log4(`Skipping cart item ${asin}: validation failed \u2014 ${parsed2.error.message}`);
+      }
+    } catch {
+    }
+  });
+  const subtotalText = $("#sc-subtotal-amount-activecart").text().trim();
+  const subtotal = subtotalText ? parsePrice(subtotalText) : null;
+  const currency = "USD";
+  const rawCart = { items, subtotal, currency };
+  const parsed = CartSchema.safeParse(rawCart);
+  if (!parsed.success) {
+    log4(`Cart validation failed: ${parsed.error.message}`);
+    return { items: [], subtotal: null, currency: "USD" };
+  }
+  log4(`Parsed ${items.length} cart items, subtotal: ${subtotal ?? "N/A"}`);
+  return parsed.data;
+}
+function parseOrderDate(dateText) {
+  const months = {
+    January: "01",
+    February: "02",
+    March: "03",
+    April: "04",
+    May: "05",
+    June: "06",
+    July: "07",
+    August: "08",
+    September: "09",
+    October: "10",
+    November: "11",
+    December: "12"
+  };
+  const match = dateText.match(/(\w+)\s+(\d+),?\s+(\d{4})/);
+  if (match) {
+    const month = months[match[1]] ?? "01";
+    const day = match[2].padStart(2, "0");
+    const year = match[3];
+    return `${year}-${month}-${day}`;
+  }
+  return dateText;
+}
+function parseOrderHistory(html) {
+  const $ = cheerio.load(html);
+  const orders = [];
+  $(".order-card.js-order-card").each((_index, element) => {
+    try {
+      const orderEl = $(element);
+      const orderId = orderEl.find('.yohtmlc-order-id span[dir="ltr"]').text().trim();
+      if (!orderId || orderId.trim() === "") return;
+      const dateText = orderEl.find(".order-header .a-size-base.a-color-secondary.aok-break-word").first().text().trim();
+      const date = parseOrderDate(dateText);
+      let total = 0;
+      orderEl.find(".order-header__header-list-item").each((_i, item) => {
+        const $item = $(item);
+        const text = $item.text();
+        if (text.includes("Total")) {
+          const priceMatch = text.match(/\$[\d,]+\.?\d*/);
+          if (priceMatch) {
+            total = parsePrice(priceMatch[0]) ?? 0;
+          }
+        }
+      });
+      const currency = "USD";
+      const status = orderEl.find(".delivery-box__primary-text").first().text().trim() || "Unknown";
+      const items = [];
+      const seenAsins = /* @__PURE__ */ new Set();
+      const itemLinks = orderEl.find('a[href*="/gp/product/"], a[href*="/dp/"]');
+      itemLinks.each((_i, link) => {
+        try {
+          const $link = $(link);
+          const href = $link.attr("href") || "";
+          const asinMatch = href.match(/\/(?:dp|gp\/product)\/([A-Z0-9]{10})/);
+          if (!asinMatch) return;
+          const asin = asinMatch[1];
+          if (seenAsins.has(asin)) return;
+          seenAsins.add(asin);
+          let title = $link.text().trim();
+          if (!title || title.length < 3) {
+            title = $link.find("img").attr("alt") || "";
+          }
+          if (!title || title.length < 3) return;
+          const price = null;
+          const quantity = 1;
+          const rawItem = { asin, title, price, quantity };
+          const parsed2 = OrderItemSchema.safeParse(rawItem);
+          if (parsed2.success) {
+            items.push(parsed2.data);
+          }
+        } catch {
+        }
+      });
+      const itemCount = items.length || void 0;
+      const rawOrder = {
+        orderId,
+        date,
+        total,
+        currency,
+        status,
+        itemCount,
+        items
+      };
+      const parsed = OrderSchema.safeParse(rawOrder);
+      if (parsed.success) {
+        orders.push(parsed.data);
+      } else {
+        log4(`Skipping order ${orderId}: validation failed \u2014 ${parsed.error.message}`);
+      }
+    } catch {
+    }
+  });
+  log4(`Parsed ${orders.length} orders from order history`);
+  return orders;
+}
+function parseOrderDetails(html) {
+  const $ = cheerio.load(html);
+  let orderId = "";
+  $("span").each((_i, el) => {
+    const text = $(el).text().trim();
+    if (/^\d{3}-\d{7}-\d{7}$/.test(text)) {
+      orderId = text;
+      return false;
+    }
+  });
+  if (!orderId) {
+    log4("No order ID found in order details HTML");
+    return null;
+  }
+  let date = "";
+  $("span").each((_i, el) => {
+    const text = $(el).text().trim();
+    if (text === "Order placed") {
+      const parent = $(el).parent();
+      const dateSpan = parent.find("span").filter((_j, s) => {
+        const t = $(s).text().trim();
+        return /\w+\s+\d+,\s+\d{4}/.test(t);
+      }).first();
+      if (dateSpan.length) {
+        date = parseOrderDate(dateSpan.text().trim());
+        return false;
+      }
+    }
+  });
+  if (!date) {
+    const bodyText = $("body").text();
+    const dateMatch = bodyText.match(
+      /(January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},\s+\d{4}/
+    );
+    if (dateMatch) {
+      date = parseOrderDate(dateMatch[0]);
+    }
+  }
+  let total = 0;
+  const allText = $("body").text();
+  const grandTotalMatch = allText.match(/Grand Total[:\s]*\$?([\d,]+\.?\d*)/i);
+  if (grandTotalMatch) {
+    total = parsePrice(`$${grandTotalMatch[1]}`) ?? 0;
+  } else {
+    const orderTotalMatch = allText.match(/Order Total[:\s]*\$?([\d,]+\.?\d*)/i);
+    if (orderTotalMatch) {
+      total = parsePrice(`$${orderTotalMatch[1]}`) ?? 0;
+    }
+  }
+  const currency = "USD";
+  let status = "Unknown";
+  const deliveredEl = $(".a-text-bold").filter((_i, el) => {
+    return $(el).text().trim().toLowerCase().includes("delivered");
+  }).first();
+  if (deliveredEl.length) {
+    const nextSpan = deliveredEl.next("span");
+    status = `Delivered ${nextSpan.text().trim()}`.trim();
+  }
+  const items = [];
+  const seenAsins = /* @__PURE__ */ new Set();
+  $('a[href*="/dp/"]').each((_index, element) => {
+    try {
+      const link = $(element);
+      const href = link.attr("href") || "";
+      const asinMatch = href.match(/\/dp\/([A-Z0-9]{10})/);
+      if (!asinMatch) return;
+      const asin = asinMatch[1];
+      if (seenAsins.has(asin)) return;
+      seenAsins.add(asin);
+      let title = link.text().trim();
+      if (!title || title.length < 3) {
+        title = link.find("img").attr("alt") || "";
+      }
+      if (!title || title.length < 3) return;
+      let price = null;
+      const container = link.closest(".a-row, .a-section, div").parent();
+      const priceEl = container.find(".a-offscreen").first();
+      if (priceEl.length) {
+        const priceText = priceEl.text().trim();
+        if (priceText.startsWith("$")) {
+          price = parsePrice(priceText);
+        }
+      }
+      const quantity = 1;
+      const rawItem = { asin, title, price, quantity };
+      const parsed2 = OrderItemSchema.safeParse(rawItem);
+      if (parsed2.success) {
+        items.push(parsed2.data);
+      } else {
+        log4(`Skipping order item ${asin}: validation failed \u2014 ${parsed2.error.message}`);
+      }
+    } catch {
+    }
+  });
+  const itemCount = items.length;
+  const rawOrder = {
+    orderId,
+    date,
+    total,
+    currency,
+    status,
+    itemCount,
+    items
+  };
+  const parsed = OrderSchema.safeParse(rawOrder);
+  if (!parsed.success) {
+    log4(`Order details validation failed: ${parsed.error.message}`);
+    return null;
+  }
+  log4(`Parsed order details for ${orderId} with ${items.length} items`);
+  return parsed.data;
+}
+function parseCartForCheckout(html) {
+  const $ = cheerio.load(html);
+  const emptyCartText = $("h1, h2, .a-section").text().toLowerCase();
+  if (emptyCartText.includes("your cart is empty") || emptyCartText.includes("your amazon cart is empty") || emptyCartText.includes("your shopping cart is empty")) {
+    log4("Cart is empty");
+    return { isEmpty: true, itemCount: 0 };
+  }
+  const itemCount = $(".sc-list-item[data-asin]").length;
+  log4(`Cart has ${itemCount} items`);
+  return { isEmpty: itemCount === 0, itemCount };
+}
+function parseCheckoutPage(html) {
+  const $ = cheerio.load(html);
+  const errorAlert = $(".a-alert-error, .a-box.a-alert-error").text().toLowerCase();
+  const warningAlert = $(".a-alert-warning, .a-box.a-alert-warning").text().toLowerCase();
+  const pageText = $("body").text().toLowerCase();
+  if (errorAlert.includes("payment") || errorAlert.includes("declined") || pageText.includes("payment method was declined") || pageText.includes("payment was declined")) {
+    log4("Checkout error: payment declined");
+    return {
+      summary: null,
+      error: {
+        type: "payment_declined",
+        message: "Your payment method was declined. Please update your payment method or use a different one."
+      },
+      hasPlaceOrderButton: false
+    };
+  }
+  if (warningAlert.includes("out of stock") || warningAlert.includes("no longer available") || pageText.includes("no longer available") || pageText.includes("currently unavailable")) {
+    const affectedItems = [];
+    $(".unavailable-item, [data-asin]").filter((_i, el) => {
+      const text = $(el).text().toLowerCase();
+      return text.includes("unavailable") || text.includes("out of stock");
+    }).each((_i, el) => {
+      const title = $(el).find(".item-title, .item-name").text().trim();
+      if (title) affectedItems.push(title);
+    });
+    log4(`Checkout error: out of stock (${affectedItems.length} items)`);
+    return {
+      summary: null,
+      error: {
+        type: "out_of_stock",
+        message: "Some items in your cart are no longer available.",
+        affectedItems: affectedItems.length > 0 ? affectedItems : void 0
+      },
+      hasPlaceOrderButton: false
+    };
+  }
+  if (errorAlert.includes("address") || pageText.includes("address is not valid") || pageText.includes("unable to ship")) {
+    log4("Checkout error: address invalid");
+    return {
+      summary: null,
+      error: {
+        type: "address_invalid",
+        message: "The shipping address is not valid or we cannot ship to this location."
+      },
+      hasPlaceOrderButton: false
+    };
+  }
+  const items = [];
+  $(".checkout-item, .order-summary-content .checkout-item, [data-asin]").each((_i, el) => {
+    const $item = $(el);
+    const asin = $item.attr("data-asin") ?? "";
+    if (!asin) return;
+    const title = $item.find(".item-title, .item-name, .sc-product-title").text().trim() || $item.find("a").first().text().trim();
+    const price = $item.find(".item-price, .a-price .a-offscreen").first().text().trim();
+    const qtyText = $item.find(".item-quantity, [name='quantity']").text().trim();
+    const qtyMatch = qtyText.match(/\d+/);
+    const quantity = qtyMatch ? parseInt(qtyMatch[0], 10) : 1;
+    if (title) {
+      items.push({ asin, title, price, quantity });
+    }
+  });
+  const getText = (selector) => $(selector).text().trim();
+  const findTotal = (label) => {
+    let value = "";
+    $(".order-totals div, .a-row").each((_i, el) => {
+      const text = $(el).text();
+      if (text.toLowerCase().includes(label.toLowerCase())) {
+        const priceMatch = text.match(/\$[\d,]+\.?\d*/);
+        if (priceMatch) {
+          value = priceMatch[0];
+          return false;
+        }
+      }
+    });
+    return value;
+  };
+  const subtotal = findTotal("items") || findTotal("subtotal") || "";
+  const shipping = findTotal("shipping") || "$0.00";
+  const tax = findTotal("tax") || "$0.00";
+  const total = getText(".grand-total-price") || getText(".order-total-value") || findTotal("order total") || findTotal("grand total") || "";
+  const hasPlaceOrderButton = $('input[name="placeYourOrder1"], #submitOrderButtonId, [name*="placeOrder"]').length > 0;
+  if (items.length === 0 && !total) {
+    log4("Could not parse checkout summary");
+    return {
+      summary: null,
+      error: { type: "unknown", message: "Could not parse checkout page" },
+      hasPlaceOrderButton
+    };
+  }
+  const summary = {
+    items,
+    subtotal,
+    shipping,
+    tax,
+    total
+  };
+  log4(`Parsed checkout: ${items.length} items, total ${total}`);
+  return { summary, error: null, hasPlaceOrderButton };
+}
+function parseOrderConfirmation(html) {
+  const $ = cheerio.load(html);
+  const successAlert = $(".a-alert-success, .a-box.a-alert-success").length > 0;
+  const thankYouText = $("body").text().toLowerCase();
+  const hasThankYou = thankYouText.includes("thanks") || thankYouText.includes("order placed") || thankYouText.includes("order confirmed");
+  if (!successAlert && !hasThankYou) {
+    log4("Order confirmation page does not show success");
+    const raw2 = {
+      success: false,
+      orderId: null,
+      message: "Order placement failed - confirmation not found",
+      orderTotal: null
+    };
+    const parsed2 = PurchaseResultSchema.safeParse(raw2);
+    return parsed2.success ? parsed2.data : raw2;
+  }
+  let orderId = null;
+  const orderIdEl = $(".order-id, #orderDetails .order-id, bdi.order-id").first();
+  if (orderIdEl.length) {
+    orderId = orderIdEl.text().trim();
+  }
+  if (!orderId) {
+    $("bdi").each((_i, el) => {
+      const text = $(el).text().trim();
+      if (/^\d{3}-\d{7}-\d{7}$/.test(text)) {
+        orderId = text;
+        return false;
+      }
+    });
+  }
+  if (!orderId) {
+    const orderMatch = $("body").text().match(/Order\s*#?\s*(\d{3}-\d{7}-\d{7})/i);
+    if (orderMatch) {
+      orderId = orderMatch[1];
+    }
+  }
+  let orderTotal = null;
+  const totalEl = $(".order-total-value, .order-total").first();
+  if (totalEl.length) {
+    orderTotal = totalEl.text().trim();
+  }
+  if (!orderTotal) {
+    const totalMatch = $("body").text().match(/Order total[:\s]*(\$[\d,]+\.?\d*)/i);
+    if (totalMatch) {
+      orderTotal = totalMatch[1];
+    }
+  }
+  const message = orderId ? `Order placed successfully. Order ID: ${orderId}` : "Order placed successfully, but order ID could not be extracted.";
+  const raw = {
+    success: true,
+    orderId,
+    message,
+    orderTotal
+  };
+  const parsed = PurchaseResultSchema.safeParse(raw);
+  if (!parsed.success) {
+    log4(`Order confirmation validation failed: ${parsed.error.message}`);
+    return raw;
+  }
+  log4(`Parsed order confirmation: ${orderId}, total ${orderTotal}`);
+  return parsed.data;
+}
+
+// src/providers/serpapi.ts
+import { getJson } from "serpapi";
+function log5(message) {
+  console.error(`[serpapi] ${message}`);
+}
+function parsePrice2(raw) {
+  if (!raw) return { price: null, currency: "USD" };
+  const match = raw.match(/([£€$])?([\d,]+\.?\d*)/);
+  if (!match) return { price: null, currency: "USD" };
+  const currencyMap = { $: "USD", "\xA3": "GBP", "\u20AC": "EUR" };
+  return {
+    price: parseFloat(match[2].replace(/,/g, "")),
+    currency: currencyMap[match[1]] ?? "USD"
+  };
+}
+function createSerpApiClient(apiKey) {
+  return {
+    async searchProducts(query, category, maxResults = 20) {
+      log5(`Searching for "${query}"${category ? ` in ${category}` : ""}`);
+      try {
+        const params = {
+          engine: "amazon",
+          amazon_domain: "amazon.com",
+          search_term: query,
+          api_key: apiKey
+        };
+        if (category) {
+          params.amazon_url = `https://www.amazon.com/s?k=${encodeURIComponent(query)}&i=${encodeURIComponent(category)}`;
+        }
+        const json = await getJson(params);
+        const results = json.organic_results ?? [];
+        const products = results.slice(0, maxResults).map((r) => {
+          const { price, currency } = parsePrice2(r.price?.raw ?? r.price?.value?.toString());
+          return {
+            asin: r.asin ?? "",
+            title: r.title ?? "",
+            price,
+            currency,
+            rating: r.rating ?? null,
+            reviewCount: r.reviews ?? 0,
+            brand: r.brand ?? null,
+            isPrime: r.is_prime ?? false,
+            imageUrl: r.thumbnail ?? null,
+            url: r.link ?? `https://www.amazon.com/dp/${r.asin}`
+          };
+        });
+        log5(`Found ${products.length} products`);
+        return products;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log5(`Search error: ${message}`);
+        return [];
+      }
+    },
+    async getProductDetails(asin) {
+      log5(`Fetching product details for ${asin}`);
+      try {
+        const json = await getJson({
+          engine: "amazon_product",
+          asin,
+          amazon_domain: "amazon.com",
+          api_key: apiKey
+        });
+        const p = json.product_results ?? json.product_result;
+        if (!p) {
+          log5(`No product result for ${asin}`);
+          return null;
+        }
+        const { price, currency } = parsePrice2(p.price?.raw ?? p.price?.value?.toString());
+        const details = {
+          asin: p.asin ?? asin,
+          title: p.title ?? "",
+          price,
+          currency,
+          rating: p.rating ?? null,
+          reviewCount: p.reviews_total ?? p.reviews ?? 0,
+          brand: p.brand ?? null,
+          isPrime: p.is_prime ?? false,
+          description: json.product_description?.text ?? p.description ?? "",
+          features: json.about_item?.map((item) => item.text ?? item) ?? p.feature_bullets ?? [],
+          imageUrls: p.images?.map((img) => img.link ?? img) ?? [],
+          availability: p.availability?.raw ?? p.availability ?? "Unknown",
+          url: p.link ?? `https://www.amazon.com/dp/${asin}`
+        };
+        log5(`Got details for "${details.title}"`);
+        return details;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log5(`Product details error: ${message}`);
+        return null;
+      }
+    },
+    async getReviews(asin, maxReviews, _sortBy, _filterByStars) {
+      log5(`Fetching reviews for ${asin}`);
+      try {
+        const json = await getJson({
+          engine: "amazon_product",
+          asin,
+          amazon_domain: "amazon.com",
+          api_key: apiKey
+        });
+        const reviewsInfo = json.reviews_information ?? {};
+        const rawReviews = reviewsInfo.authors_reviews ?? [];
+        if (rawReviews.length === 0) {
+          log5(`No reviews found for ${asin}`);
+          return null;
+        }
+        const reviews = rawReviews.slice(0, maxReviews ?? rawReviews.length).map((r, i) => ({
+          id: r.id ?? `serpapi-${asin}-${i}`,
+          author: r.author ?? "Unknown",
+          rating: r.rating ?? 0,
+          title: r.title ?? "",
+          body: r.text ?? r.body ?? "",
+          date: r.date ?? "",
+          verified: r.verified_purchase ?? false
+        }));
+        const customerReviews = reviewsInfo.summary?.customer_reviews ?? {};
+        const product = json.product_results ?? {};
+        const starDist = {
+          1: customerReviews["1 star"] ?? 0,
+          2: customerReviews["2 star"] ?? 0,
+          3: customerReviews["3 star"] ?? 0,
+          4: customerReviews["4 star"] ?? 0,
+          5: customerReviews["5 star"] ?? 0
+        };
+        const totalFromStars = starDist[1] + starDist[2] + starDist[3] + starDist[4] + starDist[5];
+        const totalCount = product.reviews_total ?? (totalFromStars > 0 ? totalFromStars : 0);
+        const summary = {
+          averageRating: product.rating ?? 0,
+          totalCount,
+          starDistribution: starDist
+        };
+        log5(`Got ${reviews.length} reviews (avg ${summary.averageRating}/5)`);
+        return { reviews, summary };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log5(`Reviews error: ${message}`);
+        return null;
+      }
+    }
+  };
+}
+
+// src/cache/index.ts
+import { createHash } from "crypto";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  mkdirSync as mkdirSync2,
+  readdirSync
+} from "fs";
+import { join as join2 } from "path";
+var DEFAULT_TTL_SECONDS = 600;
+function getCacheDir() {
+  return join2(getDataDir(), "cache");
+}
+function getCacheFilePath(key) {
+  const hash = createHash("sha256").update(key).digest("hex");
+  return join2(getCacheDir(), `${hash}.json`);
+}
+function getCached(key, _options) {
+  const filePath = getCacheFilePath(key);
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const entry = JSON.parse(content);
+    if (Date.now() > entry.expiresAt) {
+      try {
+        unlinkSync(filePath);
+      } catch {
+      }
+      return null;
+    }
+    return entry.value;
+  } catch {
+    try {
+      unlinkSync(filePath);
+    } catch {
+    }
+    return null;
+  }
+}
+function setCache(key, value, options) {
+  const cacheDir = getCacheDir();
+  mkdirSync2(cacheDir, { recursive: true });
+  const ttlSeconds = options?.ttlSeconds ?? getDefaultTTL();
+  const filePath = getCacheFilePath(key);
+  const entry = {
+    value,
+    expiresAt: Date.now() + ttlSeconds * 1e3,
+    metadata: {
+      namespace: options?.namespace,
+      createdAt: Date.now()
+    }
+  };
+  writeFileSync(filePath, JSON.stringify(entry), "utf-8");
+}
+function getDefaultTTL() {
+  const envTTL = process.env.AMAZON_MCP_CACHE_TTL;
+  if (envTTL) {
+    const parsed = parseInt(envTTL, 10);
+    if (!isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return DEFAULT_TTL_SECONDS;
+}
+
+// src/providers/playwright/captcha.ts
+var logger4 = createLogger("captcha");
+var CAPTCHA_PATTERNS = [
+  // Amazon text CAPTCHA prompts (visible text)
+  /enter the characters you see/i,
+  /type the characters/i,
+  /sorry,?\s*we just need to make sure you'?re not a robot/i,
+  /to continue, please type the characters/i,
+  // Amazon CAPTCHA form elements (specific IDs/classes)
+  /id="auth-captcha-image"/i,
+  /id="auth-captcha-guess"/i,
+  /id="captchacharacters"/i,
+  // reCAPTCHA iframe/div (specific attributes)
+  /class="g-recaptcha"/i,
+  /data-sitekey=/i
+];
+var ELEMENT_PATTERNS = [
+  "#auth-captcha-image",
+  "#auth-captcha-guess",
+  "#captchacharacters"
+];
+function detectCaptcha(html) {
+  if (!html || html.length < 50) {
+    return false;
+  }
+  const lowerHtml = html.toLowerCase();
+  for (const pattern of CAPTCHA_PATTERNS) {
+    if (pattern.test(lowerHtml)) {
+      return true;
+    }
+  }
+  for (const selector of ELEMENT_PATTERNS) {
+    const selectorParts = selector.replace(/[[\]#.]/g, " ").split(/\s+/).filter((p) => p.length > 3);
+    const matchCount = selectorParts.filter(
+      (part) => lowerHtml.includes(part.toLowerCase())
+    ).length;
+    if (matchCount >= Math.ceil(selectorParts.length * 0.5)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function detectCaptchaOnPage(page) {
+  const html = await page.content();
+  return detectCaptcha(html);
+}
+async function handleCaptcha(currentUrl) {
+  logger4.info("CAPTCHA detected - switching to headed browser mode");
+  await closeBrowser();
+  const page = await getPage({ headless: false });
+  logger4.info("Headed browser opened - please solve the CAPTCHA in the browser window");
+  await page.goto(currentUrl, { waitUntil: "domcontentloaded" });
+  const resolved = await waitForCaptchaResolution(page);
+  if (!resolved) {
+    throw new CaptchaRequiredError("CAPTCHA timeout. The CAPTCHA was not solved within 5 minutes.");
+  }
+  logger4.info("CAPTCHA resolved - continuing operation");
+  return page;
+}
+async function waitForCaptchaResolution(page, timeoutMs = 3e5) {
+  const startTime = Date.now();
+  const pollIntervalMs = 2e3;
+  while (Date.now() - startTime < timeoutMs) {
+    const hasCaptcha = await detectCaptchaOnPage(page);
+    if (!hasCaptcha) {
+      return true;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+  }
+  return false;
+}
+
+// src/utils/retry.ts
+var DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  initialDelayMs: 1e3,
+  maxDelayMs: 16e3,
+  backoffFactor: 2,
+  jitter: true
+};
+var TRANSIENT_ERROR_PATTERNS = [
+  /timeout/i,
+  /ECONNRESET/i,
+  /ENOTFOUND/i,
+  /ETIMEDOUT/i,
+  /ECONNREFUSED/i,
+  /EPIPE/i,
+  /ENETUNREACH/i,
+  /EHOSTUNREACH/i,
+  /socket hang up/i,
+  /network/i
+];
+function isTransientError(error) {
+  const message = error.message || "";
+  for (const pattern of TRANSIENT_ERROR_PATTERNS) {
+    if (pattern.test(message)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function retryWithBackoff(fn, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let lastError = null;
+  for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (!isTransientError(lastError)) {
+        throw lastError;
+      }
+      if (attempt < opts.maxRetries - 1) {
+        const delay = calculateDelay(attempt, opts);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+}
+function calculateDelay(attempt, opts) {
+  let delay = opts.initialDelayMs * Math.pow(opts.backoffFactor, attempt);
+  delay = Math.min(delay, opts.maxDelayMs);
+  if (opts.jitter) {
+    const jitterRange = delay * 0.2;
+    delay = delay - jitterRange + Math.random() * jitterRange * 2;
+  }
+  return Math.round(delay);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/providers/playwright/index.ts
+var SCRAPE_TIMEOUT_MS = 3e4;
+var SEARCH_CACHE_TTL_SECONDS = 600;
+var PRODUCT_CACHE_TTL_SECONDS = 1800;
+var REVIEWS_CACHE_TTL_SECONDS = 1800;
+var logger5 = createLogger("provider");
+function log6(message) {
+  logger5.info(message);
+}
+async function downloadImageAsBase64(page, imageUrl) {
+  try {
+    const response = await page.request.get(imageUrl, { timeout: 1e4 });
+    if (!response.ok()) {
+      log6(`Image download failed: ${response.status()} for ${imageUrl}`);
+      return null;
+    }
+    const buffer = await response.body();
+    return buffer.toString("base64");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log6(`Image download error: ${message}`);
+    return null;
+  }
+}
+var PlaywrightProvider = class {
+  serpapi;
+  constructor(serpApiKey) {
+    this.serpapi = serpApiKey ? createSerpApiClient(serpApiKey) : null;
+    log6(`SerpAPI fallback: ${this.serpapi ? "configured" : "not configured"}`);
+  }
+  async searchProducts(query, category, maxResults) {
+    const cacheKey = `search:${query}:${category ?? "all"}`;
+    const cached = getCached(cacheKey, { namespace: "search" });
+    if (cached) {
+      log6(`Cache hit for search: ${query}`);
+      const limit2 = maxResults ?? 20;
+      return cached.slice(0, limit2);
+    }
+    const page = await getPage();
+    await assertSessionValid(page);
+    const searchUrl = new URL("/s", AMAZON_BASE_URL);
+    searchUrl.searchParams.set("k", query);
+    if (category) {
+      searchUrl.searchParams.set("i", category);
+    }
+    log6(`Searching: ${searchUrl.toString()}`);
+    await throttleNavigation();
+    try {
+      await retryWithBackoff(async () => {
+        await page.goto(searchUrl.toString(), {
+          waitUntil: "domcontentloaded",
+          timeout: SCRAPE_TIMEOUT_MS
+        });
+      });
+      await simulateMouseMovement(page);
+      await simulateScroll(page);
+      await randomDelay(500, 1500);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load search results: ${message}`, {
+        cause: error
+      });
+    }
+    await assertSessionValid(page);
+    const html = await page.content();
+    if (detectCaptcha(html)) {
+      logger5.warn("CAPTCHA detected on search page - switching to headed browser");
+      const resolvedPage = await handleCaptcha(page.url());
+      const freshHtml = await resolvedPage.content();
+      if (detectCaptcha(freshHtml)) {
+        throw new CaptchaRequiredError("CAPTCHA could not be resolved");
+      }
+      const products2 = parseSearchResults(freshHtml);
+      const limit2 = maxResults ?? 20;
+      const result2 = products2.slice(0, limit2);
+      if (products2.length > 0) {
+        setCache(cacheKey, products2, { ttlSeconds: SEARCH_CACHE_TTL_SECONDS, namespace: "search" });
+      }
+      return result2;
+    }
+    const products = parseSearchResults(html);
+    const limit = maxResults ?? 20;
+    const result = products.slice(0, limit);
+    if (result.length === 0 && this.serpapi) {
+      log6(`Empty search results from scraper, trying SerpAPI fallback`);
+      const serpResult = await this.serpapi.searchProducts(query, category, maxResults);
+      if (serpResult.length > 0) {
+        log6(`SerpAPI fallback returned ${serpResult.length} products`);
+        setCache(cacheKey, serpResult, {
+          ttlSeconds: SEARCH_CACHE_TTL_SECONDS,
+          namespace: "search"
+        });
+        return serpResult;
+      }
+    }
+    if (products.length > 0) {
+      setCache(cacheKey, products, { ttlSeconds: SEARCH_CACHE_TTL_SECONDS, namespace: "search" });
+    }
+    return result;
+  }
+  async getProductDetails(asin) {
+    const cacheKey = `product:${asin}`;
+    const cached = getCached(
+      cacheKey,
+      { namespace: "product" }
+    );
+    if (cached) {
+      log6(`Cache hit for product: ${asin}`);
+      return cached;
+    }
+    const page = await getPage();
+    await assertSessionValid(page);
+    const productUrl = new URL(`/dp/${asin}`, AMAZON_BASE_URL);
+    log6(`Fetching product details: ${productUrl.toString()}`);
+    await throttleNavigation();
+    try {
+      await retryWithBackoff(async () => {
+        await page.goto(productUrl.toString(), {
+          waitUntil: "domcontentloaded",
+          timeout: SCRAPE_TIMEOUT_MS
+        });
+      });
+      await simulateMouseMovement(page);
+      await simulateScroll(page);
+      await randomDelay(500, 1500);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load product page: ${message}`, { cause: error });
+    }
+    await assertSessionValid(page);
+    const html = await page.content();
+    let contentHtml = html;
+    if (detectCaptcha(html)) {
+      logger5.warn("CAPTCHA detected on product page - switching to headed browser");
+      const resolvedPage = await handleCaptcha(page.url());
+      contentHtml = await resolvedPage.content();
+      if (detectCaptcha(contentHtml)) {
+        throw new CaptchaRequiredError("CAPTCHA could not be resolved");
+      }
+    }
+    const details = parseProductDetails(contentHtml);
+    if (!details) {
+      if (this.serpapi) {
+        log6(`Could not parse product details, trying SerpAPI fallback for ${asin}`);
+        const serpDetails = await this.serpapi.getProductDetails(asin);
+        if (serpDetails) {
+          log6(`SerpAPI fallback returned details for "${serpDetails.title}"`);
+          const result2 = { details: serpDetails, primaryImageBase64: null };
+          setCache(cacheKey, result2, {
+            ttlSeconds: PRODUCT_CACHE_TTL_SECONDS,
+            namespace: "product"
+          });
+          return result2;
+        }
+      }
+      throw new ScrapingError(`Could not parse product details for ASIN ${asin}`);
+    }
+    let primaryImageBase64 = null;
+    if (details.imageUrls.length > 0) {
+      primaryImageBase64 = await downloadImageAsBase64(page, details.imageUrls[0]);
+    }
+    const result = { details, primaryImageBase64 };
+    setCache(cacheKey, result, { ttlSeconds: PRODUCT_CACHE_TTL_SECONDS, namespace: "product" });
+    return result;
+  }
+  async getReviews(asin, maxReviews, sortBy, filterByStars) {
+    const cacheKey = `reviews:${asin}:${sortBy ?? "default"}:${filterByStars ?? "all"}`;
+    const cached = getCached(cacheKey, {
+      namespace: "reviews"
+    });
+    if (cached) {
+      log6(`Cache hit for reviews: ${asin}`);
+      const limit2 = maxReviews ?? cached.reviews.length;
+      return { reviews: cached.reviews.slice(0, limit2), summary: cached.summary };
+    }
+    const page = await getPage();
+    await assertSessionValid(page);
+    const reviewsUrl = new URL(`/product-reviews/${asin}`, AMAZON_BASE_URL);
+    if (sortBy) {
+      reviewsUrl.searchParams.set("sortBy", sortBy);
+    }
+    if (filterByStars !== void 0) {
+      const starMap = {
+        1: "one_star",
+        2: "two_star",
+        3: "three_star",
+        4: "four_star",
+        5: "five_star"
+      };
+      const filterValue = starMap[filterByStars];
+      if (filterValue) {
+        reviewsUrl.searchParams.set("filterByStar", filterValue);
+      }
+    }
+    log6(`Fetching reviews: ${reviewsUrl.toString()}`);
+    await throttleNavigation();
+    try {
+      await retryWithBackoff(async () => {
+        await page.goto(reviewsUrl.toString(), {
+          waitUntil: "domcontentloaded",
+          timeout: SCRAPE_TIMEOUT_MS
+        });
+      });
+      await simulateMouseMovement(page);
+      await simulateScroll(page);
+      await randomDelay(500, 1500);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load reviews page: ${message}`, { cause: error });
+    }
+    await assertSessionValid(page);
+    try {
+      await page.waitForSelector('[data-hook="review"]', { timeout: 1e4 });
+    } catch {
+      log6("Warning: review elements did not appear within timeout");
+    }
+    const html = await page.content();
+    let contentHtml = html;
+    if (detectCaptcha(html)) {
+      logger5.warn("CAPTCHA detected on reviews page - switching to headed browser");
+      const resolvedPage = await handleCaptcha(page.url());
+      contentHtml = await resolvedPage.content();
+      if (detectCaptcha(contentHtml)) {
+        throw new CaptchaRequiredError("CAPTCHA could not be resolved");
+      }
+    }
+    const { reviews, summary } = parseReviews(contentHtml);
+    const limit = maxReviews ?? reviews.length;
+    const result = { reviews: reviews.slice(0, limit), summary };
+    if (result.reviews.length === 0 && this.serpapi) {
+      log6(`Empty reviews from scraper, trying SerpAPI fallback for ${asin}`);
+      const serpResult = await this.serpapi.getReviews(asin, maxReviews, sortBy, filterByStars);
+      if (serpResult && serpResult.reviews.length > 0) {
+        log6(`SerpAPI fallback returned ${serpResult.reviews.length} reviews`);
+        setCache(cacheKey, serpResult, {
+          ttlSeconds: REVIEWS_CACHE_TTL_SECONDS,
+          namespace: "reviews"
+        });
+        return serpResult;
+      }
+    }
+    if (reviews.length > 0) {
+      setCache(
+        cacheKey,
+        { reviews, summary },
+        { ttlSeconds: REVIEWS_CACHE_TTL_SECONDS, namespace: "reviews" }
+      );
+    }
+    return result;
+  }
+  async dismissSubscribeAndSave(page) {
+    try {
+      const noThanks = page.locator('text="No thanks"');
+      if (await noThanks.isVisible({ timeout: 2e3 })) {
+        await noThanks.click();
+        log6("Dismissed subscribe-and-save dialog");
+      }
+    } catch {
+    }
+    try {
+      const buyOnce = page.locator('input[data-action="sos-one-time-purchase"]');
+      if (await buyOnce.isVisible({ timeout: 500 })) {
+        await buyOnce.click();
+        log6("Selected one-time purchase option");
+      }
+    } catch {
+    }
+  }
+  async dismissInsurancePrompt(page) {
+    try {
+      const decline = page.locator(
+        '[data-action="decline-warranty"], button:has-text("No Thanks")'
+      );
+      if (await decline.first().isVisible({ timeout: 2e3 })) {
+        await decline.first().click();
+        log6("Dismissed insurance/warranty prompt");
+      }
+    } catch {
+    }
+  }
+  async addToCart(asin, _quantity) {
+    const page = await getPage();
+    await assertSessionValid(page);
+    const productUrl = new URL(`/dp/${asin}`, AMAZON_BASE_URL);
+    log6(`Adding to cart: ${productUrl.toString()}`);
+    await throttleNavigation();
+    try {
+      await page.goto(productUrl.toString(), {
+        waitUntil: "domcontentloaded",
+        timeout: SCRAPE_TIMEOUT_MS
+      });
+      await simulateMouseMovement(page);
+      await randomDelay(300, 800);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load product page: ${message}`, { cause: error });
+    }
+    await assertSessionValid(page);
+    try {
+      const addToCartBtn = page.locator("#add-to-cart-button, #add-to-cart-button-ubb");
+      await addToCartBtn.first().click({ timeout: 5e3 });
+      log6("Clicked Add to Cart button");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Could not find or click Add to Cart button: ${message}`, {
+        cause: error
+      });
+    }
+    await randomDelay(1e3, 2e3);
+    await this.dismissSubscribeAndSave(page);
+    await this.dismissInsurancePrompt(page);
+    const cart = await this.getCart();
+    return {
+      success: true,
+      message: `Added ${asin} to cart`,
+      cart
+    };
+  }
+  async removeFromCart(asin) {
+    const page = await getPage();
+    await assertSessionValid(page);
+    const cartUrl = new URL("/gp/cart/view.html", AMAZON_BASE_URL);
+    log6(`Removing from cart: ${asin}`);
+    await throttleNavigation();
+    try {
+      await page.goto(cartUrl.toString(), {
+        waitUntil: "domcontentloaded",
+        timeout: SCRAPE_TIMEOUT_MS
+      });
+      await simulateMouseMovement(page);
+      await randomDelay(300, 800);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load cart page: ${message}`, { cause: error });
+    }
+    await assertSessionValid(page);
+    try {
+      const cartItem = page.locator(`.sc-list-item[data-asin="${asin}"]`);
+      if (!await cartItem.isVisible({ timeout: 2e3 })) {
+        const cart2 = await this.getCart();
+        return {
+          success: false,
+          message: `Item ${asin} not in cart`,
+          cart: cart2
+        };
+      }
+      const deleteBtn = cartItem.locator(
+        'input[value="Delete"], [data-feature-id="item-delete-button"]'
+      );
+      await deleteBtn.first().click({ timeout: 5e3 });
+      log6(`Deleted item ${asin} from cart`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Could not remove item from cart: ${message}`, { cause: error });
+    }
+    await randomDelay(1e3, 2e3);
+    const cart = await this.getCart();
+    return {
+      success: true,
+      message: `Removed ${asin} from cart`,
+      cart
+    };
+  }
+  async getCart() {
+    const page = await getPage();
+    await assertSessionValid(page);
+    const cartUrl = new URL("/gp/cart/view.html", AMAZON_BASE_URL);
+    log6(`Fetching cart: ${cartUrl.toString()}`);
+    await throttleNavigation();
+    try {
+      await page.goto(cartUrl.toString(), {
+        waitUntil: "domcontentloaded",
+        timeout: SCRAPE_TIMEOUT_MS
+      });
+      await simulateMouseMovement(page);
+      await simulateScroll(page);
+      await randomDelay(500, 1500);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load cart page: ${message}`, { cause: error });
+    }
+    await assertSessionValid(page);
+    const html = await page.content();
+    return parseCart(html);
+  }
+  async clearCart() {
+    const page = await getPage();
+    await assertSessionValid(page);
+    log6("Clearing cart");
+    let cart = await this.getCart();
+    while (cart.items.length > 0) {
+      const asin = cart.items[0].asin;
+      log6(`Removing item ${asin} (${cart.items.length} items remaining)`);
+      await this.removeFromCart(asin);
+      cart = await this.getCart();
+    }
+    log6("Cart cleared");
+  }
+  async getOrderHistory(params) {
+    const page = await getPage();
+    log6("Loading order history page");
+    const limit = params?.limit ?? 10;
+    const currentPage = params?.page ?? 1;
+    const startIndex = (currentPage - 1) * limit;
+    let url = `${AMAZON_BASE_URL}/gp/your-account/order-history`;
+    const urlParams = [];
+    if (startIndex > 0) {
+      urlParams.push(`startIndex=${startIndex}`);
+    }
+    if (params?.startDate || params?.endDate) {
+      if (params.startDate && params.endDate) {
+        urlParams.push(`startDate=${params.startDate}`);
+        urlParams.push(`endDate=${params.endDate}`);
+      } else if (params.startDate) {
+        urlParams.push(`startDate=${params.startDate}`);
+      } else if (params.endDate) {
+        urlParams.push(`endDate=${params.endDate}`);
+      }
+    }
+    if (urlParams.length > 0) {
+      url += `?${urlParams.join("&")}`;
+    }
+    await throttleNavigation();
+    try {
+      await page.goto(url, {
+        waitUntil: "domcontentloaded",
+        timeout: SCRAPE_TIMEOUT_MS
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load order history page: ${message}`, { cause: error });
+    }
+    await assertSessionValid(page);
+    await simulateMouseMovement(page);
+    await randomDelay(500, 1500);
+    await simulateScroll(page);
+    const html = await page.content();
+    const allOrders = parseOrderHistory(html);
+    const orders = allOrders.slice(0, limit);
+    const hasMore = allOrders.length > limit;
+    const nextPage = hasMore ? currentPage + 1 : null;
+    log6(`Retrieved ${orders.length} orders (page ${currentPage})`);
+    return {
+      orders,
+      hasMore,
+      nextPage
+    };
+  }
+  async getOrderDetails(orderId) {
+    const page = await getPage();
+    log6(`Loading order details for ${orderId}`);
+    const url = `${AMAZON_BASE_URL}/gp/your-account/order-details?orderID=${orderId}`;
+    await throttleNavigation();
+    try {
+      await page.goto(url, {
+        waitUntil: "domcontentloaded",
+        timeout: SCRAPE_TIMEOUT_MS
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load order details page: ${message}`, { cause: error });
+    }
+    await assertSessionValid(page);
+    await simulateMouseMovement(page);
+    await randomDelay(500, 1500);
+    const html = await page.content();
+    const order = parseOrderDetails(html);
+    if (!order) {
+      throw new ScrapingError(`Order ${orderId} not found or could not be parsed`);
+    }
+    log6(`Retrieved order details for ${orderId}`);
+    return order;
+  }
+  async purchase(confirmationToken) {
+    if (!confirmationToken || confirmationToken.trim() === "") {
+      return {
+        success: false,
+        orderId: null,
+        message: "Confirmation token is required. The AI assistant must confirm with the user before calling this tool.",
+        orderTotal: null
+      };
+    }
+    const page = await getPage();
+    await assertSessionValid(page);
+    const cartUrl = new URL("/gp/cart/view.html", AMAZON_BASE_URL);
+    log6("Starting purchase flow - checking cart");
+    await throttleNavigation();
+    try {
+      await page.goto(cartUrl.toString(), {
+        waitUntil: "domcontentloaded",
+        timeout: SCRAPE_TIMEOUT_MS
+      });
+      await simulateMouseMovement(page);
+      await randomDelay(500, 1e3);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Failed to load cart page: ${message}`, { cause: error });
+    }
+    await assertSessionValid(page);
+    const cartHtml = await page.content();
+    const { isEmpty, itemCount } = parseCartForCheckout(cartHtml);
+    if (isEmpty) {
+      return {
+        success: false,
+        orderId: null,
+        message: "Your cart is empty. Add items before attempting to purchase.",
+        orderTotal: null
+      };
+    }
+    const cart = parseCart(cartHtml);
+    log6(`=== PRE-PURCHASE SUMMARY ===`);
+    log6(`Items in cart: ${itemCount}`);
+    for (const item of cart.items) {
+      log6(`  - ${item.title} (ASIN: ${item.asin}) x${item.quantity} @ $${item.price ?? "N/A"}`);
+    }
+    log6(`Subtotal: $${cart.subtotal ?? "N/A"}`);
+    log6(`=============================`);
+    log6("Proceeding to checkout");
+    await throttleNavigation();
+    try {
+      const checkoutBtn = page.locator(
+        '#sc-buy-box-ptc-button, input[name="proceedToRetailCheckout"], [data-feature-id="proceed-to-checkout-action"]'
+      );
+      await checkoutBtn.first().click({ timeout: 5e3 });
+      await randomDelay(1500, 3e3);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Could not find or click checkout button: ${message}`, {
+        cause: error
+      });
+    }
+    await page.waitForLoadState("domcontentloaded", { timeout: SCRAPE_TIMEOUT_MS });
+    await assertSessionValid(page);
+    await this.dismissSubscribeAndSave(page);
+    await this.dismissInsurancePrompt(page);
+    const checkoutHtml = await page.content();
+    const checkoutResult = parseCheckoutPage(checkoutHtml);
+    if (checkoutResult.error) {
+      const err = checkoutResult.error;
+      let errorMessage = err.message;
+      if (err.type === "out_of_stock" && err.affectedItems && err.affectedItems.length > 0) {
+        errorMessage += ` Affected items: ${err.affectedItems.join(", ")}`;
+      }
+      return {
+        success: false,
+        orderId: null,
+        message: errorMessage,
+        orderTotal: null
+      };
+    }
+    if (!checkoutResult.hasPlaceOrderButton) {
+      log6("No place order button found - checkout may require additional action");
+      return {
+        success: false,
+        orderId: null,
+        message: "Checkout page is not ready. You may need to select an address or payment method on Amazon directly.",
+        orderTotal: null
+      };
+    }
+    if (checkoutResult.summary) {
+      log6(
+        `Order summary: ${checkoutResult.summary.items.length} items, total ${checkoutResult.summary.total}`
+      );
+    }
+    log6("Placing order");
+    await throttleNavigation();
+    try {
+      const placeOrderBtn = page.locator(
+        'input[name="placeYourOrder1"], #submitOrderButtonId input, [name*="placeOrder"]'
+      );
+      await placeOrderBtn.first().click({ timeout: 5e3 });
+      await randomDelay(2e3, 4e3);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ScrapingError(`Could not find or click place order button: ${message}`, {
+        cause: error
+      });
+    }
+    await page.waitForLoadState("domcontentloaded", { timeout: SCRAPE_TIMEOUT_MS });
+    const confirmationHtml = await page.content();
+    const result = parseOrderConfirmation(confirmationHtml);
+    if (result.success) {
+      log6(`Order placed successfully! Order ID: ${result.orderId}`);
+    } else {
+      log6(`Order placement failed: ${result.message}`);
+    }
+    return result;
+  }
+};
+
+// src/providers/factory.ts
+var SUPPORTED_PROVIDERS = ["playwright"];
+function log7(message) {
+  console.error(`[provider] ${message}`);
+}
+function createProvider() {
+  const providerName = process.env.AMAZON_MCP_PROVIDER ?? "playwright";
+  if (!SUPPORTED_PROVIDERS.includes(providerName)) {
+    throw new Error(
+      `Unsupported provider: "${providerName}". Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}`
+    );
+  }
+  const serpApiKey = process.env.SERPAPI_API_KEY;
+  log7(`Creating provider: ${providerName}`);
+  log7(`SerpAPI fallback: ${serpApiKey ? "configured" : "not configured"}`);
+  switch (providerName) {
+    case "playwright":
+      return new PlaywrightProvider(serpApiKey);
+  }
+}
+
+// src/index.ts
+var provider = createProvider();
+var server = createServer(provider);
+var transport = new StdioServerTransport();
+try {
+  await ensureBrowser();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[startup] Browser setup warning: ${message}`);
+}
+await server.connect(transport);
+console.error("amazon-shopping-mcp server started on stdio");
+async function shutdown() {
+  console.error("[shutdown] Shutting down...");
+  await closeBrowser();
+  await server.close();
+  process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+//# sourceMappingURL=index.js.map