universal-parcel-scraper 0.14.0-main.340 → 0.14.1-main.344

package/dist/carriers/dhl-express/adapter.d.ts

@@ -6,12 +6,14 @@ export declare function trackingUrl(raw: string): string;
 export declare function parseUnified(payload: unknown, raw: string): CarrierResult;
 /** A waybill can be reused. Multiple or duplicate shipments need recipient disambiguation. */
 export declare function parse(payload: unknown, raw: string): CarrierResult;
+/** Guest mobile history has facility-local clocks and orders scans by counter. */
+export declare function parseMobile(payload: unknown, raw: string): CarrierResult;
 export declare class DhlExpressTracker {
     private readonly environment;
+    private readonly mobileDevice;
     constructor(environment: AdapterEnvironment);
     direct(number: string, context?: TrackingContext): Promise<CarrierResult>;
     browser(number: string, context?: TrackingContext): Promise<CarrierResult>;
-    private decode;
     fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
 }
 export declare const adapter: AdapterFactory;

package/dist/carriers/dhl-express/adapter.js

@@ -1,14 +1,15 @@
 import { DateTime } from 'luxon';
+import { randomUUID } from 'node:crypto';
 import { accepted, lookupBudget, recognizeFromBrowserLookup, recognizeFromLookup } from '../../core/adapter/index.js';
 import { isValidDhlExpressWaybill } from '../../core/detection/numericChecksums.js';
 import { BudgetExceededError, ChallengeError, IndeterminateError, InvalidInputError, NotFoundError, RateLimitedError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
 import { classifyWording } from '../../core/status/index.js';
 import { explicitOffsetTime } from '../../core/time/index.js';
-import { clean, decodeText, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { clean, parseJsonBytes } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
+import { mobileTracking } from './mobile.js';
 const PROVIDER = 'DHL Express';
-const API = 'https://mydhl.express.dhl/shipmentTracking';
 const BROWSER_API = 'https://www.dhl.com/utapi';
 const MAX_BYTES = 1_000_000;
 // The scoped browser runner bounds context cleanup to 1.5 seconds. Leave room
@@ -24,10 +25,6 @@ export function normalizeNumber(raw) {
 export function trackingUrl(raw) {
     return `https://mydhl.express.dhl/gb/en/tracking.html#/results?id=${normalizeNumber(raw)}`;
 }
-function apiUrl(number) {
-    return `${API}?${new URLSearchParams({ AWB: number, clientApp: 'mydhlplus', countryCode: 'gb', languageCode: 'en',
-        requestAdditionalDetails: 'controlledAccessDataCodes,productCode,shipmentActivationDate,countryCodes' }).toString().replace(/%2C/g, ',')}`;
-}
 /** MyDHL clocks are local to each facility; they do not carry a UTC offset. */
 function clock(date, time) {
     if (typeof date !== 'string' || typeof time !== 'string' || !/^\d{2}:\d{2}$/.test(time))
@@ -131,19 +128,37 @@ export function parse(payload, raw) {
         ...(typeof shipment.consigneeCountryCode === 'string' && /^[A-Z]{2}$/.test(shipment.consigneeCountryCode)
             ? { destination_country: shipment.consigneeCountryCode } : {}) };
 }
+/** Guest mobile history has facility-local clocks and orders scans by counter. */
+export function parseMobile(payload, raw) {
+    const number = normalizeNumber(raw);
+    if (!Array.isArray(payload) || payload.length > 20 || payload.some((shipment) => !isRecord(shipment)))
+        throw new SchemaError(PROVIDER, 'DHL mobile tracking returned invalid shipments');
+    if (!payload.length)
+        throw new NotFoundError(PROVIDER);
+    const shipments = payload.filter(isRecord).map((shipment) => {
+        if (!Array.isArray(shipment.checkpoints) || shipment.checkpoints.length > 1000)
+            throw new SchemaError(PROVIDER, 'DHL mobile tracking returned invalid checkpoints');
+        const counters = new Set();
+        const checkpoints = shipment.checkpoints.map((row) => {
+            if (!isRecord(row) || typeof row.counter !== 'number' || !Number.isSafeInteger(row.counter) || row.counter < 1 || counters.has(row.counter))
+                throw new SchemaError(PROVIDER, 'DHL mobile tracking returned an invalid checkpoint counter');
+            counters.add(row.counter);
+            return { ...row, counter: row.counter, date: typeof row.date_en === 'string' ? row.date_en : row.date };
+        }).sort((a, b) => b.counter - a.counter);
+        return { ...shipment, checkpoints };
+    });
+    return parse({ results: shipments }, number);
+}
 export class DhlExpressTracker {
     environment;
+    mobileDevice = randomUUID();
     constructor(environment) {
         this.environment = environment;
     }
     async direct(number, context) {
+        const normalized = normalizeNumber(number);
         const budget = lookupBudget(context, 10_000, PROVIDER);
-        const { bytes } = await fetchBounded(apiUrl(normalizeNumber(number)), {
-            headers: { accept: 'application/json', 'user-agent': this.environment.userAgent ?? 'Mozilla/5.0' }, signal: budget.signal,
-        }, { provider: PROVIDER, timeoutMs: budget.remainingMs(), maxBytes: MAX_BYTES, fetcher: this.environment.fetcher });
-        if (/^\s*</.test(decodeText(bytes)))
-            throw new ChallengeError(PROVIDER, 'DHL Express rejected the tracking request');
-        return this.decode(bytes, number);
+        return parseMobile(await mobileTracking(normalized, budget, this.environment, this.mobileDevice), normalized);
     }
     async browser(number, context) {
         const budget = lookupBudget(context, 45_000, PROVIDER);
@@ -192,16 +207,6 @@ export class DhlExpressTracker {
             throw new SchemaError(PROVIDER, 'DHL Express returned invalid browser data');
         return parseUnified(parseJsonBytes(new TextEncoder().encode(response.body), PROVIDER), number);
     }
-    decode(bytes, number) {
-        let payload;
-        try {
-            payload = parseJsonBytes(bytes, PROVIDER);
-        }
-        catch (error) {
-            throw new SchemaError(PROVIDER, 'DHL Express returned invalid tracking JSON', { cause: error });
-        }
-        return parse(payload, number);
-    }
     fetch(raw, context) {
         const number = normalizeNumber(raw);
         return runSteps({ carrier: 'dhl-express', budgetMs: context?.budgetMs ?? 45_000, signal: context?.signal, recorder: this.environment.recorder }, [

package/dist/carriers/dhl-express/mobile.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterEnvironment, LookupBudget } from '../../core/adapter/index.js';
+/** Verify current application configuration before treating an empty tracking list as missing. */
+export declare function mobileTracking(number: string, budget: LookupBudget, environment: AdapterEnvironment, device: string): Promise<unknown>;

package/dist/carriers/dhl-express/mobile.js

@@ -0,0 +1,73 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { ChallengeError, RateLimitedError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { decodeText, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+const PROVIDER = 'DHL Express';
+const APP = 'com.dhl.exp.dhlmobile';
+const VERSION = '6.1.0';
+const API = `https://dhle.dhl.com/access/access/${APP}`;
+// The shared guest application bearer is deliberately distributed with this adapter.
+const APPLICATION_BEARER = "Bearer MtX6uKNcGM295BXaJGa83GFhTHCL9a";
+/** Mobile errors can arrive as JSON strings or envelopes with HTTP 200. */
+function checkReply(payload, httpStatus) {
+    const root = isRecord(payload) ? payload : {};
+    const nested = isRecord(root.error) ? root.error : {};
+    const codes = [payload, root.error, root.statusCode, root.status, root.code, root.message,
+        nested.error, nested.statusCode, nested.status, nested.code, nested.message]
+        .filter((value) => typeof value === 'string' || typeof value === 'number')
+        .map((value) => String(value).trim());
+    if (codes.some((code) => ['429', 'temporary_blocked', 'max_attempts_reached'].includes(code)))
+        throw new RateLimitedError(PROVIDER);
+    if (codes.some((code) => ['401', '403', '428', 'DRG10012', 'DRG10013'].includes(code)))
+        throw new ChallengeError(PROVIDER, 'DHL mobile tracking requires verification', httpStatus === 200 ? undefined : { status: httpStatus });
+    const serverError = codes.find((code) => /^5\d{2}$/.test(code));
+    if (serverError)
+        throw new UpstreamHttpError(PROVIDER, Number(serverError));
+}
+/** Verify current application configuration before treating an empty tracking list as missing. */
+export async function mobileTracking(number, budget, environment, device) {
+    const request = async (method, service, extra) => {
+        budget.signal.throwIfAborted();
+        const { response, bytes } = await fetchBounded(`${API}?${new URLSearchParams({ appVersion: VERSION, service: `${service}-${method}` })}`, {
+            method: 'POST', signal: budget.signal,
+            headers: { accept: 'application/json', 'content-type': 'application/json', authorization: APPLICATION_BEARER,
+                'cache-control': 'no-cache', transactionId: randomUUID(), 'user-agent': environment.userAgent ?? 'Mozilla/5.0' },
+            body: JSON.stringify({ method, service, authentication: { provider: 'DEMP.RS1', token: '', login: '' },
+                data: { parameters: {}, timezoneOffset: '+00:00', appVersion: VERSION, UIClient: 'Android',
+                    device_info: { device_unique_id: device, deviceId: device, device_language: 'en', app_id: APP,
+                        platform: 'Android', appStore: 'PlayStore', gpsLoc: '', pushToken: '' }, ...extra } }),
+        }, { provider: PROVIDER, timeoutMs: budget.remainingMs(), maxBytes: 1_000_000, fetcher: environment.fetcher,
+            allowHttpStatuses: [400, 404, 410, 503] });
+        budget.signal.throwIfAborted();
+        if (response.status === 404 || response.status === 410)
+            throw new TransportError(PROVIDER, 'DHL mobile tracking endpoint is unavailable', { status: response.status });
+        if (/^\s*</.test(decodeText(bytes))) {
+            if (response.status !== 200)
+                throw new UpstreamHttpError(PROVIDER, response.status);
+            throw new ChallengeError(PROVIDER, 'DHL mobile tracking rejected the request');
+        }
+        let payload;
+        try {
+            payload = parseJsonBytes(bytes, PROVIDER);
+        }
+        catch (error) {
+            if (response.status !== 200)
+                throw new UpstreamHttpError(PROVIDER, response.status);
+            throw new SchemaError(PROVIDER, 'DHL mobile tracking returned invalid JSON', { cause: error });
+        }
+        checkReply(payload, response.status);
+        if (response.status !== 200)
+            throw new UpstreamHttpError(PROVIDER, response.status);
+        return payload;
+    };
+    const settings = await request('countrySettingsBySettingName', 'common', { countryCode: 'GB', settingNames: ['api_awb_encryption'] });
+    if (!Array.isArray(settings) || settings.length > 20 || settings.some((setting) => !isRecord(setting)))
+        throw new SchemaError(PROVIDER, 'DHL mobile tracking returned invalid settings');
+    const encryption = settings.filter(isRecord).filter((setting) => setting.name === 'api_awb_encryption');
+    if (encryption.length !== 1 || (encryption[0].value !== 'N' && encryption[0].value !== 'Y'))
+        throw new SchemaError(PROVIDER, 'DHL mobile tracking returned invalid encryption settings');
+    if (encryption[0].value === 'Y')
+        throw new ChallengeError(PROVIDER, 'DHL mobile tracking requires waybill encryption');
+    return request('tracking', 'shipments', { airWayBill: number, countryCode: 'GB', languageCd: 'en', addShipmentToODD: 'N',
+        moreDetails: 'Y', iv: Buffer.from(randomBytes(8).toString('hex')).toString('base64'), captchaVerificationData: {} });
+}

package/dist/server/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Universal Parcel Scraper",
-    "version": "0.14.0"
+    "version": "0.14.1"
   },
   "paths": {
     "/health": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-parcel-scraper",
-  "version": "0.14.0-main.340",
+  "version": "0.14.1-main.344",
   "description": "Self-hosted parcel tracking: carrier detection, dedicated scrapers and optional universal providers.",
   "type": "module",
   "license": "Apache-2.0",