@mpelka/aliorders 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mpelka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @mpelka/aliorders
+
+CLI tool to fetch and display your AliExpress order history, including tracking info, by using the internal web API.
+
+## Requirements
+
+- **macOS** (cookie extraction uses Chrome's local database)
+- **Google Chrome** with an active AliExpress login
+- **[Bun](https://bun.sh/)** runtime
+
+## Install
+
+```bash
+# From npm
+npm install -g @mpelka/aliorders
+
+# Or clone and run directly
+git clone https://github.com/mpelka/aliorders.git
+cd aliorders
+bun install
+bun link
+```
+
+## Usage
+
+```bash
+aliorders                     # Show active orders (default)
+aliorders -s all              # Show all orders including completed
+aliorders -s shipped          # Filter by status
+aliorders -s completed        # Show completed orders
+aliorders -n 20               # Fetch up to 20 orders
+aliorders -p 2                # Show page 2
+aliorders --json              # Output as JSON for scripting/agents
+aliorders --no-details        # Skip tracking lookups (faster)
+aliorders statuses            # List all status filters
+```
+
+By default, only active orders are shown (awaiting payment, awaiting shipment, in transit). Use `-s all` to include completed and cancelled orders.
+
+### Status filters
+
+| Filter       | Aliases              | Description            |
+|-------------|----------------------|------------------------|
+| `all`       |                      | All orders (no filter) |
+| `waitpay`   | `paying`             | Awaiting payment       |
+| `waitsend`  | `shipping`           | Awaiting shipment      |
+| `waitaccept`| `shipped`, `transit` | Shipped / In transit   |
+| `finish`    | `completed`, `done`  | Completed              |
+| `close`     | `cancelled`          | Cancelled / Closed     |
+
+### JSON output
+
+Use `--json` to get structured output, useful for piping to `jq` or feeding to LLM agents:
+
+```bash
+aliorders --json | jq '.[].status'
+aliorders --json --no-details    # Faster, skips tracking API calls
+```
+
+### Exit codes
+
+| Code | Meaning         |
+|------|-----------------|
+| `0`  | Success         |
+| `1`  | Error           |
+| `2`  | No orders found |
+
+## How it works
+
+Every run extracts fresh authentication cookies directly from Chrome's local database for `aliexpress.com`. These cookies are used to sign requests to AliExpress's internal API endpoints. Nothing is persisted to disk — cookies are always read fresh from Chrome.
+
+## Troubleshooting
+
+**Token expired / empty response:**
+Visit aliexpress.com in Chrome and browse around (this refreshes the auth token), then run again.
+
+## Security
+
+Cookies are read directly from Chrome's database and held in memory only for the duration of the command. Nothing is written to disk.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@mpelka/aliorders",
+  "version": "1.0.0",
+  "description": "CLI tool to fetch and display your AliExpress order history using browser cookies",
+  "main": "src/cli.ts",
+  "bin": {
+    "aliorders": "src/cli.ts"
+  },
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "bun src/cli.ts",
+    "test": "bun test",
+    "lint": "biome check src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": ["aliexpress", "orders", "cli", "tracking"],
+  "author": "mpelka",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@mpelka/get-cookies": "^1.0.2",
+    "commander": "^14.0.3",
+    "ky": "^1.14.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.6",
+    "@types/bun": "^1.3.10",
+    "@types/node": "^25.4.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/AliExpressClient.ts

@@ -0,0 +1,216 @@
+import * as crypto from "node:crypto";
+import type { Cookie } from "@mpelka/get-cookies";
+import ky, { type AfterResponseHook, type BeforeRequestHook } from "ky";
+import type {
+  AliExpressApiResponse,
+  OrderDetailApiResponse,
+  OrderDetailRequestData,
+  OrderListOptions,
+  RequestConfig,
+} from "./types.ts";
+
+export class AliExpressClient {
+  private kyInstance: typeof ky;
+  private cookies: Map<string, string>;
+
+  private readonly config = {
+    tokenCookieName: "_m_h5_tk",
+    appKey: "12574478",
+    baseUrl: "https://acs.aliexpress.com/h5/",
+    endpoints: {
+      orderList: "mtop.aliexpress.trade.buyer.order.list/1.0/",
+      orderDetail: "mtop.aliexpress.trade.buyer.order.detail/1.0/",
+    },
+    defaultParams: {
+      jsv: "2.5.1",
+      v: "1.0",
+      post: "1",
+      timeout: 15000,
+      dataType: "originaljsonp",
+      type: "originaljson",
+    },
+  };
+
+  constructor(browserCookies: Cookie[]) {
+    this.cookies = new Map();
+    for (const cookie of browserCookies) {
+      this.cookies.set(cookie.name, cookie.value);
+    }
+
+    const beforeRequestHook: BeforeRequestHook = async (request) => {
+      const cookieHeader = [...this.cookies.entries()].map(([k, v]) => `${k}=${v}`).join("; ");
+      if (cookieHeader) {
+        request.headers.set("Cookie", cookieHeader);
+      }
+    };
+
+    const afterResponseHook: AfterResponseHook = async (_request, _options, response) => {
+      const setCookieHeader = response.headers.get("set-cookie");
+      if (setCookieHeader) {
+        for (const part of setCookieHeader.split(",")) {
+          const match = part.trim().match(/^([^=]+)=([^;]*)/);
+          if (match) {
+            this.cookies.set(match[1].trim(), match[2].trim());
+          }
+        }
+      }
+    };
+
+    this.kyInstance = ky.create({
+      hooks: {
+        beforeRequest: [beforeRequestHook],
+        afterResponse: [afterResponseHook],
+      },
+      headers: {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "en,pl;q=0.9",
+        referer: "https://www.aliexpress.com/",
+        "sec-ch-ua": '"Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"macOS"',
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-site",
+        "user-agent":
+          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36",
+      },
+      timeout: 15000,
+      retry: 0,
+    });
+  }
+
+  private parseJsonpResponse(responseText: string, callbackName: string) {
+    const trimmed = responseText.trim();
+
+    if (trimmed.startsWith(`${callbackName}(`) && trimmed.endsWith(")")) {
+      const jsonString = trimmed.slice(callbackName.length + 1, -1);
+      return JSON.parse(jsonString);
+    }
+
+    return JSON.parse(responseText);
+  }
+
+  private generateSignature(token: string, timestamp: number, appKey: string, dataString: string): string {
+    const signString = `${token}&${timestamp}&${appKey}&${dataString}`;
+    return crypto.createHash("md5").update(signString).digest("hex");
+  }
+
+  public getTokenInfo(): { expired: boolean; ageHours: number } {
+    const tokenValue = this.cookies.get(this.config.tokenCookieName);
+    if (!tokenValue) return { expired: true, ageHours: Infinity };
+
+    const parts = tokenValue.split("_");
+    if (parts.length < 2) return { expired: true, ageHours: Infinity };
+
+    const tokenTimestamp = parseInt(parts[1], 10);
+    if (Number.isNaN(tokenTimestamp)) return { expired: true, ageHours: Infinity };
+
+    const ageHours = (Date.now() - tokenTimestamp) / (1000 * 60 * 60);
+    return { expired: ageHours > 24, ageHours };
+  }
+
+  private getToken(): string | null {
+    const tokenValue = this.cookies.get(this.config.tokenCookieName);
+    if (!tokenValue) return null;
+    return tokenValue.split("_")[0];
+  }
+
+  async getOrders({
+    pageIndex = 1,
+    pageSize = 10,
+    statusTab = null,
+    country = "PL",
+    language = "pl_PL",
+  }: OrderListOptions): Promise<AliExpressApiResponse | null> {
+    const dataObject = {
+      params: {
+        data: {
+          pc_om_list_body_109702: { fields: { pageIndex, pageSize } },
+          pc_om_list_header_action_110846: {
+            fields: {
+              statusTab: statusTab ?? "all",
+              timeOption: "all",
+              searchOption: "order",
+              searchInput: "",
+            },
+          },
+        },
+      },
+      shipToCountry: country,
+      _lang: language,
+    };
+    return this.request({
+      endpoint: this.config.endpoints.orderList,
+      api: "mtop.aliexpress.trade.buyer.order.list",
+      data: dataObject,
+      method: "POST",
+      callbackName: "mtopjsonp1",
+    });
+  }
+
+  async getOrderDetails(
+    orderId: string,
+    { country = "PL", language = "pl_PL" }: OrderListOptions,
+  ): Promise<OrderDetailApiResponse | null> {
+    const dataObject: OrderDetailRequestData = {
+      tradeOrderId: orderId,
+      timeZone: "GMT+0200",
+      clientPlatform: "pc",
+      channel: "tracking",
+      shipToCountry: country,
+      _lang: language,
+    };
+    return this.request({
+      endpoint: this.config.endpoints.orderDetail,
+      api: "mtop.aliexpress.trade.buyer.order.detail",
+      data: dataObject,
+      callbackName: "mtopjsonp3",
+      needLogin: true,
+      method: "GET",
+    });
+  }
+
+  private async request(config: RequestConfig) {
+    const token = this.getToken();
+    if (!token) throw new Error("No authentication token found. Are you logged in to AliExpress in Chrome?");
+
+    const timestamp = Date.now();
+    const dataString = JSON.stringify(config.data);
+    const signature = this.generateSignature(token, timestamp, this.config.appKey, dataString);
+
+    const method = config.method || "GET";
+    const urlParams = new URLSearchParams({
+      jsv: this.config.defaultParams.jsv,
+      appKey: this.config.appKey,
+      t: timestamp.toString(),
+      sign: signature,
+      api: config.api,
+      v: this.config.defaultParams.v,
+      type: this.config.defaultParams.type,
+      dataType: this.config.defaultParams.dataType,
+      timeout: this.config.defaultParams.timeout.toString(),
+      method: method,
+    });
+
+    if (method === "POST") {
+      urlParams.set("post", "1");
+      urlParams.set("Content-Type", "application/x-www-form-urlencoded");
+    }
+    if (method === "GET") {
+      urlParams.set("callback", config.callbackName);
+      urlParams.set("data", dataString);
+    }
+
+    const url = `${this.config.baseUrl}${config.endpoint}?${urlParams.toString()}`;
+
+    const response =
+      method === "POST"
+        ? await this.kyInstance.post(url, { body: new URLSearchParams({ data: dataString }) })
+        : await this.kyInstance.get(url);
+
+    const responseText = await response.text();
+    if (responseText.startsWith("{")) return JSON.parse(responseText);
+
+    return this.parseJsonpResponse(responseText, config.callbackName);
+  }
+}

package/src/cli.ts

@@ -0,0 +1,327 @@
+#!/usr/bin/env bun
+import * as os from "node:os";
+import type { Cookie } from "@mpelka/get-cookies";
+import { getChromiumCookiesMacOS } from "@mpelka/get-cookies";
+import { Command } from "commander";
+import { AliExpressClient } from "./AliExpressClient.ts";
+import type {
+  LogisticPackageBlock,
+  OrderComponentData,
+  OrderDetailApiResponse,
+  OrderStatusBlock,
+  TrackingInfo,
+} from "./types.ts";
+
+const STATUS_ALIASES: Record<string, string> = {
+  paying: "waitpay",
+  shipping: "waitsend",
+  shipped: "waitaccept",
+  transit: "waitaccept",
+  completed: "finish",
+  done: "finish",
+  cancelled: "close",
+  canceled: "close",
+  all: "all",
+};
+
+const STATUS_NAMES: Record<string, string> = {
+  all: "All orders (no filter)",
+  waitpay: "Awaiting payment",
+  waitsend: "Awaiting shipment",
+  waitaccept: "Shipped / In transit",
+  finish: "Completed",
+  close: "Cancelled / Closed",
+};
+
+function resolveStatus(input: string): string | null {
+  if (input in STATUS_NAMES) return input;
+  if (input in STATUS_ALIASES) return STATUS_ALIASES[input];
+  return null;
+}
+
+function truncate(str: string, max: number): string {
+  return str.length > max ? `${str.slice(0, max - 1)}…` : str;
+}
+
+function isActiveOrder(order: OrderComponentData): boolean {
+  const status = order.fields.statusText?.toLowerCase() ?? "";
+  const completedKeywords = ["completed", "finished", "closed", "cancelled", "canceled", "ukończony", "zamknięty"];
+  return !completedKeywords.some((kw) => status.includes(kw));
+}
+
+interface OrderOutput {
+  orderId: string;
+  date: string;
+  store: string;
+  total: string;
+  currency: string;
+  status: string;
+  tracking?: {
+    number: string;
+    estimatedDelivery?: string;
+    history?: { date: string; action: string; address?: string }[];
+  };
+  items: { title: string; price: string; quantity: number }[];
+}
+
+function extractOrderData(order: OrderComponentData, orderDetails: OrderDetailApiResponse | null): OrderOutput {
+  const f = order.fields;
+
+  let status = f.statusText;
+  let trackingNumber: string | null = null;
+  let estimatedDelivery: string | null = null;
+  let trackingHistory: TrackingInfo[] | null = null;
+
+  if (orderDetails?.data?.data) {
+    const statusBlock = Object.values(orderDetails.data.data).find(
+      (block) => block.tag === "detail_order_status_block",
+    ) as OrderStatusBlock | undefined;
+    if (statusBlock?.fields?.title) {
+      status = statusBlock.fields.title;
+    }
+
+    const logisticBlock = Object.values(orderDetails.data.data).find(
+      (block) => block.tag === "detail_logistic_package_block",
+    ) as LogisticPackageBlock | undefined;
+    const packages = logisticBlock?.fields?.packageInfoList;
+    if (packages && packages.length > 0) {
+      trackingNumber = packages[0].trackingNumber;
+      estimatedDelivery = packages[0].expectDeliveryDate;
+      trackingHistory = packages[0].trackInfoList;
+    }
+  }
+
+  const output: OrderOutput = {
+    orderId: f.orderId,
+    date: f.orderDateText,
+    store: f.storeName,
+    total: f.totalPriceText,
+    currency: f.currencyCode,
+    status,
+    items: (f.orderLines ?? []).map((item) => ({
+      title: item.itemTitle,
+      price: item.itemPriceText,
+      quantity: item.quantity,
+    })),
+  };
+
+  if (trackingNumber) {
+    output.tracking = {
+      number: trackingNumber,
+      estimatedDelivery: estimatedDelivery ?? undefined,
+      history: trackingHistory?.slice(0, 5).map((e) => ({
+        date: e.date,
+        action: e.action.trim(),
+        address: e.address || undefined,
+      })),
+    };
+  }
+
+  return output;
+}
+
+function printOrder(data: OrderOutput, index: number, total: number) {
+  const header = `[${index + 1}/${total}] ${data.orderId}`;
+  console.log(`\n${header}`);
+  console.log("-".repeat(header.length));
+  console.log(`  ${data.date}  |  ${data.store}  |  ${data.total} ${data.currency}  |  ${data.status}`);
+
+  if (data.tracking) {
+    const parts = [`  Tracking: ${data.tracking.number}`];
+    if (data.tracking.estimatedDelivery) parts.push(`ETA: ${data.tracking.estimatedDelivery}`);
+    console.log(parts.join("  |  "));
+
+    if (data.tracking.history) {
+      for (const event of data.tracking.history.slice(0, 3)) {
+        const location = event.address ? ` (${event.address})` : "";
+        console.log(`    ${event.date} - ${event.action}${location}`);
+      }
+    }
+  }
+
+  for (const item of data.items) {
+    console.log(`  - ${truncate(item.title, 80)}  ${item.price} x${item.quantity}`);
+  }
+}
+
+async function createClient(): Promise<AliExpressClient | null> {
+  if (os.platform() !== "darwin") {
+    console.error("Cookie extraction is currently macOS-only.");
+    return null;
+  }
+
+  try {
+    const cookies: Cookie[] = await getChromiumCookiesMacOS("chrome", "Default", "aliexpress.com");
+    if (cookies.length === 0) {
+      console.error("No AliExpress cookies found in Chrome. Log in to aliexpress.com first.");
+      return null;
+    }
+
+    const tokenCookie = cookies.find((c) => c.name === "_m_h5_tk");
+    if (!tokenCookie) {
+      console.error("Auth cookie '_m_h5_tk' not found. Visit aliexpress.com in Chrome and browse around.");
+      return null;
+    }
+
+    return new AliExpressClient(cookies);
+  } catch (error) {
+    console.error("Failed to get cookies from Chrome:", error);
+    return null;
+  }
+}
+
+interface RunOptions {
+  status?: string;
+  limit: number;
+  page: number;
+  details: boolean;
+  json: boolean;
+}
+
+async function run(options: RunOptions): Promise<number> {
+  const client = await createClient();
+  if (!client) return 1;
+
+  const tokenInfo = client.getTokenInfo();
+  if (tokenInfo.expired) {
+    console.warn(`Warning: Token is ${tokenInfo.ageHours.toFixed(1)}h old and likely expired.`);
+    console.warn("  Visit aliexpress.com in Chrome to refresh your session, then retry.");
+  }
+
+  const showAll = options.status === "all";
+  const serverFilter = options.status && !showAll ? options.status : null;
+
+  const ordersRes = await client.getOrders({
+    pageIndex: options.page,
+    pageSize: options.limit,
+    statusTab: serverFilter,
+  });
+
+  if (ordersRes?.ret?.some((r) => r.startsWith("FAIL_") || r.includes("ERROR") || r.includes("SESSION_EXPIRED"))) {
+    console.error(`API error: ${ordersRes.ret.join(", ")}`);
+    console.error("  Visit aliexpress.com in Chrome to refresh your session, then retry.");
+    return 1;
+  }
+
+  const ordersData = ordersRes?.data?.data;
+  if (!ordersData) {
+    console.error("Failed to retrieve orders. Response was empty or malformed.");
+    if (ordersRes) {
+      console.error("Response:", JSON.stringify(ordersRes, null, 2));
+    }
+    return 1;
+  }
+
+  let orders = Object.keys(ordersData)
+    .filter((key) => key.startsWith("pc_om_list_order_"))
+    .map((key) => ordersData[key])
+    .filter((order) => order?.fields) as OrderComponentData[];
+
+  // Default: show only active orders. -s all or -s <specific> skips this filter.
+  if (!showAll && !options.status) {
+    orders = orders.filter(isActiveOrder);
+  }
+
+  if (orders.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify([]));
+    } else {
+      const context = options.status
+        ? ` with status "${STATUS_NAMES[options.status] ?? options.status}"`
+        : " (active only -- use -s all to include completed)";
+      console.log(`No orders found${context}.`);
+    }
+    return 2;
+  }
+
+  const results: OrderOutput[] = [];
+
+  for (let i = 0; i < orders.length; i++) {
+    const order = orders[i];
+    let orderDetails: OrderDetailApiResponse | null = null;
+
+    if (options.details) {
+      orderDetails = await client.getOrderDetails(order.fields.orderId, {});
+      if (i < orders.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      }
+    }
+
+    const data = extractOrderData(order, orderDetails);
+    results.push(data);
+
+    if (!options.json) {
+      printOrder(data, i, orders.length);
+    }
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    const label = options.status ? ` (${STATUS_NAMES[options.status] ?? options.status})` : " (active)";
+    console.log(`\n${results.length} order${results.length === 1 ? "" : "s"}${label}, page ${options.page}`);
+  }
+
+  return 0;
+}
+
+const allStatuses = [...new Set([...Object.keys(STATUS_NAMES), ...Object.keys(STATUS_ALIASES)])].sort();
+
+const program = new Command()
+  .name("aliorders")
+  .description("Fetch and display AliExpress order history from your browser session")
+  .version("1.0.0")
+  .option("-s, --status <name>", `Filter by status: ${allStatuses.join(", ")}`)
+  .option("-n, --limit <number>", "Number of orders to fetch per page", "10")
+  .option("-p, --page <number>", "Page number", "1")
+  .option("-j, --json", "Output as JSON (useful for scripting and LLM agents)", false)
+  .option("--no-details", "Skip fetching detailed tracking info (faster)")
+  .addHelpText(
+    "after",
+    `
+Examples:
+  aliorders                  Show active orders (default)
+  aliorders -s all           Show all orders including completed
+  aliorders -s shipped       Show shipped/in-transit orders
+  aliorders -s completed     Show completed orders
+  aliorders -n 20            Fetch up to 20 orders
+  aliorders -p 2             Show page 2
+  aliorders --json           Output as JSON for scripting/agents
+  aliorders --no-details     Skip tracking lookups (faster)
+  aliorders statuses         List all status filters`,
+  )
+  .action(async (opts) => {
+    if (opts.status) {
+      const resolved = resolveStatus(opts.status);
+      if (!resolved) {
+        console.error(`Unknown status "${opts.status}". Available: ${allStatuses.join(", ")}`);
+        process.exit(1);
+      }
+      opts.status = resolved;
+    }
+
+    const exitCode = await run({
+      status: opts.status,
+      limit: parseInt(opts.limit, 10),
+      page: parseInt(opts.page, 10),
+      details: opts.details,
+      json: opts.json,
+    });
+    process.exit(exitCode);
+  });
+
+program
+  .command("statuses")
+  .description("List available order status filters")
+  .action(() => {
+    console.log("Available status filters:\n");
+    for (const [tab, name] of Object.entries(STATUS_NAMES)) {
+      const aliases = Object.entries(STATUS_ALIASES)
+        .filter(([, v]) => v === tab)
+        .map(([k]) => k);
+      const aliasStr = aliases.length > 0 ? ` (aliases: ${aliases.join(", ")})` : "";
+      console.log(`  ${tab.padEnd(14)} ${name}${aliasStr}`);
+    }
+  });
+
+program.parse();

package/src/types.ts

@@ -0,0 +1,127 @@
+// Main API response wrapper
+export interface AliExpressApiResponse {
+  api: string;
+  data: AliExpressResponseData;
+  ret: string[];
+  v: string;
+}
+
+// Container for all response data
+export interface AliExpressResponseData {
+  data: Record<string, ComponentData>;
+}
+
+// Generic component data structure
+export interface ComponentData {
+  fields: any;
+  id: string;
+  tag: string;
+  type: string;
+}
+
+// Order-specific component data
+export interface OrderComponentData extends ComponentData {
+  fields: OrderFields;
+  tag: "pc_om_list_order";
+  type: "pc_om_list_order";
+}
+
+// Order fields containing all order details
+export interface OrderFields {
+  buttons: OrderButton[];
+  currencyCode: string;
+  orderDateText: string;
+  orderId: string;
+  orderLines: OrderLine[];
+  statusText: string;
+  storeName: string;
+  totalPriceText: string;
+}
+
+// Individual order line (product)
+export interface OrderLine {
+  itemPriceText: string;
+  itemTitle: string;
+  quantity: number;
+  skuAttrs?: SkuAttribute[];
+}
+
+// SKU attributes for product variants
+export interface SkuAttribute {
+  name: string;
+  text: string;
+}
+
+// Action buttons available for each order
+export interface OrderButton {
+  text: string;
+  type: string;
+}
+
+// Detailed tracking information
+export interface TrackingInfo {
+  action: string;
+  address?: string;
+  date: string;
+}
+
+// Package tracking details
+export interface PackageInfo {
+  expectDeliveryDate: string;
+  trackInfoList: TrackingInfo[];
+  trackingNumber: string;
+}
+
+// Logistic package block from order details
+export interface LogisticPackageBlock extends ComponentData {
+  fields: {
+    packageInfoList: PackageInfo[];
+  };
+  tag: "detail_logistic_package_block";
+  type: "detail_logistic_package_block";
+}
+
+// Order status block from order details
+export interface OrderStatusBlock extends ComponentData {
+  fields: {
+    title: string;
+  };
+  tag: "detail_order_status_block";
+  type: "detail_order_status_block";
+}
+
+// Order detail API response
+export interface OrderDetailApiResponse extends AliExpressApiResponse {
+  api: "mtop.aliexpress.trade.buyer.order.detail";
+  data: {
+    data: Record<string, ComponentData>;
+  };
+}
+
+// Request data for order details API
+export interface OrderDetailRequestData {
+  tradeOrderId: string;
+  timeZone: string;
+  clientPlatform: "pc";
+  channel: "tracking";
+  shipToCountry: string;
+  _lang: string;
+}
+
+export interface RequestConfig {
+  endpoint: string;
+  api: string;
+  data: any;
+  callbackName: string;
+  needLogin?: boolean;
+  method?: string;
+}
+
+export interface OrderListOptions {
+  statusTab?: string | null;
+  country?: string;
+  language?: string;
+  timezone?: string;
+  pageIndex?: number;
+  pageSize?: number;
+}