ozon-grabber 0.1.0

package/README.md

@@ -0,0 +1,140 @@
+# Ozon Orders History CLI
+
+A CLI utility that exports Ozon order history from a browser session where the user is already logged in.
+
+The tool opens order pages by template:
+`https://www.ozon.ru/my/orderdetails/?order=<userId>-<orderNumber>&selectedTab=archive`
+and iterates order numbers in ascending order until it hits a missing or in-progress order.
+
+## Installation & Run
+
+### Using npx (recommended)
+
+You can run the tool without local installation:
+```bash
+npx ozon-grabber start --user-id <userId> --start-order 0001
+```
+
+### Local installation
+
+```bash
+cd cli
+npm install
+npm run build
+node dist/index.js start --user-id <userId> --start-order 0001
+```
+
+## Requirements
+
+- Node.js 20+
+- Chrome/Chromium running with the remote debugging port `9222` enabled
+- The user is already authenticated in Ozon in that browser
+
+Example Chrome launch (macOS):
+```bash
+/Applications/Google\ Chrome\ Beta.app/Contents/MacOS/Google\ Chrome\ Beta \
+  --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-beta-mcp
+
+```
+
+## Publication to npm
+
+1.  **Login to npm** (if not already):
+    ```bash
+    npm login
+    ```
+2.  **Verify build**:
+    ```bash
+    npm run build
+    ```
+3.  **Publish**:
+    ```bash
+    npm publish --access public
+    ```
+
+## Run examples
+
+```bash
+# Start from order 0001
+npx ozon-grabber start --user-id 30588125 --start-order 0001
+```
+
+Or with a limited number of orders:
+```bash
+npx ozon-grabber start --user-id 30588125 --start-order 0001 --max-orders 5
+```
+
+Enable backend upload and start from the backend-provided order id:
+```bash
+npx ozon-grabber start --user-id 30588125 --backend
+```
+When backend upload is enabled, each order is submitted immediately after parsing (fail-fast on upload errors).
+
+Fetch the next order id from the backend:
+```bash
+npx ozon-grabber backend-next
+```
+This command uses the backend configuration options listed below.
+
+## Parameters
+
+Required:
+- `--user-id <string>`: user identifier (e.g., `30588125`)
+Optional:
+- `--start-order <string>`: starting order number (e.g., `0001`); required when backend is disabled
+- `--backend`: enable backend upload and backend-based start order resolution
+
+Options:
+- `--verbose`: verbose navigation and parsing logs
+- `--max-orders <n>`: limit the number of orders to scan (debugging)
+- `--page-load-timeout-ms <ms>`: how long to wait for order page widgets before declaring a missing order (default: `20000`)
+- `--output <path>`: output file path; if the extension is `.csv`, CSV is used, otherwise JSON
+- `--backend-url <url>`: backend base URL (env: `BACKEND_URL`, default: `http://localhost:3015`)
+- `--backend-api-key <token>`: backend API key (env: `BACKEND_API_KEY`, default: `local-dev`)
+
+## Output format (JSON)
+
+```json
+{
+  "userId": "30588125",
+  "startOrder": "0001",
+  "scannedOrders": 3,
+  "stopReason": "in-progress",
+  "stopOrderNumber": "0004",
+  "orders": [
+    {
+      "orderId": "30588125-0001",
+      "orderNumber": "0001",
+      "orderDate": "2026-01-09",
+      "items": [
+        {
+          "title": "...",
+          "price": "...",
+          "imageUrl": "..."
+        }
+      ]
+    }
+  ]
+}
+```
+
+`stopReason` can be:
+- `in-progress` - shipment widget text indicates the order is still in progress
+- `missing` - neither the shipment widget nor the order title appeared after the load wait
+- `max-orders` - `--max-orders` limit reached
+
+## How it works
+
+- Connects to an already-open browser via `chrome-devtools-mcp`.
+- Reuses a single tab and navigates to each order URL.
+- Parses items inside `data-widget="shipmentWidget"`.
+- Reads the order header from `data-widget="titleWithTimer"` and parses `orderDate` in `YYYY-MM-DD` (UTC).
+- Waits for `shipmentWidget` or `titleWithTimer` before declaring a missing order (logs show wait duration in verbose mode).
+- Stops at the first in-progress or missing order.
+- When backend upload is enabled, submits items per order using `orderNumber` as the backend `orderId` plus the `userId` field.
+- The backend also downloads each item's `imageUrl`, stores it under `backend/photos/`, and replaces the stored value with that relative path; use `POST /photos/download` to refresh older rows that still reference remote URLs.
+
+## Common issues
+
+- No data / empty results: make sure you're logged in to Ozon in the same browser.
+- DevTools connection error: ensure Chrome is started with `--remote-debugging-port=9222`.

package/dist/index.js

@@ -0,0 +1,842 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs from "fs/promises";
+import path from "path";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/backend-client.ts
+var DEFAULT_BACKEND_URL = "http://192.168.1.10:3015";
+var DEFAULT_API_KEY = "local-dev";
+var isRecord = (value) => value !== null && typeof value === "object";
+var normalizeBackendUrl = (rawUrl) => {
+  const trimmed = rawUrl.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Backend URL must not be empty.");
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch (error) {
+    throw new Error(`Invalid backend URL: ${trimmed}.`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Backend URL must use http or https: ${trimmed}.`);
+  }
+  if (parsed.search || parsed.hash) {
+    throw new Error(`Backend URL must not include query or hash: ${trimmed}.`);
+  }
+  const path2 = parsed.pathname.replace(/\/+$/, "");
+  return `${parsed.origin}${path2}`;
+};
+var buildUrl = (baseUrl, path2) => {
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const normalizedPath = path2.startsWith("/") ? path2 : `/${path2}`;
+  return `${normalizedBase}${normalizedPath}`;
+};
+var parseJsonPayload = (text, context) => {
+  if (text.trim().length === 0) {
+    throw new Error(`${context} returned an empty response body.`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${context} returned invalid JSON.`);
+  }
+};
+var requestJson = async (config, path2, options) => {
+  const method = options?.method ?? "GET";
+  const url = buildUrl(config.baseUrl, path2);
+  const headers = {
+    "x-api-key": config.apiKey
+  };
+  let body;
+  if (options?.body !== void 0) {
+    headers["content-type"] = "application/json";
+    body = JSON.stringify(options.body);
+  }
+  let response;
+  try {
+    response = await fetch(url, { method, headers, body });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to reach backend at ${url}: ${message}`);
+  }
+  const responseText = await response.text();
+  if (!response.ok) {
+    const detail = responseText.trim().length > 0 ? ` Response: ${responseText}` : "";
+    throw new Error(
+      `Backend request failed (${response.status} ${response.statusText}).${detail}`
+    );
+  }
+  return parseJsonPayload(responseText, `${method} ${path2}`);
+};
+var parseNextOrderId = (payload) => {
+  if (!isRecord(payload) || typeof payload.nextOrderId !== "string") {
+    throw new Error("Backend response missing nextOrderId.");
+  }
+  const nextOrderId = payload.nextOrderId.trim();
+  if (!/^\d{4}$/.test(nextOrderId)) {
+    throw new Error(`Backend nextOrderId is invalid: ${payload.nextOrderId}.`);
+  }
+  return nextOrderId;
+};
+var resolveBackendConfig = (args, env = process.env) => {
+  const baseUrlRaw = args.backendUrl ?? env.BACKEND_URL ?? DEFAULT_BACKEND_URL;
+  const apiKey = args.backendApiKey ?? env.BACKEND_API_KEY ?? DEFAULT_API_KEY;
+  return {
+    baseUrl: normalizeBackendUrl(baseUrlRaw),
+    apiKey
+  };
+};
+var getNextOrderId = async (config) => {
+  const payload = await requestJson(config, "/orders/next");
+  return parseNextOrderId(payload);
+};
+var submitItems = async (config, items) => {
+  if (items.length === 0) {
+    return [];
+  }
+  return requestJson(config, "/items", {
+    method: "POST",
+    body: items
+  });
+};
+
+// src/mcp.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var DEFAULT_BROWSER_URL = "http://127.0.0.1:9222";
+var hasOpenedPage = false;
+var defaultChromeDevtoolsArgs = (browserUrl) => [
+  "chrome-devtools-mcp@latest",
+  `--browser-url=${browserUrl}`
+];
+var connectChromeDevtoolsClient = async (options = {}) => {
+  const browserUrl = options.browserUrl ?? DEFAULT_BROWSER_URL;
+  const command = options.command ?? "npx";
+  const args = options.args ?? defaultChromeDevtoolsArgs(browserUrl);
+  const transport = new StdioClientTransport({
+    command,
+    args
+  });
+  const client = new Client(
+    { name: options.clientName ?? "ozon-grabber", version: options.clientVersion ?? "0.1.0" },
+    { capabilities: {} }
+  );
+  await client.connect(transport);
+  const rawTools = await client.listTools();
+  const tools = Array.isArray(rawTools) ? rawTools : rawTools.tools ?? [];
+  return { client, tools };
+};
+var resolveToolName = (tools, target) => {
+  const exact = tools.find((tool) => tool.name === target);
+  if (exact) {
+    return exact.name;
+  }
+  const suffixes = [
+    `.${target}`,
+    `/${target}`,
+    `:${target}`,
+    `__${target}`
+  ];
+  const fallback = tools.find((tool) => suffixes.some((suffix) => tool.name.endsWith(suffix)));
+  if (fallback) {
+    return fallback.name;
+  }
+  const available = tools.map((tool) => tool.name).sort().join(", ");
+  throw new Error(`Tool not found: ${target}. Available tools: ${available}`);
+};
+var openPage = async (client, tools, url) => {
+  const newPageTool = tools.some((tool) => tool.name.includes("new_page")) ? resolveToolName(tools, "new_page") : void 0;
+  if (newPageTool && !hasOpenedPage) {
+    hasOpenedPage = true;
+    return await client.callTool({
+      name: newPageTool,
+      arguments: { url }
+    });
+  }
+  const navigateTool = resolveToolName(tools, "navigate_page");
+  return await client.callTool({
+    name: navigateTool,
+    arguments: { type: "url", url }
+  });
+};
+
+// src/order-items.ts
+var parseJsonFromText = (text) => {
+  const match = text.match(/```json\n([\s\S]*?)\n```/);
+  if (!match) {
+    return text;
+  }
+  try {
+    const jsonText = match[1];
+    if (!jsonText) {
+      return text;
+    }
+    return JSON.parse(jsonText);
+  } catch {
+    return text;
+  }
+};
+var isRecord2 = (value) => value !== null && typeof value === "object";
+var isTextBlock = (value) => isRecord2(value) && typeof value.text === "string";
+var unwrapToolContent = (content) => {
+  if (Array.isArray(content)) {
+    const text = content.map((entry) => isTextBlock(entry) ? entry.text : "").filter((entry) => entry.length > 0).join("\n");
+    if (text.length === 0) {
+      return content;
+    }
+    return parseJsonFromText(text);
+  }
+  return content;
+};
+var extractOrderItems = async (client, tools) => {
+  const evaluateTool = resolveToolName(tools, "evaluate_script");
+  const result = await client.callTool({
+    name: evaluateTool,
+    arguments: {
+      function: `async () => {
+  const normalize = (value) => String(value ?? '').replace(/\\s+/g, ' ').trim();
+  const textOf = (el) => normalize(el.textContent);
+  const isPriceText = (text) => /\u20BD|\\b\u0440\u0443\u0431\\.?\\b/i.test(text);
+  const isShowMoreText = (text) => /\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u044C\\s+\u0435\u0449[\u0435\u0451]/i.test(text);
+
+  const shipments = Array.from(document.querySelectorAll('[data-widget="shipmentWidget"]'));
+  if (shipments.length === 0) return [];
+
+  const clickShowMore = async () => {
+    let clicked = false;
+    shipments.forEach((shipment) => {
+      const buttons = Array.from(shipment.querySelectorAll('button'))
+        .filter((btn) => isShowMoreText(textOf(btn)));
+      buttons.forEach((btn) => {
+        btn.scrollIntoView({ block: 'center', inline: 'center' });
+        btn.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+        clicked = true;
+      });
+    });
+    if (clicked) {
+      await new Promise((resolve) => setTimeout(resolve, 350));
+    }
+    return clicked;
+  };
+
+  for (let i = 0; i < 4; i += 1) {
+    const clicked = await clickShowMore();
+    if (!clicked) break;
+  }
+
+  const findItemRoot = (titleEl, shipment) => {
+    let current = titleEl;
+    let depth = 0;
+    while (current && current !== shipment && depth < 8) {
+      const text = textOf(current);
+      const hasPrice = Array.from(current.querySelectorAll('span'))
+        .some((span) => isPriceText(textOf(span)));
+      const hasImage = Boolean(current.querySelector('img'));
+      if (hasPrice && hasImage && text.length > 0) {
+        return current;
+      }
+      current = current.parentElement;
+      depth += 1;
+    }
+    return titleEl.closest('div') || titleEl;
+  };
+
+  const pickPrice = (root) => {
+    const spans = Array.from(root.querySelectorAll('span'));
+    const match = spans.map((span) => textOf(span)).find((text) => isPriceText(text));
+    return match || null;
+  };
+
+  const pickImageUrl = (root) => {
+    const img = root.querySelector('img');
+    if (!img) return null;
+    return img.currentSrc || img.getAttribute('src');
+  };
+
+  const items = [];
+  shipments.forEach((shipment) => {
+    const titleNodes = Array.from(shipment.querySelectorAll('span.tsCompact500Medium'));
+    titleNodes.forEach((titleNode) => {
+      const title = textOf(titleNode);
+      if (!title) return;
+
+      const root = findItemRoot(titleNode, shipment);
+      items.push({
+        title,
+        price: pickPrice(root),
+        imageUrl: pickImageUrl(root)
+      });
+    });
+  });
+
+  const seen = new Set();
+  return items.filter((item) => {
+    const key = [item.title, item.price || '', item.imageUrl || ''].join('::');
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}`
+    }
+  });
+  const payload = unwrapToolContent(result.content);
+  if (!Array.isArray(payload)) {
+    return [];
+  }
+  return payload.filter(isRecord2).map((item) => {
+    const title = typeof item.title === "string" ? item.title : "";
+    const price = typeof item.price === "string" ? item.price : null;
+    const imageUrl = typeof item.imageUrl === "string" ? item.imageUrl : void 0;
+    return {
+      title,
+      price,
+      imageUrl
+    };
+  }).filter((item) => item.title.length > 0);
+};
+
+// src/order-loop.ts
+var DEFAULT_ORDER_URL = "https://www.ozon.ru/my/orderdetails/";
+var DEFAULT_PAGE_LOAD_TIMEOUT_MS = 2e4;
+var DEFAULT_PAGE_LOAD_RETRY_DELAY_MS = 2e3;
+var DEFAULT_WIDGET_POLL_INTERVAL_MS = 500;
+var DEFAULT_SHIPMENT_WIDGET_TIMEOUT_MS = 8e3;
+var DEFAULT_TITLE_WIDGET_TIMEOUT_MS = 8e3;
+var normalizeText = (value) => value.replace(/\s+/g, " ").trim();
+var parseJsonFromText2 = (text) => {
+  const match = text.match(/```json\n([\s\S]*?)\n```/);
+  if (!match) {
+    return text;
+  }
+  try {
+    const jsonText = match[1];
+    if (!jsonText) {
+      return text;
+    }
+    return JSON.parse(jsonText);
+  } catch {
+    return text;
+  }
+};
+var isRecord3 = (value) => value !== null && typeof value === "object";
+var isTextBlock2 = (value) => isRecord3(value) && typeof value.text === "string";
+var unwrapToolContent2 = (content) => {
+  if (Array.isArray(content)) {
+    const text = content.map((entry) => isTextBlock2(entry) ? entry.text : "").filter((entry) => entry.length > 0).join("\n");
+    if (text.length === 0) {
+      return content;
+    }
+    return parseJsonFromText2(text);
+  }
+  return content;
+};
+var RU_MONTHS = {
+  "\u044F\u043D\u0432\u0430\u0440\u044F": 1,
+  "\u0444\u0435\u0432\u0440\u0430\u043B\u044F": 2,
+  "\u043C\u0430\u0440\u0442\u0430": 3,
+  "\u0430\u043F\u0440\u0435\u043B\u044F": 4,
+  "\u043C\u0430\u044F": 5,
+  "\u0438\u044E\u043D\u044F": 6,
+  "\u0438\u044E\u043B\u044F": 7,
+  "\u0430\u0432\u0433\u0443\u0441\u0442\u0430": 8,
+  "\u0441\u0435\u043D\u0442\u044F\u0431\u0440\u044F": 9,
+  "\u043E\u043A\u0442\u044F\u0431\u0440\u044F": 10,
+  "\u043D\u043E\u044F\u0431\u0440\u044F": 11,
+  "\u0434\u0435\u043A\u0430\u0431\u0440\u044F": 12
+};
+var formatIsoDate = (year, month, day) => {
+  const date = new Date(Date.UTC(year, month - 1, day));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() + 1 !== month || date.getUTCDate() !== day) {
+    throw new Error(`Invalid order date: ${year}-${month}-${day}.`);
+  }
+  return date.toISOString().slice(0, 10);
+};
+var parseOrderDateFromTitle = (titleText, now = /* @__PURE__ */ new Date()) => {
+  const normalized = normalizeText(titleText);
+  const explicitMatch = normalized.match(/заказ от\s*(\d{1,2})\.(\d{1,2})\.(\d{4})/i);
+  if (explicitMatch) {
+    const dayText = explicitMatch[1];
+    const monthText = explicitMatch[2];
+    const yearText = explicitMatch[3];
+    if (!dayText || !monthText || !yearText) {
+      throw new Error(`Failed to parse order date from title: ${titleText}.`);
+    }
+    const day = Number.parseInt(dayText, 10);
+    const month = Number.parseInt(monthText, 10);
+    const year = Number.parseInt(yearText, 10);
+    return formatIsoDate(year, month, day);
+  }
+  const textLower = normalized.toLowerCase().replace(/ё/g, "\u0435");
+  const monthMatch = textLower.match(/заказ от\s*(\d{1,2})\s+([а-я]+)/i);
+  if (monthMatch) {
+    const dayText = monthMatch[1];
+    const monthName = monthMatch[2];
+    if (!dayText || !monthName) {
+      throw new Error(`Failed to parse order date from title: ${titleText}.`);
+    }
+    const day = Number.parseInt(dayText, 10);
+    const month = RU_MONTHS[monthName];
+    if (!month) {
+      throw new Error(`Unknown month name in order title: ${monthName}.`);
+    }
+    const year = now.getUTCFullYear();
+    return formatIsoDate(year, month, day);
+  }
+  throw new Error(`Failed to parse order date from title: ${titleText}.`);
+};
+var parseStartOrder = (startOrder) => {
+  const trimmed = startOrder.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(`Invalid start order: ${startOrder}. Expected digits only.`);
+  }
+  const numeric = Number.parseInt(trimmed, 10);
+  if (Number.isNaN(numeric)) {
+    throw new Error(`Invalid start order: ${startOrder}.`);
+  }
+  return { width: trimmed.length, numeric };
+};
+var formatOrderNumber = (orderNumber, width) => String(orderNumber).padStart(width, "0");
+var buildOrderUrl = (orderId) => `${DEFAULT_ORDER_URL}?order=${encodeURIComponent(orderId)}&selectedTab=archive`;
+var IN_PROGRESS_MARKERS = [
+  "\u043C\u043E\u0436\u043D\u043E \u0437\u0430\u0431\u0438\u0440\u0430\u0442\u044C",
+  "\u043F\u0435\u0440\u0435\u0434\u0430\u0451\u0442\u0441\u044F \u0432 \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0443",
+  "\u043F\u0435\u0440\u0435\u0434\u0430\u0435\u0442\u0441\u044F \u0432 \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0443",
+  "\u0432 \u0441\u043B\u0443\u0436\u0431\u0435 \u0434\u043E\u0441\u0442\u0430\u0432\u043A\u0438",
+  "\u0432 \u0441\u0431\u043E\u0440\u043A\u0435",
+  "\u0432 \u043F\u0443\u0442\u0438"
+];
+var COMPLETED_MARKER = "\u043F\u043E\u043B\u0443\u0447\u0435\u043D";
+var getOrderPageState = async (client, tools) => {
+  const evaluateTool = resolveToolName(tools, "evaluate_script");
+  const result = await client.callTool({
+    name: evaluateTool,
+    arguments: {
+      function: `() => {
+  const shipments = Array.from(document.querySelectorAll('[data-widget="shipmentWidget"]'));
+  const shipmentTexts = shipments
+    .map((shipment) => shipment.textContent || '')
+    .filter((text) => text.trim().length > 0);
+  return {
+    hasItemsBlock: shipments.length > 0,
+    shipmentTexts: shipmentTexts.map((text) => String(text))
+  };
+}`
+    }
+  });
+  const payload = unwrapToolContent2(result.content);
+  if (!isRecord3(payload)) {
+    return { hasItemsBlock: false, shipmentTexts: [], isInProgress: false };
+  }
+  const hasItemsBlock = Boolean(payload.hasItemsBlock);
+  const shipmentTextsRaw = Array.isArray(payload.shipmentTexts) ? payload.shipmentTexts.filter((entry) => typeof entry === "string") : [];
+  const shipmentTexts = shipmentTextsRaw.map((text) => normalizeText(text).toLowerCase());
+  const isInProgress = shipmentTexts.some((text) => {
+    if (text.includes(COMPLETED_MARKER)) {
+      return false;
+    }
+    return IN_PROGRESS_MARKERS.some((marker) => text.includes(marker));
+  });
+  return {
+    hasItemsBlock,
+    shipmentTexts,
+    isInProgress
+  };
+};
+var getOrderTitleText = async (client, tools) => {
+  const evaluateTool = resolveToolName(tools, "evaluate_script");
+  const result = await client.callTool({
+    name: evaluateTool,
+    arguments: {
+      function: `() => {
+  const widget = document.querySelector('[data-widget="titleWithTimer"]');
+  if (!widget) return null;
+  const span = widget.querySelector('span');
+  const text = span ? span.textContent : widget.textContent;
+  return text ? String(text) : null;
+}`
+    }
+  });
+  const payload = unwrapToolContent2(result.content);
+  if (typeof payload === "string") {
+    const trimmed = normalizeText(payload);
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  return null;
+};
+var logMessage = (options, message) => {
+  if (!options?.verbose) {
+    return;
+  }
+  if (options.logger) {
+    options.logger(message);
+  } else {
+    console.log(message);
+  }
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var getOrderPageWidgetState = async (client, tools) => {
+  const evaluateTool = resolveToolName(tools, "evaluate_script");
+  const result = await client.callTool({
+    name: evaluateTool,
+    arguments: {
+      function: `() => {
+  const shipmentWidget = document.querySelector('[data-widget="shipmentWidget"]');
+  const titleWidget = document.querySelector('[data-widget="titleWithTimer"]');
+  return {
+    hasShipmentWidget: Boolean(shipmentWidget),
+    hasTitleWithTimer: Boolean(titleWidget)
+  };
+}`
+    }
+  });
+  const payload = unwrapToolContent2(result.content);
+  if (!isRecord3(payload)) {
+    return { hasShipmentWidget: false, hasTitleWithTimer: false };
+  }
+  return {
+    hasShipmentWidget: Boolean(payload.hasShipmentWidget),
+    hasTitleWithTimer: Boolean(payload.hasTitleWithTimer)
+  };
+};
+var waitForOrderPageWidgets = async (client, tools, options, description, timeoutMs, predicate) => {
+  const start = Date.now();
+  const deadline = start + timeoutMs;
+  let attempts = 0;
+  let state = {
+    hasShipmentWidget: false,
+    hasTitleWithTimer: false
+  };
+  logMessage(options, `Waiting for ${description} (timeout ${timeoutMs}ms).`);
+  while (true) {
+    attempts += 1;
+    state = await getOrderPageWidgetState(client, tools);
+    if (predicate(state)) {
+      break;
+    }
+    const now = Date.now();
+    if (now >= deadline) {
+      break;
+    }
+    const remaining = deadline - now;
+    await sleep(Math.min(DEFAULT_WIDGET_POLL_INTERVAL_MS, remaining));
+  }
+  const elapsedMs = Date.now() - start;
+  const timedOut = !predicate(state);
+  logMessage(
+    options,
+    `Wait for ${description} finished in ${elapsedMs}ms (shipmentWidget=${state.hasShipmentWidget}, titleWithTimer=${state.hasTitleWithTimer}, attempts=${attempts}, timedOut=${timedOut}).`
+  );
+  return {
+    state,
+    elapsedMs,
+    attempts,
+    timedOut
+  };
+};
+var scanOrders = async (client, tools, userId, startOrder, options = {}) => {
+  const { width, numeric } = parseStartOrder(startOrder);
+  const pageLoadTimeoutMs = options.pageLoadTimeoutMs ?? DEFAULT_PAGE_LOAD_TIMEOUT_MS;
+  const pageLoadRetryDelayMs = options.pageLoadRetryDelayMs ?? DEFAULT_PAGE_LOAD_RETRY_DELAY_MS;
+  const shipmentWidgetTimeoutMs = Math.min(
+    pageLoadTimeoutMs,
+    DEFAULT_SHIPMENT_WIDGET_TIMEOUT_MS
+  );
+  const titleWidgetTimeoutMs = Math.min(pageLoadTimeoutMs, DEFAULT_TITLE_WIDGET_TIMEOUT_MS);
+  const orders = [];
+  let offset = 0;
+  while (true) {
+    if (options.maxOrders !== void 0 && orders.length >= options.maxOrders) {
+      const stopOrderNumber = formatOrderNumber(numeric + offset, width);
+      return {
+        orders,
+        scannedOrders: orders.length,
+        stopReason: "max-orders",
+        stopOrderNumber
+      };
+    }
+    const orderNumber = formatOrderNumber(numeric + offset, width);
+    const orderId = `${userId}-${orderNumber}`;
+    const url = buildOrderUrl(orderId);
+    logMessage(options, `Opening order ${orderId}`);
+    await openPage(client, tools, url);
+    await waitForOrderPageWidgets(
+      client,
+      tools,
+      options,
+      "order page widgets",
+      pageLoadTimeoutMs,
+      (state) => state.hasShipmentWidget || state.hasTitleWithTimer
+    );
+    let pageState = await getOrderPageState(client, tools);
+    let titleText = null;
+    if (!pageState.hasItemsBlock) {
+      logMessage(
+        options,
+        `No shipment widgets detected for ${orderId}, retrying after ${pageLoadRetryDelayMs}ms.`
+      );
+      if (pageLoadRetryDelayMs > 0) {
+        await sleep(pageLoadRetryDelayMs);
+      }
+      await waitForOrderPageWidgets(
+        client,
+        tools,
+        options,
+        "shipmentWidget",
+        shipmentWidgetTimeoutMs,
+        (state) => state.hasShipmentWidget
+      );
+      pageState = await getOrderPageState(client, tools);
+    }
+    if (!pageState.hasItemsBlock) {
+      titleText = await getOrderTitleText(client, tools);
+      if (titleText) {
+        logMessage(options, `Shipment widget still missing for ${orderId}, continuing with title.`);
+      }
+    }
+    if (!pageState.hasItemsBlock && !titleText) {
+      return {
+        orders,
+        scannedOrders: orders.length,
+        stopReason: "missing",
+        stopOrderNumber: orderNumber
+      };
+    }
+    if (pageState.isInProgress) {
+      logMessage(options, `Order ${orderId} is in progress, stopping scan.`);
+      return {
+        orders,
+        scannedOrders: orders.length,
+        stopReason: "in-progress",
+        stopOrderNumber: orderNumber
+      };
+    }
+    if (!titleText) {
+      titleText = await getOrderTitleText(client, tools);
+    }
+    if (!titleText) {
+      logMessage(
+        options,
+        `TitleWithTimer missing for ${orderId}, waiting up to ${titleWidgetTimeoutMs}ms.`
+      );
+      await waitForOrderPageWidgets(
+        client,
+        tools,
+        options,
+        "titleWithTimer",
+        titleWidgetTimeoutMs,
+        (state) => state.hasTitleWithTimer
+      );
+      titleText = await getOrderTitleText(client, tools);
+    }
+    if (!titleText) {
+      throw new Error(`Order ${orderId} is missing titleWithTimer text.`);
+    }
+    const orderDate = parseOrderDateFromTitle(titleText);
+    const items = await extractOrderItems(client, tools);
+    const order = { orderId, orderNumber, orderDate, items };
+    if (options.onOrder) {
+      await options.onOrder(order);
+    }
+    orders.push(order);
+    offset += 1;
+  }
+};
+
+// src/index.ts
+var resolveOutputFormat = (outputPath) => {
+  if (!outputPath) {
+    return "json";
+  }
+  const extension = path.extname(outputPath).toLowerCase();
+  if (extension === ".csv") {
+    return "csv";
+  }
+  return "json";
+};
+var escapeCsvValue = (value) => {
+  const text = value === null || value === void 0 ? "" : String(value);
+  if (/[",\n]/.test(text)) {
+    return `"${text.replace(/"/g, '""')}"`;
+  }
+  return text;
+};
+var toCsv = (output) => {
+  const header = ["userId", "orderId", "orderNumber", "orderDate", "title", "price", "imageUrl"];
+  const rows = [header.join(",")];
+  output.orders.forEach((order) => {
+    order.items.forEach((item) => {
+      const row = [
+        escapeCsvValue(output.userId),
+        escapeCsvValue(order.orderId),
+        escapeCsvValue(order.orderNumber),
+        escapeCsvValue(order.orderDate),
+        escapeCsvValue(item.title),
+        escapeCsvValue(item.price),
+        escapeCsvValue(item.imageUrl ?? "")
+      ];
+      rows.push(row.join(","));
+    });
+  });
+  return rows.join("\n");
+};
+var toJson = (output) => JSON.stringify(output, null, 2);
+var writeOutput = async (payload, outputPath) => {
+  if (!outputPath) {
+    console.log(payload);
+    return;
+  }
+  const dir = path.dirname(outputPath);
+  if (dir !== ".") {
+    await fs.mkdir(dir, { recursive: true });
+  }
+  await fs.writeFile(outputPath, payload, "utf-8");
+};
+var addBackendOptions = (builder) => builder.option("backend-url", {
+  type: "string",
+  describe: "Backend base URL (env: BACKEND_URL, default: http://localhost:3015)"
+}).option("backend-api-key", {
+  type: "string",
+  describe: "Backend API key (env: BACKEND_API_KEY, default: local-dev)"
+});
+var cli = yargs(hideBin(process.argv)).scriptName("ozon-grabber").command(
+  "ping",
+  "CLI health check",
+  () => void 0,
+  async () => {
+    console.log("pong");
+  }
+).command(
+  "backend-next",
+  "Fetch next orderId from backend",
+  (builder) => addBackendOptions(builder),
+  async (argv) => {
+    try {
+      const config = resolveBackendConfig({
+        backendUrl: argv.backendUrl,
+        backendApiKey: argv.backendApiKey
+      });
+      const nextOrderId = await getNextOrderId(config);
+      console.log(nextOrderId);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(message);
+      process.exitCode = 1;
+    }
+  }
+).command(
+  "start",
+  "Collect order history",
+  (builder) => {
+    const configured = builder.option("user-id", {
+      type: "string",
+      demandOption: true,
+      describe: "Ozon user identifier"
+    }).option("start-order", {
+      type: "string",
+      describe: "Starting order number (e.g., 0008)"
+    }).option("max-orders", {
+      type: "number",
+      describe: "Maximum number of orders to scan"
+    }).option("page-load-timeout-ms", {
+      type: "number",
+      default: 2e4,
+      describe: "Timeout in ms to wait for order page widgets before marking missing"
+    }).option("output", {
+      type: "string",
+      describe: "Output file path"
+    }).option("verbose", {
+      type: "boolean",
+      default: false,
+      describe: "Show verbose logs"
+    }).option("backend", {
+      type: "boolean",
+      default: false,
+      describe: "Enable backend upload and next-order resolution"
+    });
+    return addBackendOptions(configured);
+  },
+  async (argv) => {
+    try {
+      const userId = argv.userId;
+      const maxOrders = argv.maxOrders;
+      const pageLoadTimeoutMs = argv.pageLoadTimeoutMs;
+      const outputPath = argv.output;
+      const verbose = argv.verbose;
+      const useBackend = Boolean(argv.backend);
+      const backendConfig = useBackend ? resolveBackendConfig({
+        backendUrl: argv.backendUrl,
+        backendApiKey: argv.backendApiKey
+      }) : null;
+      const resolvedStartOrder = argv.startOrder ?? (backendConfig ? await getNextOrderId(backendConfig) : void 0);
+      if (!resolvedStartOrder) {
+        throw new Error("Starting order number is required when backend is disabled.");
+      }
+      if (backendConfig && !/^\d{4}$/.test(resolvedStartOrder.trim())) {
+        throw new Error(
+          `Starting order must be a 4-digit string when using backend: ${resolvedStartOrder}.`
+        );
+      }
+      console.log(`Starting orderId: ${resolvedStartOrder}`);
+      const { client, tools } = await connectChromeDevtoolsClient();
+      try {
+        const summary = await scanOrders(client, tools, userId, resolvedStartOrder, {
+          maxOrders,
+          pageLoadTimeoutMs,
+          verbose,
+          logger: (message) => console.log(message),
+          onOrder: backendConfig ? async (order) => {
+            const items = order.items.map((item) => ({
+              orderId: order.orderNumber,
+              userId,
+              orderDate: order.orderDate,
+              title: item.title,
+              price: item.price,
+              imageUrl: item.imageUrl
+            }));
+            if (items.length === 0) {
+              console.log(`Order ${order.orderId} has no items to submit.`);
+              return;
+            }
+            try {
+              await submitItems(backendConfig, items);
+              console.log(
+                `Submitted order ${order.orderId} (${items.length} items) to backend.`
+              );
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              console.error(`Failed to submit order ${order.orderId}: ${message}`);
+              throw error;
+            }
+          } : void 0
+        });
+        console.log(`Scanned orders: ${summary.scannedOrders}`);
+        const output = {
+          userId,
+          startOrder: resolvedStartOrder,
+          scannedOrders: summary.scannedOrders,
+          stopReason: summary.stopReason,
+          stopOrderNumber: summary.stopOrderNumber,
+          orders: summary.orders
+        };
+        const format = resolveOutputFormat(outputPath);
+        const payload = format === "csv" ? toCsv(output) : toJson(output);
+        await writeOutput(payload, outputPath);
+      } finally {
+        await client.close();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(message);
+      process.exitCode = 1;
+    }
+  }
+).option("verbose", {
+  type: "boolean",
+  default: false,
+  describe: "Show verbose logs"
+}).strict().demandCommand(1, "Specify a command").help();
+cli.parse();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "ozon-grabber",
+  "version": "0.1.0",
+  "description": "Ozon order history grabber CLI",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/isachivka/ozon-orders-history.git",
+    "directory": "cli"
+  },
+  "keywords": [
+    "ozon",
+    "grabber",
+    "orders",
+    "history",
+    "cli"
+  ],
+  "author": "Igor Sachivka",
+  "bugs": {
+    "url": "https://github.com/isachivka/ozon-orders-history/issues"
+  },
+  "homepage": "https://github.com/isachivka/ozon-orders-history/tree/main/cli#readme",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "ozon-grabber": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run typecheck && tsup src/index.ts --format esm --target es2022 --out-dir dist --clean",
+    "dev": "tsup src/index.ts --format esm --target es2022 --out-dir dist --watch",
+    "lint": "npm run typecheck",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "@types/yargs": "^17.0.33",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5"
+  }
+}